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

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


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

ONF_MetricIntensity::ONF_MetricIntensity(const ONF_MetricIntensity &other) : CT_AbstractMetric_LAS(other)
{
    declareAttributes();
    m_conf = other.m_conf;
}

QString ONF_MetricIntensity::getShortDisplayableName() const
{
    return tr("Métriques d'intensité (LAS, Alti/Ht)");
}

QString ONF_MetricIntensity::getShortDescription() const
{
    return tr("Calcul d'indicateurs d'intensités. Ces métriques peuvent être calculées indifféremment sur des données en altitude ou en hauteurs.<br>"
              "Les métriques calculées sont le nombre de points, l'intensité mximale, l'intensité moyenne, l'écart-type de l'intensité et le coefficient de variation de l'intensité.<br>"
              "Ces métriques sont déclinées selon différentes catégories de points (cf. détails).");
}

QString ONF_MetricIntensity::getDetailledDescription() const
{
    return tr("Les indicateurs suivants peuvent être calculés :"
              "<ul>"
              "<li><strong>n</strong>, </li>"
              "<li><strong>n_f</strong>, <strong>n0595_f</strong>, <strong>n1090_f</strong>, <strong>ntp25_f</strong>, </li>"
              "<li><strong>n_o</strong>, <strong>n0595_o</strong>, <strong>n1090_o</strong>, <strong>ntp25_o</strong>, </li>"
              "<br>"
              "<li><strong>imx_f</strong>, <strong>imn_f</strong>, <strong>isd_f</strong>, <strong>icv_f</strong>, </li>"
              "<li><strong>imx_o</strong>, <strong>imn_o</strong>, <strong>isd_o</strong>, <strong>icv_o</strong>, </li>"
              "<li><strong>imx_a</strong>, <strong>imn_a</strong>, <strong>isd_a</strong>, <strong>icv_a</strong>, </li>"
              "<br>"
              "<li><strong>i0595mnf</strong>, <strong>i0595sd_f</strong>, <strong>i0595cv_f</strong>, </li>"
              "<li><strong>i0595mno</strong>, <strong>i0595sd_o</strong>, <strong>i0595cv_o</strong>, </li>"
              "<br>"
              "<li><strong>i1090mnf</strong>, <strong>i1090sd_f</strong>, <strong>i1090cv_f</strong>, </li>"
              "<li><strong>i1090mno</strong>, <strong>i1090sd_o</strong>, <strong>i1090cv_o</strong>, </li>"
              "<br>"
              "<li><strong>itp25mnf</strong>, <strong>itp25sd_f</strong>, <strong>itp25cv_f</strong>, </li>"
              "<li><strong>itp25mno</strong>, <strong>itp25sd_o</strong>, <strong>itp25cv_o</strong>, </li>"
              "<br>"
              "<li><strong>ip05_f</strong>, <strong>ip10_f</strong>, <strong>ip25_f</strong>, <strong>ip50_f</strong>, <strong>ip75_f</strong>, <strong>ip90_f</strong>, <strong>ip95_f</strong>, </li>"
              "<li><strong>ip05_o</strong>, <strong>ip10_o</strong>, <strong>ip25_o</strong>, <strong>ip50_o</strong>, <strong>ip75_o</strong>, <strong>ip90_o</strong>, <strong>ip95_o</strong></li>"
              "</ul>"
              "n est le nombre total de points de la zone (tous retours confondus).<br>"
              "Pour les autres métriques, le préfixe signifie : "
              "<ul>"
              "<li><strong>n</strong> : le nombre de points d'un sous-ensemble utilisé pour le calcul</li>"
              "<li><strong>i</strong> : une métrique d'intensité pour le sous-ensemble de points considéré</li>"
              "</ul>"
              "Le type de calcul est codé comme suit :"
              "<ul>"
              "<li><strong>mx</strong> : maximum</li>"
              "<li><strong>mn</strong> : moyenne</li>"
              "<li><strong>sd</strong> : écart-type</li>"
              "<li><strong>cv</strong> : coefficient de variation</li>"
              "</ul>"
              "Le type de retours considérés (définissant le sous-ensemble de points utilisé) est codé comme suit :"
              "<ul>"
              "<li><strong>f</strong> : premiers retours</li>"
              "<li><strong>o</strong> : retours uniques. Il s'agit des retours pour lequels le rayon laser n'a généré aucun autre retour (sous-ensemble des f)</li>"
              "<li><strong>a</strong> : tous les retours</li>"
              "</ul>"
              "Enfin, différentes sélections de points basées sur leur intensité (ou leur coordonnée Z pour tp25) sont proposées :"
              "<ul>"
              "<li><strong>Pas de code</strong> : tous les points f/o</li>"
              "<li><strong>0595</strong> : tous les points f/o situés entre les percentiles 5% et 95% d'intensité. Elimination de 5% des intensités les plus faibles et les plus fortes.</li>"
              "<li><strong>1090</strong> : tous les points f/o situés entre les percentiles 10% et 90% d'intensité. Elimination de 10% des intensités les plus faibles et les plus fortes.</li>"
              "<li><strong>tp25</strong> : tous les points situés dans les 25% les plus hauts de la plage de hauteurs des points f/o</li>"
              "</ul>"
              "<strong>P05, P10, P25, P50, P75, P90 et P95</strong> correspondent aux percentiles d'intensité 5%, 10%, 25%, , 50%, 75%, 90% et 95%, pour les points f/o.<br>"
              "<br>Par exemple :"
              "<ul>"
              "<li><strong>i0595mn_f</strong> correspond à la moyenne des intensités, des points f, situées entre les percentiles 5% et 95% d'intensité (en ne tenant compte que des points f)</li>"
              "<li><strong>itp25sd_f</strong> correpond à l'écart-type des intensités des 25% de points f les plus hauts</li>"
              "<li><strong>ip25_o</strong> correspond au percentile 25% d'intensité des points o</li>"
              "</ul>");
}


ONF_MetricIntensity::Config ONF_MetricIntensity::metricConfiguration() const
{
    return m_conf;
}

void ONF_MetricIntensity::setMetricConfiguration(const ONF_MetricIntensity::Config &conf)
{
    m_conf = conf;
}

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

void ONF_MetricIntensity::computeMetric()
{    
    m_conf.n.value = 0;

    m_conf.n_f.value = 0;
    m_conf.n_o.value = 0;
    m_conf.n0595_f.value = 0;
    m_conf.n0595_o.value = 0;
    m_conf.n1090_f.value = 0;
    m_conf.n1090_o.value = 0;
    m_conf.ntp25_f.value = 0;
    m_conf.ntp25_o.value = 0;

    m_conf.imx_f.value = -std::numeric_limits<double>::max();
    m_conf.imn_f.value = 0;
    m_conf.isd_f.value = 0;
    m_conf.icv_f.value = 0;

    m_conf.imx_o.value = -std::numeric_limits<double>::max();
    m_conf.imn_o.value = 0;
    m_conf.isd_o.value = 0;
    m_conf.icv_o.value = 0;

    m_conf.imx_a.value = -std::numeric_limits<double>::max();
    m_conf.imn_a.value = 0;
    m_conf.isd_a.value = 0;
    m_conf.icv_a.value = 0;

    m_conf.i0595mn_f.value = 0;
    m_conf.i0595sd_f.value = 0;
    m_conf.i0595cv_f.value = 0;

    m_conf.i0595mn_o.value = 0;
    m_conf.i0595sd_o.value = 0;
    m_conf.i0595cv_o.value = 0;

    m_conf.i1090mn_f.value = 0;
    m_conf.i1090sd_f.value = 0;
    m_conf.i1090cv_f.value = 0;

    m_conf.i1090mn_o.value = 0;
    m_conf.i1090sd_o.value = 0;
    m_conf.i1090cv_o.value = 0;

    m_conf.ip05_f.value = 0;
    m_conf.ip10_f.value = 0;
    m_conf.ip25_f.value = 0;
    m_conf.ip50_f.value = 0;
    m_conf.ip75_f.value = 0;
    m_conf.ip90_f.value = 0;
    m_conf.ip95_f.value = 0;

    m_conf.ip05_o.value = 0;
    m_conf.ip10_o.value = 0;
    m_conf.ip25_o.value = 0;
    m_conf.ip50_o.value = 0;
    m_conf.ip75_o.value = 0;
    m_conf.ip90_o.value = 0;
    m_conf.ip95_o.value = 0;

    m_conf.itp25mn_f.value = 0;
    m_conf.itp25sd_f.value = 0;
    m_conf.itp25cv_f.value = 0;

    m_conf.itp25mn_o.value = 0;
    m_conf.itp25sd_o.value = 0;
    m_conf.itp25cv_o.value = 0;

    QList<double> i_f;
    QList<double> i_o;
    QMultiMap<double, double> tp25f;
    QMultiMap<double, double> tp25o;
    double minZ_f = std::numeric_limits<double>::max();
    double maxZ_f = -std::numeric_limits<double>::max();

    double minZ_o = std::numeric_limits<double>::max();
    double maxZ_o = -std::numeric_limits<double>::max();

    CT_AbstractPointAttributesScalar* attributeReturnNumber = static_cast<CT_AbstractPointAttributesScalar*>(lasAttributes()->pointsAttributesAt(CT_LasDefine::Return_Number));
    CT_AbstractPointAttributesScalar* attributeNumber_of_Returns = static_cast<CT_AbstractPointAttributesScalar*>(lasAttributes()->pointsAttributesAt(CT_LasDefine::Number_of_Returns));
    CT_AbstractPointAttributesScalar* attributeIntensity = static_cast<CT_AbstractPointAttributesScalar*>(lasAttributes()->pointsAttributesAt(CT_LasDefine::Intensity));

    if((attributeReturnNumber != nullptr)
            && (attributeNumber_of_Returns != nullptr)
            && (attributeIntensity != nullptr))
    {
        bool rnHasBeenSet;
        bool norHasBeenSet;
        bool intensityHasBeenSet;

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

            if ((plotArea() == nullptr) || plotArea()->contains(point(0), point(1)))
            {
                ++(m_conf.n.value);

                const size_t index = itP.currentGlobalIndex();

                const quint16 returnNumber = quint16(attributeReturnNumber->scalarAsDoubleAt(index, &rnHasBeenSet));
                const quint16 number_of_Returns = quint16(attributeNumber_of_Returns->scalarAsDoubleAt(index, &norHasBeenSet));
                double intensity = attributeIntensity->scalarAsDoubleAt(index, &intensityHasBeenSet);

                if (rnHasBeenSet
                        && norHasBeenSet
                        && intensityHasBeenSet)
                {
                    // f
                    if (returnNumber == 1 && number_of_Returns >= 1)
                    {
                        ++(m_conf.n_f.value);
                        i_f.append(intensity);
                        tp25f.insert(point(2), intensity);
                        if (point(2) < minZ_f) {minZ_f = point(2);}
                        if (point(2) > maxZ_f) {maxZ_f = point(2);}

                        if (intensity > m_conf.imx_f.value) {m_conf.imx_f.value = intensity;}
                        m_conf.imn_f.value += intensity;
                        m_conf.isd_f.value += intensity*intensity;
                    }

                    // o
                    if (returnNumber == 1 && number_of_Returns == 1)
                    {
                        ++(m_conf.n_o.value);
                        i_o.append(intensity);
                        tp25o.insert(point(2), intensity);
                        if (point(2) < minZ_o) {minZ_o = point(2);}
                        if (point(2) > maxZ_o) {maxZ_o = point(2);}

                        if (intensity > m_conf.imx_o.value) {m_conf.imx_o.value = intensity;}
                        m_conf.imn_o.value += intensity;
                        m_conf.isd_o.value += intensity*intensity;
                    }

                    // a
                    if (intensity > m_conf.imx_a.value) {m_conf.imx_a.value = intensity;}
                    m_conf.imn_a.value += intensity;
                    m_conf.isd_a.value += intensity*intensity;

                }
            }
        }

        if (m_conf.imx_f.value < 0) {m_conf.imx_f.value = 0;}
        if (m_conf.imx_o.value < 0) {m_conf.imx_o.value = 0;}
        if (m_conf.imx_a.value < 0) {m_conf.imx_a.value = 0;}


        if (m_conf.n_f.value > 0)
        {
            m_conf.imn_f.value /= double(m_conf.n_f.value);
            if (m_conf.n_f.value > 1)
            {
                m_conf.isd_f.value = sqrt((double(m_conf.n_f.value)/double(m_conf.n_f.value - 1.0)) * ((1.0/double(m_conf.n_f.value)) * m_conf.isd_f.value - m_conf.imn_f.value*m_conf.imn_f.value));

                if (m_conf.imn_f.value != 0)
                {
                    m_conf.icv_f.value = m_conf.isd_f.value / m_conf.imn_f.value;
                }
            } else {
                m_conf.isd_f.value = 0;
                m_conf.icv_f.value = 0;
            }

            m_conf.ip05_f.value = CT_MathStatistics::computeQuantile(i_f, 0.05, true);
            m_conf.ip10_f.value = CT_MathStatistics::computeQuantile(i_f, 0.10, false);
            m_conf.ip25_f.value = CT_MathStatistics::computeQuantile(i_f, 0.25, false);
            m_conf.ip50_f.value = CT_MathStatistics::computeQuantile(i_f, 0.50, false);
            m_conf.ip75_f.value = CT_MathStatistics::computeQuantile(i_f, 0.75, false);
            m_conf.ip90_f.value = CT_MathStatistics::computeQuantile(i_f, 0.90, false);
            m_conf.ip95_f.value = CT_MathStatistics::computeQuantile(i_f, 0.95, false);

            for (int i = 0 ; i < i_f.size() ; i++)
            {
                double intensity = i_f.at(i);

                if (intensity >= m_conf.ip05_f.value && intensity <= m_conf.ip95_f.value)
                {
                    ++m_conf.n0595_f.value;
                    m_conf.i0595mn_f.value += intensity;
                    m_conf.i0595sd_f.value += intensity*intensity;
                }

                if (intensity >= m_conf.ip10_f.value && intensity <= m_conf.ip90_f.value)
                {
                    ++m_conf.n1090_f.value;
                    m_conf.i1090mn_f.value += intensity;
                    m_conf.i1090sd_f.value += intensity*intensity;
                }
            }

            if (m_conf.n0595_f.value > 0)
            {
                m_conf.i0595mn_f.value /= double(m_conf.n0595_f.value);
                if (m_conf.n0595_f.value > 1)
                {
                    m_conf.i0595sd_f.value = sqrt((double(m_conf.n0595_f.value)/double(m_conf.n0595_f.value - 1.0)) * ((1.0/double(m_conf.n0595_f.value)) * m_conf.i0595sd_f.value - m_conf.i0595mn_f.value*m_conf.i0595mn_f.value));

                    if (m_conf.i0595mn_f.value != 0)
                    {
                        m_conf.i0595cv_f.value = m_conf.i0595sd_f.value / m_conf.i0595mn_f.value;
                    }
                } else {
                    m_conf.i0595sd_f.value = 0;
                    m_conf.i0595cv_f.value = 0;
                }

            }

            if (m_conf.n1090_f.value > 0)
            {
                m_conf.i1090mn_f.value /= double(m_conf.n1090_f.value);
                if (m_conf.n1090_f.value > 1)
                {
                    m_conf.i1090sd_f.value = sqrt((double(m_conf.n1090_f.value)/double(m_conf.n1090_f.value - 1.0)) * ((1.0/double(m_conf.n1090_f.value)) * m_conf.i1090sd_f.value - m_conf.i1090mn_f.value*m_conf.i1090mn_f.value));

                    if (m_conf.i1090mn_f.value != 0)
                    {
                        m_conf.i1090cv_f.value = m_conf.i1090sd_f.value / m_conf.i1090mn_f.value;
                    }
                } else {
                    m_conf.i1090sd_f.value = 0;
                    m_conf.i1090cv_f.value = 0;
                }
            }

            minZ_f = maxZ_f - (maxZ_f - minZ_f)*0.25;
            QMapIterator<double, double> itm_f(tp25f);
            while (itm_f.hasNext())
            {
                itm_f.next();
                double z =itm_f.key();
                double intensity = itm_f.value();
                if (z >= minZ_f)
                {
                    ++m_conf.ntp25_f.value;
                    m_conf.itp25mn_f.value += intensity;
                    m_conf.itp25sd_f.value += intensity*intensity;
                }
            }

            if (m_conf.ntp25_f.value > 0)
            {
                m_conf.itp25mn_f.value /= double(m_conf.ntp25_f.value);
                if (m_conf.ntp25_f.value > 1)
                {
                    m_conf.itp25sd_f.value = sqrt((double(m_conf.ntp25_f.value)/double(m_conf.ntp25_f.value - 1.0)) * ((1.0/double(m_conf.ntp25_f.value)) * m_conf.itp25sd_f.value - m_conf.itp25mn_f.value*m_conf.itp25mn_f.value));

                    if (m_conf.itp25mn_f.value != 0)
                    {
                        m_conf.itp25cv_f.value = m_conf.itp25sd_f.value / m_conf.itp25mn_f.value;
                    }
                } else {
                    m_conf.itp25sd_f.value = 0;
                    m_conf.itp25cv_f.value = 0;
                }
            }

        }

        if (m_conf.n_o.value > 0)
        {
            m_conf.imn_o.value /= double(m_conf.n_o.value);

            if (m_conf.n_o.value > 1)
            {
                m_conf.isd_o.value = sqrt((double(m_conf.n_o.value)/double(m_conf.n_o.value - 1.0)) * ((1.0/double(m_conf.n_o.value)) * m_conf.isd_o.value - m_conf.imn_o.value*m_conf.imn_o.value));

                if (m_conf.imn_o.value != 0)
                {
                    m_conf.icv_o.value = m_conf.isd_o.value / m_conf.imn_o.value;
                }
            } else {
                m_conf.isd_o.value = 0;
                m_conf.icv_o.value = 0;
            }

            m_conf.ip05_o.value = CT_MathStatistics::computeQuantile(i_o, 0.05, true);
            m_conf.ip10_o.value = CT_MathStatistics::computeQuantile(i_o, 0.10, false);
            m_conf.ip25_o.value = CT_MathStatistics::computeQuantile(i_o, 0.25, false);
            m_conf.ip50_o.value = CT_MathStatistics::computeQuantile(i_o, 0.50, false);
            m_conf.ip75_o.value = CT_MathStatistics::computeQuantile(i_o, 0.75, false);
            m_conf.ip90_o.value = CT_MathStatistics::computeQuantile(i_o, 0.90, false);
            m_conf.ip95_o.value = CT_MathStatistics::computeQuantile(i_o, 0.95, false);

            for (int i = 0 ; i < i_o.size() ; i++)
            {
                double intensity = i_o.at(i);

                if (intensity >= m_conf.ip05_o.value && intensity <= m_conf.ip95_o.value)
                {
                    ++m_conf.n0595_o.value;
                    m_conf.i0595mn_o.value += intensity;
                    m_conf.i0595sd_o.value += intensity*intensity;
                }

                if (intensity >= m_conf.ip10_o.value && intensity <= m_conf.ip90_o.value)
                {
                    ++m_conf.n1090_o.value;
                    m_conf.i1090mn_o.value += intensity;
                    m_conf.i1090sd_o.value += intensity*intensity;
                }
            }

            if (m_conf.n0595_o.value > 0)
            {
                m_conf.i0595mn_o.value /= double(m_conf.n0595_o.value);
                if (m_conf.n0595_o.value > 1)
                {
                    m_conf.i0595sd_o.value = sqrt((double(m_conf.n0595_o.value)/double(m_conf.n0595_o.value - 1.0)) * ((1.0/double(m_conf.n0595_o.value)) * m_conf.i0595sd_o.value - m_conf.i0595mn_o.value*m_conf.i0595mn_o.value));

                    if (m_conf.i0595mn_o.value != 0)
                    {
                        m_conf.i0595cv_o.value = m_conf.i0595sd_o.value / m_conf.i0595mn_o.value;
                    }
                } else {
                    m_conf.i0595sd_o.value = 0;
                    m_conf.i0595cv_o.value = 0;
                }
            }

            if (m_conf.n1090_o.value > 0)
            {
                m_conf.i1090mn_o.value /= double(m_conf.n1090_o.value);
                if (m_conf.n1090_o.value > 1)
                {
                    m_conf.i1090sd_o.value = sqrt((double(m_conf.n1090_o.value)/double(m_conf.n1090_o.value - 1.0)) * ((1.0/double(m_conf.n1090_o.value)) * m_conf.i1090sd_o.value - m_conf.i1090mn_o.value*m_conf.i1090mn_o.value));

                    if (m_conf.i1090mn_o.value != 0)
                    {
                        m_conf.i1090cv_o.value = m_conf.i1090sd_o.value / m_conf.i1090mn_o.value;
                    }
                } else {
                    m_conf.i1090sd_o.value = 0;
                    m_conf.i1090cv_o.value = 0;
                }
            }

            minZ_o = maxZ_o - (maxZ_o - minZ_o)*0.25;
            QMapIterator<double, double> itm_o(tp25o);
            while (itm_o.hasNext())
            {
                itm_o.next();
                double z =itm_o.key();
                double intensity = itm_o.value();
                if (z >= minZ_o)
                {
                    ++m_conf.ntp25_o.value;
                    m_conf.itp25mn_o.value += intensity;
                    m_conf.itp25sd_o.value += intensity*intensity;
                }
            }

            if (m_conf.ntp25_o.value > 0)
            {
                m_conf.itp25mn_o.value /= double(m_conf.ntp25_o.value);
                if (m_conf.ntp25_o.value > 1)
                {
                    m_conf.itp25sd_o.value = sqrt((double(m_conf.ntp25_o.value)/double(m_conf.ntp25_o.value - 1.0)) * ((1.0/double(m_conf.ntp25_o.value)) * m_conf.itp25sd_o.value - m_conf.itp25mn_o.value*m_conf.itp25mn_o.value));

                    if (m_conf.itp25mn_o.value != 0)
                    {
                        m_conf.itp25cv_o.value = m_conf.itp25sd_o.value / m_conf.itp25mn_o.value;
                    }
                } else {
                    m_conf.itp25sd_o.value = 0;
                    m_conf.itp25cv_o.value = 0;
                }
            }
        }

        if (m_conf.n.value > 0)
        {
            m_conf.imn_a.value /= double(m_conf.n.value);

            if (m_conf.n.value > 1)
            {
                m_conf.isd_a.value = sqrt((double(m_conf.n.value)/double(m_conf.n.value - 1.0)) * ((1.0/double(m_conf.n.value)) * m_conf.isd_a.value - m_conf.imn_a.value*m_conf.imn_a.value));

                if (m_conf.imn_a.value != 0)
                {
                    m_conf.icv_a.value = m_conf.isd_a.value / m_conf.imn_a.value;
                }
            } else {
                m_conf.isd_a.value = 0;
                m_conf.icv_a.value = 0;
            }
        }
    }
    setAttributeValueVaB(m_conf.n);

    setAttributeValueVaB(m_conf.n_f);
    setAttributeValueVaB(m_conf.n_o);
    setAttributeValueVaB(m_conf.n0595_f);
    setAttributeValueVaB(m_conf.n0595_o);
    setAttributeValueVaB(m_conf.n1090_f);
    setAttributeValueVaB(m_conf.n1090_o);
    setAttributeValueVaB(m_conf.ntp25_f);
    setAttributeValueVaB(m_conf.ntp25_o);

    setAttributeValueVaB(m_conf.imx_f);
    setAttributeValueVaB(m_conf.imn_f);
    setAttributeValueVaB(m_conf.isd_f);
    setAttributeValueVaB(m_conf.icv_f);
    setAttributeValueVaB(m_conf.imx_o);
    setAttributeValueVaB(m_conf.imn_o);
    setAttributeValueVaB(m_conf.isd_o);
    setAttributeValueVaB(m_conf.icv_o);
    setAttributeValueVaB(m_conf.imx_a);
    setAttributeValueVaB(m_conf.imn_a);
    setAttributeValueVaB(m_conf.isd_a);
    setAttributeValueVaB(m_conf.icv_a);


    setAttributeValueVaB(m_conf.i0595mn_f);
    setAttributeValueVaB(m_conf.i0595sd_f);
    setAttributeValueVaB(m_conf.i0595cv_f);
    setAttributeValueVaB(m_conf.i0595mn_o);
    setAttributeValueVaB(m_conf.i0595sd_o);
    setAttributeValueVaB(m_conf.i0595cv_o);

    setAttributeValueVaB(m_conf.i1090mn_f);
    setAttributeValueVaB(m_conf.i1090sd_f);
    setAttributeValueVaB(m_conf.i1090cv_f);
    setAttributeValueVaB(m_conf.i1090mn_o);
    setAttributeValueVaB(m_conf.i1090sd_o);
    setAttributeValueVaB(m_conf.i1090cv_o);

    setAttributeValueVaB(m_conf.itp25mn_f);
    setAttributeValueVaB(m_conf.itp25sd_f);
    setAttributeValueVaB(m_conf.itp25cv_f);
    setAttributeValueVaB(m_conf.itp25mn_o);
    setAttributeValueVaB(m_conf.itp25sd_o);
    setAttributeValueVaB(m_conf.itp25cv_o);

    setAttributeValueVaB(m_conf.ip05_f);
    setAttributeValueVaB(m_conf.ip10_f);
    setAttributeValueVaB(m_conf.ip25_f);
    setAttributeValueVaB(m_conf.ip50_f);
    setAttributeValueVaB(m_conf.ip75_f);
    setAttributeValueVaB(m_conf.ip90_f);
    setAttributeValueVaB(m_conf.ip95_f);
    setAttributeValueVaB(m_conf.ip05_o);
    setAttributeValueVaB(m_conf.ip10_o);
    setAttributeValueVaB(m_conf.ip25_o);
    setAttributeValueVaB(m_conf.ip50_o);
    setAttributeValueVaB(m_conf.ip75_o);
    setAttributeValueVaB(m_conf.ip90_o);
    setAttributeValueVaB(m_conf.ip95_o);
}

void ONF_MetricIntensity::declareAttributes()
{
    registerAttributeVaB(m_conf.n, CT_AbstractCategory::DATA_NUMBER, "n");

    registerAttributeVaB(m_conf.n_f, CT_AbstractCategory::DATA_NUMBER, "n_f");
    registerAttributeVaB(m_conf.n_o, CT_AbstractCategory::DATA_NUMBER, "n_o");
    registerAttributeVaB(m_conf.n0595_f, CT_AbstractCategory::DATA_NUMBER, "n0595_f");
    registerAttributeVaB(m_conf.n0595_o, CT_AbstractCategory::DATA_NUMBER, "n0595_o");
    registerAttributeVaB(m_conf.n1090_f, CT_AbstractCategory::DATA_NUMBER, "n1090_f");
    registerAttributeVaB(m_conf.n1090_o, CT_AbstractCategory::DATA_NUMBER, "n1090_o");
    registerAttributeVaB(m_conf.ntp25_f, CT_AbstractCategory::DATA_NUMBER, "ntp25_f");
    registerAttributeVaB(m_conf.ntp25_o, CT_AbstractCategory::DATA_NUMBER, "ntp25_o");

    registerAttributeVaB(m_conf.imx_f, CT_AbstractCategory::DATA_NUMBER, "imx_f");
    registerAttributeVaB(m_conf.imn_f, CT_AbstractCategory::DATA_NUMBER, "imn_f");
    registerAttributeVaB(m_conf.isd_f, CT_AbstractCategory::DATA_NUMBER, "isd_f");
    registerAttributeVaB(m_conf.icv_f, CT_AbstractCategory::DATA_NUMBER, "icv_f");
    registerAttributeVaB(m_conf.imx_o, CT_AbstractCategory::DATA_NUMBER, "imx_o");
    registerAttributeVaB(m_conf.imn_o, CT_AbstractCategory::DATA_NUMBER, "imn_o");
    registerAttributeVaB(m_conf.isd_o, CT_AbstractCategory::DATA_NUMBER, "isd_o");
    registerAttributeVaB(m_conf.icv_o, CT_AbstractCategory::DATA_NUMBER, "icv_o");
    registerAttributeVaB(m_conf.imx_a, CT_AbstractCategory::DATA_NUMBER, "imx_a");
    registerAttributeVaB(m_conf.imn_a, CT_AbstractCategory::DATA_NUMBER, "imn_a");
    registerAttributeVaB(m_conf.isd_a, CT_AbstractCategory::DATA_NUMBER, "isd_a");
    registerAttributeVaB(m_conf.icv_a, CT_AbstractCategory::DATA_NUMBER, "icv_a");

    registerAttributeVaB(m_conf.i0595mn_f, CT_AbstractCategory::DATA_NUMBER, "i0595mn_f");
    registerAttributeVaB(m_conf.i0595sd_f, CT_AbstractCategory::DATA_NUMBER, "i0595sd_f");
    registerAttributeVaB(m_conf.i0595cv_f, CT_AbstractCategory::DATA_NUMBER, "i0595cv_f");
    registerAttributeVaB(m_conf.i0595mn_o, CT_AbstractCategory::DATA_NUMBER, "i0595mn_o");
    registerAttributeVaB(m_conf.i0595sd_o, CT_AbstractCategory::DATA_NUMBER, "i0595sd_o");
    registerAttributeVaB(m_conf.i0595cv_o, CT_AbstractCategory::DATA_NUMBER, "i0595cv_o");

    registerAttributeVaB(m_conf.i1090mn_f, CT_AbstractCategory::DATA_NUMBER, "i1090mn_f");
    registerAttributeVaB(m_conf.i1090sd_f, CT_AbstractCategory::DATA_NUMBER, "i1090sd_f");
    registerAttributeVaB(m_conf.i1090cv_f, CT_AbstractCategory::DATA_NUMBER, "i1090cv_f");
    registerAttributeVaB(m_conf.i1090mn_o, CT_AbstractCategory::DATA_NUMBER, "i1090mn_o");
    registerAttributeVaB(m_conf.i1090sd_o, CT_AbstractCategory::DATA_NUMBER, "i1090sd_o");
    registerAttributeVaB(m_conf.i1090cv_o, CT_AbstractCategory::DATA_NUMBER, "i1090cv_o");

    registerAttributeVaB(m_conf.ip05_f, CT_AbstractCategory::DATA_NUMBER, "ip05_f");
    registerAttributeVaB(m_conf.ip10_f, CT_AbstractCategory::DATA_NUMBER, "ip10_f");
    registerAttributeVaB(m_conf.ip25_f, CT_AbstractCategory::DATA_NUMBER, "ip25_f");
    registerAttributeVaB(m_conf.ip50_f, CT_AbstractCategory::DATA_NUMBER, "ip50_f");
    registerAttributeVaB(m_conf.ip75_f, CT_AbstractCategory::DATA_NUMBER, "ip75_f");
    registerAttributeVaB(m_conf.ip90_f, CT_AbstractCategory::DATA_NUMBER, "ip90_f");
    registerAttributeVaB(m_conf.ip95_f, CT_AbstractCategory::DATA_NUMBER, "ip95_f");

    registerAttributeVaB(m_conf.ip05_o, CT_AbstractCategory::DATA_NUMBER, "ip05_o");
    registerAttributeVaB(m_conf.ip10_o, CT_AbstractCategory::DATA_NUMBER, "ip10_o");
    registerAttributeVaB(m_conf.ip25_o, CT_AbstractCategory::DATA_NUMBER, "ip25_o");
    registerAttributeVaB(m_conf.ip50_o, CT_AbstractCategory::DATA_NUMBER, "ip50_o");
    registerAttributeVaB(m_conf.ip75_o, CT_AbstractCategory::DATA_NUMBER, "ip75_o");
    registerAttributeVaB(m_conf.ip90_o, CT_AbstractCategory::DATA_NUMBER, "ip90_o");
    registerAttributeVaB(m_conf.ip95_o, CT_AbstractCategory::DATA_NUMBER, "ip95_o");

    registerAttributeVaB(m_conf.itp25mn_f, CT_AbstractCategory::DATA_NUMBER, "itp25mn_f");
    registerAttributeVaB(m_conf.itp25sd_f, CT_AbstractCategory::DATA_NUMBER, "itp25sd_f");
    registerAttributeVaB(m_conf.itp25cv_f, CT_AbstractCategory::DATA_NUMBER, "itp25cv_f");
    registerAttributeVaB(m_conf.itp25mn_o, CT_AbstractCategory::DATA_NUMBER, "itp25mn_o");
    registerAttributeVaB(m_conf.itp25sd_o, CT_AbstractCategory::DATA_NUMBER, "itp25sd_o");
    registerAttributeVaB(m_conf.itp25cv_o, CT_AbstractCategory::DATA_NUMBER, "itp25cv_o");
}