/****************************************************************************
 Copyright (C) 2010-2012 the Office National des Forêts (ONF), France
                         All rights reserved.

 Contact : alexandre.piboule@onf.fr

 Developers : Alexandre PIBOULE (ONF)

 This file is part of PluginONF library.

 PluginONF is free library: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 PluginONF is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with PluginONF.  If not, see <http://www.gnu.org/licenses/lgpl.html>.
*****************************************************************************/

#include "onf_metricminmaxlasfields.h"
#include "ct_pointcloudindex/ct_pointcloudindexvector.h"
#include "ct_iterator/ct_pointiterator.h"

#include "ctliblas/tools/las/ct_lasdata.h"

ONF_MetricMinMaxLASFields::ONF_MetricMinMaxLASFields(QString pluginName) : CT_AbstractMetric_LAS(pluginName)
{
    declareAttributes();
}

ONF_MetricMinMaxLASFields::ONF_MetricMinMaxLASFields(const ONF_MetricMinMaxLASFields &other) : CT_AbstractMetric_LAS(other)
{
    declareAttributes();
    m_configAndResults = other.m_configAndResults;
}

QString ONF_MetricMinMaxLASFields::getShortDisplayableName() const
{
    return tr("Min et Max des champs LAS");
}

QString ONF_MetricMinMaxLASFields::getShortDescription() const
{
    return tr("Calcul pour chaque champ du format LAS, les valeurs min et max. Ces métriques sont principalement utilisées pour du contrôle de données. ");
}

QString ONF_MetricMinMaxLASFields::getDetailledDescription() const
{
    return tr("Les indicateurs peuvent être calculés :"
              "<ul>"
              "<li><strong>X_Min</strong> : Minimum des coordonnées X</li>"
              "<li><strong>X_Max</strong> : Maximum des coordonnées X</li>"
              "<li><strong>Y_Min</strong> : Minimum des coordonnées Y</li>"
              "<li><strong>Y_Max</strong> : Maximum des coordonnées Y</li>"
              "<li><strong>Z_Min</strong> : Minimum des coordonnées Z</li>"
              "<li><strong>Z_Max</strong> : Maximum des coordonnées Z</li>"
              "<li><strong>Intensity_Min</strong> : Minimum des Intensités</li>"
              "<li><strong>Intensity_Max</strong> : Maximum des Intensités</li>"
              "<li><strong>Return_Number_Min</strong> : Minimum des Numéros de retours (N)</li>"
              "<li><strong>Return_Number_Max</strong> : Maximum des Numéros de retours (N)</li>"
              "<li><strong>Number_of_Returns_Min</strong> : Minimum des Nombres de retours (R)</li>"
              "<li><strong>Number_of_Returns_Max</strong> : Maximum des Nombres de retours (R)</li>"
              "<li><strong>Classification_Flags_Min</strong> : Minimum du champ Classification_Flags</li>"
              "<li><strong>Classification_Flags_Max</strong> : Minimum du champ Classification_Flags</li>"
              "<li><strong>Scanner_Channel_Min</strong> : Minimum du champ Scanner_Channel</li>"
              "<li><strong>Scanner_Channel_Max</strong> : Maximum du champ Scanner_Channel</li>"
              "<li><strong>Scan_Direction_Flag_Min</strong> : Minimum du flag Scan_Direction</li>"
              "<li><strong>Scan_Direction_Flag_Max</strong> : Maximum du flag Scan_Direction</li>"
              "<li><strong>Edge_of_Flight_Line_Min</strong> : Minimum du champ Ligne de vol</li>"
              "<li><strong>Edge_of_Flight_Line_Max</strong> : Maximum du champ Ligne de vol</li>"
              "<li><strong>Classification_Min</strong> : Plus petite classe de Classification utilisée</li>"
              "<li><strong>Classification_Max</strong> : Plus grande classe de Classification utilisée</li>"
              "<li><strong>Scan_Angle_Rank_Min</strong> : Minimum du champ Scan_Angle_Rank</li>"
              "<li><strong>Scan_Angle_Rank_Max</strong> : Maximum du champ Scan_Angle_Rank</li>"
              "<li><strong>User_Data_Min</strong> : Minimum du champ User_Data</li>"
              "<li><strong>User_Data_Max</strong> : Maximum du champ User_Data</li>"
              "<li><strong>Point_Source_ID_Min</strong> : Minimum du champ Point_Source_ID</li>"
              "<li><strong>Point_Source_ID_Max</strong> : Maximum du champ Point_Source_ID</li>"
              "<li><strong>GPS_Time_Min</strong> : Minimum des Temps GPS</li>"
              "<li><strong>GPS_Time_Max</strong> : Maximum des Temps GPS</li>"
              "<li><strong>Red_Min</strong> : Minimum de la composante Rouge</li>"
              "<li><strong>Red_Max</strong> : Maximum de la composante Rouge</li>"
              "<li><strong>Green_Min</strong> : Minimum de la composante Verte</li>"
              "<li><strong>Green_Max</strong> : Maximum de la composante Verte</li>"
              "<li><strong>Blue_Min</strong> : Minimum de la composante Bleue</li>"
              "<li><strong>Blue_Max</strong> : Maximum de la composante Bleue</li>"
              "</ul>");
}

ONF_MetricMinMaxLASFields::Config ONF_MetricMinMaxLASFields::metricConfiguration() const
{
    return m_configAndResults;
}

void ONF_MetricMinMaxLASFields::setMetricConfiguration(const ONF_MetricMinMaxLASFields::Config &conf)
{
    m_configAndResults = conf;
}

CT_AbstractConfigurableElement *ONF_MetricMinMaxLASFields::copy() const
{
    return new ONF_MetricMinMaxLASFields(*this);
}

void ONF_MetricMinMaxLASFields::computeMetric()
{    
    m_configAndResults._X_Min.value = std::numeric_limits<double>::max();
    m_configAndResults._X_Max.value = 0;
    m_configAndResults._Y_Min.value = std::numeric_limits<double>::max();
    m_configAndResults._Y_Max.value = 0;
    m_configAndResults._Z_Min.value = std::numeric_limits<double>::max();
    m_configAndResults._Z_Max.value = 0;
    m_configAndResults._Intensity_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Intensity_Max.value = 0;
    m_configAndResults._Return_Number_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Return_Number_Max.value = 0;
    m_configAndResults._Number_of_Returns_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Number_of_Returns_Max.value = 0;
    m_configAndResults._Classification_Flags_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Classification_Flags_Max.value = 0;
    m_configAndResults._Scanner_Channel_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Scanner_Channel_Max.value = 0;
    m_configAndResults._Scan_Direction_Flag_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Scan_Direction_Flag_Max.value = 0;
    m_configAndResults._Edge_of_Flight_Line_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Edge_of_Flight_Line_Max.value = 0;
    m_configAndResults._Classification_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Classification_Max.value = 0;
    m_configAndResults._Scan_Angle_Rank_Min.value = 0;
    m_configAndResults._Scan_Angle_Rank_Max.value = 0;
    m_configAndResults._Scan_Angle_Rank_Ext_Min.value = std::numeric_limits<double>::max();
    m_configAndResults._Scan_Angle_Rank_Ext_Max.value = -std::numeric_limits<double>::max();
    m_configAndResults._User_Data_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._User_Data_Max.value = 0;
    m_configAndResults._Point_Source_ID_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Point_Source_ID_Max.value = 0;
    m_configAndResults._GPS_Time_Min.value = std::numeric_limits<double>::max();
    m_configAndResults._GPS_Time_Max.value = -std::numeric_limits<double>::max();
    m_configAndResults._Red_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Red_Max.value = 0;
    m_configAndResults._Green_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Green_Max.value = 0;
    m_configAndResults._Blue_Min.value = std::numeric_limits<int>::max();
    m_configAndResults._Blue_Max.value = 0;


    CT_PointIterator itP(pointCloud());
    while(itP.hasNext())
    {
        const CT_Point& point = itP.next().currentPoint();

        if ((plotArea() == nullptr) || plotArea()->contains(point(0), point(1)))
        {
            const size_t index = itP.currentGlobalIndex();

            CT_LASData lasData;
            lasAttributes()->getLASDataAt(index, lasData);

            if (point(0) < m_configAndResults._X_Min.value) {m_configAndResults._X_Min.value = point(0);}
            if (point(0) > m_configAndResults._X_Max.value) {m_configAndResults._X_Max.value = point(0);}

            if (point(1) < m_configAndResults._Y_Min.value) {m_configAndResults._Y_Min.value = point(1);}
            if (point(1) > m_configAndResults._Y_Max.value) {m_configAndResults._Y_Max.value = point(1);}

            if (point(2) < m_configAndResults._Z_Min.value) {m_configAndResults._Z_Min.value = point(2);}
            if (point(2) > m_configAndResults._Z_Max.value) {m_configAndResults._Z_Max.value = point(2);}

            if (lasData._Intensity < m_configAndResults._Intensity_Min.value) {m_configAndResults._Intensity_Min.value = lasData._Intensity;}
            if (lasData._Intensity > m_configAndResults._Intensity_Max.value) {m_configAndResults._Intensity_Max.value = lasData._Intensity;}

            if (lasData._Return_Number < m_configAndResults._Return_Number_Min.value) {m_configAndResults._Return_Number_Min.value = lasData._Return_Number;}
            if (lasData._Return_Number > m_configAndResults._Return_Number_Max.value) {m_configAndResults._Return_Number_Max.value = lasData._Return_Number;}

            if (lasData._Number_of_Returns < m_configAndResults._Number_of_Returns_Min.value) {m_configAndResults._Number_of_Returns_Min.value = lasData._Number_of_Returns;}
            if (lasData._Number_of_Returns > m_configAndResults._Number_of_Returns_Max.value) {m_configAndResults._Number_of_Returns_Max.value = lasData._Number_of_Returns;}

            if (lasData._Classification_Flags < m_configAndResults._Classification_Flags_Min.value) {m_configAndResults._Classification_Flags_Min.value = lasData._Classification_Flags;}
            if (lasData._Classification_Flags > m_configAndResults._Classification_Flags_Max.value) {m_configAndResults._Classification_Flags_Max.value = lasData._Classification_Flags;}

            if (lasData._Scanner_Channel < m_configAndResults._Scanner_Channel_Min.value) {m_configAndResults._Scanner_Channel_Min.value = lasData._Scanner_Channel;}
            if (lasData._Scanner_Channel > m_configAndResults._Scanner_Channel_Max.value) {m_configAndResults._Scanner_Channel_Max.value = lasData._Scanner_Channel;}

            if (lasData._Scan_Direction_Flag < m_configAndResults._Scan_Direction_Flag_Min.value) {m_configAndResults._Scan_Direction_Flag_Min.value = lasData._Scan_Direction_Flag;}
            if (lasData._Scan_Direction_Flag > m_configAndResults._Scan_Direction_Flag_Max.value) {m_configAndResults._Scan_Direction_Flag_Max.value = lasData._Scan_Direction_Flag;}

            if (lasData._Edge_of_Flight_Line < m_configAndResults._Edge_of_Flight_Line_Min.value) {m_configAndResults._Edge_of_Flight_Line_Min.value = lasData._Edge_of_Flight_Line;}
            if (lasData._Edge_of_Flight_Line > m_configAndResults._Edge_of_Flight_Line_Max.value) {m_configAndResults._Edge_of_Flight_Line_Max.value = lasData._Edge_of_Flight_Line;}

            if (lasData._Classification < m_configAndResults._Classification_Min.value) {m_configAndResults._Classification_Min.value = lasData._Classification;}
            if (lasData._Classification > m_configAndResults._Classification_Max.value) {m_configAndResults._Classification_Max.value = lasData._Classification;}

            if (lasData._Scan_Angle_Rank < m_configAndResults._Scan_Angle_Rank_Ext_Min.value) {m_configAndResults._Scan_Angle_Rank_Ext_Min.value = lasData._Scan_Angle_Rank;}
            if (lasData._Scan_Angle_Rank > m_configAndResults._Scan_Angle_Rank_Ext_Max.value) {m_configAndResults._Scan_Angle_Rank_Ext_Max.value = lasData._Scan_Angle_Rank;}

            if (lasData._User_Data < m_configAndResults._User_Data_Min.value) {m_configAndResults._User_Data_Min.value = lasData._User_Data;}
            if (lasData._User_Data > m_configAndResults._User_Data_Max.value) {m_configAndResults._User_Data_Max.value = lasData._User_Data;}

            if (lasData._Point_Source_ID < m_configAndResults._Point_Source_ID_Min.value) {m_configAndResults._Point_Source_ID_Min.value = lasData._Point_Source_ID;}
            if (lasData._Point_Source_ID > m_configAndResults._Point_Source_ID_Max.value) {m_configAndResults._Point_Source_ID_Max.value = lasData._Point_Source_ID;}

            if (lasData._GPS_Time < m_configAndResults._GPS_Time_Min.value) {m_configAndResults._GPS_Time_Min.value = lasData._GPS_Time;}
            if (lasData._GPS_Time > m_configAndResults._GPS_Time_Max.value) {m_configAndResults._GPS_Time_Max.value = lasData._GPS_Time;}

            if (lasData._Red < m_configAndResults._Red_Min.value) {m_configAndResults._Red_Min.value = lasData._Red;}
            if (lasData._Red > m_configAndResults._Red_Max.value) {m_configAndResults._Red_Max.value = lasData._Red;}

            if (lasData._Green < m_configAndResults._Green_Min.value) {m_configAndResults._Green_Min.value = lasData._Green;}
            if (lasData._Green > m_configAndResults._Green_Max.value) {m_configAndResults._Green_Max.value = lasData._Green;}

            if (lasData._Blue < m_configAndResults._Blue_Min.value) {m_configAndResults._Blue_Min.value = lasData._Blue;}
            if (lasData._Blue > m_configAndResults._Blue_Max.value) {m_configAndResults._Blue_Max.value = lasData._Blue;}
        }
    }


    if (std::max(std::fabs(m_configAndResults._Scan_Angle_Rank_Ext_Min.value), std::fabs(m_configAndResults._Scan_Angle_Rank_Ext_Max.value)) > 180.0)
    {      
        m_configAndResults._Scan_Angle_Rank_Min.value = m_configAndResults._Scan_Angle_Rank_Ext_Min.value * 0.006;
        m_configAndResults._Scan_Angle_Rank_Max.value = m_configAndResults._Scan_Angle_Rank_Ext_Max.value * 0.006;

    } else {
        m_configAndResults._Scan_Angle_Rank_Min.value = m_configAndResults._Scan_Angle_Rank_Ext_Min.value;
        m_configAndResults._Scan_Angle_Rank_Max.value = m_configAndResults._Scan_Angle_Rank_Ext_Max.value;
    }

    setAttributeValueVaB(m_configAndResults._X_Min);
    setAttributeValueVaB(m_configAndResults._X_Max);
    setAttributeValueVaB(m_configAndResults._Y_Min);
    setAttributeValueVaB(m_configAndResults._Y_Max);
    setAttributeValueVaB(m_configAndResults._Z_Min);
    setAttributeValueVaB(m_configAndResults._Z_Max);
    setAttributeValueVaB(m_configAndResults._Intensity_Min);
    setAttributeValueVaB(m_configAndResults._Intensity_Max);
    setAttributeValueVaB(m_configAndResults._Return_Number_Min);
    setAttributeValueVaB(m_configAndResults._Return_Number_Max);
    setAttributeValueVaB(m_configAndResults._Number_of_Returns_Min);
    setAttributeValueVaB(m_configAndResults._Number_of_Returns_Max);
    setAttributeValueVaB(m_configAndResults._Classification_Flags_Min);
    setAttributeValueVaB(m_configAndResults._Classification_Flags_Max);
    setAttributeValueVaB(m_configAndResults._Scanner_Channel_Min);
    setAttributeValueVaB(m_configAndResults._Scanner_Channel_Max);
    setAttributeValueVaB(m_configAndResults._Scan_Direction_Flag_Min);
    setAttributeValueVaB(m_configAndResults._Scan_Direction_Flag_Max);
    setAttributeValueVaB(m_configAndResults._Edge_of_Flight_Line_Min);
    setAttributeValueVaB(m_configAndResults._Edge_of_Flight_Line_Max);
    setAttributeValueVaB(m_configAndResults._Classification_Min);
    setAttributeValueVaB(m_configAndResults._Classification_Max);
    setAttributeValueVaB(m_configAndResults._Scan_Angle_Rank_Min);
    setAttributeValueVaB(m_configAndResults._Scan_Angle_Rank_Max);
    setAttributeValueVaB(m_configAndResults._Scan_Angle_Rank_Ext_Min);
    setAttributeValueVaB(m_configAndResults._Scan_Angle_Rank_Ext_Max);
    setAttributeValueVaB(m_configAndResults._User_Data_Min);
    setAttributeValueVaB(m_configAndResults._User_Data_Max);
    setAttributeValueVaB(m_configAndResults._Point_Source_ID_Min);
    setAttributeValueVaB(m_configAndResults._Point_Source_ID_Max);
    setAttributeValueVaB(m_configAndResults._GPS_Time_Min);
    setAttributeValueVaB(m_configAndResults._GPS_Time_Max);
    setAttributeValueVaB(m_configAndResults._Red_Min);
    setAttributeValueVaB(m_configAndResults._Red_Max);
    setAttributeValueVaB(m_configAndResults._Green_Min);
    setAttributeValueVaB(m_configAndResults._Green_Max);
    setAttributeValueVaB(m_configAndResults._Blue_Min);
    setAttributeValueVaB(m_configAndResults._Blue_Max);
}

void ONF_MetricMinMaxLASFields::declareAttributes()
{    
    registerAttributeVaB(m_configAndResults._X_Min, CT_AbstractCategory::DATA_NUMBER, "X_Min");
    registerAttributeVaB(m_configAndResults._X_Max, CT_AbstractCategory::DATA_NUMBER, "X_Max");
    registerAttributeVaB(m_configAndResults._Y_Min, CT_AbstractCategory::DATA_NUMBER, "Y_Min");
    registerAttributeVaB(m_configAndResults._Y_Max, CT_AbstractCategory::DATA_NUMBER, "Y_Max");
    registerAttributeVaB(m_configAndResults._Z_Min, CT_AbstractCategory::DATA_NUMBER, "Z_Min");
    registerAttributeVaB(m_configAndResults._Z_Max, CT_AbstractCategory::DATA_NUMBER, "Z_Max");
    registerAttributeVaB(m_configAndResults._Intensity_Min, CT_AbstractCategory::DATA_NUMBER, "Intensity_Min");
    registerAttributeVaB(m_configAndResults._Intensity_Max, CT_AbstractCategory::DATA_NUMBER, "Intensity_Max");
    registerAttributeVaB(m_configAndResults._Return_Number_Min, CT_AbstractCategory::DATA_NUMBER, "Return_Number_Min");
    registerAttributeVaB(m_configAndResults._Return_Number_Max, CT_AbstractCategory::DATA_NUMBER, "Return_Number_Max");
    registerAttributeVaB(m_configAndResults._Number_of_Returns_Min, CT_AbstractCategory::DATA_NUMBER, "Number_of_Returns_Min");
    registerAttributeVaB(m_configAndResults._Number_of_Returns_Max, CT_AbstractCategory::DATA_NUMBER, "Number_of_Returns_Max");
    registerAttributeVaB(m_configAndResults._Classification_Flags_Min, CT_AbstractCategory::DATA_NUMBER, "Classification_Flags_Min");
    registerAttributeVaB(m_configAndResults._Classification_Flags_Max, CT_AbstractCategory::DATA_NUMBER, "Classification_Flags_Max");
    registerAttributeVaB(m_configAndResults._Scanner_Channel_Min, CT_AbstractCategory::DATA_NUMBER, "Scanner_Channel_Min");
    registerAttributeVaB(m_configAndResults._Scanner_Channel_Max, CT_AbstractCategory::DATA_NUMBER, "Scanner_Channel_Max");
    registerAttributeVaB(m_configAndResults._Scan_Direction_Flag_Min, CT_AbstractCategory::DATA_NUMBER, "Scan_Direction_Flag_Min");
    registerAttributeVaB(m_configAndResults._Scan_Direction_Flag_Max, CT_AbstractCategory::DATA_NUMBER, "Scan_Direction_Flag_Max");
    registerAttributeVaB(m_configAndResults._Edge_of_Flight_Line_Min, CT_AbstractCategory::DATA_NUMBER, "Edge_of_Flight_Line_Min");
    registerAttributeVaB(m_configAndResults._Edge_of_Flight_Line_Max, CT_AbstractCategory::DATA_NUMBER, "Edge_of_Flight_Line_Max");
    registerAttributeVaB(m_configAndResults._Classification_Min, CT_AbstractCategory::DATA_NUMBER, "Classification_Min");
    registerAttributeVaB(m_configAndResults._Classification_Max, CT_AbstractCategory::DATA_NUMBER, "Classification_Max");
    registerAttributeVaB(m_configAndResults._Scan_Angle_Rank_Min, CT_AbstractCategory::DATA_NUMBER, "Scan_Angle_Rank_Min");
    registerAttributeVaB(m_configAndResults._Scan_Angle_Rank_Max, CT_AbstractCategory::DATA_NUMBER, "Scan_Angle_Rank_Max");
    registerAttributeVaB(m_configAndResults._Scan_Angle_Rank_Ext_Min, CT_AbstractCategory::DATA_NUMBER, "Scan_Angle_Rank_Extended_Min");
    registerAttributeVaB(m_configAndResults._Scan_Angle_Rank_Ext_Max, CT_AbstractCategory::DATA_NUMBER, "Scan_Angle_Rank_Extended_Max");
    registerAttributeVaB(m_configAndResults._User_Data_Min, CT_AbstractCategory::DATA_NUMBER, "User_Data_Min");
    registerAttributeVaB(m_configAndResults._User_Data_Max, CT_AbstractCategory::DATA_NUMBER, "User_Data_Max");
    registerAttributeVaB(m_configAndResults._Point_Source_ID_Min, CT_AbstractCategory::DATA_NUMBER, "Point_Source_ID_Min");
    registerAttributeVaB(m_configAndResults._Point_Source_ID_Max, CT_AbstractCategory::DATA_NUMBER, "Point_Source_ID_Max");
    registerAttributeVaB(m_configAndResults._GPS_Time_Min, CT_AbstractCategory::DATA_NUMBER, "GPS_Time_Min");
    registerAttributeVaB(m_configAndResults._GPS_Time_Max, CT_AbstractCategory::DATA_NUMBER, "GPS_Time_Max");
    registerAttributeVaB(m_configAndResults._Red_Min, CT_AbstractCategory::DATA_NUMBER, "Red_Min");
    registerAttributeVaB(m_configAndResults._Red_Max, CT_AbstractCategory::DATA_NUMBER, "Red_Max");
    registerAttributeVaB(m_configAndResults._Green_Min, CT_AbstractCategory::DATA_NUMBER, "Green_Min");
    registerAttributeVaB(m_configAndResults._Green_Max, CT_AbstractCategory::DATA_NUMBER, "Green_Max");
    registerAttributeVaB(m_configAndResults._Blue_Min, CT_AbstractCategory::DATA_NUMBER, "Blue_Min");
    registerAttributeVaB(m_configAndResults._Blue_Max, CT_AbstractCategory::DATA_NUMBER, "Blue_Max");
}