// Inclusion du fichier d'entête
#include "metrics/tufr_metrictutorial06.h"

// Inclure ensuite les éventuelles classes de définitions nécessaires à votre étape
#include "ct_itemdrawable/ct_pointcluster.h"

// Pour afficher des messages à la console
#include <QDebug>

// Pour inclure certaines fonctions mathématiques
#include <math.h>

// Constructeur : appel du constructeur de la classe mère
// et initialisation des paramètres (valeurs par défaut)
TUFR_MetricTutorial06::TUFR_MetricTutorial06() : SuperClass()
{
    declareAttributes();
}

// Constructeur de copie : appel du constructeur de la classe mère
// et initialisation des paramètres (valeurs par défaut)
TUFR_MetricTutorial06::TUFR_MetricTutorial06(const TUFR_MetricTutorial06 &other) : SuperClass(other)
{
    declareAttributes();
    _minimum = other._minimum;
    _maximum = other._maximum;
    _mean    = other._mean;
}

// Nom qui s'affiche de le menu
QString TUFR_MetricTutorial06::getDetailledDisplayableName() const
{
    return QString("Filtered");
}

// Description (tooltip dans le menu contectuel)
QString TUFR_MetricTutorial06::getShortDescription() const
{
    return QString(tr("Distance à l'origine"));
}

// Description détaillée (dans le menu de description)
QString TUFR_MetricTutorial06::getDetailledDescription() const
{
    return QString(tr("Distance moyenne/max/min entre l'origine et le(s) nuage(s) de points"));
}

// Boite de saisie des paramètres du filtre
CT_AbstractConfigurableWidget* TUFR_MetricTutorial06::createConfigurationWidget()
{
    CT_GenericConfigurableWidget* configDialog = new CT_GenericConfigurableWidget();

    configDialog->addTitle(tr("Elements a calculer :"));
    configDialog->addBool(tr("- min" ), "", "", _minimum.used);
    configDialog->addBool(tr("- max" ), "", "", _maximum.used);
    configDialog->addBool(tr("- mean"), "", "", _mean.used   );

    return configDialog;
}

// Import/export des paramètres choisis
void TUFR_MetricTutorial06::saveSettings(SettingsWriterInterface &writer) const
{
    SuperClass::saveSettings(writer);

    writer.addParameter(this, "min", _minimum.value);
    writer.addParameter(this, "max", _maximum.value);
    writer.addParameter(this, "mean", _mean.value);
}

bool TUFR_MetricTutorial06::restoreSettings(SettingsReaderInterface &reader)
{
    if(!SuperClass::restoreSettings(reader))
        return false;

    QVariant value;

    if(reader.parameter(this, "min", value))
        _minimum.value = value.toDouble();

    if(reader.parameter(this, "max", value))
        _maximum.value = value.toDouble();

    if(reader.parameter(this, "mean", value))
        _mean.value = value.toDouble();

    return true;
}

// Méthodes génériques à surcharger par défaut
CT_AbstractConfigurableElement *TUFR_MetricTutorial06::copy() const
{
    return new TUFR_MetricTutorial06(*this);
}

// Etape de calcul des métriques à partir des nuages de points
void TUFR_MetricTutorial06::computeMetric()
{
	// S'il n'y a pas d'attribut (métrique) à calculer, on ne fait rien
    if(attributes().isEmpty())
        return;

    // On initialise les valeurs pour le calcul
    initValues();

    // Itérateur servant à parcourir la liste des points en entrée
    CT_PointIterator itP(pointCloud());

	// On parcourt les points et on calcule les métriques
    size_t i = 0;
    while(itP.hasNext())
    {
        const CT_Point& point = itP.next().currentPoint();
        double norm = point.squaredNorm();

        _mean.value += norm;
        if (norm < _minimum.value)
            _minimum.value = norm;
        if (norm > _maximum.value)
            _maximum.value = norm;

        i++;
    }

    if (i != 0)
        _mean.value /= i;

    // On enregistre les valeurs calculées
    setAttributeValueVaB(_minimum);
    setAttributeValueVaB(_maximum);
    setAttributeValueVaB(_mean);
}

// Initialisation des valeurs nécessaires aux calculs
void TUFR_MetricTutorial06::initValues()
{
    _minimum.value = std::numeric_limits<double>::max();
    _maximum.value = -_minimum.value;
    _mean.value = 0;
}

// Déclaration des attributs servant de métrique
void TUFR_MetricTutorial06::declareAttributes()
{
    registerAttributeVaB(_minimum, CT_AbstractCategory::DATA_NUMBER, tr("min"));
    registerAttributeVaB(_maximum, CT_AbstractCategory::DATA_NUMBER, tr("max"));
    registerAttributeVaB(_mean   , CT_AbstractCategory::DATA_NUMBER, tr("mean"));
}