EX> // Inclusion du fichier d'entête
CM> #include "metrics/{{CODE_LOWER}}_metric{{NAME_LOWER}}.h"
CM> 
EX> // Inclure ensuite les éventuelles classes de définitions nécessaires à votre étape
CM> #include "ct_itemdrawable/ct_pointcluster.h"
CM> 
EX> // Pour afficher des messages à la console
EX> #include <QDebug>
EX> 
EX> // Pour inclure certaines fonctions mathématiques
EX> #include <math.h>
EX> 
EX> // Constructeur : appel du constructeur de la classe mère
EX> // et initialisation des paramètres (valeurs par défaut)
CM> {{CODE_UPPER}}_Metric{{NAME}}::{{CODE_UPPER}}_Metric{{NAME}}() : SuperClass()
CM> {
CM>     declareAttributes();
CM> }
CM> 
EX> // Constructeur de copie : appel du constructeur de la classe mère
EX> // et initialisation des paramètres (valeurs par défaut)
CM> {{CODE_UPPER}}_Metric{{NAME}}::{{CODE_UPPER}}_Metric{{NAME}}(const {{CODE_UPPER}}_Metric{{NAME}} &other) : SuperClass(other)
CM> {
CM>     declareAttributes();
EX>     _minimum = other._minimum;
EX>     _maximum = other._maximum;
EX>     _mean    = other._mean;
CM> }
CM> 
EX> // Nom qui s'affiche de le menu
CM> QString {{CODE_UPPER}}_Metric{{NAME}}::getDetailledDisplayableName() const
CM> {
EX>     return QString("Filtered");
NC>     return QString("");
CM> }
CM> 
EX> // Description (tooltip dans le menu contectuel)
CM> QString {{CODE_UPPER}}_Metric{{NAME}}::getShortDescription() const
CM> {
EX>     return QString(tr("Distance à l'origine"));
NC>     return QString("");
CM> }
CM> 
EX> // Description détaillée (dans le menu de description)
CM> QString {{CODE_UPPER}}_Metric{{NAME}}::getDetailledDescription() const
CM> {
EX>     return QString(tr("Distance moyenne/max/min entre l'origine et le(s) nuage(s) de points"));
NC>     return QString("");
CM> }
CM> 
EX> // Boite de saisie des paramètres du filtre
CM> CT_AbstractConfigurableWidget* {{CODE_UPPER}}_Metric{{NAME}}::createConfigurationWidget()
CM> {
CM>     CT_GenericConfigurableWidget* configDialog = new CT_GenericConfigurableWidget();
CM> 
EX>     configDialog->addTitle(tr("Elements a calculer :"));
EX>     configDialog->addBool(tr("- min" ), "", "", _minimum.used);
EX>     configDialog->addBool(tr("- max" ), "", "", _maximum.used);
EX>     configDialog->addBool(tr("- mean"), "", "", _mean.used   );
EX> 
CM>     return configDialog;
CM> }
CM> 
EX> // Import/export des paramètres choisis
CM> void {{CODE_UPPER}}_Metric{{NAME}}::saveSettings(SettingsWriterInterface &writer) const
CM> {
CM>     SuperClass::saveSettings(writer);
EX> 
EX>     writer.addParameter(this, "min", _minimum.value);
EX>     writer.addParameter(this, "max", _maximum.value);
EX>     writer.addParameter(this, "mean", _mean.value);
CM> }
CM> 
CM> bool {{CODE_UPPER}}_Metric{{NAME}}::restoreSettings(SettingsReaderInterface &reader)
CM> {
CM>     if(!SuperClass::restoreSettings(reader))
CM>         return false;
CM> 
EX>     QVariant value;
EX> 
EX>     if(reader.parameter(this, "min", value))
EX>         _minimum.value = value.toDouble();
EX> 
EX>     if(reader.parameter(this, "max", value))
EX>         _maximum.value = value.toDouble();
EX> 
EX>     if(reader.parameter(this, "mean", value))
EX>         _mean.value = value.toDouble();
EX> 
CM>     return true;
CM> }
CM> 
EX> // Méthodes génériques à surcharger par défaut
CM> CT_AbstractConfigurableElement *{{CODE_UPPER}}_Metric{{NAME}}::copy() const
CM> {
CM>     return new {{CODE_UPPER}}_Metric{{NAME}}(*this);
CM> }
CM> 
EX> // Etape de calcul des métriques à partir des nuages de points
CM> void {{CODE_UPPER}}_Metric{{NAME}}::computeMetric()
CM> {
EX> 	// S'il n'y a pas d'attribut (métrique) à calculer, on ne fait rien
CM>     if(attributes().isEmpty())
CM>         return;
CM> 
EX>     // On initialise les valeurs pour le calcul
CM>     initValues();
CM> 
EX>     // Itérateur servant à parcourir la liste des points en entrée
CM>     CT_PointIterator itP(pointCloud());
CM> 
EX> 	// On parcourt les points et on calcule les métriques
CM>     size_t i = 0;
CM>     while(itP.hasNext())
CM>     {
CM>         const CT_Point& point = itP.next().currentPoint();
EX>         double norm = point.squaredNorm();
CM> 
EX>         _mean.value += norm;
EX>         if (norm < _minimum.value)
EX>             _minimum.value = norm;
EX>         if (norm > _maximum.value)
EX>             _maximum.value = norm;
NC>         // Compute here your metric values
CM> 
CM>         i++;
CM>     }
CM> 
EX>     if (i != 0)
EX>         _mean.value /= i;
EX> 
EX>     // On enregistre les valeurs calculées
EX>     setAttributeValueVaB(_minimum);
EX>     setAttributeValueVaB(_maximum);
EX>     setAttributeValueVaB(_mean);
CM> }
CM> 
EX> // Initialisation des valeurs nécessaires aux calculs
CM> void {{CODE_UPPER}}_Metric{{NAME}}::initValues()
CM> {
EX>     _minimum.value = std::numeric_limits<double>::max();
EX>     _maximum.value = -_minimum.value;
EX>     _mean.value = 0;
CM> }
CM> 
EX> // Déclaration des attributs servant de métrique
CM> void {{CODE_UPPER}}_Metric{{NAME}}::declareAttributes()
CM> {
EX>     registerAttributeVaB(_minimum, CT_AbstractCategory::DATA_NUMBER, tr("min"));
EX>     registerAttributeVaB(_maximum, CT_AbstractCategory::DATA_NUMBER, tr("max"));
EX>     registerAttributeVaB(_mean   , CT_AbstractCategory::DATA_NUMBER, tr("mean"));
CM> }