EX> // Inclusion du fichier d'entête
EX> #include "{{CODE_LOWER}}_step{{NAME_LOWER}}.h"
EX> 
EX> // Inclure ensuite les éventuelles classes de définitions nécessaires à votre étape
EX> 
EX> // Inclusion pour la gestion des actions en cours d'étape
EX> #include "interfacesforplugin.h"
EX> #include <QMessageBox>
EX> 
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)
EX> {{CODE_UPPER}}_Step{{NAME}}::{{CODE_UPPER}}_Step{{NAME}}() : SuperClass()
EX> {
EX>     _dataContainer = new {{CODE_UPPER}}_ActionStep{{NAME}}::{{CODE_UPPER}}_ActionStep{{NAME}}_dataContainer();
EX>     _dataContainer->_limitBuffer = 0.0;
EX>     _dataContainer->_sceneList = new QList<CT_PointCluster*>();
EX> 
EX>     _manual = false;
EX>     _m_doc = nullptr;
EX> }
EX> 
EX> // Destructeur
EX> {{CODE_UPPER}}_Step{{NAME}}::~{{CODE_UPPER}}_Step{{NAME}}()
EX> {
EX>     _dataContainer->_sceneList->clear();
EX>     delete _dataContainer;
EX> }
EX> 
EX> // Description de l'étape (tooltip du menu contextuel)
EX> QString {{CODE_UPPER}}_Step{{NAME}}::description() const
EX> {
EX>     return QString(tr("Générer des ReferencePoints"));
EX> }
EX> 
EX> // Description détaillée de l'étape (dans le menu de description)
EX> QString {{CODE_UPPER}}_Step{{NAME}}::detailledDescription() const
EX> {
EX>     return QString(tr("Générer des ReferencePoints à partir des barycentres de PointClusters"));
EX> }
EX> 
EX> // Méthode de recopie de l'étape
EX> CT_VirtualAbstractStep* {{CODE_UPPER}}_Step{{NAME}}::createNewInstance() const
EX> {
EX>     // cree une copie de cette étape
EX>     return new {{CODE_UPPER}}_Step{{NAME}}();
EX> }
EX> 
EX> // Création et affiliation des modèles IN
EX> void {{CODE_UPPER}}_Step{{NAME}}::declareInputModels(CT_StepInModelStructureManager& manager)
EX> {
EX>     // On se base sur les résultats entrants
EX>     manager.addResult(_inResult, tr("Scène(s)"));
EX>     // Déclaration et création du modèle de groupe de référence
EX>     manager.setZeroOrMoreRootGroup(_inResult, _inZeroOrMoreRootGroup);
EX>     // Déclaration et création du modèle de groupe
EX>     manager.addGroup(_inZeroOrMoreRootGroup, _inGroup);
EX>     // On ajoute le modèle d'item au modèle du groupe racine (le type d'item sera automatiquement déduit)
EX>     manager.addItem(_inGroup, _inScene, tr("Scène source"));
EX> }
EX> 
EX> // Création et affiliation des modèles OUT
EX> void {{CODE_UPPER}}_Step{{NAME}}::declareOutputModels(CT_StepOutModelStructureManager& manager)
EX> {
EX>     // On se base sur les résultats entrants (copie)
EX>     manager.addResultCopy(_inResult);
EX>     // Déclaration et création du modèle de groupe
EX>     manager.addGroup(_inGroup, _outGroup);
EX>     // On ajoute le modèle d'item au modèle du groupe racine (le type d'item sera automatiquement déduit)
EX>     manager.addItem(_outGroup, _outPoint, tr("Barycentre"));
EX> }
EX> 
EX> // Création semi-automatique de la boite de dialogue de paramétrage de l'étape
EX> void {{CODE_UPPER}}_Step{{NAME}}::fillPostInputConfigurationDialog(CT_StepConfigurableDialog* postInputConfigDialog)
EX> {
EX> 	// Ajout de contrôles unitaires de paramètrages à la boite (un par paramètre en général)
EX>     postInputConfigDialog->addBool("","",tr("Choix interactif des paramètres"), _manual);
EX> }
EX> 
EX> // Etape de calcul, créant les données des résultats de sortie
EX> void {{CODE_UPPER}}_Step{{NAME}}::compute()
EX> {
EX>     // On prépare le mode manuel pour l'action
EX>     setManual(_manual);
EX> 
EX>     // Ici on peut faire quelques initialisations et/ou calculs préliminaires
EX> 	
EX> 	// On Recopie ici le(s) cluster(s) de point dans la vue d'action, afin d'éventuellement
EX> 	// intéragir avec (sélection, visualisation d'effet de paramètre, ...)
EX>     for (CT_PointCluster* inScene : _inScene.iterateOutputs(_inResult))
EX>     {
EX>         _dataContainer->_sceneList->append(inScene);
EX>     }
EX> 
EX>     // On fat appel a l'action
EX>     requestManualMode();
EX> 
EX>     // On peut maintenant utiliser les variables mises à jour avec l'action dans la suite du calcul, puis on continue le calcul
EX> 
EX>     // Récupération de la liste des groupes d'entrée et leurs items
EX>     // L'ordre dans cette liste est celui des ajouts successifs
EX>     for (CT_StandardItemGroup* group : _inGroup.iterateOutputs(_inResult))
EX>     {
EX>         for (const CT_PointCluster* inScene : group->singularItems(_inScene))
EX>         {
EX>             if (isStopped())
EX>                 return;
EX> 
EX>             // Ici on peut faire d'autre calculs préliminaires pour l'item en cours
EX> 
EX>             // On récupère le barycentre auto-calculé du groupe de points
EX>             const CT_PointClusterBarycenter barycentre = inScene->getBarycenter();
EX> 
EX>             // Coordonnées du barycentre
EX>             float xref = barycentre.x();
EX>             float yref = barycentre.y();
EX>             float zref = barycentre.z();
EX> 
EX>             // Calcul du bufferXY : maximum de la distance point/refPoint(barycentre) pour chaque segment
EX>             float buffer = 0.0;
EX> 
EX>             if (_dataContainer->_limitBuffer != 0.0)
EX>             {
EX>                 buffer = _dataContainer->_limitBuffer;
EX>             }
EX>             else
EX>             {
EX>                 const CT_AbstractPointCloudIndex *pointCloudIndex = inScene->pointCloudIndex();
EX>                 CT_PointIterator itP(pointCloudIndex);
EX> 
EX>                 size_t nbPoints = pointCloudIndex->size();
EX>                 size_t i = 0;
EX> 
EX>                 while(itP.hasNext())
EX>                 {
EX>                     if (isStopped())
EX>                         return;
EX> 
EX>                     const CT_Point &point = itP.next().currentPoint();
EX> 
EX>                     float distance = pow(xref-point.x(), 2) + pow(yref-point.y(), 2);
EX> 
EX>                     if (distance > buffer)
EX>                         buffer = distance;
EX> 
EX>                     // On fait avancer le % de progression (ici par rapport au nombre de points traités sur le total)
EX>                     setProgress(float(100.0*i++ /nbPoints));
EX>                 }
EX> 
EX>                 if (buffer > 0) {buffer = sqrt(buffer);}
EX>             }
EX> 
EX>             // On fait avancer le % de progression : calcul terminé
EX>             setProgress(float(100.0));
EX> 			
EX> 			// Création du barycentre du cluster en cours
EX> 			CT_ReferencePoint *refPoint = new CT_ReferencePoint(xref, yref, zref, buffer);
EX> 
EX>             // Création du groupe contenant le(s) item(s)
EX> 			CT_StandardItemGroup* outGroup = new CT_StandardItemGroup();
EX> 			
EX>             // Ajout du groupe au résultat (AVANT d'ajouter l'item !)
EX> 			group->addGroup(_outGroup, outGroup);
EX> 
EX>             // Ajout de l'item au groupe
EX>             outGroup->addSingularItem(_outPoint, refPoint);
EX>         }
EX>     }
EX> 
EX>     if (_manual)
EX>     {
EX>         _m_doc = nullptr;
EX>     }
EX> }
EX> 
EX> void {{CODE_UPPER}}_Step{{NAME}}::initManualMode()
EX> {
EX>     if(_m_doc == nullptr)
EX>     {
EX>         // Création d'une nouvelle action
EX>         {{CODE_UPPER}}_ActionStep{{NAME}}* action = new {{CODE_UPPER}}_ActionStep{{NAME}}(_dataContainer);
EX> 
EX>         GuiContextInterface* context = this->guiContext();
EX>         context->actionsManager()->addAction(action);
EX> 
EX>         _m_doc = context->documentManager()->new3DDocument();
EX>         _m_doc->setCurrentAction(action);
EX>     }
EX> 
EX>     QMessageBox::information(nullptr,
EX>                              tr("Mode manuel"),
EX>                              tr("Bienvenue dans le mode manuel de cette étape.\n"
EX>                                 "Veuillez sélectionner les paramètres pour réaliser les tranches."),
EX>                              QMessageBox::Ok);
EX> }
EX> 
EX> void {{CODE_UPPER}}_Step{{NAME}}::useManualMode(bool quit)
EX> {
EX>     Q_UNUSED(quit);
EX> }