lib/maracasVisuLib/src/interface/wxWindows/widgets/WidgetShowNPoints.cxx

   1
   2 #include <wx/button.h>
   3 #include <wx/sizer.h>
   4 #include <wx/filedlg.h>
   5 #include <wx/msgdlg.h>
   6 #include <wx/notebook.h>
   7
   8
   9 #include <vtkStaticPointLocator.h>
  10 #include <vtkPointData.h>
  11 #include <vtkDataArray.h>
  12 #include <vtkMath.h>
  13 #include <vtkStaticPointLocator.h>
  14 #include <vtkPoints.h>
  15
  16 #include "vtkSphereSource.h"
  17 #include "vtkRenderer.h"
  18 #include "vtkTextActor3D.h"
  19
  20 #include "WidgetShowNPoints.h"
  21 #include <creaContoursFactory.h>
  22
  23
  24 //----------------------------------------------------------------------
  25 //----------------------------------------------------------------------
  26 //----------------------------------------------------------------------
  27 //----------------------------------------------------------------------
  28 //----------------------------------------------------------------------
  29   WidgetShowNPoints::WidgetShowNPoints(wxWindow *parent, int type)
  30     : wxPanel( parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL)
  31   {
  32       aux_mesh      =   NULL;
  33       aux_mesh_spc.push_back(1);
  34       aux_mesh_spc.push_back(1);
  35       aux_mesh_spc.push_back(1);
  36       aux_mesh_type = 0;   // 0:Patch  1:CloseSpline1  2:CloseSpline2
  37
  38         // EED 2022-05-19
  39     //  mmodelShowNPoints                                   = new ModelShowNPoints();
  40                         idUndoRedo          = 0;
  41                         maxUndoRedo         = 0;
  42 #if defined(_WIN32)
  43                                                 char * val = getenv( "TEMP" );
  44                                                 if (val == NULL)
  45                                                 {
  46                                                         UndoRedoDir = std::string("");
  47                                                 } else {
  48                                                         UndoRedoDir = std::string(val)+"\\creatools";
  49                                                         std::string cmd1 = "mkdir "+ UndoRedoDir;
  50                                                         system( cmd1.c_str() );
  51                                                         // Erasing files of more than 1 day old  ( -1 )
  52                                                         std::string cmd2 = "ForFiles /p \"" + UndoRedoDir + "\" /s /d -1 /c \"cmd /c del @file \"";
  53                                                         system( cmd2.c_str() );
  54                                                 }
  55 #elif defined(__GNUC__)
  56
  57
  58     #if defined(MACOSX)
  59                                                 UndoRedoDir         = "/tmp/creatools";
  60     #else  // Linux
  61                                                 UndoRedoDir         = "/tmp/creatools";
  62     #endif
  63
  64     std::string cmd1 = "mkdir "+ UndoRedoDir;
  65     system( cmd1.c_str() );
  66         // Erasing files of more than 1 day old  ( +1 )
  67         std::string cmd= "find "+UndoRedoDir+" -name \"UndoRedo_collection_*.undoredo\" -type f -mtime +1 -delete";
  68         system( cmd.c_str() );
  69
  70 #else
  71                                                 UndoRedoDir         = "./";
  72 #endif
  73
  74
  75                         mActualCollection   = 0;
  76     ModelShowNPoints*   modelShowNPoints    = new ModelShowNPoints();
  77     lstModelShowNPoints.push_back( modelShowNPoints );
  78     lstViewShowNPoints.push_back( new  ViewShowNPoints( modelShowNPoints ) );
  79
  80     mtype                                                       = type;
  81     SetType(mtype);
  82     wxPanel*        panelParent         = this;
  83     wxSizer*        sizer                               = NULL;
  84     wxSizer*        MNPsizer            = NULL;
  85     wxNotebook*     bookSetPoints       = NULL;
  86     wxNotebook*     bookGroupManager    = NULL;
  87     wxPanel*        panel               = NULL;
  88     wxPanel*        panel2              = NULL;
  89                     txtNrCollections    = NULL;
  90                     txtNrPoints         = NULL;
  91                 cbVisuActualCollection  = NULL;
  92                     bookSetPoints       = new wxNotebook(panelParent, -1, wxDefaultPosition, wxDefaultSize, wxNB_TOP );
  93                     panel               = new wxPanel(bookSetPoints);
  94
  95       wxSize sizeButton( 50  ,  -1 );
  96       wxSize sizeSlider( 90  ,  -1 );
  97
  98     // Group Manager
  99     if (mtype==4)
 100     {
 101           bookGroupManager   = new wxNotebook(panelParent, //bbGetWxParent(),
 102                               -1,
 103                               wxDefaultPosition,
 104                               wxDefaultSize,
 105                               wxNB_TOP );
 106           panel2  = new wxPanel(bookGroupManager);
 107           cbVisuActualCollection                = new wxCheckBox    ( panel2,-1, _T("Cur.")   ,   wxDefaultPosition, sizeButton );
 108           txtNrCollections                      = new wxStaticText  ( panel2,-1, _T("    1/1    "));
 109           wxButton *btnBackCollection           = new wxButton      ( panel2, -1, _T("<")     ,   wxDefaultPosition, sizeButton );
 110           wxButton *btnNextCollection           = new wxButton      ( panel2, -1, _T(">")     ,   wxDefaultPosition, sizeButton );
 111           wxButton *btnInsertCollectionBefore   = new wxButton      ( panel2, -1, _T("+<")    ,   wxDefaultPosition, sizeButton );
 112           wxButton *btnInsertCollectionAfter    = new wxButton      ( panel2, -1, _T("+>")    ,   wxDefaultPosition, sizeButton );
 113           wxButton *btnDeleteCollection         = new wxButton      ( panel2, -1, _T("-")     ,   wxDefaultPosition, sizeButton );
 114           wxButton *btnResetCollection          = new wxButton      ( panel2, -1, _T("--")    ,   wxDefaultPosition, sizeButton );
 115           wxButton *btnSaveCollection           = new wxButton      ( panel2, -1, _T("Save")  ,   wxDefaultPosition, sizeButton );
 116           wxButton *btnLoadCollection           = new wxButton      ( panel2, -1, _T("Load")  ,   wxDefaultPosition, sizeButton );
 117           wxButton *btnUndo                     = new wxButton      ( panel2, -1, _T("Undo")  ,   wxDefaultPosition, sizeButton );
 118           wxButton *btnRedo                     = new wxButton      ( panel2, -1, _T("Redo")  ,   wxDefaultPosition, sizeButton );
 119
 120          sCtrlRadio = new wxSpinCtrl( panel2, -1  , wxEmptyString, wxDefaultPosition, sizeButton );
 121          sCtrlRadio->SetRange(1,10);
 122          sCtrlRadio->SetValue( 2 );
 123          sCtrlOpacity= new wxSpinCtrl( panel2, -1  , wxEmptyString, wxDefaultPosition, sizeButton );
 124          sCtrlOpacity->SetRange(0,10);
 125          sCtrlOpacity->SetValue( 10 );
 126
 127           wxFlexGridSizer *sizer1               = new wxFlexGridSizer(1);
 128           wxFlexGridSizer *sizer2               = new wxFlexGridSizer(2);
 129           wxFlexGridSizer *sizer3               = new wxFlexGridSizer(3);
 130           wxFlexGridSizer *sizer4               = new wxFlexGridSizer(3);
 131           wxFlexGridSizer *sizer5               = new wxFlexGridSizer(2);
 132           wxFlexGridSizer *sizer5a              = new wxFlexGridSizer(2);
 133           wxFlexGridSizer *sizer6               = new wxFlexGridSizer(2);
 134           wxFlexGridSizer *sizer7               = new wxFlexGridSizer(2);
 135           wxFlexGridSizer *sizer8               = new wxFlexGridSizer(2);
 136
 137           cbVisuActualCollection      -> SetToolTip( _T("Current group") );
 138           btnInsertCollectionBefore   -> SetToolTip( _T("+  Add group before") );
 139           btnInsertCollectionAfter    -> SetToolTip( _T("+>  Add group after") );
 140           btnDeleteCollection         -> SetToolTip( _T("-  Erase group") );
 141           btnResetCollection          -> SetToolTip( _T("-- Reset : Erase all groups") );
 142           sCtrlRadio                  -> SetToolTip( _T("Radio")   );
 143           sCtrlOpacity                -> SetToolTip( _T("Opacity") );
 144
 145 //          sdrOpacity                            = new wxSlider(panel2, -1, 0, 0, 100, wxDefaultPosition, sizeSlider, wxSL_LABELS);
 146 //          sdrRadio                              = new wxSlider(panel2, -1, 0, 1, 50, wxDefaultPosition, sizeSlider, wxSL_LABELS);
 147 //          sdrRadio                    -> SetToolTip( _T("Radio")   );
 148 //          sdrOpacity                  -> SetToolTip( _T("Opacity") );
 149
 150           Connect(cbVisuActualCollection->GetId()   , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) & WidgetShowNPoints::OnVisuActualCollection     );
 151           Connect(btnBackCollection->GetId()        , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) & WidgetShowNPoints::OnBackCollection           );
 152           Connect(btnNextCollection->GetId()        , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) & WidgetShowNPoints::OnNextCollection           );
 153           Connect(btnInsertCollectionBefore->GetId(), wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) & WidgetShowNPoints::OnInsertCollectionBefore   );
 154           Connect(btnInsertCollectionAfter->GetId() , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) & WidgetShowNPoints::OnInsertCollectionAfter    );
 155           Connect(btnDeleteCollection->GetId()      , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) & WidgetShowNPoints::OnDeleteCollection         );
 156
 157 //        Connect(sdrOpacity->GetId()               , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) & WidgetShowNPoints::UpdatePoints               );
 158 //        Connect(sdrRadio->GetId()                 , wxEVT_COMMAND_SLIDER_UPDATED  , (wxObjectEventFunction) & WidgetShowNPoints::UpdatePoints               );
 159           Connect( sCtrlRadio->GetId()              ,wxEVT_COMMAND_SPINCTRL_UPDATED ,(wxObjectEventFunction)(void (wxPanel::*)(wxScrollEvent&)) &WidgetShowNPoints::UpdatePoints);
 160           Connect( sCtrlOpacity->GetId()            ,wxEVT_COMMAND_SPINCTRL_UPDATED ,(wxObjectEventFunction)(void (wxPanel::*)(wxScrollEvent&)) &WidgetShowNPoints::UpdatePoints);
 161
 162           Connect(btnSaveCollection->GetId()        , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) & WidgetShowNPoints::OnSaveCollections          );
 163           Connect(btnLoadCollection->GetId()        , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) & WidgetShowNPoints::OnLoadCollections          );
 164           Connect(btnResetCollection->GetId()       , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) & WidgetShowNPoints::OnResetCollections         );
 165           Connect(btnUndo->GetId()                  , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnUndo                      );
 166           Connect(btnRedo->GetId()                  , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnRedo                      );
 167
 168           sizer2->Add( btnBackCollection );
 169           sizer2->Add( btnNextCollection );
 170           sizer3->Add( btnInsertCollectionBefore );
 171           sizer3->Add( btnInsertCollectionAfter );
 172           sizer4->Add( btnLoadCollection );
 173           sizer4->Add( btnSaveCollection );
 174 //          sizer5->Add( txRadio ,wxGROW );
 175 //          sizer5->Add( sdrRadio ,wxGROW );
 176 //          sizer5->Add( txOpacity ,wxGROW );
 177 //          sizer5->Add( sdrOpacity ,wxGROW );
 178
 179           sizer5->Add( sCtrlRadio );
 180           sizer5->Add( sCtrlOpacity );
 181
 182           sizer6->Add( btnDeleteCollection );
 183           sizer6->Add( btnResetCollection );
 184
 185          sizer7->Add( cbVisuActualCollection );
 186          sizer7->Add( txtNrCollections );
 187
 188          sizer8->Add( btnUndo        );
 189          sizer8->Add( btnRedo        );
 190
 191           sizer1->Add( sizer7 );
 192           sizer1->Add( sizer2 );
 193           sizer1->Add( sizer3 );
 194           sizer1->Add( sizer6 );
 195           sizer1->Add( sizer4 );
 196           sizer1->Add( sizer5 );
 197           sizer1->Add( sizer8 );
 198
 199 //          sizer1->Add( sizer5 ,wxGROW );
 200
 201           MNPsizer                        = sizer1;
 202           panel2->SetSizer( MNPsizer );
 203           panel2->SetAutoLayout(true);
 204           panel2->Layout();
 205           bookGroupManager->AddPage(panel2 , _T("Groups") );
 206     } // if mtype 4
 207
 208         if ( (mtype==0) || (mtype==3) || (mtype==4) )
 209         {
 210                 // Widget interface
 211 //              askPointLabel                                       = new wxStaticText(panel, -1, _T("Label:")); // JPR
 212                 textCtrl                                                    = new wxTextCtrl(panel, -1, wxEmptyString   ,   wxDefaultPosition, sizeButton);
 213                 wxButton    *btnBackPoint                   = new wxButton( panel, -1, _T("<")          ,   wxDefaultPosition, sizeButton );
 214                 wxButton    *btnNextPoint                   = new wxButton( panel, -1, _T(">")          ,   wxDefaultPosition, sizeButton );
 215         wxButton    *btnAddPoint            = new wxButton( panel, -1, _T("+")          ,   wxDefaultPosition, sizeButton );
 216         wxButton    *btnInsertPoint         = new wxButton( panel, -1, _T("(+)")        ,   wxDefaultPosition, sizeButton );
 217                     cbAutoAddPoints         = new wxCheckBox(panel,-1, _T("Auto")       ,   wxDefaultPosition, sizeButton );
 218         wxButton    *btnMovePointUp         = new wxButton( panel, -1, _T("<-")         ,   wxDefaultPosition, sizeButton );
 219         wxButton    *btnMovePointDown       = new wxButton( panel, -1, _T("->")         ,   wxDefaultPosition, sizeButton );
 220         wxButton    *btnSetPositionPoint    = new wxButton( panel, -1, _T("Set")        ,   wxDefaultPosition, sizeButton );
 221                      cbTrackPoint           = new wxCheckBox(panel,-1, _T("Tra.")       ,   wxDefaultPosition, sizeButton );
 222         wxButton    *btnRenamePoint                 = new wxButton( panel, -1, _T("Ren.")       ,   wxDefaultPosition, sizeButton );
 223         wxButton    *btnErasePoint          = new wxButton( panel, -1, _T("-")          ,   wxDefaultPosition, sizeButton );
 224 //              wxButton    *btnEraseLastPoint      = new wxButton( panel, -1, _T("- lst")      ,   wxDefaultPosition, sizeButton );
 225                 wxButton    *btnDeleteAllPoints     = new wxButton( panel, -1, _T("--")         ,   wxDefaultPosition, sizeButton );
 226         wxButton    *btnUndo                = NULL;
 227         wxButton    *btnRedo                = NULL;
 228                 wxButton    *btnSavePoints                  = NULL;
 229                 wxButton    *btnLoadPoints                  = NULL;
 230         btnBackPoint        -> SetToolTip( _T("Select befor point")                         );
 231         btnNextPoint        -> SetToolTip( _T("Select next point")                          );
 232         cbAutoAddPoints     -> SetToolTip( _T("Auto Add point")                             );
 233         btnAddPoint         -> SetToolTip( _T("+  Add point")                               );
 234         btnInsertPoint      -> SetToolTip( _T("(+)  Insert point")                          );
 235         btnMovePointUp      -> SetToolTip( _T("Move point Up in the normal direction")      );
 236         btnMovePointDown    -> SetToolTip( _T("Move point Down in the normal direction")    );
 237         btnRenamePoint      -> SetToolTip( _T("Rename label for each point")                );
 238         textCtrl            -> SetToolTip( _T("Point label")                                );
 239         btnErasePoint       -> SetToolTip( _T("-  Erase point")                             );
 240 //        btnEraseLastPoint   -> SetToolTip( _T("- lst  Erase last point")                  );
 241         btnDeleteAllPoints  -> SetToolTip( _T("-- Erase all points")                        );
 242                 if ( mtype==0 )
 243                 {
 244             btnUndo             = new wxButton( panel, -1, _T("Undo")       ,   wxDefaultPosition, sizeButton   );
 245             btnRedo             = new wxButton( panel, -1, _T("Redo")       ,   wxDefaultPosition, sizeButton   );
 246                         btnSavePoints           = new wxButton( panel, -1, _T("Save")       ,   wxDefaultPosition, sizeButton   );
 247                         btnLoadPoints       = new wxButton( panel, -1, _T("Load")       ,   wxDefaultPosition, sizeButton   );
 248             Connect(btnSavePoints->GetId()    , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnSavePoints    );
 249             Connect(btnLoadPoints->GetId()    , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnLoadPoints    );
 250             Connect(btnUndo->GetId()          , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnUndo          );
 251             Connect(btnRedo->GetId()          , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnRedo          );
 252                 } // if mtype
 253                 txtNrPoints                                             = new wxStaticText(panel,-1, _T("   -/-"));
 254         wxStaticText* txOpacity;
 255         wxStaticText* txRadio;
 256         if ( (mtype==0) || (mtype==3) )
 257         {
 258             //NTU: Sliders for opacity and radio change
 259 //            txOpacity         = new wxStaticText(panel, -1, wxString(_T("  Points Opacity  ")));
 260 //            sdrOpacity        = new wxSlider(panel, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_LABELS);
 261 //            txRadio           = new wxStaticText(panel, -1, wxString(_T("  Points Radius  ")));
 262 //            sdrRadio          = new wxSlider(panel, -1, 0, 1, 50, wxDefaultPosition, wxDefaultSize, wxSL_LABELS);
 263 //            //NTU: Slider events
 264 //            Connect(sdrOpacity->GetId()          , wxEVT_COMMAND_SLIDER_UPDATED    , (wxObjectEventFunction) &WidgetShowNPoints::UpdatePoints);
 265 //            Connect(sdrRadio->GetId()            , wxEVT_COMMAND_SLIDER_UPDATED    , (wxObjectEventFunction) &WidgetShowNPoints::UpdatePoints);
 266
 267             sCtrlRadio = new wxSpinCtrl( panel, -1  , wxEmptyString, wxDefaultPosition, sizeButton );
 268             sCtrlRadio->SetRange(1,10);
 269             sCtrlRadio->SetValue( 2 );
 270             sCtrlOpacity= new wxSpinCtrl( panel, -1  , wxEmptyString, wxDefaultPosition, sizeButton );
 271             sCtrlOpacity->SetRange(0,10);
 272             sCtrlOpacity->SetValue( 10 );
 273             Connect( sCtrlRadio->GetId()              ,wxEVT_COMMAND_SPINCTRL_UPDATED,(wxObjectEventFunction)(void (wxPanel::*)(wxScrollEvent&)) &WidgetShowNPoints::UpdatePoints);
 274             Connect( sCtrlOpacity->GetId()            ,wxEVT_COMMAND_SPINCTRL_UPDATED,(wxObjectEventFunction)(void (wxPanel::*)(wxScrollEvent&)) &WidgetShowNPoints::UpdatePoints);
 275
 276
 277         } // if mtype 0 3
 278         Connect(cbAutoAddPoints->GetId()    , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &WidgetShowNPoints::OnAutoAddPoints       );
 279         Connect(btnBackPoint->GetId()       , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnBackPoint           );
 280         Connect(btnNextPoint->GetId()       , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnNextPoint           );
 281                 Connect(btnAddPoint->GetId()            , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnAddPoint            );
 282                 Connect(btnInsertPoint->GetId()         , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnInsertPoint         );
 283         Connect(btnMovePointUp->GetId()     , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnMovePointUp         );
 284         Connect(btnMovePointDown->GetId()   , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnMovePointDown       );
 285                 Connect(btnSetPositionPoint->GetId(), wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnSetPoint            );
 286                 Connect(btnRenamePoint->GetId()         , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnRenamePoint         );
 287 //              Connect(btnEraseLastPoint->GetId()      , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnEraseLastPoint      );
 288                 Connect(btnErasePoint->GetId()          , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnErasePoint          );
 289                 Connect(btnDeleteAllPoints->GetId()     , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnDeleteAllPoints     );
 290         Connect(cbTrackPoint->GetId()       , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &WidgetShowNPoints::OnTrackPoint          );
 291         wxFlexGridSizer *sizer0 = new wxFlexGridSizer(1);
 292         wxFlexGridSizer *sizer1 = new wxFlexGridSizer(2);
 293         wxFlexGridSizer *sizer2 = new wxFlexGridSizer(3);
 294         wxFlexGridSizer *sizer3 = new wxFlexGridSizer(2);
 295         wxFlexGridSizer *sizer4 = new wxFlexGridSizer(3);
 296 //        wxFlexGridSizer *sizer5 = new wxFlexGridSizer(2);
 297         wxFlexGridSizer *sizer6 = new wxFlexGridSizer(2);
 298         wxFlexGridSizer *sizer7 = new wxFlexGridSizer(2);
 299         wxFlexGridSizer *sizer8 = new wxFlexGridSizer(2);
 300         sizer1->Add( textCtrl               );
 301         sizer1->Add( btnRenamePoint         );
 302         sizer2->Add( btnAddPoint            );
 303         sizer2->Add( btnInsertPoint         );
 304 //        sizer2->Add( cbAutoAddPoints      );
 305         sizer3->Add( btnSetPositionPoint    );
 306         sizer3->Add( cbTrackPoint           );
 307         sizer4->Add( btnErasePoint          );
 308 //        sizer4->Add( btnEraseLastPoint    );
 309         sizer4->Add( btnDeleteAllPoints     );
 310 //        sizer5->Add( btnUndo                );
 311 //        sizer5->Add( btnRedo                );
 312         sizer6->Add( btnBackPoint           );
 313         sizer6->Add( btnNextPoint           );
 314         sizer7->Add( btnMovePointUp         );
 315         sizer7->Add( btnMovePointDown       );
 316         sizer8->Add( cbAutoAddPoints        );
 317         sizer8->Add( txtNrPoints            );
 318         //              sizer0->Add(askPointLabel); // JPR
 319         sizer0->Add(sizer8);
 320         sizer0->Add(sizer6);
 321         sizer0->Add(sizer2);
 322         sizer0->Add(sizer7);
 323                 sizer0->Add(sizer3);
 324         sizer0->Add(sizer4);
 325         sizer0->Add(sizer1);
 326   //      sizer0->Add(sizer5);
 327         if ( (mtype==0) || (mtype==3) )
 328         {
 329             wxFlexGridSizer *sizer5 = new wxFlexGridSizer(2);
 330 //            sizer5->Add(txRadio);
 331 //            sizer5->Add(sdrRadio,1,wxGROW );
 332 //            sizer5->Add(txOpacity);
 333 //            sizer5->Add(sdrOpacity,1,wxGROW );
 334             sizer5->Add( sCtrlRadio      );
 335             sizer5->Add( sCtrlOpacity    );
 336             sizer0->Add(sizer5);
 337         }  // if mtype 0 3
 338         if ( mtype==0 )
 339                 {
 340             wxFlexGridSizer *sizer5 = new wxFlexGridSizer(2);
 341             wxFlexGridSizer *sizer6 = new wxFlexGridSizer(2);
 342                         sizer6->Add( btnSavePoints  );
 343                         sizer6->Add( btnLoadPoints  );
 344             sizer5->Add( btnUndo        );
 345             sizer5->Add( btnRedo        );
 346             sizer0->Add( sizer6         );
 347             sizer0->Add( sizer5         );
 348                 } // if mtype 0
 349                 sizer = sizer0;
 350         }
 351
 352           if (mtype==1)
 353           {
 354                   // Widget interface
 355                   wxButton *btnSetPositionPoint         = new wxButton( panel, -1, _T("Set nearest point"));
 356                   txtNrPoints                                           = new wxStaticText(panel,-1, _T("-/-"));
 357
 358                   //NTU: Sliders for opacity and radio change
 359 //          sdrRadio                            = new wxSlider(panel, -1, 0, 1, 50, wxDefaultPosition, wxDefaultSize, wxSL_LABELS);
 360 //          sdrOpacity                        = new wxSlider(panel, -1, 0, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_LABELS);
 361 //          Connect(sdrOpacity->GetId()           , wxEVT_COMMAND_SLIDER_UPDATED    , (wxObjectEventFunction) &WidgetShowNPoints::UpdatePoints);
 362 //          Connect(sdrRadio->GetId()             , wxEVT_COMMAND_SLIDER_UPDATED    , (wxObjectEventFunction) &WidgetShowNPoints::UpdatePoints);
 363                   wxStaticText* txOpacity                       = new wxStaticText(panel, -1, wxString(_T("  Points Opacity  ")));
 364                   wxStaticText* txRadio                         = new wxStaticText(panel, -1, wxString(_T("  Points Radio  ")));
 365
 366           sCtrlRadio = new wxSpinCtrl( panel, -1  , wxEmptyString, wxDefaultPosition, sizeButton );
 367           sCtrlRadio->SetRange(1,10);
 368           sCtrlRadio->SetValue( 2 );
 369           sCtrlOpacity= new wxSpinCtrl( panel, -1  , wxEmptyString, wxDefaultPosition, sizeButton );
 370           sCtrlOpacity->SetRange(0,10);
 371           sCtrlOpacity->SetValue( 10 );
 372           Connect( sCtrlRadio->GetId()              ,wxEVT_COMMAND_SPINCTRL_UPDATED,(wxObjectEventFunction)(void (wxPanel::*)(wxScrollEvent&)) &WidgetShowNPoints::UpdatePoints);
 373           Connect( sCtrlOpacity->GetId()            ,wxEVT_COMMAND_SPINCTRL_UPDATED,(wxObjectEventFunction)(void (wxPanel::*)(wxScrollEvent&)) &WidgetShowNPoints::UpdatePoints);
 374                   Connect(btnSetPositionPoint->GetId()  , wxEVT_COMMAND_BUTTON_CLICKED  , (wxObjectEventFunction) &WidgetShowNPoints::OnSetPoint);
 375           wxFlexGridSizer *sizer1           = new wxFlexGridSizer(1);
 376                   sizer1->Add(btnSetPositionPoint);
 377                   sizer1->Add(txtNrPoints);
 378                   sizer1->Add(txRadio);
 379                   //sizer1->Add(sdrRadio,1,wxGROW );
 380           //sizer1->Add(sdrOpacity,1,wxGROW );
 381           sizer1->Add(sCtrlRadio );
 382           sizer1->Add(sCtrlOpacity);
 383                   sizer = sizer1;
 384           }
 385
 386     if (mtype == 2)
 387         {
 388                 askPointLabel                                           = new wxStaticText(panel, -1, _T("\nPOINT CONTROLS:")); // JPR
 389         wxButton                *btnAddPoint            = new wxButton(panel    , -1, _T("      Add  Point      "));
 390         wxButton                *btnDeleteAllPoints = new wxButton(panel    , -1, _T("      Delete All      "));
 391         wxStaticText    *spacer                         = new wxStaticText(panel, -1, _T("\n")); // JPR
 392                                          textCtrl                       = new wxTextCtrl(panel, -1);
 393         Connect(btnAddPoint->GetId(), wxEVT_COMMAND_BUTTON_CLICKED, (wxObjectEventFunction) & WidgetShowNPoints::OnAddPoint);
 394         Connect(btnDeleteAllPoints->GetId(), wxEVT_COMMAND_BUTTON_CLICKED, (wxObjectEventFunction) & WidgetShowNPoints::OnDeleteAllPoints);
 395         wxFlexGridSizer *sizer1             = new wxFlexGridSizer(1);
 396         sizer1->Add(askPointLabel);
 397         sizer1->Add(btnAddPoint);
 398         sizer1->Add(btnDeleteAllPoints);
 399         sizer1->Add(spacer);
 400         sizer1->Add(textCtrl);
 401       //  sdrOpacity                          = new wxSlider();
 402       //  sdrRadio                            = new wxSlider();
 403         txtNrPoints                         = new wxStaticText(panel, -1, _T("\n\n\n"));
 404         sizer                               = sizer1;
 405         } // bbGetInputType 2
 406
 407     panel->SetSizer(sizer);
 408     panel->SetAutoLayout(true);
 409     panel->Layout();
 410     bookSetPoints->AddPage(panel , _T("Points") );
 411
 412     if ((mtype >= 0) && (mtype <= 3) )
 413     {
 414         if (sizer!=NULL)
 415         {
 416             wxFlexGridSizer *sizerParent             = new wxFlexGridSizer(1);
 417             sizerParent->Add( bookSetPoints );
 418             panelParent->SetSizer( sizerParent );
 419             panelParent->SetAutoLayout(true);
 420             panelParent->Layout();
 421         } // if sizer
 422     } // if  mtype 0 1 2 3
 423
 424     if (mtype == 4)
 425     {
 426         if ((sizer!=NULL) && (MNPsizer!=NULL))
 427         {
 428             wxFlexGridSizer *sizerG             = new wxFlexGridSizer(2);
 429             sizerG->Add(bookGroupManager);
 430             sizerG->Add(bookSetPoints);
 431             panelParent->SetSizer(sizerG);
 432             panelParent->SetAutoLayout(true);
 433             panelParent->Layout();
 434         } // if sizer
 435     } // if mtype 4
 436 }
 437
 438 //------------------------------------------------------------------------
 439 WidgetShowNPoints::~WidgetShowNPoints()
 440 {
 441 }
 442
 443 //------------------------------------------------------------------------
 444 ModelShowNPoints* WidgetShowNPoints::GetModelShowNPoints()
 445 {
 446     // EED 2022-05-19
 447     // return mmodelShowNPoints;
 448     return lstModelShowNPoints[ mActualCollection ];
 449 }
 450
 451 //------------------------------------------------------------------------
 452 ModelShowNPoints* WidgetShowNPoints::GetModelShowNPoints(int id)
 453 {
 454         if(id >= 0 && id < lstModelShowNPoints.size())
 455         {
 456                 return lstModelShowNPoints[ id ];
 457         }
 458 }
 459
 460 // EED 2022-05-19
 461 //------------------------------------------------------------------------
 462 ViewShowNPoints* WidgetShowNPoints::GetViewShowNPoints()
 463 {
 464     return lstViewShowNPoints[ mActualCollection ];
 465 }
 466
 467
 468 //------------------------------------------------------------------------
 469 void WidgetShowNPoints::SetRadio(double radio)
 470 {
 471     // EED 2022-05-19
 472     // GetModelShowNPoints()->SetRadio(radio);
 473     int i,size = lstModelShowNPoints.size();
 474     for (i=0;i<size;i++)
 475     {
 476         lstModelShowNPoints[i]->SetRadio( radio );
 477     } // for i
 478         //NTU: For Slider
 479 //      sdrRadio->SetValue(radio);
 480     sCtrlRadio->SetValue(radio);
 481 }
 482
 483 //------------------------------------------------------------------------
 484 void WidgetShowNPoints::SetColour(std::vector<double> colour)
 485 {
 486     // EED 2022-05-19
 487     //this->mcolour = colour;
 488     int i,size = lstViewShowNPoints.size();
 489     for (i=0 ; i<size ; i++)
 490     {
 491         lstViewShowNPoints[i]->mcolour = colour;
 492     } // for i
 493 }
 494
 495 //------------------------------------------------------------------------
 496 void WidgetShowNPoints::SetImage(vtkImageData* image)
 497 {
 498     // EED 2022-05-19
 499         //GetModelShowNPoints()->SetImage(image);
 500     int i,size = lstModelShowNPoints.size();
 501     for (i=0 ; i<size ; i++)
 502     {
 503         lstModelShowNPoints[i]->SetImage(image);
 504     } // for i
 505 }
 506
 507 //------------------------------------------------------------------------
 508 void WidgetShowNPoints::SetOpacity(double opacity)
 509 {
 510     // EED 2022-05-19
 511         //this->mopacity=opacity;
 512     int i,size = lstViewShowNPoints.size();
 513     for (i=0 ; i<size ; i++)
 514     {
 515         lstViewShowNPoints[i]->mopacity = opacity;
 516     } // for i
 517         //NTU: For Slider
 518 //      sdrOpacity->SetValue( opacity*100.0 );
 519     sCtrlOpacity->SetValue( opacity*10.0 );
 520
 521 }
 522
 523
 524 //------------------------------------------------------------------------
 525 void  WidgetShowNPoints::SetRenderer(vtkRenderer *renderer)
 526 {
 527     // EED 2022-05-19
 528         //this->renderer        = renderer;
 529     int i,size = lstViewShowNPoints.size();
 530     for (i=0 ; i<size ; i++)
 531     {
 532         lstViewShowNPoints[i]->renderer = renderer;
 533     } // for i
 534 }
 535
 536 /* EED 2022-05-19
 537 //------------------------------------------------------------------------
 538
 539 void WidgetShowNPoints::RefreshPoint(int id)
 540 {
 541         double spc[3];
 542         int x,y,z;
 543         GetModelShowNPoints()->GetIdPoint(id,&x,&y,&z);
 544         GetModelShowNPoints()->GetImage()->GetSpacing(spc);
 545         std::string label       = GetModelShowNPoints()->GetIdLabel(id);
 546         double radio            = GetModelShowNPoints()->GetRadio();
 547     lstActorsSphere[id]->SetPosition( spc[0]*x , spc[1]*y , spc[2]*z );
 548     lstActorsSphere[id]->GetProperty()->SetColor( mcolour[0] , mcolour[1] , mcolour[2] );
 549     lstActorsSphere[id]->GetProperty()->SetOpacity( mopacity );
 550     lstSourceSphere[id]->SetRadius( radio );
 551 //EED 2017-01-01 Migration VTK7
 552 #if VTK_MAJOR_VERSION <= 5
 553         // ..
 554 #else
 555     lstSourceSphere[id]->Update();
 556 #endif
 557     lstActorsText[id]->SetInput( label.c_str()  );
 558     lstActorsText[id]->SetPosition(  radio+spc[0]*x , spc[1]*y , spc[2]*z );
 559 }
 560
 561 //------------------------------------------------------------------------
 562 void WidgetShowNPoints::RefreshPoints()
 563 {
 564         int id,size=lstActorsSphere.size();
 565         for (id=0;id<size;id++)
 566         {
 567                 RefreshPoint(id);
 568         } // for
 569         renderer->GetRenderWindow()->Render();
 570 }
 571
 572 //------------------------------------------------------------------------
 573 void WidgetShowNPoints::AddVtkPoint()
 574 {
 575         // Sphere
 576         vtkSphereSource *vtksphere = vtkSphereSource::New();
 577         vtksphere->SetThetaResolution (20);
 578         vtksphere->SetPhiResolution (20);
 579         vtksphere->SetRadius( 1 );
 580         //NTU: For updating points
 581         lstSourceSphere.push_back(vtksphere);
 582         vtkPolyDataMapper *sphereMapper = vtkPolyDataMapper::New();
 583
 584 //EED 2017-01-01 Migration VTK7
 585 #if VTK_MAJOR_VERSION <= 5
 586         sphereMapper->SetInput( vtksphere->GetOutput() );
 587 #else
 588         vtksphere->Update();
 589         sphereMapper->SetInputData( vtksphere->GetOutput() );
 590 #endif
 591
 592         vtkActor *sphereActor   = vtkActor::New();
 593         sphereActor->SetMapper(sphereMapper);
 594         sphereActor->SetOrigin(0, 0, 0);
 595
 596         lstActorsSphere.push_back(sphereActor);
 597         if(renderer==NULL){
 598                 wxMessageDialog dialog(this, _T("Renderer Not Set"),_T("Renderer Not Set"),wxICON_ERROR);
 599                 dialog.ShowModal();
 600                 return;
 601         }
 602         renderer->AddActor( sphereActor );
 603         // Actor
 604         vtkTextActor3D *textActor = vtkTextActor3D::New();
 605 //      textActor->SetInput( strLabel.c_str()  );
 606         renderer->AddActor( textActor );
 607         lstActorsText.push_back(textActor);
 608 }
 609  */
 610
 611
 612 void WidgetShowNPoints::SetCurrentPoint(int idCurrentPoint )
 613 {
 614     int size = GetModelShowNPoints()->GetLstPointsSize();
 615     if (idCurrentPoint<0)       { idCurrentPoint = size-1;  }
 616     if (idCurrentPoint>=size )  { idCurrentPoint = 0;       }
 617     GetModelShowNPoints()->SetIdCurrentPoint( idCurrentPoint );
 618     RefreshCollectionText();
 619     RefreshColourCollection();
 620 }
 621
 622 void WidgetShowNPoints::OnBackPoint(wxCommandEvent &event)
 623 {
 624     SetCurrentPoint(  GetModelShowNPoints()->GetIdCurrentPoint() - 1 );
 625 }
 626
 627 void WidgetShowNPoints::OnNextPoint(wxCommandEvent &event)
 628 {
 629     SetCurrentPoint(  GetModelShowNPoints()->GetIdCurrentPoint() + 1 );
 630 }
 631
 632
 633 //------------------------------------------------------------------------
 634 void WidgetShowNPoints::AddPoint(double x, double y, double z, std::string label)
 635 {
 636         GetModelShowNPoints()->AddPoint(x,y,z, label );
 637     // EED 2022-05-19
 638     //AddVtkPoint();
 639     //RefreshPoint(lstActorsSphere.size()-1);
 640     GetViewShowNPoints()->AddPoint();
 641 }
 642
 643 //------------------------------------------------------------------------
 644 void WidgetShowNPoints::InsertPoint(double x, double y, double z, std::string label)//CFT
 645 {
 646     // EED 2022-05-19
 647         //if ( GetModelShowNPoints()->InsertPoint(x,y,z,label) != -1 )
 648         //{
 649     //    AddVtkPoint();
 650         //} else {
 651         //      AddPoint(x,y,z,label);
 652         //}
 653         //RefreshPoints();
 654     if ( GetModelShowNPoints()->InsertPoint(x,y,z,label) != -1 )
 655     {
 656         GetViewShowNPoints()->AddVtkPoint();
 657     } else {
 658         AddPoint(x,y,z,label);
 659     }
 660     GetViewShowNPoints()->RefreshPoints();
 661 }
 662
 663 //------------------------------------------------------------------------
 664 void WidgetShowNPoints::OnInsertPoint_()
 665 {
 666     // EED 2022-05-19
 667     //if (this->renderer==NULL)
 668
 669     StopAutoAddPoints();
 670     StopTrackPoint();
 671
 672     if (GetViewShowNPoints()->renderer==NULL)
 673     {
 674         return;
 675     }
 676     UndoRedo_SaveCollection(); //A
 677     std::vector<double> point = GetModelShowNPoints()->GetReferencePoint();
 678     if (point.size()==3)
 679     {
 680         InsertPoint(point[0],point[1],point[2], (const char*) ( textCtrl->GetValue().mb_str() ) );
 681         SetOutputBox();
 682     } else {//mpoint.size
 683         printf("creaMaracasVisu::ShowNPoints (not match point) \n");
 684     }
 685     RefreshCollectionText();
 686     RefreshColourCollection();
 687     UndoRedo_SaveCollection(); //B
 688 }
 689
 690 //------------------------------------------------------------------------
 691 void WidgetShowNPoints::OnInsertPoint (wxCommandEvent& event)//CFT
 692 {
 693     OnInsertPoint_();
 694 }
 695
 696 //------------------------------------------------------------------------
 697 void WidgetShowNPoints::OnAddPoint__()
 698 {
 699     // EED 2022-05-19
 700         //if (this->renderer==NULL)
 701     if (GetViewShowNPoints()->renderer==NULL)
 702         {
 703                 return;
 704         }
 705         std::vector<double> point = GetModelShowNPoints()->GetReferencePoint();
 706         if (point.size()==3)
 707         {
 708         UndoRedo_SaveCollection(); //A
 709                 AddPoint(point[0],point[1],point[2], (const char*) ( textCtrl->GetValue().mb_str() ) );
 710         SetOutputBox();
 711         // EED 2022-05-19
 712         //renderer->GetRenderWindow()->Render();
 713         GetViewShowNPoints()->Render();
 714         UndoRedo_SaveCollection(); //B
 715         } else {//mpoint.size
 716                 printf("creaMaracasVisu::ShowNPoints (not match point) \n");
 717         }
 718 }
 719
 720 void WidgetShowNPoints::OnAddPoint_()
 721 {
 722     StopAutoAddPoints();
 723     StopTrackPoint();
 724     OnAddPoint__();
 725 }
 726
 727 //------------------------------------------------------------------------
 728 void WidgetShowNPoints::OnAddPoint (wxCommandEvent& event)
 729 {
 730     OnAddPoint_();
 731 }
 732
 733 //------------------------------------------------------------------------
 734 void WidgetShowNPoints::AutoAddPoints()
 735 {
 736     if ( cbAutoAddPoints->GetValue() == true )
 737     {
 738         OnAddPoint__();
 739         RefreshCollectionText();
 740         RefreshColourCollection();
 741     } // if cbAutoAddPoints
 742 }
 743
 744 //------------------------------------------------------------------------
 745 void WidgetShowNPoints::OnAutoAddPoints_tool()
 746 {
 747     StopTrackPoint();
 748     cbAutoAddPoints->SetValue( !cbAutoAddPoints->GetValue() );
 749 }
 750
 751 //------------------------------------------------------------------------
 752 void WidgetShowNPoints::OnAutoAddPoints_()
 753 {
 754     StopTrackPoint();
 755 }
 756
 757 //------------------------------------------------------------------------
 758 void WidgetShowNPoints::OnAutoAddPoints(wxCommandEvent& event)
 759 {
 760     StopTrackPoint();
 761 }
 762
 763 //------------------------------------------------------------------------
 764 void WidgetShowNPoints::StopAutoAddPoints( )
 765 {
 766     cbAutoAddPoints->SetValue(false);
 767 }
 768
 769 //------------------------------------------------------------------------
 770         void WidgetShowNPoints::SetOutputBox()
 771         {
 772                 wxString strTmp;
 773         if (GetModelShowNPoints()->GetIdCurrentPoint()<0)
 774         {
 775             strTmp.Printf(_T("   -/%d") , GetModelShowNPoints()->GetLstPointsSize() );
 776         } else {
 777             strTmp.Printf(_T("   %d/%d"), GetModelShowNPoints()->GetIdCurrentPoint()+1 , GetModelShowNPoints()->GetLstPointsSize() );
 778         }// if IdCurrent<0
 779                 txtNrPoints->SetLabel( strTmp );
 780                 //--BBTK
 781
 782 //EED 2017-06-03
 783 //              mbbShowNPoints->bbSetOutputlstPointsX( GetModelShowNPoints()->GetLstPointsX() );
 784 //              mbbShowNPoints->bbSetOutputlstPointsY( GetModelShowNPoints()->GetLstPointsY() );
 785 //              mbbShowNPoints->bbSetOutputlstPointsZ( GetModelShowNPoints()->GetLstPointsZ() );
 786 //              mbbShowNPoints->bbSetOutputlstLabels( GetModelShowNPoints()->GetLstLabels() );
 787 //              mbbShowNPoints->bbSignalOutputModification();
 788         }
 789
 790
 791 //------------------------------------------------------------------------
 792         void WidgetShowNPoints::OnSavePoints(wxCommandEvent& event)
 793         {
 794
 795 //EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
 796 #if wxMAJOR_VERSION <= 2
 797                 wxFileDialog* FD = new wxFileDialog( 0,
 798                                             _T("Save points .."),
 799                                             _T(""),
 800                                             _T(""),
 801                                             _T("(*.xls)|*.xls"),
 802                                             wxSAVE | wxOVERWRITE_PROMPT,
 803                                             wxDefaultPosition);
 804 #else
 805                 wxFileDialog* FD = new wxFileDialog( 0,
 806                                             _T("Save points .."),
 807                                             _T(""),
 808                                             _T(""),
 809                                             _T("(*.xls)|*.xls"),
 810                                             wxFD_SAVE | wxFD_OVERWRITE_PROMPT,
 811                                             wxDefaultPosition);
 812 #endif
 813
 814                 int result_FD = FD->ShowModal();
 815                 // This line is need it by windows //EED
 816                 FD->SetReturnCode( result_FD );
 817                 if (FD->GetReturnCode()==wxID_OK)
 818                 {
 819                         std::string filename= (const char*) ( FD->GetPath().mb_str() );
 820                         GetModelShowNPoints()->SavePoints( filename );
 821                 }       // dialog box
 822         }
 823
 824
 825 //------------------------------------------------------------------------
 826         void WidgetShowNPoints::OnLoadPoints(wxCommandEvent& event)
 827         {
 828
 829 //EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
 830 #if wxMAJOR_VERSION <= 2
 831                 wxFileDialog* FD = new wxFileDialog( 0,
 832                                              _T("Load points .."),
 833                                              _T(""),
 834                                              _T(""),
 835                                              _T("(*.xls)|*.xls"),
 836                                              wxOPEN | wxFILE_MUST_EXIST,
 837                                              wxDefaultPosition);
 838 #else
 839                 wxFileDialog* FD = new wxFileDialog( 0,
 840                                              _T("Load points .."),
 841                                              _T(""),
 842                                              _T(""),
 843                                              _T("(*.xls)|*.xls"),
 844                                              wxFD_OPEN | wxFD_FILE_MUST_EXIST,
 845                                              wxDefaultPosition);
 846 #endif
 847                 int i;
 848                 //EED
 849                 int result_FD = FD->ShowModal();
 850                 // This line is need it by windows //EED
 851                 FD->SetReturnCode( result_FD );
 852                 if (FD->GetReturnCode()==wxID_OK)
 853                 {
 854
 855                         std::string filename= (const char*) ( FD->GetPath().mb_str() );
 856                         int numberPointsRead = GetModelShowNPoints()->ReadPoints( filename );
 857                         for (i=0;i<numberPointsRead;i++)
 858                         {
 859                 // EED 2022-05-19
 860                 //AddVtkPoint();
 861                 GetViewShowNPoints()->AddVtkPoint();
 862                         }// for
 863                         SetOutputBox();
 864             // EED 2022-05-19
 865                         //RefreshPoints();
 866             GetViewShowNPoints()->RefreshPoints();
 867                 }       // dialog box
 868         }
 869
 870 //------------------------------------------------------------------------
 871 void WidgetShowNPoints::OnSetPoint_()
 872 {
 873     UndoRedo_SaveCollection(); //A
 874
 875     StopAutoAddPoints();
 876     StopTrackPoint();
 877
 878     //int id=GetModelShowNPoints()->GetNearestPoint();
 879     int id=GetModelShowNPoints()->GetIdCurrentPoint();
 880
 881     if((id==-1) && (mtype==1))
 882     {
 883         id=0;
 884         AddPoint(0,0,0,"");
 885         SetOutputBox();
 886     }
 887     if (id>=0)
 888     {
 889         GetModelShowNPoints()->SetPointId_mReferencePoint(id);
 890         // EED 2022-05-19
 891         //RefreshPoint(id);
 892         //renderer->GetRenderWindow()->Render();
 893         GetViewShowNPoints()->RefreshPoint(id);
 894         GetViewShowNPoints()->Render();
 895     } // if id
 896     RefreshCollectionText();
 897     RefreshColourCollection();
 898     SetOutputBox();
 899     UndoRedo_SaveCollection(); //B
 900 }
 901
 902 //------------------------------------------------------------------------
 903 void WidgetShowNPoints::OnSetPoint(wxCommandEvent& event)
 904 {
 905     OnSetPoint_();
 906 }
 907
 908 //------------------------------------------------------------------------
 909 void WidgetShowNPoints::MovePoint_(double step)
 910 {
 911     step=step;
 912     StopAutoAddPoints();
 913     StopTrackPoint();
 914     int id=GetModelShowNPoints()->GetIdCurrentPoint();
 915     if (aux_mesh!=NULL)
 916     {
 917         if((GetLstModelShowNPointsSize()>=2)  //Check condition
 918             && (GetModelShowNPoints()->GetLstPointsSize()>0)
 919             && (aux_mesh != NULL)
 920             && (aux_mesh_spc.size() == 3))
 921         {
 922             double              x,y,z;
 923             double              p[3];
 924             double              normal[3];      // point to modify and normal
 925             std::vector<double> pN(3);          // new point
 926             vtkStaticPointLocator   *pointLocator   = vtkStaticPointLocator::New();
 927             pointLocator->SetDataSet( aux_mesh );
 928             pointLocator->BuildLocator();
 929
 930     //        int idControlPoint = wsp->GetModelShowNPoints()->GetNearestPoint();
 931             int idControlPoint = GetModelShowNPoints()->GetIdCurrentPoint();
 932             if(idControlPoint >= 0)
 933             {
 934                 GetModelShowNPoints()->GetIdPoint(idControlPoint, &x, &y, &z);
 935                 p[0] = x * aux_mesh_spc[0];
 936                 p[1] = y * aux_mesh_spc[1];
 937                 p[2] = z * aux_mesh_spc[2];
 938                 long int idMeshPoint = pointLocator->FindClosestPoint(p);
 939                 vtkDataArray *dataArrayNormals = aux_mesh->GetPointData()->GetNormals();
 940                 if (dataArrayNormals!=NULL)
 941                 {
 942                     dataArrayNormals->GetTuple(idMeshPoint, normal);
 943                     int direction = step;
 944     //                pN[0] = p[0] / spc[0] + direction*normal[0];
 945     //                pN[1] = p[1] / spc[1] + direction*normal[1];
 946     //                pN[2] = p[2] / spc[2] + direction*normal[2];
 947                     pN[0] = x + (direction * normal[0]);
 948                     pN[1] = y + (direction * normal[1]);
 949                     pN[2] = z + (direction * normal[2]);
 950                     UndoRedo_SaveCollection(); //A
 951                     GetModelShowNPoints()->SetPointById(idControlPoint, pN);
 952         //          GetViewShowNPoints()->RefreshPoint(idControlPoint);
 953     //                RefreshCollectionText();
 954     //                RefreshColourCollection();
 955     //                SetOutputBox();
 956                     UndoRedo_SaveCollection(); //B
 957                 } else {
 958                     printf("Error!  WidgetShowNPoints::MovePoint_  Missing normals in aux_mesh  \n");
 959                 }
 960             } // if idControlPoint
 961         } // if wsp->GetLstModelShowNPointsSiz->size()>=2
 962     } else {
 963         if (id>=0) {
 964             int i,j,sizeG,sizeP;
 965             double max=100000;
 966             double minX=max,minY=max,minZ=max;
 967             double maxX=-max,maxY=-max,maxZ=-max;
 968             sizeG = lstModelShowNPoints.size();
 969             for (i=0; i<sizeG; i++)
 970             {
 971                 std::vector<double> lstX = lstModelShowNPoints[i]->GetLstPointsX();
 972                 std::vector<double> lstY = lstModelShowNPoints[i]->GetLstPointsY();
 973                 std::vector<double> lstZ = lstModelShowNPoints[i]->GetLstPointsZ();
 974                 sizeP=lstX.size();
 975                 for (j=0; j<sizeP; j++)
 976                 {
 977                     if ( lstX[j]<minX ) { minX=lstX[j]; }
 978                     if ( lstY[j]<minY ) { minY=lstY[j]; }
 979                     if ( lstZ[j]<minZ ) { minZ=lstZ[j]; }
 980                     if ( lstX[j]>maxX ) { maxX=lstX[j]; }
 981                     if ( lstY[j]>maxY ) { maxY=lstY[j]; }
 982                     if ( lstZ[j]>maxZ ) { maxZ=lstZ[j]; }
 983                 } // for j
 984             } // for i
 985             double pc[3];
 986             pc[0]=(minX+maxX) /2 ;  pc[1]=(minY+maxY) /2 ;  pc[2]=(minZ+maxZ) /2 ;
 987             double p[3];
 988             p[0]=GetModelShowNPoints()->GetLstPointsX()[id];
 989             p[1]=GetModelShowNPoints()->GetLstPointsY()[id];
 990             p[2]=GetModelShowNPoints()->GetLstPointsZ()[id];
 991             double v[3];
 992             v[0] = p[0]-pc[0];
 993             v[1] = p[1]-pc[1];
 994             v[2] = p[2]-pc[2];
 995             double mag=sqrt ( v[0]*v[0] + v[1]*v[1] + v[2]*v[2] );
 996             std::vector<double> point;
 997             if (mag!=0)
 998             {
 999                 v[0] = v[0]/mag;
1000                 v[1] = v[1]/mag;
1001                 v[2] = v[2]/mag;
1002             } else {
1003                 v[0] = 0;
1004                 v[1] = 0;
1005                 v[2] = 0;
1006             }// if mag
1007             UndoRedo_SaveCollection(); //A
1008             point.push_back( p[0] + step*v[0] );
1009             point.push_back( p[1] + step*v[1] );
1010             point.push_back( p[2] + step*v[2] );
1011             GetModelShowNPoints()->SetPointById(id,point);
1012             UndoRedo_SaveCollection(); //B
1013      } // if id
1014     } // if aux_mesh
1015  RefreshCollectionText();
1016  RefreshColourCollection();
1017 }
1018
1019 //------------------------------------------------------------------------
1020 void WidgetShowNPoints::OnMovePointUp(wxCommandEvent& event)
1021 {
1022     MovePoint_(-1);
1023 }
1024
1025 //------------------------------------------------------------------------
1026 void WidgetShowNPoints::OnMovePointDown(wxCommandEvent& event)
1027 {
1028     MovePoint_(+1);
1029 }
1030
1031 //------------------------------------------------------------------------
1032 void WidgetShowNPoints::TrackingPoint( )
1033 {
1034     if ( cbTrackPoint->GetValue() == true )
1035     {
1036 //        int id = GetModelShowNPoints()->IdInsidePoint();
1037 //        if (id>=0)
1038 //        {
1039 //            idTrack=id;
1040 //        }
1041
1042 //       int idTrack = GetModelShowNPoints()->GetIdCurrentPoint();
1043         int idTrack = GetModelShowNPoints()->GetNearestPoint();
1044
1045
1046         if (idTrack>=0)
1047         {
1048             UndoRedo_SaveCollection(); //A
1049             GetModelShowNPoints()->SetPointId_mReferencePoint(idTrack);
1050
1051             RefreshCollectionText();
1052             RefreshColourCollection();
1053
1054 //            GetViewShowNPoints()->RefreshPoint(idTrack);
1055 //            GetViewShowNPoints()->Render();
1056             UndoRedo_SaveCollection(); //B
1057         } // if id
1058     } // if trackPointFlag
1059 }
1060
1061 //------------------------------------------------------------------------
1062 void WidgetShowNPoints::OnTrackPoint_tool()
1063 {
1064     cbTrackPoint->SetValue( !cbTrackPoint->GetValue() );
1065     OnTrackPoint_();
1066 }
1067
1068 //------------------------------------------------------------------------
1069 void WidgetShowNPoints::OnTrackPoint_()
1070 {
1071     StopAutoAddPoints();
1072
1073 //    idTrack         =   -1;
1074     if ( cbTrackPoint->GetValue() == true )
1075     {
1076         // EED 2023-06-23
1077 //        idTrack = GetModelShowNPoints()->IdInsidePoint();
1078 //        idTrack = GetModelShowNPoints()->GetIdCurrentPoint();
1079     } // if trackPointFlag
1080 }
1081
1082 //------------------------------------------------------------------------
1083 void WidgetShowNPoints::OnTrackPoint(wxCommandEvent& event)
1084 {
1085     OnTrackPoint_();
1086 }
1087
1088 //------------------------------------------------------------------------
1089 void WidgetShowNPoints::StopTrackPoint( )
1090 {
1091     cbTrackPoint->SetValue(false);
1092 //    idTrack=-1;
1093 }
1094
1095 //------------------------------------------------------------------------
1096         void WidgetShowNPoints::OnRenamePoint(wxCommandEvent& event)
1097         {
1098                 int id = GetModelShowNPoints()->RenamePoint( (const char*) ( textCtrl->GetValue().mb_str() ) );
1099                 if (id>=0)
1100                 {
1101             // EED 2022-05-19
1102                         //lstActorsText[id]->SetInput(  (const char*) ( textCtrl->GetValue().mb_str() ) );
1103                         //renderer->GetRenderWindow()->Render();
1104             UndoRedo_SaveCollection(); //A
1105             GetViewShowNPoints()->lstActorsText[id]->SetInput(  (const char*) ( textCtrl->GetValue().mb_str() ) );
1106             GetViewShowNPoints()->Render();
1107             SetOutputBox();
1108             UndoRedo_SaveCollection(); //B
1109                 } // if id
1110         }
1111
1112 //------------------------------------------------------------------------
1113         bool WidgetShowNPoints::ErasePoint(int id)
1114         {
1115         // EED 2022-05-19
1116                 //if (this->renderer!=NULL)
1117         bool ok=false;
1118         if (GetViewShowNPoints()->renderer!=NULL)
1119                 {
1120                         if (id>=0)
1121                         {
1122                 // EED 2022-05-19
1123                                 //renderer->RemoveActor( lstActorsSphere[id] );
1124                                 //renderer->RemoveActor( lstActorsText[id] );
1125                                 //lstActorsSphere[id]->Delete();
1126                                 //lstActorsText[id]->Delete();
1127                                 //lstSourceSphere[id]->Delete();
1128                                 //lstActorsSphere.erase( lstActorsSphere.begin()+id );
1129                                 //lstActorsText.erase( lstActorsText.begin()+id );
1130                                 //lstSourceSphere.erase( lstSourceSphere.begin()+id );
1131                 GetViewShowNPoints()->ErasePoint(id);
1132                                 GetModelShowNPoints()->ErasePoint(id);
1133                 ok=true;
1134                         } // if id
1135                 } // if renderer
1136         return ok;
1137         }
1138
1139 //------------------------------------------------------------------------
1140     void WidgetShowNPoints::OnErasePoint_()
1141     {
1142         StopAutoAddPoints();
1143         StopTrackPoint();
1144
1145         //ErasePoint( GetModelShowNPoints()->IdInsidePoint() );
1146         UndoRedo_SaveCollection(); //A
1147         if (ErasePoint( GetModelShowNPoints()->GetIdCurrentPoint() ) == true)
1148         {
1149             SetOutputBox();
1150             // EED 2022-05-19
1151             //renderer->GetRenderWindow()->Render();
1152             //        GetViewShowNPoints()->Render();
1153             RefreshCollectionText();
1154             RefreshColourCollection();
1155             StopTrackPoint();
1156             UndoRedo_SaveCollection(); //B
1157         }
1158     }
1159
1160 //------------------------------------------------------------------------
1161         void WidgetShowNPoints::OnErasePoint(wxCommandEvent& event)
1162         {
1163                 OnErasePoint_();
1164         }
1165
1166 //------------------------------------------------------------------------
1167         void WidgetShowNPoints::OnEraseLastPoint(wxCommandEvent& event)
1168         {
1169         // EED 2022-05-19
1170         //ErasePoint( lstActorsSphere.size()-1 );
1171         //renderer->GetRenderWindow()->Render();
1172         StopAutoAddPoints();
1173         StopTrackPoint();
1174
1175         UndoRedo_SaveCollection(); //A
1176         int id = GetViewShowNPoints()->lstActorsSphere.size()-1;
1177         ErasePoint( id );
1178
1179         RefreshCollectionText();
1180         RefreshColourCollection();
1181
1182         UndoRedo_SaveCollection(); //B
1183         GetViewShowNPoints()->Render();
1184         SetOutputBox();
1185         StopTrackPoint();
1186         }
1187
1188 //------------------------------------------------------------------------
1189 void WidgetShowNPoints::DeleteAllPoints_()
1190 {
1191     // EED 2022-05-19
1192     //int id,size=lstActorsSphere.size();
1193     int id,size=GetViewShowNPoints()->lstActorsSphere.size();
1194     for (id=size-1;id>=0;id--)
1195     {
1196         ErasePoint(id);
1197     }// for id
1198 }
1199
1200 void WidgetShowNPoints::OnDeleteAllPoints_()
1201 {
1202     StopAutoAddPoints();
1203     StopTrackPoint();
1204
1205     UndoRedo_SaveCollection(); //A
1206     DeleteAllPoints_();
1207     UndoRedo_SaveCollection(); //B
1208 }
1209
1210 //------------------------------------------------------------------------
1211 void WidgetShowNPoints::OnDeleteAllPoints(wxCommandEvent& event)
1212 {
1213         OnDeleteAllPoints_();
1214     SetOutputBox();
1215     GetViewShowNPoints()->Render();
1216 }
1217
1218 //NTU: Method for updating points opacity and Radio
1219
1220 //------------------------------------------------------------------------
1221 void WidgetShowNPoints::UpdatePoints_()
1222 {
1223     // EED 2022-05-19
1224     //this->mopacity = sdrOpacity->GetValue()/100.0;
1225     //GetModelShowNPoints()->SetRadio( sdrRadio->GetValue() ) ;
1226     //RefreshPoints();
1227
1228 //    double opacity  = sdrOpacity->GetValue()/100.0;
1229 //    double radio    = sdrRadio->GetValue();
1230     double opacity  = (sCtrlOpacity->GetValue()*10)/100.0;
1231      double radio    = sCtrlRadio->GetValue();
1232
1233     int i,size      = lstViewShowNPoints.size();
1234     for (i=0 ; i<size ; i++)
1235     {
1236         lstViewShowNPoints[i]->mopacity = opacity;
1237         lstModelShowNPoints[i]->SetRadio( radio ) ;
1238     } // for i
1239 //    GetViewShowNPoints()->RefreshPoints();
1240 }
1241
1242 //------------------------------------------------------------------------
1243 void WidgetShowNPoints::UpdatePoints(wxCommandEvent &event)
1244 {
1245     RefreshColourCollection();
1246 }
1247
1248 //------------------------------------------------------------------------
1249 void  WidgetShowNPoints::SetReferencePoint(std::vector<double> point)
1250 {
1251         GetModelShowNPoints()->SetReferencePoint(point);
1252     int i,size=lstModelShowNPoints.size();
1253     for (i=0;i<size;i++)
1254     {
1255         lstModelShowNPoints[i]->SetReferencePoint(point);    // All collection
1256     } // for i
1257 }
1258
1259 //------------------------------------------------------------------------
1260 void WidgetShowNPoints::SetActualCollection( int actual )
1261 {
1262     if (actual<0)
1263     {
1264         actual=0;
1265     } // if actual<0
1266
1267     if (actual>lstModelShowNPoints.size()-1 )
1268     {
1269         actual=lstModelShowNPoints.size()-1;
1270     } // if actual<0
1271
1272     mActualCollection=actual;
1273 }
1274
1275
1276 //------------------------------------------------------------------------
1277 void  WidgetShowNPoints::SetInitLstPoints( std::vector<double> initLstPointsX,  std::vector<double> initLstPointsY, std::vector<double> initLstPointsZ, std::vector<std::string> initLstLabels,   std::vector<int> initLstIndexs )
1278 {
1279     if (GetViewShowNPoints()->renderer==NULL)
1280     {
1281         return;
1282     }
1283     double x,y,z;
1284     std::string label;
1285     int i,sizeX,sizeY,sizeZ,sizeTmp,sizeLabels;
1286     int ii,iIndexs,sizeIndexs;
1287
1288     sizeX       = (int)initLstPointsX.size();
1289     sizeY       = (int)initLstPointsY.size();
1290     sizeZ       = (int)initLstPointsZ.size();
1291     sizeLabels  = (int)initLstLabels.size();
1292     sizeIndexs  = (int)initLstIndexs.size();
1293
1294     if (sizeIndexs==0)
1295     {
1296         initLstIndexs.push_back(sizeX);
1297         sizeIndexs  = (int)initLstIndexs.size();
1298     }
1299
1300     if ( (sizeX==sizeY) && (sizeX==sizeZ) )
1301     {
1302         i=0;
1303         for (iIndexs=0;iIndexs<sizeIndexs;iIndexs++ )
1304         {
1305             if (iIndexs!=0)
1306             {
1307                 InsertCollectionAfter_();
1308             }// if last iIndexs
1309             sizeTmp = initLstIndexs[iIndexs];
1310             for (ii=0;ii<sizeTmp;ii++)
1311             {
1312                 x        = initLstPointsX[i];
1313                 y        = initLstPointsY[i];
1314                 z        = initLstPointsZ[i];
1315                 if (i<sizeLabels)
1316                 {
1317                     label    = initLstLabels[i];
1318                 } else {
1319                     label="";
1320                 }
1321                 AddPoint( x,y,z,label );
1322                 i++;
1323             } // for i
1324
1325
1326         }// for ii
1327         //    SetOutputBox();
1328         //    renderer->GetRenderWindow()->Render();
1329     } // if size
1330
1331
1332
1333
1334     /*
1335
1336     // EED 2022-05-19
1337         //if (this->renderer==NULL)
1338     if (GetViewShowNPoints()->renderer==NULL)
1339         {
1340                 return;
1341         }
1342         int i,sizeX,sizeY,sizeZ,sizeLabels;
1343         sizeX = (int)initLstPointsX.size();
1344         sizeY = (int)initLstPointsY.size();
1345         sizeZ = (int)initLstPointsZ.size();
1346         sizeLabels = (int)initLstLabels.size();
1347         double x,y,z;
1348         std::string label;
1349         if ( (sizeX==sizeY) && (sizeX==sizeZ) )
1350         {
1351                 for (i=0;i<sizeX;i++)
1352                 {
1353                         x               = initLstPointsX[i];
1354                         y               = initLstPointsY[i];
1355                         z               = initLstPointsZ[i];
1356                         if (i<sizeLabels)
1357                         {
1358                                 label   = initLstLabels[i];
1359                         } else {
1360                                 label="";
1361                         }
1362                         AddPoint( x,y,z,label );
1363                 } // for i
1364                 //      SetOutputBox();
1365                 //      renderer->GetRenderWindow()->Render();
1366         } // if size
1367
1368    */
1369 }
1370
1371 //------------------------------------------------------------------------
1372 void WidgetShowNPoints::SetType(int type)
1373 {
1374         mtype=type;
1375 }
1376
1377 //------------------------------------------------------------------------
1378 int WidgetShowNPoints::GetType()
1379 {
1380         return mtype;
1381 }
1382
1383
1384 //------------------------------------------------------------------------
1385 double WidgetShowNPoints::GetRadio()
1386 {
1387 //      return sdrRadio->GetValue();
1388     return sCtrlRadio->GetValue();
1389 }
1390 //------------------------------------------------------------------------
1391 double WidgetShowNPoints::GetOpacity()
1392 {
1393 //    return sdrOpacity->GetValue()/100;
1394     return (sCtrlOpacity->GetValue()*10)/100.0;
1395 }
1396
1397 //------------------------------------------------------------------------
1398 void WidgetShowNPoints::InsertCollection()
1399 {
1400     ModelShowNPoints*   model   = new ModelShowNPoints();
1401     ViewShowNPoints*    view    = new ViewShowNPoints( model );
1402     view->mopacity              = lstViewShowNPoints[0]->mopacity;
1403     view->renderer              = lstViewShowNPoints[0]->renderer;
1404     model->SetImage( lstModelShowNPoints[0]->GetImage() );
1405     lstModelShowNPoints.insert( lstModelShowNPoints.begin()+mActualCollection , model );
1406     lstViewShowNPoints.insert( lstViewShowNPoints.begin()+mActualCollection , view );
1407 }
1408
1409 //------------------------------------------------------------------------
1410 void WidgetShowNPoints::InsertCollectionBefore_()
1411 {
1412     InsertCollection();
1413     RefreshCollectionText();
1414     RefreshColourCollection();
1415     StopTrackPoint();
1416 }
1417
1418 //------------------------------------------------------------------------
1419 void WidgetShowNPoints::OnInsertCollectionBefore_()
1420 {
1421     UndoRedo_SaveCollection(); //A
1422     InsertCollectionBefore_();
1423     CreatePointsIntoNewCollection();
1424     UndoRedo_SaveCollection(); //B
1425 }
1426
1427
1428 //------------------------------------------------------------------------
1429 void WidgetShowNPoints::OnInsertCollectionBefore(wxCommandEvent &event)
1430 {
1431     OnInsertCollectionBefore_();
1432 }
1433
1434
1435 //------------------------------------------------------------------------
1436 void WidgetShowNPoints::InsertCollectionAfter_()
1437 {
1438     mActualCollection++;
1439     InsertCollection();
1440     RefreshCollectionText();
1441     RefreshColourCollection();
1442     StopTrackPoint();
1443 }
1444
1445
1446 //------------------------------------------------------------------------
1447 void WidgetShowNPoints::OnInsertCollectionAfter_()
1448 {
1449     UndoRedo_SaveCollection(); //A
1450     InsertCollectionAfter_();
1451     CreatePointsIntoNewCollection();
1452     UndoRedo_SaveCollection(); //B
1453 }
1454
1455 //------------------------------------------------------------------------
1456 void WidgetShowNPoints::OnInsertCollectionAfter(wxCommandEvent &event)
1457 {
1458     OnInsertCollectionAfter_();
1459 }
1460
1461 //------------------------------------------------------------------------
1462 void WidgetShowNPoints::CreatePointsIntoNewCollection()
1463 {
1464     int c1          = mActualCollection-1;
1465     int c2          = mActualCollection+1;
1466     int modelSize   = lstModelShowNPoints.size();
1467     if (aux_mesh_type==2)  // SplineClose2
1468     {
1469         if (c1==-1)         { c1=modelSize-1;   }
1470         if (c2==modelSize)  { c2=0;             }
1471     } // if aux_mesh_type
1472
1473     if ( (c1!=c2) && (c1>=0) && (c1<modelSize) && (c2>=0) && (c2<modelSize) )
1474     {
1475         std::vector<double> c1LstX = lstModelShowNPoints[c1]->GetLstPointsX();
1476         std::vector<double> c1LstY = lstModelShowNPoints[c1]->GetLstPointsY();
1477         std::vector<double> c1LstZ = lstModelShowNPoints[c1]->GetLstPointsZ();
1478         std::vector<double> c2LstX = lstModelShowNPoints[c2]->GetLstPointsX();
1479         std::vector<double> c2LstY = lstModelShowNPoints[c2]->GetLstPointsY();
1480         std::vector<double> c2LstZ = lstModelShowNPoints[c2]->GetLstPointsZ();
1481         std::vector<double> c1LstXX;
1482         std::vector<double> c1LstYY;
1483         std::vector<double> c1LstZZ;
1484         std::vector<double> c2LstXX;
1485         std::vector<double> c2LstYY;
1486         std::vector<double> c2LstZZ;
1487         creaContoursFactory     f;
1488         manualContourModel      *m;
1489         double                  x,y,z;
1490         int                     i,ii,size;
1491         int                     sc; // sizeContour
1492
1493         if ( (c1LstX.size()!=0) && (c2LstX.size()!=0) )
1494         {
1495             // ----------------- Spline 1 --------------------
1496             sc          = 100;
1497             size        = c1LstX.size();
1498             m           = (manualContourModel*)f.getContourModel( 1 );  // Spline
1499             //        m->SetNumberOfPointsSpline( bbGetInputNbPoints() );
1500             m->SetNumberOfPointsSpline( sc );
1501             m->SetCloseContour( false );
1502             for (i=0;i<size;i++)
1503             {
1504                 m->AddPoint( c1LstX[i] , c1LstY[i] , c1LstZ[i] );
1505             } // for
1506             m->UpdateSpline();
1507             for (i=0;i<sc;i++)
1508             {
1509                 m->GetSpline_i_Point(i,&x,&y,&z);
1510                 c1LstXX.push_back(x);
1511                 c1LstYY.push_back(y);
1512                 c1LstZZ.push_back(z);
1513             } // for
1514             delete m;
1515             // ----------------- Spline 2 --------------------
1516             size        = c2LstX.size();
1517             m           = (manualContourModel*)f.getContourModel( 1 );  // Spline
1518             //        m->SetNumberOfPointsSpline( bbGetInputNbPoints() );
1519             m->SetNumberOfPointsSpline( sc );
1520             m->SetCloseContour( false );
1521             for (i=0;i<size;i++)
1522             {
1523                 m->AddPoint( c2LstX[i] , c2LstY[i] , c2LstZ[i] );
1524             } // for
1525             m->UpdateSpline();
1526             for (i=0;i<sc;i++)
1527             {
1528                 m->GetSpline_i_Point(i,&x,&y,&z);
1529                 c2LstXX.push_back(x);
1530                 c2LstYY.push_back(y);
1531                 c2LstZZ.push_back(z);
1532             } // for
1533             delete m;
1534             // ----------------- Add new Points --------------------
1535             vtkPoints               *points         = NULL;
1536             vtkStaticPointLocator   *pointLocator   = NULL;
1537             if (aux_mesh!=NULL)
1538             {
1539                 points         = aux_mesh->GetPoints();
1540                 pointLocator   = vtkStaticPointLocator::New();
1541                 pointLocator->SetDataSet( aux_mesh );
1542                 pointLocator->BuildLocator();
1543             } // if aux_mesh
1544
1545             double p[3], pM[3];
1546             if ( c1LstX.size()<c2LstX.size() ) { size=c2LstX.size(); } else { size=c1LstX.size(); }
1547             for (ii=0;ii<size;ii++)
1548             {
1549                 i = (int) ((double)ii/((double)size-1)*(sc-1));
1550                 x = (c1LstXX[i]+c2LstXX[i])/2;
1551                 y = (c1LstYY[i]+c2LstYY[i])/2;
1552                 z = (c1LstZZ[i]+c2LstZZ[i])/2;
1553                 if (aux_mesh!=NULL)
1554                 {
1555                     p[0]  = x * aux_mesh_spc[0];
1556                     p[1]  = y * aux_mesh_spc[1];
1557                     p[2]  = z * aux_mesh_spc[2];
1558                     points->GetPoint( pointLocator->FindClosestPoint(p) , pM );
1559                     x = pM[0] / aux_mesh_spc[0];
1560                     y = pM[1] / aux_mesh_spc[1];
1561                     z = pM[2] / aux_mesh_spc[2];
1562                 } // aux_mesh
1563                 AddPoint(x,y,z,"");
1564             }
1565             if (pointLocator!=NULL) { pointLocator->Delete(); }
1566             RefreshCollectionText();
1567             RefreshColourCollection();
1568         } // if size of c1LstX c2LstX
1569     }  // if c1 && c2
1570 }
1571
1572 //------------------------------------------------------------------------
1573 void WidgetShowNPoints::DeleteCollection_()
1574 {
1575     if ( lstModelShowNPoints.size()>1 )
1576     {
1577         DeleteAllPoints_();  // Actual Collection
1578         lstModelShowNPoints.erase( lstModelShowNPoints.begin()+mActualCollection );
1579         lstViewShowNPoints.erase( lstViewShowNPoints.begin()+mActualCollection );
1580         if ( mActualCollection>=lstModelShowNPoints.size() )
1581         {
1582             mActualCollection--;
1583         } // if
1584     } else {
1585         DeleteAllPoints_();  // Actual Collection
1586     } // if
1587 }
1588
1589 //------------------------------------------------------------------------
1590 void WidgetShowNPoints::OnDeleteCollection_()
1591 {
1592     UndoRedo_SaveCollection(); //A
1593     DeleteCollection_();
1594     SetOutputBox();
1595     GetViewShowNPoints()->Render();
1596     RefreshCollectionText();
1597     RefreshColourCollection();
1598     StopTrackPoint();
1599     UndoRedo_SaveCollection(); //B
1600 }
1601
1602 //------------------------------------------------------------------------
1603 void WidgetShowNPoints::OnDeleteCollection(wxCommandEvent &event)
1604 {
1605     OnDeleteCollection_();
1606 }
1607
1608 //------------------------------------------------------------------------
1609 void WidgetShowNPoints::ResetCollections_()
1610 {
1611     int i,size=lstModelShowNPoints.size();
1612     for (i=0;i<size;i++)
1613     {
1614         DeleteCollection_();
1615     }
1616     GetViewShowNPoints()->Render();
1617     RefreshCollectionText();
1618     RefreshColourCollection();
1619     StopTrackPoint();
1620 }
1621
1622
1623 //------------------------------------------------------------------------
1624 void WidgetShowNPoints::OnResetCollections_()
1625 {
1626     UndoRedo_SaveCollection(); //A
1627     ResetCollections_();
1628     UndoRedo_SaveCollection(); //B
1629 }
1630
1631
1632 //------------------------------------------------------------------------
1633 void WidgetShowNPoints::OnResetCollections(wxCommandEvent &event)
1634 {
1635     OnResetCollections_();
1636 }
1637
1638 //------------------------------------------------------------------------
1639 void WidgetShowNPoints::OnBackCollection(wxCommandEvent &event)
1640 {
1641     mActualCollection--;
1642     if ( mActualCollection <0  )
1643     {
1644 //        mActualCollection=0;
1645          mActualCollection = lstModelShowNPoints.size()-1;
1646     } //if <=0
1647     RefreshCollectionText();
1648     RefreshColourCollection();
1649     StopTrackPoint();
1650 //    UndoRedo_SaveCollection();
1651 }
1652
1653 //------------------------------------------------------------------------
1654 void WidgetShowNPoints::OnNextCollection(wxCommandEvent &event)
1655 {
1656     mActualCollection++;
1657     if ( mActualCollection >=lstModelShowNPoints.size() )
1658     {
1659 //        mActualCollection = lstModelShowNPoints.size()-1;
1660          mActualCollection = 0;
1661     } //if mActualCollection >= size
1662     RefreshCollectionText();
1663     RefreshColourCollection();
1664     StopTrackPoint();
1665 //    UndoRedo_SaveCollection();
1666 }
1667
1668 //------------------------------------------------------------------------
1669 void WidgetShowNPoints::DetectCollectionActive()
1670 {
1671     int id;
1672     int i,size=lstModelShowNPoints.size();
1673     for (i=0;i<size;i++)
1674     {
1675         id = lstModelShowNPoints[i]->IdInsidePoint();
1676         if (id>=0)
1677         {
1678             mActualCollection=i;
1679         } // if id>=0
1680     } // for i
1681     RefreshCollectionText();
1682     RefreshColourCollection();
1683 }
1684
1685
1686
1687
1688 //------------------------------------------------------------------------
1689 void WidgetShowNPoints::RefreshColourCollection()
1690 {
1691     UpdatePoints_();
1692     std::vector<double> colourAll;
1693     colourAll.push_back(0);
1694     colourAll.push_back(1);
1695     colourAll.push_back(1);
1696     std::vector<double> colourActualGroup;
1697     colourActualGroup.push_back(1);
1698     colourActualGroup.push_back(0);
1699     colourActualGroup.push_back(0);
1700     // For all collections
1701     SetColour( colourAll );
1702     int sizeLstPoints;
1703     int iCollection,sizeLstCollection=lstViewShowNPoints.size();
1704     for ( iCollection=0 ; iCollection<sizeLstCollection ; iCollection++ )
1705     {
1706         if (iCollection==mActualCollection)
1707         {
1708             // Actual collection
1709             lstViewShowNPoints[mActualCollection] -> mcolour = colourActualGroup;
1710             lstViewShowNPoints[mActualCollection] -> mopacity   = sCtrlOpacity->GetValue()*10.0/100.0;
1711             lstViewShowNPoints[mActualCollection] -> ratioRadio = 1.2;
1712             lstViewShowNPoints[mActualCollection] -> RefreshEachPoint();
1713
1714             //Actual Point
1715             int curPnt      = lstModelShowNPoints[mActualCollection]->GetIdCurrentPoint();
1716             sizeLstPoints   = lstModelShowNPoints[mActualCollection]->GetLstPointsSize();
1717             if ((curPnt>=0)  && (curPnt<sizeLstPoints  ) )
1718             {
1719                 std::vector<double> colourActualPoint;
1720                 colourActualPoint.push_back(1);
1721                 colourActualPoint.push_back(1);
1722                 colourActualPoint.push_back(0);
1723                 double radio          = GetModelShowNPoints()->GetRadio();
1724                 lstViewShowNPoints[mActualCollection] -> mcolour  = colourActualPoint;
1725                 lstViewShowNPoints[mActualCollection]->RefreshPoint( curPnt   );
1726                 lstViewShowNPoints[mActualCollection] -> mcolour = colourActualGroup;
1727             } // if
1728             lstViewShowNPoints[mActualCollection]->TryToShowActorsInRender(true);
1729         } else {
1730             lstViewShowNPoints[iCollection] -> mcolour    = colourAll;
1731             lstViewShowNPoints[iCollection] -> ratioRadio = 1;
1732             if ((cbVisuActualCollection!=NULL) && (cbVisuActualCollection->GetValue()==true))
1733             {
1734                 lstViewShowNPoints[iCollection]->TryToShowActorsInRender(false);
1735       //          lstViewShowNPoints[i] -> mopacity   = 0.0;
1736             } else {
1737                 lstViewShowNPoints[iCollection]->TryToShowActorsInRender(true);
1738       //          lstViewShowNPoints[i] -> mopacity   = sCtrlOpacity->GetValue()*10.0/100.0;
1739             }
1740             lstViewShowNPoints[iCollection]->RefreshEachPoint();
1741         }// if mActualCollection
1742     } // for i
1743     lstViewShowNPoints[mActualCollection] -> renderer->GetRenderWindow()->Render();
1744 }
1745
1746 //------------------------------------------------------------------------
1747 void WidgetShowNPoints::RefreshCollectionText()
1748 {
1749     if ((mtype==4) && (txtNrCollections!=NULL))  // Just for Collection interface
1750     {
1751         wxString strTmp;
1752         strTmp.Printf(_T("   %d/%d"),  (int)mActualCollection+1, (int)lstModelShowNPoints.size() );
1753         txtNrCollections->SetLabel( strTmp );
1754     } // if mtype 4
1755     SetOutputBox();
1756 }
1757
1758
1759 //------------------------------------------------------------------------
1760 void WidgetShowNPoints::OnSaveCollections_( std::string filename )
1761 {
1762     FILE *ff;
1763     ff = fopen( filename.c_str() , "w+" );
1764     if (ff!=NULL)
1765     {
1766         int i,size = lstModelShowNPoints.size();
1767         fprintf(ff,"NumberOfGroups %d \n",size);
1768         for (i=0 ; i<size ; i++)
1769         {
1770             lstModelShowNPoints[i]->SavePoints_(ff);
1771         } // for i
1772         fclose(ff);
1773     } else {   // else ff
1774         printf("WidgetShowNPoints::Save Groups Points  ...Error... creating file \n");
1775     } //ff
1776
1777 }
1778
1779 //------------------------------------------------------------------------
1780 void WidgetShowNPoints::OnSaveCollectionsIdsCurrent_( std::string filename )
1781 {
1782     FILE *ff;
1783     ff = fopen( filename.c_str() , "w+" );
1784     if (ff!=NULL)
1785     {
1786         int i,size = lstModelShowNPoints.size();
1787         fprintf(ff,"ActualCollection %d \n",mActualCollection);
1788         fprintf(ff,"NumberOfGroups %d \n",size);
1789         for (i=0 ; i<size ; i++)
1790         {
1791             fprintf(ff,"CurrentIdPoint %d \n",lstModelShowNPoints[i]->GetIdCurrentPoint());
1792         } // for i
1793         fclose(ff);
1794     } else {   // else ff
1795         printf("WidgetShowNPoints::Save Groups Points  ...Error... creating file \n");
1796     } //ff
1797 }
1798
1799 //------------------------------------------------------------------------
1800 void WidgetShowNPoints::OnSaveCollections(wxCommandEvent &event)
1801 {
1802     //EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
1803     #if wxMAJOR_VERSION <= 2
1804             wxFileDialog* FD = new wxFileDialog( 0,
1805                                                 _T("Save groups of points .."),
1806                                                 _T(""),
1807                                                 _T(""),
1808                                                 _T("(*.xls)|*.xls"),
1809                                                 wxSAVE | wxOVERWRITE_PROMPT,
1810                                                 wxDefaultPosition);
1811     #else
1812             wxFileDialog* FD = new wxFileDialog( 0,
1813                                                 _T("Save groups of points .."),
1814                                                 _T(""),
1815                                                 _T(""),
1816                                                 _T("(*.xls)|*.xls"),
1817                                                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT,
1818                                                 wxDefaultPosition);
1819     #endif
1820
1821             int result_FD = FD->ShowModal();
1822             // This line is need it by windows //EED
1823             FD->SetReturnCode( result_FD );
1824             if (FD->GetReturnCode()==wxID_OK)
1825             {
1826                 std::string filename= (const char*) ( FD->GetPath().mb_str() );
1827                 OnSaveCollections_( filename );
1828             }     // dialog box
1829     StopTrackPoint();
1830 }
1831
1832 //------------------------------------------------------------------------
1833 void WidgetShowNPoints::OnLoadCollections_( std::string filename )
1834 {
1835     bool okEraseFirstGroup=false;
1836     if (lstModelShowNPoints.size()==1)
1837     {
1838         if (GetModelShowNPoints()->GetLstPointsSize()==0) { okEraseFirstGroup=true; }
1839     }
1840     FILE *ff = fopen( filename.c_str() , "r+" );
1841     if (ff!=NULL)
1842     {
1843         int i;
1844         int iGroup,sizeGroups;
1845         int iPoint,numberPointsRead;
1846         char chartmp[256];
1847         fscanf(ff," %s %d",chartmp,&sizeGroups);
1848         for (iGroup=0;iGroup<sizeGroups;iGroup++)
1849         {
1850             mActualCollection = lstModelShowNPoints.size();
1851             InsertCollection();
1852             int numberPointsRead= lstModelShowNPoints[mActualCollection]->ReadPoints_(ff);
1853             for (i=0;i<numberPointsRead;i++)
1854             {
1855                 // EED 2022-05-19
1856                 //AddVtkPoint();
1857                 GetViewShowNPoints()->AddVtkPoint();
1858             }// for
1859         } // for i
1860
1861         fclose(ff);
1862     } else {   // else ff
1863         printf("WidgetShowNPoints::Load Group of Points  ...Error... reading file");
1864     } //ff
1865     if (okEraseFirstGroup==true)
1866     {
1867         mActualCollection=0;
1868         DeleteCollection_();
1869         mActualCollection = lstModelShowNPoints.size()-1;
1870     }
1871     GetViewShowNPoints()->Render();
1872     RefreshCollectionText();
1873     RefreshColourCollection();
1874     StopTrackPoint();
1875 }
1876
1877
1878 //------------------------------------------------------------------------
1879 void WidgetShowNPoints::OnLoadCollectionsIdsCurrent_( std::string filename )
1880 {
1881     FILE *ff = fopen( filename.c_str() , "r+" );
1882     int iGroup,sizeGroups;
1883     int IdCurrentPoint;
1884     char chartmp[256];
1885     fscanf(ff," %s %d",chartmp,&mActualCollection);     // ActualCollection
1886     fscanf(ff," %s %d",chartmp,&sizeGroups);            // NumberOfGroups
1887     for (iGroup=0;iGroup<sizeGroups;iGroup++)
1888     {
1889         fscanf(ff," %s %d",chartmp,&IdCurrentPoint);  // CurrentPointId
1890         lstModelShowNPoints[iGroup]->SetIdCurrentPoint( IdCurrentPoint );
1891     } // for iGroup
1892
1893     GetViewShowNPoints()->Render();
1894     RefreshCollectionText();
1895     RefreshColourCollection();
1896
1897 }
1898
1899
1900
1901
1902 //------------------------------------------------------------------------
1903 void WidgetShowNPoints::OnLoadCollections(wxCommandEvent &event)
1904 {
1905     //EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
1906     #if wxMAJOR_VERSION <= 2
1907             wxFileDialog* FD = new wxFileDialog( 0,
1908                                                  _T("Load groups of points .."),
1909                                                  _T(""),
1910                                                  _T(""),
1911                                                  _T("(*.xls)|*.xls"),
1912                                                  wxOPEN | wxFILE_MUST_EXIST,
1913                                                  wxDefaultPosition);
1914     #else
1915             wxFileDialog* FD = new wxFileDialog( 0,
1916                                                  _T("Load groups of points .."),
1917                                                  _T(""),
1918                                                  _T(""),
1919                                                  _T("(*.xls)|*.xls"),
1920                                                  wxFD_OPEN | wxFD_FILE_MUST_EXIST,
1921                                                  wxDefaultPosition);
1922     #endif
1923             int result_FD = FD->ShowModal();
1924             // This line is need it by windows //EED
1925             FD->SetReturnCode( result_FD );
1926             if (FD->GetReturnCode()==wxID_OK)
1927             {
1928                 std::string filename= (const char*) ( FD->GetPath().mb_str() );
1929                 UndoRedo_SaveCollection(); // A
1930                 OnLoadCollections_( filename );
1931                 UndoRedo_SaveCollection(); // B
1932             }     // dialog box
1933 }
1934
1935 //------------------------------------------------------------------------
1936 void WidgetShowNPoints::GetCollectionPoint(int idCol,int idPoint, double *pPoint)
1937 {
1938     double x,y,z;
1939     lstModelShowNPoints[idCol]->GetIdPoint(idPoint,&x,&y,&z);
1940     pPoint[0] = x;
1941     pPoint[1] = y;
1942     pPoint[2] = z;
1943 }
1944 //------------------------------------------------------------------------
1945 void WidgetShowNPoints::SetCollectionPoint(int idCol, int idPoint, std::vector<double> modPoint)
1946 {
1947         if(idCol >= 0 && idCol < lstModelShowNPoints.size())
1948         {
1949                 lstModelShowNPoints[idCol]->SetPointById(idPoint, modPoint);
1950                 lstViewShowNPoints[idCol]->RefreshPoint(idPoint);
1951         }
1952         else{
1953                 printf("WidgetShowNPoints::SetCollectionPoint  ...Error... Invalid collection, out of range");
1954         }
1955 }
1956 //------------------------------------------------------------------------
1957 std::vector<double> WidgetShowNPoints::GetLstPointsX()
1958 {
1959     if (mtype!=4)
1960     {
1961         return GetModelShowNPoints()->GetLstPointsX();
1962     } else {
1963         std::vector<double> lst;
1964         int iP,s;
1965         int iG,sG=lstModelShowNPoints.size();
1966         for (iG=0 ; iG<sG ; iG++)
1967         {
1968             std::vector<double> lstTmp = lstModelShowNPoints[iG]->GetLstPointsX();
1969             s = lstTmp.size();
1970             for (iP=0 ; iP<s ; iP++)
1971             {
1972                 lst.push_back( lstTmp[iP] );
1973             } // for iP
1974         } // for iG
1975         return lst;
1976     } // if 4
1977 }
1978
1979 //------------------------------------------------------------------------
1980 std::vector<double> WidgetShowNPoints::GetLstPointsY()
1981 {
1982     if (mtype!=4)
1983     {
1984         return GetModelShowNPoints()->GetLstPointsY();
1985     } else {
1986         std::vector<double> lst;
1987         int iP,s;
1988         int iG,sG=lstModelShowNPoints.size();
1989         for (iG=0 ; iG<sG ; iG++)
1990         {
1991             std::vector<double> lstTmp = lstModelShowNPoints[iG]->GetLstPointsY();
1992             s = lstTmp.size();
1993             for (iP=0 ; iP<s ; iP++)
1994             {
1995                 lst.push_back( lstTmp[iP] );
1996             } // for iP
1997         } // for iG
1998         return lst;
1999     }
2000 }
2001
2002 //------------------------------------------------------------------------
2003 std::vector<double> WidgetShowNPoints::GetLstPointsZ()
2004 {
2005     if (mtype!=4)
2006     {
2007         return GetModelShowNPoints()->GetLstPointsZ();
2008     } else {
2009         std::vector<double> lst;
2010         int iP,s;
2011         int iG,sG=lstModelShowNPoints.size();
2012         for (iG=0 ; iG<sG ; iG++)
2013         {
2014             std::vector<double> lstTmp = lstModelShowNPoints[iG]->GetLstPointsZ();
2015             s = lstTmp.size();
2016             for (iP=0 ; iP<s ; iP++)
2017             {
2018                 lst.push_back( lstTmp[iP] );
2019             } // for iP
2020         } // for iG
2021         return lst;
2022
2023     }
2024 }
2025
2026 //------------------------------------------------------------------------
2027 std::vector<std::string> WidgetShowNPoints::GetLstLabels()
2028 {
2029     if (mtype!=4)
2030     {
2031         return GetModelShowNPoints()->GetLstLabels();
2032     } else {
2033         std::vector< std::string > lst;
2034         int iP,s;
2035         int iG,sG=lstModelShowNPoints.size();
2036         for (iG=0 ; iG<sG ; iG++)
2037         {
2038             std::vector< std::string > lstTmp = lstModelShowNPoints[iG]->GetLstLabels();
2039             s = lstTmp.size();
2040             for (iP=0 ; iP<s ; iP++)
2041             {
2042                 lst.push_back( lstTmp[iP] );
2043             } // for iP
2044         } // for iG
2045         return lst;
2046     }
2047 }
2048
2049 //------------------------------------------------------------------------
2050 std::vector<int> WidgetShowNPoints::GetLstIndexs()
2051 {
2052     std::vector<int> lstIndexs;
2053     if (mtype!=4)
2054     {
2055         lstIndexs.push_back( GetModelShowNPoints()->GetLstPointsSize() );
2056     } else {
2057         int iG,sG=lstModelShowNPoints.size();
2058         for (iG=0 ; iG<sG ; iG++)
2059         {
2060             lstIndexs.push_back( lstModelShowNPoints[iG]->GetLstPointsSize() );
2061         } // for iG
2062     }
2063     return lstIndexs;
2064 }
2065
2066 //------------------------------------------------------------------------
2067 std::vector<int> WidgetShowNPoints::GetLstSelectedIndexs()
2068 {
2069     std::vector<int> lstSelectedIndexs;
2070     if ( (cbVisuActualCollection!=NULL) && (cbVisuActualCollection->GetValue()==true) )
2071     {
2072         lstSelectedIndexs.push_back( mActualCollection );
2073     }
2074     return lstSelectedIndexs;
2075 }
2076
2077 //------------------------------------------------------------------------
2078 int WidgetShowNPoints::GetLstModelShowNPointsSize()
2079 {
2080     return lstModelShowNPoints.size();
2081 }
2082
2083 //------------------------------------------------------------------------
2084 void WidgetShowNPoints::InvertLstPoints_()
2085 {
2086     int i,size=lstModelShowNPoints.size();
2087
2088     for (i=0 ;  i < size ; i++)
2089     {
2090         lstModelShowNPoints[i]->InversLstPoints();
2091     } // for iM
2092
2093     /*
2094     ModelShowNPoints* tmpModel;
2095     int size2=size/2;
2096     for (i=0 ;  i < size2 ; i++)
2097     {
2098         tmpModel                        = lstModelShowNPoints[i];
2099         lstModelShowNPoints[i]          = lstModelShowNPoints[size-1-i];
2100         lstModelShowNPoints[size-1-i]   = tmpModel;
2101     } // for iM
2102      */
2103 }
2104
2105 //------------------------------------------------------------------------
2106 void WidgetShowNPoints::OnInvertLstPoints_()
2107 {
2108     UndoRedo_SaveCollection(); // A
2109     StopAutoAddPoints();
2110     StopTrackPoint();
2111     InvertLstPoints_();
2112     SetOutputBox();
2113     UndoRedo_SaveCollection(); // B
2114 }
2115
2116
2117 //------------------------------------------------------------------------
2118 std::string WidgetShowNPoints::GetUndoRedoFileName()
2119 {
2120     char buff[20];
2121     sprintf(buff,"%p_%d",this, idUndoRedo);
2122     return  UndoRedoDir+"/"+"UndoRedo_collection_" + std::string(buff) + ".undoredo";
2123 }
2124
2125
2126 //------------------------------------------------------------------------
2127 void WidgetShowNPoints::OnUndo(wxCommandEvent &event)
2128 {
2129     ResetCollections_();
2130 //    if (idUndoRedo==maxUndoRedo+1)
2131 //    {
2132 //       idUndoRedo--;
2133 //    } // if idUndoRedo+1
2134     idUndoRedo--;
2135     idUndoRedo--;
2136     if (idUndoRedo<0)
2137     {
2138         idUndoRedo=-1;
2139     } else {
2140         OnLoadCollections_( GetUndoRedoFileName() );
2141         OnLoadCollectionsIdsCurrent_( GetUndoRedoFileName()+".current" );
2142     }// if idUndoRedo
2143     idUndoRedo++;
2144
2145 }
2146
2147 //------------------------------------------------------------------------
2148 void WidgetShowNPoints::OnRedo(wxCommandEvent &event)
2149 {
2150     if (idUndoRedo>maxUndoRedo)
2151     {
2152         idUndoRedo=maxUndoRedo+1;
2153     } else {
2154         ResetCollections_();
2155         OnLoadCollections_( GetUndoRedoFileName() );
2156         OnLoadCollectionsIdsCurrent_( GetUndoRedoFileName()+".current" );
2157         idUndoRedo++;
2158     }// if idUndoRedo
2159 }
2160
2161 //------------------------------------------------------------------------
2162 void WidgetShowNPoints::UndoRedo_SaveCollection()
2163 {
2164     OnSaveCollections_( GetUndoRedoFileName() );
2165     OnSaveCollectionsIdsCurrent_( GetUndoRedoFileName()+".current" );
2166     maxUndoRedo = idUndoRedo;
2167     idUndoRedo++;
2168 }
2169
2170 //------------------------------------------------------------------------
2171 void WidgetShowNPoints::SetAuxMesh(vtkPolyData* mesh, std::vector<double> spc, std::vector<double> params)
2172 {
2173     aux_mesh        = mesh;
2174     aux_mesh_spc    = spc;
2175     if (params.size()==1)
2176     {
2177         aux_mesh_type   = params[0];
2178     } else {
2179         aux_mesh_type   = 0;
2180     }// if params size
2181 }
2182
2183 //------------------------------------------------------------------------
2184 void WidgetShowNPoints::OnVisuActualCollection(wxCommandEvent &event)
2185 {
2186     printf("EED WidgetShowNPoints::OnVisuActualCollection  \n");
2187     RefreshCollectionText();
2188     RefreshColourCollection();
2189 }