/****************************************************************************
 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_metricpointcrownshape.h"
#include "ct_pointcloudindex/ct_pointcloudindexvector.h"
#include "ct_iterator/ct_pointiterator.h"

ONF_MetricPointCrownShape::ONF_MetricPointCrownShape(QString pluginName) : CT_AbstractMetric_XYZ(pluginName)
{
    declareAttributes();
}

ONF_MetricPointCrownShape::ONF_MetricPointCrownShape(const ONF_MetricPointCrownShape &other) : CT_AbstractMetric_XYZ(other)
{
    declareAttributes();
    m_configAndResults = other.m_configAndResults;
}
QString ONF_MetricPointCrownShape::getShortDisplayableName() const
{
    return tr("Métriques de forme de houppier (Alti/Ht)");
}

QString ONF_MetricPointCrownShape::getShortDescription() const
{
    return tr("Ces métriques décrivent la forme du sommet d'un houppier (sur les 5 mètres les plus hauts).<br>"
              "Elles sont conçues pour être calculées sur des nuages de points à l'échelle de l'arbre.<br>"
              "Elles n'utilisent que les coodonnées (X, Y, Z), et peuvent fonctionner indifféremment en altitude ou en hauteur.<br>"
              "Attention cependant, en zone de forte pente la soustraction de l'altitude du sol pour passer à un nuage en hauteur, conduit à une déformation du houppier. En cas de fort relief, il est donc conseillé de calculer ces métriques avec des nuages de points par houppier codés en altitude. ");
}

QString ONF_MetricPointCrownShape::getDetailledDescription() const
{
    return tr("Les indicateurs suivants peuvent être calculés :"
              "<ul>"
              "<li><strong>X_Apex</strong> : coordonnées X du point le plus haut (apex). </li>"
              "<li><strong>Y_Apex</strong> : coordonnées Y du point le plus haut (apex)</li>"
              "<li><strong>Z_Apex</strong> : coordonnées Z du point le plus haut (apex)</li>"
              "<li>Ainsi que les métriques suivantes, détaillées ci-dessous : Npu05m, Npu1m, Npu2m, Npu3m, Npu4m, Npu5m, mDZu05m, mDZu1m, mDistZu2m, MDZu3m, MDZu4m, MDistZu5m, mAngu05m, mAngu1m, mAngu2m, mAngu3m, mAngu4m, mAngu5m, mDXYu05m, mDXYu1m, mDXYu2m, mDXYu3m, mDXYu4m, mDtXYnf5m, mDXY05m, mDXY1m, mDXY2m, mDXY3m, mDXY4m, mDXY5m, Slope05m, Slope1m, Slope2m, Slope3m, Slope4m, Slope5m, Convex05m, Convex1m, Convex2m, Convex3m, Convex_4m, AUC1m, AUC2m, AUC3m, AUC4m, AUC5m"
              "</ul>"
              "Les métriques sont calculées sur des tranches de hauteur en descendant depuis l'apex (point le plus haut), et sont codées comme suit."
              "Pour une partie des métriques (Np, mDZ, mAng, mDXY) il s'agit de tranches plus ou moins épaisses mais partant toujours du sommet (suffixées _uXm, u comme under) :"
              "<ul>"
              "<li><strong>u05m</strong> : tranche depuis le sommet, jusqu'à -0.5 m</li>"
              "<li><strong>u1m</strong> : tranche depuis le sommet, jusqu'à -1 m</li>"
              "<li><strong>u2m</strong> : tranche depuis le sommet, jusqu'à -2 m</li>"
              "<li><strong>u3m</strong> : tranche depuis le sommet, jusqu'à -3 m</li>"
              "<li><strong>u4m</strong> : tranche depuis le sommet, jusqu'à -4 m</li>"
              "<li><strong>u5m</strong> : tranche depuis le sommet, jusqu'à -5 m</li>"
              "</ul>"
              "Les métriques calculées sur ces tranches, sont les suivantes :"
              "<ul>"
              "<li><strong>Np</strong> : Nombre de points total de la tranche</li>"
              "<li><strong>mDZ</strong> en mètres : Moyenne de la distance verticale entre chaque point de la tranche et l'apex (points projetés sur l'axe Z)</li>"
              "<li><strong>mDXY</strong> en mètres : Moyenne de la distance horizontale entre chaque point de la tranche et l'apex (points projetés sur le plan (X,Y))</li>"
              "<li><strong>mAng</strong> en degrés: Moyenne de l'angle des points de la tranche depuis l'apex : Moyenne(atan(DXY/DZ))</li>"
              "</ul>"
              "Pour les autres métriques (DXY, Slope, Convex, AUC) il s'agit de tranches successives, centrées sur les hauteurs indiquées H (suffixées _Xm) :"
              "<ul>"
              "<li><strong>05m</strong> : tranche de -0.25 m à -0.75 m depuis le sommet</li>"
              "<li><strong>1m</strong> : tranche de -0.75 m à -1.25 m depuis le sommet</li>"
              "<li><strong>2m</strong> : tranche de -1.5 m à -2.5 m depuis le sommet</li>"
              "<li><strong>3m</strong> : tranche de -2.5 m à -3.5 m depuis le sommet</li>"
              "<li><strong>4m</strong> : tranche de -3.5 m à -4.5 m depuis le sommet</li>"
              "<li><strong>5m</strong> : tranche de -4.5 m à -5.5 m depuis le sommet</li>"
              "</ul>"
              "Les métriques calculées sur ces tranches, sont les suivantes :"
              "<ul>"
              "<li><strong>mDXY</strong> en mètres : Moyenne de la distance horizontale entre chaque point de la tranche et l'apex (points projetés sur le plan (X,Y))</li>"
              "<li><strong>Slope</strong> : Pente depuis la tranche précédente. </li>"
              "<li><strong>Convex</strong> : Convexité depuis la tranche précédente</li>"
              "<li><strong>AUC</strong> : Aire sous la courbe depuis le sommet, jusqu'au centre de la tranche</li>"
              "</ul>"
              "L'idée des métriques Slope, Convexity et Area Under Curve (AUC), est de décrire un \"profil de forme du houppier\" en deux dimensions (distance XY moyenne à l'apex ; Z).<br>"
              "Pour cela, pour chacune des tranches [-0.25;-0.75] [-0.75;-1.25] [-1.5;-2.5] [-2.5;-3.5] [-3.5;-4.5] [-4.5;-5.5], une distance moyenne horizontale (XY) des points à l'apex est calculée, en ne prenant en compte que les points qui sont à plus ou moins un écart-type de la distance horizontale moyenne de ces points.<br>"
              "Le profil est ainsi consitué sur un graphique à deux dimensions, de \"points moyens\" ayant pour coordonnée X de cette distance moyenne, et pour coordonnée Z la hauteur du centre de la tranche.<br>"
              "L'indicateur Slope_Xm, donne en degrés, la pente reliant un point moyen de ce profil à celui de la tranche précédente (au-dessus). Par exemple Slope_0_5m est la pente entre l'apex et le point moyen de la tranche [-0.25;-0.75], et Slope_3m est la pente entre le point moyen de la tranche [-1.5;-2.5] et le point moyen de la tranche [-2.5;-3.5]<br>"
              "L'indicateur Convexity_Xm donne la convexités pour deux pentes successives (tranche indiquée + précédente.<br>"
              "L'indicateur AreaUnderCurve donne l'aire sous le profil jusqu'à la tranche indiquée."
              );
}

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

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

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

void ONF_MetricPointCrownShape::computeMetric()
{
    m_configAndResults._X_Apex.value = std::numeric_limits<double>::quiet_NaN();
    m_configAndResults._Y_Apex.value = std::numeric_limits<double>::quiet_NaN();
    m_configAndResults._Z_Apex.value = -std::numeric_limits<double>::max();
    m_configAndResults._NbPts_u0_5m.value = 0;
    m_configAndResults._NbPts_u1m.value = 0;
    m_configAndResults._NbPts_u2m.value = 0;
    m_configAndResults._NbPts_u3m.value = 0;
    m_configAndResults._NbPts_u4m.value = 0;
    m_configAndResults._NbPts_u5m.value = 0;
    m_configAndResults._MeanDistZ_u0_5m.value = 0;
    m_configAndResults._MeanDistZ_u1m.value = 0;
    m_configAndResults._MeanDistZ_u2m.value = 0;
    m_configAndResults._MeanDistZ_u3m.value = 0;
    m_configAndResults._MeanDistZ_u4m.value = 0;
    m_configAndResults._MeanDistZ_u5m.value = 0;
    m_configAndResults._MeanAngle_u0_5m.value = 0;
    m_configAndResults._MeanAngle_u1m.value = 0;
    m_configAndResults._MeanAngle_u2m.value = 0;
    m_configAndResults._MeanAngle_u3m.value = 0;
    m_configAndResults._MeanAngle_u4m.value = 0;
    m_configAndResults._MeanAngle_u5m.value = 0;
    m_configAndResults._MeanDistXY_u0_5m.value = 0;
    m_configAndResults._MeanDistXY_u1m.value = 0;
    m_configAndResults._MeanDistXY_u2m.value = 0;
    m_configAndResults._MeanDistXY_u3m.value = 0;
    m_configAndResults._MeanDistXY_u4m.value = 0;
    m_configAndResults._MeanDistXY_u5m.value = 0;
    m_configAndResults._DistXY_0_5m.value = 0;
    m_configAndResults._DistXY_1m.value = 0;
    m_configAndResults._DistXY_2m.value = 0;
    m_configAndResults._DistXY_3m.value = 0;
    m_configAndResults._DistXY_4m.value = 0;
    m_configAndResults._DistXY_5m.value = 0;
    m_configAndResults._Slope_0_5m.value = 0;
    m_configAndResults._Slope_1m.value = 0;
    m_configAndResults._Slope_2m.value = 0;
    m_configAndResults._Slope_3m.value = 0;
    m_configAndResults._Slope_4m.value = 0;
    m_configAndResults._Slope_5m.value = 0;
    m_configAndResults._Convexity_0_5m.value = 0;
    m_configAndResults._Convexity_1m.value = 0;
    m_configAndResults._Convexity_2m.value = 0;
    m_configAndResults._Convexity_3m.value = 0;
    m_configAndResults._Convexity_4m.value = 0;
    m_configAndResults._AreaUnderCurve_1m.value = 0;
    m_configAndResults._AreaUnderCurve_2m.value = 0;
    m_configAndResults._AreaUnderCurve_3m.value = 0;
    m_configAndResults._AreaUnderCurve_4m.value = 0;
    m_configAndResults._AreaUnderCurve_5m.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)))
        {
            if (point(2) > m_configAndResults._Z_Apex.value)
            {
                m_configAndResults._X_Apex.value = point(0);
                m_configAndResults._Y_Apex.value = point(1);
                m_configAndResults._Z_Apex.value = point(2);
            }
        }                
    }

    double MeanDXY_0_5m = 0;
    double MeanDXY_1m = 0;
    double MeanDXY_2m = 0;
    double MeanDXY_3m = 0;
    double MeanDXY_4m = 0;
    double MeanDXY_5m = 0;

    double MeanDXYcorr_0_5m = 0;
    double MeanDXYcorr_1m = 0;
    double MeanDXYcorr_2m = 0;
    double MeanDXYcorr_3m = 0;
    double MeanDXYcorr_4m = 0;
    double MeanDXYcorr_5m = 0;

    double SDpartDXY_0_5m = 0;
    double SDpartDXY_1m = 0;
    double SDpartDXY_2m = 0;
    double SDpartDXY_3m = 0;
    double SDpartDXY_4m = 0;
    double SDpartDXY_5m = 0;

    double SDDXY_0_5m = 0;
    double SDDXY_1m = 0;
    double SDDXY_2m = 0;
    double SDDXY_3m = 0;
    double SDDXY_4m = 0;
    double SDDXY_5m = 0;
    QList<double> distsXY_0_5m;
    QList<double> distsXY_1m;
    QList<double> distsXY_2m;
    QList<double> distsXY_3m;
    QList<double> distsXY_4m;
    QList<double> distsXY_5m;

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

        if ((plotArea() == nullptr) || plotArea()->contains(point(0), point(1)))
        {

            double distXY = sqrt(pow(m_configAndResults._X_Apex.value - point(0), 2) + pow(m_configAndResults._Y_Apex.value - point(1), 2));
            double distZ = m_configAndResults._Z_Apex.value - point(2);
            double angleRad = 0;
            if (distZ > 0) {angleRad = std::atan(distXY / distZ);}
            double angleDegrees = angleRad * 180.0 / M_PI;

            // Calcul des indicateurs simples par distance Z
            if (distZ < 0.5)
            {
                m_configAndResults._NbPts_u0_5m.value += 1.0;
                m_configAndResults._MeanDistZ_u0_5m.value += distZ;
                m_configAndResults._MeanAngle_u0_5m.value += angleDegrees;
                m_configAndResults._MeanDistXY_u0_5m.value += distXY;
            }
            if (distZ < 1)
            {
                m_configAndResults._NbPts_u1m.value += 1.0;
                m_configAndResults._MeanDistZ_u1m.value += distZ;
                m_configAndResults._MeanAngle_u1m.value += angleDegrees;
                m_configAndResults._MeanDistXY_u1m.value += distXY;
            }
            if (distZ < 2)
            {
                m_configAndResults._NbPts_u2m.value += 1.0;
                m_configAndResults._MeanDistZ_u2m.value += distZ;
                m_configAndResults._MeanAngle_u2m.value += angleDegrees;
                m_configAndResults._MeanDistXY_u2m.value += distXY;
            }
            if (distZ < 3)
            {
                m_configAndResults._NbPts_u3m.value += 1.0;
                m_configAndResults._MeanDistZ_u3m.value += distZ;
                m_configAndResults._MeanAngle_u3m.value += angleDegrees;
                m_configAndResults._MeanDistXY_u3m.value += distXY;
            }
            if (distZ < 4)
            {
                m_configAndResults._NbPts_u4m.value += 1.0;
                m_configAndResults._MeanDistZ_u4m.value += distZ;
                m_configAndResults._MeanAngle_u4m.value += angleDegrees;
                m_configAndResults._MeanDistXY_u4m.value += distXY;
            }
            if (distZ < 5)
            {
                m_configAndResults._NbPts_u5m.value += 1.0;
                m_configAndResults._MeanDistZ_u5m.value += distZ;
                m_configAndResults._MeanAngle_u5m.value += angleDegrees;
                m_configAndResults._MeanDistXY_u5m.value += distXY;
            }


            // Calculs des moyennes et écarts-types des distances XY par tranche

                if (distZ >= 0.25 && distZ < 0.75)
                {
                    MeanDXY_0_5m += distXY;
                    SDpartDXY_0_5m += distXY*distXY;
                    distsXY_0_5m.append(distXY);
                } else if (distZ >= 0.75 && distZ < 1.25)
                {
                    MeanDXY_1m += distXY;
                    SDpartDXY_1m += distXY*distXY;
                    distsXY_1m.append(distXY);
                } else if (distZ >= 1.50 && distZ < 2.50)
                {
                    MeanDXY_2m += distXY;
                    SDpartDXY_2m += distXY*distXY;
                    distsXY_2m.append(distXY);
                } else if (distZ >= 2.50 && distZ < 3.50)
                {
                    MeanDXY_3m += distXY;
                    SDpartDXY_3m += distXY*distXY;
                    distsXY_3m.append(distXY);
                } else if (distZ >= 3.50 && distZ < 4.50)
                {
                    MeanDXY_4m += distXY;
                    SDpartDXY_4m += distXY*distXY;
                    distsXY_4m.append(distXY);
                } else if (distZ >= 4.50 && distZ < 5.50)
                {
                    MeanDXY_5m += distXY;
                    SDpartDXY_5m += distXY*distXY;
                    distsXY_5m.append(distXY);
                }
        }
    }

    // Finalisation des calculs des indicateurs simples par distance Z
    if (m_configAndResults._NbPts_u0_5m.value > 0)
    {
        m_configAndResults._MeanDistZ_u0_5m.value /= m_configAndResults._NbPts_u0_5m.value;
        m_configAndResults._MeanAngle_u0_5m.value /= m_configAndResults._NbPts_u0_5m.value;
        m_configAndResults._MeanDistXY_u0_5m.value /= m_configAndResults._NbPts_u0_5m.value;
    }
    if (m_configAndResults._NbPts_u1m.value > 0)
    {
        m_configAndResults._MeanDistZ_u1m.value /= m_configAndResults._NbPts_u1m.value;
        m_configAndResults._MeanAngle_u1m.value /= m_configAndResults._NbPts_u1m.value;
        m_configAndResults._MeanDistXY_u1m.value /= m_configAndResults._NbPts_u1m.value;
    }
    if (m_configAndResults._NbPts_u2m.value > 0)
    {
        m_configAndResults._MeanDistZ_u2m.value /= m_configAndResults._NbPts_u2m.value;
        m_configAndResults._MeanAngle_u2m.value /= m_configAndResults._NbPts_u2m.value;
        m_configAndResults._MeanDistXY_u2m.value /= m_configAndResults._NbPts_u2m.value;
    }
    if (m_configAndResults._NbPts_u3m.value > 0)
    {
        m_configAndResults._MeanDistZ_u3m.value /= m_configAndResults._NbPts_u3m.value;
        m_configAndResults._MeanAngle_u3m.value /= m_configAndResults._NbPts_u3m.value;
        m_configAndResults._MeanDistXY_u3m.value /= m_configAndResults._NbPts_u3m.value;
    }
    if (m_configAndResults._NbPts_u4m.value > 0)
    {
        m_configAndResults._MeanDistZ_u4m.value /= m_configAndResults._NbPts_u4m.value;
        m_configAndResults._MeanAngle_u4m.value /= m_configAndResults._NbPts_u4m.value;
        m_configAndResults._MeanDistXY_u4m.value /= m_configAndResults._NbPts_u4m.value;
    }
    if (m_configAndResults._NbPts_u5m.value > 0)
    {
        m_configAndResults._MeanDistZ_u5m.value /= m_configAndResults._NbPts_u5m.value;
        m_configAndResults._MeanAngle_u5m.value /= m_configAndResults._NbPts_u5m.value;
        m_configAndResults._MeanDistXY_u5m.value /= m_configAndResults._NbPts_u5m.value;
    }




    // Finalisation des calculs des moyennes et écarts-types des distances XY par tranche
    if (distsXY_0_5m.size() > 0)
    {
        MeanDXY_0_5m /= distsXY_0_5m.size();
        SDDXY_0_5m = std::sqrt(SDpartDXY_0_5m/distsXY_0_5m.size() - MeanDXY_0_5m*MeanDXY_0_5m);

        int nval = 0;
        for (int i = 0 ; i < distsXY_0_5m.size() ; i++)
        {
            double disti = distsXY_0_5m.at(i);
            if (disti > (MeanDXY_0_5m - SDDXY_0_5m) && disti < (MeanDXY_0_5m + SDDXY_0_5m))
            {
                MeanDXYcorr_0_5m += disti;
                nval++;
            }
        }
        if (nval > 0) {MeanDXYcorr_0_5m /= nval;}
    }
    if (distsXY_1m.size() > 0)
    {
        MeanDXY_1m /= distsXY_1m.size();
        SDDXY_1m = std::sqrt(SDpartDXY_1m/distsXY_1m.size() - MeanDXY_1m*MeanDXY_1m);
        int nval = 0;
        for (int i = 0 ; i < distsXY_1m.size() ; i++)
        {
            double disti = distsXY_1m.at(i);
            if (disti > (MeanDXY_1m - SDDXY_1m) && disti < (MeanDXY_1m + SDDXY_1m))
            {
                MeanDXYcorr_1m += disti;
                nval++;
            }
        }
        if (nval > 0) {MeanDXYcorr_1m /= nval;}
    }
    if (distsXY_2m.size() > 0)
    {
        MeanDXY_2m /= distsXY_2m.size();
        SDDXY_2m = std::sqrt(SDpartDXY_2m/distsXY_2m.size() - MeanDXY_2m*MeanDXY_2m);

        int nval = 0;
        for (int i = 0 ; i < distsXY_2m.size() ; i++)
        {
            double disti = distsXY_2m.at(i);
            if (disti > (MeanDXY_2m - SDDXY_2m) && disti < (MeanDXY_2m + SDDXY_2m))
            {
                MeanDXYcorr_2m += disti;
                nval++;
            }
        }
        if (nval > 0) {MeanDXYcorr_2m /= nval;}
    }
    if (distsXY_3m.size() > 0)
    {
        MeanDXY_3m /= distsXY_3m.size();
        SDDXY_3m = std::sqrt(SDpartDXY_3m/distsXY_3m.size() - MeanDXY_3m*MeanDXY_3m);

        int nval = 0;
        for (int i = 0 ; i < distsXY_3m.size() ; i++)
        {
            double disti = distsXY_3m.at(i);
            if (disti > (MeanDXY_3m - SDDXY_3m) && disti < (MeanDXY_3m + SDDXY_3m))
            {
                MeanDXYcorr_3m += disti;
                nval++;
            }
        }
        if (nval > 0) {MeanDXYcorr_3m /= nval;}
    }
    if (distsXY_4m.size() > 0)
    {
        MeanDXY_4m /= distsXY_4m.size();
        SDDXY_4m = std::sqrt(SDpartDXY_4m/distsXY_4m.size() - MeanDXY_4m*MeanDXY_4m);

        int nval = 0;
        for (int i = 0 ; i < distsXY_4m.size() ; i++)
        {
            double disti = distsXY_4m.at(i);
            if (disti > (MeanDXY_4m - SDDXY_4m) && disti < (MeanDXY_4m + SDDXY_4m))
            {
                MeanDXYcorr_4m += disti;
                nval++;
            }
        }
        if (nval > 0) {MeanDXYcorr_4m /= nval;}
    }
    if (distsXY_5m.size() > 0)
    {
        MeanDXY_5m /= distsXY_5m.size();
        SDDXY_5m = std::sqrt(SDpartDXY_5m/distsXY_5m.size() - MeanDXY_5m*MeanDXY_5m);

        int nval = 0;
        for (int i = 0 ; i < distsXY_5m.size() ; i++)
        {
            double disti = distsXY_5m.at(i);
            if (disti > (MeanDXY_5m - SDDXY_5m) && disti < (MeanDXY_5m + SDDXY_5m))
            {
                MeanDXYcorr_5m += disti;
                nval++;
            }
        }
        if (nval > 0) {MeanDXYcorr_5m /= nval;}
    }

    m_configAndResults._DistXY_0_5m.value = MeanDXY_0_5m;
    m_configAndResults._DistXY_1m.value   = MeanDXY_1m;
    m_configAndResults._DistXY_2m.value   = MeanDXY_2m;
    m_configAndResults._DistXY_3m.value   = MeanDXY_3m;
    m_configAndResults._DistXY_4m.value   = MeanDXY_4m;
    m_configAndResults._DistXY_5m.value   = MeanDXY_5m;

    m_configAndResults._Slope_0_5m.value = std::atan((MeanDXYcorr_0_5m - 0.0)              / (0.5 - 0.0));
    m_configAndResults._Slope_1m.value =   std::atan((MeanDXYcorr_1m   - MeanDXYcorr_0_5m) / (1.0 - 0.5));
    m_configAndResults._Slope_2m.value =   std::atan((MeanDXYcorr_2m   - MeanDXYcorr_1m)   / (2.0 - 1.0));
    m_configAndResults._Slope_3m.value =   std::atan((MeanDXYcorr_3m   - MeanDXYcorr_2m)   / (3.0 - 2.0));
    m_configAndResults._Slope_4m.value =   std::atan((MeanDXYcorr_4m   - MeanDXYcorr_3m)   / (4.0 - 3.0));
    m_configAndResults._Slope_5m.value =   std::atan((MeanDXYcorr_5m   - MeanDXYcorr_4m)   / (5.0 - 4.0));

    m_configAndResults._Convexity_0_5m.value = std::atan((m_configAndResults._Slope_1m.value - m_configAndResults._Slope_0_5m.value) / (0.75 - 0.25));
    m_configAndResults._Convexity_1m.value =   std::atan((m_configAndResults._Slope_2m.value - m_configAndResults._Slope_1m.value)   / (1.25 - 0.75));
    m_configAndResults._Convexity_2m.value =   std::atan((m_configAndResults._Slope_3m.value - m_configAndResults._Slope_2m.value)   / (2.50 - 1.50));
    m_configAndResults._Convexity_3m.value =   std::atan((m_configAndResults._Slope_4m.value - m_configAndResults._Slope_3m.value)   / (3.50 - 2.50));
    m_configAndResults._Convexity_4m.value =   std::atan((m_configAndResults._Slope_5m.value - m_configAndResults._Slope_4m.value)   / (4.50 - 3.50));

    m_configAndResults._Slope_0_5m.value *= (180.0/M_PI);
    m_configAndResults._Slope_1m.value   *= (180.0/M_PI);
    m_configAndResults._Slope_2m.value   *= (180.0/M_PI);
    m_configAndResults._Slope_3m.value   *= (180.0/M_PI);
    m_configAndResults._Slope_4m.value   *= (180.0/M_PI);
    m_configAndResults._Slope_5m.value   *= (180.0/M_PI);

    if (MeanDXYcorr_1m > 0) {m_configAndResults._AreaUnderCurve_1m.value = (MeanDXYcorr_0_5m + 0.5*MeanDXYcorr_1m) / (1.0*MeanDXYcorr_1m);}
    if (MeanDXYcorr_2m > 0) {m_configAndResults._AreaUnderCurve_2m.value = (MeanDXYcorr_0_5m + 1.5*MeanDXYcorr_1m + 1.0*MeanDXYcorr_2m) / (2.0*MeanDXYcorr_2m);}
    if (MeanDXYcorr_3m > 0) {m_configAndResults._AreaUnderCurve_3m.value = (MeanDXYcorr_0_5m + 1.5*MeanDXYcorr_1m + 2.0*MeanDXYcorr_2m + 1.0*MeanDXYcorr_3m) / (3.0*MeanDXYcorr_3m);}
    if (MeanDXYcorr_4m > 0) {m_configAndResults._AreaUnderCurve_4m.value = (MeanDXYcorr_0_5m + 1.5*MeanDXYcorr_1m + 2.0*MeanDXYcorr_2m + 2.0*MeanDXYcorr_3m + 1.0*MeanDXYcorr_4m) / (4.0*MeanDXYcorr_4m);}
    if (MeanDXYcorr_5m > 0) {m_configAndResults._AreaUnderCurve_5m.value = (MeanDXYcorr_0_5m + 1.5*MeanDXYcorr_1m + 2.0*MeanDXYcorr_2m + 2.0*MeanDXYcorr_3m + 2.0*MeanDXYcorr_4m + 1.0*MeanDXYcorr_5m) / (5.0*MeanDXYcorr_5m);}

    setAttributeValueVaB(m_configAndResults._X_Apex);
    setAttributeValueVaB(m_configAndResults._Y_Apex);
    setAttributeValueVaB(m_configAndResults._Z_Apex);

    setAttributeValueVaB(m_configAndResults._NbPts_u0_5m);
    setAttributeValueVaB(m_configAndResults._NbPts_u1m);
    setAttributeValueVaB(m_configAndResults._NbPts_u2m);
    setAttributeValueVaB(m_configAndResults._NbPts_u3m);
    setAttributeValueVaB(m_configAndResults._NbPts_u4m);
    setAttributeValueVaB(m_configAndResults._NbPts_u5m);
    setAttributeValueVaB(m_configAndResults._MeanDistZ_u0_5m);
    setAttributeValueVaB(m_configAndResults._MeanDistZ_u1m);
    setAttributeValueVaB(m_configAndResults._MeanDistZ_u2m);
    setAttributeValueVaB(m_configAndResults._MeanDistZ_u3m);
    setAttributeValueVaB(m_configAndResults._MeanDistZ_u4m);
    setAttributeValueVaB(m_configAndResults._MeanDistZ_u5m);
    setAttributeValueVaB(m_configAndResults._MeanAngle_u0_5m);
    setAttributeValueVaB(m_configAndResults._MeanAngle_u1m);
    setAttributeValueVaB(m_configAndResults._MeanAngle_u2m);
    setAttributeValueVaB(m_configAndResults._MeanAngle_u3m);
    setAttributeValueVaB(m_configAndResults._MeanAngle_u4m);
    setAttributeValueVaB(m_configAndResults._MeanAngle_u5m);
    setAttributeValueVaB(m_configAndResults._MeanDistXY_u0_5m);
    setAttributeValueVaB(m_configAndResults._MeanDistXY_u1m);
    setAttributeValueVaB(m_configAndResults._MeanDistXY_u2m);
    setAttributeValueVaB(m_configAndResults._MeanDistXY_u3m);
    setAttributeValueVaB(m_configAndResults._MeanDistXY_u4m);
    setAttributeValueVaB(m_configAndResults._MeanDistXY_u5m);

    setAttributeValueVaB(m_configAndResults._DistXY_0_5m);
    setAttributeValueVaB(m_configAndResults._DistXY_1m);
    setAttributeValueVaB(m_configAndResults._DistXY_2m);
    setAttributeValueVaB(m_configAndResults._DistXY_3m);
    setAttributeValueVaB(m_configAndResults._DistXY_4m);
    setAttributeValueVaB(m_configAndResults._DistXY_5m);
    setAttributeValueVaB(m_configAndResults._Slope_0_5m);
    setAttributeValueVaB(m_configAndResults._Slope_1m);
    setAttributeValueVaB(m_configAndResults._Slope_2m);
    setAttributeValueVaB(m_configAndResults._Slope_3m);
    setAttributeValueVaB(m_configAndResults._Slope_4m);
    setAttributeValueVaB(m_configAndResults._Slope_5m);
    setAttributeValueVaB(m_configAndResults._Convexity_0_5m);
    setAttributeValueVaB(m_configAndResults._Convexity_1m);
    setAttributeValueVaB(m_configAndResults._Convexity_2m);
    setAttributeValueVaB(m_configAndResults._Convexity_3m);
    setAttributeValueVaB(m_configAndResults._Convexity_4m);
    setAttributeValueVaB(m_configAndResults._AreaUnderCurve_1m);
    setAttributeValueVaB(m_configAndResults._AreaUnderCurve_2m);
    setAttributeValueVaB(m_configAndResults._AreaUnderCurve_3m);
    setAttributeValueVaB(m_configAndResults._AreaUnderCurve_4m);
    setAttributeValueVaB(m_configAndResults._AreaUnderCurve_5m);
}

void ONF_MetricPointCrownShape::declareAttributes()
{    
    registerAttributeVaB(m_configAndResults._X_Apex, CT_AbstractCategory::DATA_X, "X_Apex");
    registerAttributeVaB(m_configAndResults._Y_Apex, CT_AbstractCategory::DATA_Y, "Y_Apex");
    registerAttributeVaB(m_configAndResults._Z_Apex, CT_AbstractCategory::DATA_NUMBER, "Z_Apex");
    registerAttributeVaB(m_configAndResults._NbPts_u0_5m, CT_AbstractCategory::DATA_NUMBER, "Npu05m");
    registerAttributeVaB(m_configAndResults._NbPts_u1m, CT_AbstractCategory::DATA_NUMBER, "Npu1m");
    registerAttributeVaB(m_configAndResults._NbPts_u2m, CT_AbstractCategory::DATA_NUMBER, "Npu2m");
    registerAttributeVaB(m_configAndResults._NbPts_u3m, CT_AbstractCategory::DATA_NUMBER, "Npu3m");
    registerAttributeVaB(m_configAndResults._NbPts_u4m, CT_AbstractCategory::DATA_NUMBER, "Npu4m");
    registerAttributeVaB(m_configAndResults._NbPts_u5m, CT_AbstractCategory::DATA_NUMBER, "Npu5m");
    registerAttributeVaB(m_configAndResults._MeanDistZ_u0_5m, CT_AbstractCategory::DATA_NUMBER, "mDZu05m");
    registerAttributeVaB(m_configAndResults._MeanDistZ_u1m, CT_AbstractCategory::DATA_NUMBER, "mDZu1m");
    registerAttributeVaB(m_configAndResults._MeanDistZ_u2m, CT_AbstractCategory::DATA_NUMBER, "mDZu2m");
    registerAttributeVaB(m_configAndResults._MeanDistZ_u3m, CT_AbstractCategory::DATA_NUMBER, "mDZu3m");
    registerAttributeVaB(m_configAndResults._MeanDistZ_u4m, CT_AbstractCategory::DATA_NUMBER, "mDZu4m");
    registerAttributeVaB(m_configAndResults._MeanDistZ_u5m, CT_AbstractCategory::DATA_NUMBER, "mDZu5m");
    registerAttributeVaB(m_configAndResults._MeanDistXY_u0_5m, CT_AbstractCategory::DATA_NUMBER, "mDXYu05m");
    registerAttributeVaB(m_configAndResults._MeanDistXY_u1m, CT_AbstractCategory::DATA_NUMBER, "mDXYu1m");
    registerAttributeVaB(m_configAndResults._MeanDistXY_u2m, CT_AbstractCategory::DATA_NUMBER, "mDXYu2m");
    registerAttributeVaB(m_configAndResults._MeanDistXY_u3m, CT_AbstractCategory::DATA_NUMBER, "mDXYu3m");
    registerAttributeVaB(m_configAndResults._MeanDistXY_u4m, CT_AbstractCategory::DATA_NUMBER, "mDXYu4m");
    registerAttributeVaB(m_configAndResults._MeanDistXY_u5m, CT_AbstractCategory::DATA_NUMBER, "mDXYu5m");
    registerAttributeVaB(m_configAndResults._MeanAngle_u0_5m, CT_AbstractCategory::DATA_NUMBER, "mAngu05m");
    registerAttributeVaB(m_configAndResults._MeanAngle_u1m, CT_AbstractCategory::DATA_NUMBER, "mAngu1m");
    registerAttributeVaB(m_configAndResults._MeanAngle_u2m, CT_AbstractCategory::DATA_NUMBER, "mAngu2m");
    registerAttributeVaB(m_configAndResults._MeanAngle_u3m, CT_AbstractCategory::DATA_NUMBER, "mAngu3m");
    registerAttributeVaB(m_configAndResults._MeanAngle_u4m, CT_AbstractCategory::DATA_NUMBER, "mAngu4m");
    registerAttributeVaB(m_configAndResults._MeanAngle_u5m, CT_AbstractCategory::DATA_NUMBER, "mAngu5m");
    registerAttributeVaB(m_configAndResults._DistXY_0_5m, CT_AbstractCategory::DATA_NUMBER, "mDXY05m");
    registerAttributeVaB(m_configAndResults._DistXY_1m, CT_AbstractCategory::DATA_NUMBER, "mDXY1m");
    registerAttributeVaB(m_configAndResults._DistXY_2m, CT_AbstractCategory::DATA_NUMBER, "mDXY2m");
    registerAttributeVaB(m_configAndResults._DistXY_3m, CT_AbstractCategory::DATA_NUMBER, "mDXY3m");
    registerAttributeVaB(m_configAndResults._DistXY_4m, CT_AbstractCategory::DATA_NUMBER, "mDXY4m");
    registerAttributeVaB(m_configAndResults._DistXY_5m, CT_AbstractCategory::DATA_NUMBER, "mDXY5m");
    registerAttributeVaB(m_configAndResults._Slope_0_5m, CT_AbstractCategory::DATA_NUMBER, "Slope05m");
    registerAttributeVaB(m_configAndResults._Slope_1m, CT_AbstractCategory::DATA_NUMBER, "Slope1m");
    registerAttributeVaB(m_configAndResults._Slope_2m, CT_AbstractCategory::DATA_NUMBER, "Slope2m");
    registerAttributeVaB(m_configAndResults._Slope_3m, CT_AbstractCategory::DATA_NUMBER, "Slope3m");
    registerAttributeVaB(m_configAndResults._Slope_4m, CT_AbstractCategory::DATA_NUMBER, "Slope4m");
    registerAttributeVaB(m_configAndResults._Slope_5m, CT_AbstractCategory::DATA_NUMBER, "Slope5m");
    registerAttributeVaB(m_configAndResults._Convexity_0_5m, CT_AbstractCategory::DATA_NUMBER, "Convex05m");
    registerAttributeVaB(m_configAndResults._Convexity_1m, CT_AbstractCategory::DATA_NUMBER, "Convex1m");
    registerAttributeVaB(m_configAndResults._Convexity_2m, CT_AbstractCategory::DATA_NUMBER, "Convex2m");
    registerAttributeVaB(m_configAndResults._Convexity_3m, CT_AbstractCategory::DATA_NUMBER, "Convex3m");
    registerAttributeVaB(m_configAndResults._Convexity_4m, CT_AbstractCategory::DATA_NUMBER, "Convex4m");
    registerAttributeVaB(m_configAndResults._AreaUnderCurve_1m, CT_AbstractCategory::DATA_NUMBER, "AUC1m");
    registerAttributeVaB(m_configAndResults._AreaUnderCurve_2m, CT_AbstractCategory::DATA_NUMBER, "AUC2m");
    registerAttributeVaB(m_configAndResults._AreaUnderCurve_3m, CT_AbstractCategory::DATA_NUMBER, "AUC3m");
    registerAttributeVaB(m_configAndResults._AreaUnderCurve_4m, CT_AbstractCategory::DATA_NUMBER, "AUC4m");
    registerAttributeVaB(m_configAndResults._AreaUnderCurve_5m, CT_AbstractCategory::DATA_NUMBER, "AUC5m");

}