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

   1 /*# ---------------------------------------------------------------------
   2 #
   3 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   4 #                        pour la Sant�)
   5 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   6 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   7 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   8 #
   9 #  This software is governed by the CeCILL-B license under French law and
  10 #  abiding by the rules of distribution of free software. You can  use,
  11 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  12 #  license as circulated by CEA, CNRS and INRIA at the following URL
  13 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  14 #  or in the file LICENSE.txt.
  15 #
  16 #  As a counterpart to the access to the source code and  rights to copy,
  17 #  modify and redistribute granted by the license, users are provided only
  18 #  with a limited warranty  and the software's author,  the holder of the
  19 #  economic rights,  and the successive licensors  have only  limited
  20 #  liability.
  21 #
  22 #  The fact that you are presently reading this means that you have had
  23 #  knowledge of the CeCILL-B license and that you accept its terms.
  24 # ------------------------------------------------------------------------ */
  25
  26 //---------------------------------------------------------------------------------------------
  27 // Class definition include
  28 //---------------------------------------------------------------------------------------------
  29 #include "pPlotter.h"
  30
  31 // --------------------------------------------------------------------------------------------
  32 // WX headers inclusion.
  33 // For compilers that support precompilation, includes <wx/wx.h>.
  34 // --------------------------------------------------------------------------------------------
  35
  36 #ifndef WX_PRECOMP
  37 #include <wx/wx.h>
  38 #endif
  39
  40 //---------------------------------------------------------------------------------------------
  41 // Class implementation
  42 //---------------------------------------------------------------------------------------------
  43
  44 IMPLEMENT_CLASS(pPlotter, wxPanel)
  45
  46 //------------------------------------------------------------------------------------------------------------
  47 // Generated events declaration and definition
  48 //------------------------------------------------------------------------------------------------------------
  49 BEGIN_DECLARE_EVENT_TYPES()
  50         DECLARE_EVENT_TYPE( wxEVT_NW_TEXT_MESAGGE, -1 )
  51 END_DECLARE_EVENT_TYPES()
  52
  53 DEFINE_EVENT_TYPE( wxEVT_NW_TEXT_MESAGGE )
  54
  55 // ----------------------------------------------------------------------------------------------------
  56 // Handdled events from pColorBar
  57 // ----------------------------------------------------------------------------------------------------
  58 DECLARE_EVENT_TYPE(wxEVT_ADDED_POINT, -1)
  59 DECLARE_EVENT_TYPE(wxEVT_REMOVED_POINT, -1)
  60 DECLARE_EVENT_TYPE(wxEVT_MOVED_POINT, -1)
  61 DECLARE_EVENT_TYPE(wxEVT_CHANGED_POINT, -1)
  62 DECLARE_EVENT_TYPE(wxEVT_ON_COLOR_BAR, -1)
  63
  64 // ----------------------------------------------------------------------------------------------------
  65 // Handdled events from plotter
  66 // ----------------------------------------------------------------------------------------------------
  67 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_CHANGED_FUNCTION, -1)
  68 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_POINT_MOVE, -1)
  69 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_POINT_ADD, -1)
  70 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_POINT_DELETE, -1)
  71 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_GUIDELINES, -1)
  72
  73 // ----------------------------------------------------------------------------------------------------
  74 // Handdled events from max-min barrange
  75 // ----------------------------------------------------------------------------------------------------
  76 DECLARE_EVENT_TYPE(wxEVT_TSBAR, -1)
  77 DECLARE_EVENT_TYPE(wxEVT_TSBAR_ACTUAL, -1)
  78 DECLARE_EVENT_TYPE(wxEVT_TSBAR_START, -1)
  79 DECLARE_EVENT_TYPE(wxEVT_TSBAR_END, -1)
  80 DECLARE_EVENT_TYPE(wxEVT_TSBAR_MOVED, -1)
  81 DECLARE_EVENT_TYPE(wxEVT_SELECTION_END, -1)
  82
  83
  84 // ----------------------------------------------------------------------------------------------------
  85 // EVENT TABLE (->Connect: analogous)
  86 //-----------------------------------------------------------------------------------------------------
  87 BEGIN_EVENT_TABLE(pPlotter, wxPanel)
  88         //OnSize
  89         //EVT_SIZE  (pPlotter::OnSize)
  90
  91         // Connectting the handled envents for the plotter to the corresponding methods
  92         EVT_COMMAND  (-1,wxEVT_PPLOTTER_CHANGED_FUNCTION, pPlotter::onChangeFunction)
  93         EVT_COMMAND  (-1,wxEVT_PPLOTTER_POINT_MOVE, pPlotter::onMovePoint_Plotter)
  94         EVT_COMMAND  (-1,wxEVT_PPLOTTER_POINT_ADD, pPlotter::onAddedPoint_Plotter)
  95         EVT_COMMAND  (-1,wxEVT_PPLOTTER_POINT_DELETE, pPlotter::onRemovedPoint_Plotter)
  96         EVT_COMMAND  (-1,wxEVT_PPLOTTER_GUIDELINES, pPlotter::onGuideLines)
  97
  98         // Connectting the handled envents for the color bar  to the corresponding methods
  99     EVT_COMMAND  (-1,wxEVT_ADDED_POINT, pPlotter :: onAdded_ColorPoint )
 100         EVT_COMMAND  (-1,wxEVT_REMOVED_POINT, pPlotter :: onRemoved_ColorPoint )
 101         EVT_COMMAND  (-1,wxEVT_MOVED_POINT, pPlotter :: onMoved_ColorPoint )
 102         EVT_COMMAND  (-1,wxEVT_CHANGED_POINT, pPlotter :: onChanged_ColorPoint )
 103         EVT_COMMAND  (-1,wxEVT_ON_COLOR_BAR, pPlotter :: onColorBar )
 104
 105         // Connectting the handled envents from the max-min barrange  to the corresponding methods
 106         EVT_COMMAND  (-1,wxEVT_TSBAR, pPlotter::onBarrange)
 107         EVT_COMMAND  (-1,wxEVT_SELECTION_END, pPlotter::onSelectionEnd)
 108         EVT_COMMAND  (-1,wxEVT_TSBAR_MOVED, pPlotter::onMovedBar)
 109         EVT_COMMAND  (-1,wxEVT_TSBAR_ACTUAL, pPlotter:: onActualChange_Bar)
 110         EVT_COMMAND  (-1,wxEVT_TSBAR_START, pPlotter::onStartChange_Bar)
 111         EVT_COMMAND  (-1,wxEVT_TSBAR_END, pPlotter::onEndChange_Bar)
 112
 113 END_EVENT_TABLE()
 114
 115
 116 //---------------------------------------------------------------------------------------------
 117 // Constructors & Destructors
 118 //---------------------------------------------------------------------------------------------
 119         /*
 120         * Creates an integrated plotter instance
 121         * @param *parent Container window
 122         */
 123         pPlotter :: pPlotter  (wxWindow *parent,int nWidth, int nHeight)
 124         :wxPanel(parent,-1,wxDefaultPosition,wxDefaultSize,wxTAB_TRAVERSAL)
 125         {
 126                 SetBackgroundColour(wxColour(255,255,255));
 127                 m_plot = new pPlotterWindow( this, -1, wxPoint(0,0), wxSize(nWidth,nHeight), wxSUNKEN_BORDER );
 128                 actualFunction =NULL;
 129                 // Adding the axis layers to the plotter
 130                 m_plot->AddLayer( new pPlotterScaleX() );
 131                 m_plot->AddLayer( new pPlotterScaleY() );
 132
 133                 // Creating the log window
 134         /*
 135
 136                 m_log = new wxTextCtrl( panel, -1, wxT("This is the log window.\n"), wxPoint(0,0), wxSize(400,100), wxTE_MULTILINE );
 137                 // Sharing the log window of the application with the plotter widget
 138                 m_plot->setmLog(m_log);
 139
 140                 */
 141
 142
 143                 // Creating a function for the plotter with given points x-vector and y-vector
 144
 145                 /*
 146                 double vectX_F1 [] = { 0, 20, 50, 80, 100, 115, 120, 210, 220,250 };
 147
 148
 149 //              double vectX_F1 [] = { 0, 20, 50, 80, 100, 115, 120, 210, 220,250 };
 150
 151                 double vectY_F1 [] = { 0, 40, 70, 100, 200, 100, 40, 170, 0, 50  };
 152                 pGraphicalFunction * f1 = m_plot ->getFunctionForVectors( vectX_F1, 10, vectY_F1, 10 );
 153                 // Including and drawing the created function in the plotter
 154                 if (f1)
 155                 {
 156                         m_plot->addFunction( f1 );
 157                         m_plot->addFunctionToMove(f1);
 158                         //m_plot->addFunctionToMove(f1);
 159                         wxPen mypen1(*wxBLUE, 2, wxDOT_DASH );
 160                         mypen1.SetWidth(2);
 161                         f1->SetPen( mypen1 );
 162                 }
 163                 */
 164
 165                 //=================== lines to sychronyze the bars width with the drawed plotter--------------------------
 166
 167                 mpWindow* mplotWindow = ((mpWindow*)m_plot);
 168                 float minReal_X = 0; //(float)mplotWindow->getMinScrX();
 169                 float maxReal_X =(float)mplotWindow->getMaxScrX();
 170                 //float scrX=(float)mplotWindow->GetScrX()-100; // JPRx
 171                 //double scaleX=(scrX/(maxReal_X))* (mplotWindow->getZoomFactor()); // JPRx
 172
 173                 // Creating the color bar with values according to the plotter added widget
 174                 color_bar = new pColorBar(this, (m_plot->GetSize()).GetWidth(),40, true);
 175                 color_bar -> setRepresentedValues ((int)minReal_X, (int)maxReal_X);
 176                 color_bar -> setDeviceBlitStart (70,0);
 177                 color_bar -> setVisibleRange ((int)minReal_X,(int) maxReal_X);
 178                 color_bar -> setDeviceEndMargin (50);
 179
 180
 181                 // Creating the min-max barrange bar with values according to the plotter added widget
 182                 barrange = new mBarRange(this, (m_plot->GetSize()).GetWidth(),30);
 183                 barrange -> setVisibleLabels (false);
 184                 barrange -> setRepresentedValues (minReal_X, maxReal_X);
 185                 barrange -> setDeviceBlitStart (70,0);
 186                 barrange -> setDeviceEndMargin (50);
 187
 188                 // Adding the components to the sizer
 189                 /*
 190                 if(m_plot->getActualFunction())
 191                         setAll();
 192                 */
 193                 wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 194                 sizer->Add( m_plot, 4, wxEXPAND);
 195                 sizer->Add( color_bar,0, wxEXPAND );
 196                 sizer->Add( barrange, 0, wxEXPAND );
 197
 198                 // sizer->Add( m_log, 0, wxEXPAND);
 199
 200                 // Stablishing the layout and sizer of the panel
 201                 /*panel->*/SetAutoLayout(true);
 202                 /*panel->*/SetSizer(sizer);
 203                 /*panel->*/Layout();
 204
 205                 /*panel->*/Refresh();
 206         }
 207
 208
 209         pPlotter :: ~pPlotter ()
 210         {
 211
 212
 213         }
 214
 215 //---------------------------------------------------------------------------------------------
 216 // Methods
 217 //---------------------------------------------------------------------------------------------
 218 /*
 219 Set the bars according to the actual function
 220 */
 221
 222 void pPlotter::setAll()
 223 {
 224         actualFunction = m_plot->getActualFunction();
 225         if (actualFunction != NULL)
 226         {
 227                 barrange -> setActiveStateTo(true);
 228                 color_bar -> setActiveStateTo(true);
 229                 text.Clear();
 230                 text = _T("minX=");
 231                 double realMin_X = actualFunction->getMinX();
 232 //EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
 233 #if wxMAJOR_VERSION <= 2
 234                 text = text + realMin_X;
 235 #else
 236                 text = text + wxString::FromDouble( realMin_X );
 237 #endif
 238                 text = text + _T(" maxX=");
 239                 double realMax_X = actualFunction->getMaxX();
 240 //EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
 241 #if wxMAJOR_VERSION <= 2
 242                 text = text + realMax_X;
 243 #else
 244                 text = text + wxString::FromDouble( realMax_X );
 245 #endif
 246                 int minShowed = actualFunction->getMinXShowed();
 247                 int maxShowed = actualFunction->getMaxXShowed();
 248                 barrange -> setRepresentedValues (realMin_X, realMax_X);
 249                 barrange->SetStart( minShowed );
 250                 barrange->SetEnd( maxShowed );
 251                 std::vector<pColorPoint *> actualColorPoints;
 252                 actualFunction->getColorPoints(actualColorPoints);
 253                 if(actualColorPoints.empty())
 254                 {
 255                         color_bar->reinitiateColorBar (realMin_X, realMax_X);
 256                 } else {
 257                         color_bar->reinitiateColorBarTo(actualColorPoints);
 258                 }
 259                 color_bar->setVisibleRange (minShowed, maxShowed);
 260                 // Refresh
 261                 color_bar->RefreshForce();
 262                 barrange->RefreshForce();
 263                 sendTMessage(text);
 264         } // if actualFunction
 265 }
 266
 267
 268 //*****************************************************************************************************
 269 // Color bar control methods
 270 //*****************************************************************************************************
 271
 272 //-----------------------------------------------------------------------------------------------------
 273 // Updating methods for occured events in the color bar
 274 //-----------------------------------------------------------------------------------------------------
 275 void  pPlotter::onAdded_ColorPoint(wxCommandEvent& event)
 276 {
 277         text.Clear();
 278         text = _T( "Last event was on color bar: Color point added, total#");
 279         actualFunction = m_plot->getActualFunction();
 280         if(actualFunction!=NULL)
 281         {
 282                 std::vector<pColorPoint *> actualColorPoints;
 283                 color_bar ->getAddedColorsPointsList(actualColorPoints);
 284                 actualFunction -> setColorPoints(actualColorPoints);
 285                 text << actualColorPoints.size();
 286                 sendTMessage(text);
 287         }
 288 }
 289
 290 void  pPlotter :: onRemoved_ColorPoint(wxCommandEvent& event)
 291 {
 292         text.Clear();
 293         text = _T( "Last event on color bar: Color point removed total#");
 294         actualFunction = m_plot->getActualFunction();
 295         std::vector<pColorPoint *> actualColorPoints;
 296         color_bar ->getAddedColorsPointsList(actualColorPoints);
 297         actualFunction -> setColorPoints(actualColorPoints);
 298         text << actualColorPoints.size();
 299         sendTMessage(text);
 300 }
 301
 302 void  pPlotter :: onMoved_ColorPoint(wxCommandEvent& event)
 303 {
 304         text.Clear();
 305         text = _T( "Last event was on color bar: Color point moved to: ");
 306         int lastReal_X = (int)(color_bar->getLastMovedColorPoint())->getRealX();
 307         text << lastReal_X;
 308         barrange ->setRealX_vertical_line (lastReal_X);
 309         barrange -> RefreshForce();
 310         m_plot->setRealGuideX (lastReal_X);
 311         m_plot->UpdateAll();
 312         sendTMessage(text);
 313 }
 314
 315 void  pPlotter:: onChanged_ColorPoint(wxCommandEvent& event)
 316 {
 317         text.Clear();
 318         sendTMessage(_T("Last event was on color bar: Color point changed color"));
 319 }
 320
 321 void pPlotter :: onColorBar( wxCommandEvent& event )
 322 {
 323         if( (barrange->getRealX_vertical_line())!=-1)
 324         {
 325                 barrange ->setRealX_vertical_line (-1);
 326                 m_plot->setRealGuideX (-1);
 327
 328                 barrange -> RefreshForce();
 329                 m_plot->UpdateAll();
 330         }
 331 }
 332
 333 //*****************************************************************************************************
 334 // Plotter control methods
 335 //*****************************************************************************************************
 336
 337
 338 /*
 339 * Method called when actual function is changed
 340 */
 341 void pPlotter :: onChangeFunction (wxCommandEvent& event)
 342 {
 343         actualFunction = m_plot->getActualFunction();
 344
 345         if (actualFunction != NULL)
 346         {
 347                 if( !barrange->isActive() )
 348                 {
 349                         barrange -> setActiveStateTo(true);
 350                         color_bar -> setActiveStateTo(true);
 351                 }
 352
 353                 text.Clear();
 354                 text = _T("Last event was on plotter: function changed, minX=");
 355                 double realMin_X = actualFunction->getMinX();
 356                 text << realMin_X;
 357                 text << _T(" maxX=");
 358                 double realMax_X = actualFunction->getMaxX();
 359                 text << realMax_X;
 360
 361                 int minShowed = actualFunction->getMinXShowed();
 362                 int maxShowed = actualFunction->getMaxXShowed();
 363
 364                 barrange -> setRepresentedValues (realMin_X, realMax_X);
 365                 barrange->SetStart( minShowed );
 366                 barrange->SetEnd( maxShowed );
 367
 368                 std::vector<pColorPoint *> actualColorPoints;
 369                 actualFunction->getColorPoints(actualColorPoints);
 370                 if(actualColorPoints.empty())
 371                 {
 372                         color_bar->reinitiateColorBar (realMin_X, realMax_X);
 373                 } else {
 374                         color_bar->reinitiateColorBarTo(actualColorPoints);
 375                 }
 376                 color_bar->setVisibleRange ((int)realMin_X, maxShowed);
 377
 378                 // Refresh
 379                 color_bar->RefreshForce();
 380                 barrange->RefreshForce();
 381
 382                 sendTMessage(text);
 383         } // if actualFunction
 384 }
 385
 386
 387 /*
 388 * Method called when a point is added to the actual function on the plotter
 389 */
 390
 391 void pPlotter :: onAddedPoint_Plotter (wxCommandEvent& event)
 392 {
 393         text.Clear();
 394         m_plot->writeInText(text);
 395         sendTMessage(text);
 396 }
 397
 398 /*
 399 * Method called when a point is removed to the actual function on the plotter
 400 */
 401 void pPlotter :: onRemovedPoint_Plotter (wxCommandEvent& event)
 402 {
 403         text.Clear();
 404         m_plot->writeInText(text);
 405         sendTMessage(text);
 406 }
 407
 408 /*
 409 * Method called when a point is moved from the actual function on the plotter
 410 */
 411 void pPlotter :: onMovePoint_Plotter (wxCommandEvent& event)
 412 {
 413         text.Clear();
 414         m_plot->writeInText(text);
 415         sendTMessage(text);
 416 }
 417 /*
 418 * Method called when turn off the guide line from the actual function on the plotter
 419 */
 420 void pPlotter::onGuideLines(wxCommandEvent& event)
 421 {
 422
 423 }
 424
 425
 426
 427 //*****************************************************************************************************
 428 // Max-Min Barrange control methods
 429 //*****************************************************************************************************
 430 /*
 431 *
 432 */
 433 void  pPlotter::onBarrange(wxCommandEvent& event)
 434 {
 435
 436 }
 437 /*
 438 *
 439 */
 440 void  pPlotter::onActualChange_Bar(wxCommandEvent& event)
 441 {
 442         int lastActual_X = barrange->GetActual();
 443
 444         color_bar ->setRealX_vertical_line (lastActual_X);
 445         color_bar -> RefreshForce();
 446
 447         m_plot->setRealGuideX(lastActual_X);
 448         m_plot->UpdateAll();
 449
 450         text.Clear();
 451         text = _T( "Last event was on min-max bar: Actual triangle moved to: " );
 452         text << lastActual_X;
 453         sendTMessage(text);
 454 }
 455
 456 /*
 457 * Method called when the start triangle is moved. Adjusts the plotter and color bar view-range.
 458 */
 459 void  pPlotter::onStartChange_Bar(wxCommandEvent& event)
 460 {
 461         text.Clear();
 462
 463         text = _T( "Last event was on min-max bar: Start triangle moved to: ");
 464         int realMin_X = barrange->GetStart();
 465         text += wxString::Format(_T("%d"), realMin_X);
 466         double realMax_X = m_plot->getMaxScrX();
 467
 468         color_bar -> setVisibleRange (realMin_X, (int)realMax_X);
 469
 470         m_plot->actualizeViewRange(realMin_X, (int)realMax_X);
 471
 472         //setting the plotter for draw the functions that
 473         //it has to move.
 474
 475         float startP    =       (float)barrange->getStartShowPorcentage();
 476         float endP              =       (float)barrange->getEndShowPorcentage();
 477         m_plot->moveFunctions(startP,endP);
 478
 479         //Updating
 480         color_bar -> RefreshForce();
 481         m_plot -> UpdateAll();
 482         sendTMessage(text);
 483 }
 484
 485 void  pPlotter::onEndChange_Bar(wxCommandEvent& event)
 486 {
 487         text.Clear();
 488         text += _T("Last event was on min-max bar: End  triangle moved to: ");
 489         int realMax_X           = barrange->GetEnd();
 490         text += wxString::Format(_T("%d"),realMax_X);
 491         double realMin_X        = m_plot->getMinScrX();
 492         color_bar -> setVisibleRange ((int)realMin_X, realMax_X);
 493         m_plot->actualizeViewRange((int)realMin_X,realMax_X);
 494         float startP            = (float)barrange->getStartShowPorcentage();
 495         float endP                      = (float)barrange->getEndShowPorcentage();
 496         m_plot->moveFunctions(startP,endP);
 497         color_bar -> RefreshForce();
 498         m_plot -> UpdateAll();
 499         sendTMessage(text);
 500 }
 501
 502 void pPlotter :: onSelectionEnd(wxCommandEvent& event)
 503 {
 504         if( (color_bar->getRealX_vertical_line())!=-1)
 505         {
 506                 color_bar ->setRealX_vertical_line (-1);
 507                 m_plot->setRealGuideX (-1);
 508
 509                 color_bar -> RefreshForce();
 510                 m_plot->UpdateAll();
 511         }
 512 }
 513 void  pPlotter :: onMovedBar(wxCommandEvent& event)
 514 {
 515         text.Clear();
 516         text = _T( "Last event was on min-max bar: Moved bar to min:" );
 517
 518         int realMin_X = barrange->GetStart();
 519         text +=  wxString::Format(_T("%d"),realMin_X);
 520         text +=  _T(" max:");
 521
 522         int realMax_X = barrange->GetEnd();
 523         text +=  wxString::Format(_T("%d"),realMax_X);
 524
 525         color_bar -> setVisibleRange (realMin_X, realMax_X);
 526
 527         float startP=(float)barrange->getStartShowPorcentage();
 528         float endP=(float)barrange->getEndShowPorcentage();
 529         m_plot->moveFunctions(startP,endP);
 530
 531         color_bar -> RefreshForce();
 532         m_plot -> UpdateAll();
 533
 534         sendTMessage(text);
 535 }
 536
 537 /*
 538         * Method for sending a text message to the container window
 539         * @param theText Is the text of the message
 540         */
 541 void pPlotter :: sendTMessage(wxString theText)
 542 {
 543         //Creating a message event
 544         wxCommandEvent puntualMSG_Event( wxEVT_NW_TEXT_MESAGGE, GetId() );
 545         puntualMSG_Event.SetEventObject(this);
 546         //Sending the event
 547         GetEventHandler()->ProcessEvent( puntualMSG_Event );
 548 }
 549
 550 /*
 551         * Sets the text message
 552         * @param nMessage Is the text message to set
 553         */
 554         void pPlotter :: setTextMessage(wxString nMessage)
 555         {
 556                 text = nMessage;
 557         }
 558
 559         /*
 560         * Gets the text message
 561         * @param text Is the actual text message
 562         */
 563         wxString pPlotter :: getTextMessage()
 564         {
 565                 return text;
 566         }
 567         /**
 568         * Add a function to the plotter
 569         * when the function doesnt come from window
 570         */
 571         int pPlotter:: addFunction(pGraphicalFunction * function)
 572         {
 573                 return m_plot->addFunction(function);
 574         }
 575         /**
 576         * Creates and returns a graphical funcion according to the indicated vectors.
 577         */
 578         pGraphicalFunction* pPlotter::getFunctionForVectors( double* vectorX, int sizeX,double * vectorY, int sizeY )
 579         {
 580                 return m_plot->getFunctionForVectors(vectorX,sizeX, vectorY, sizeY );
 581         }
 582                 /*
 583          Set Type
 584         */
 585         void pPlotter::setType(int t)
 586         {
 587                 m_plot->setType(t);
 588         }
 589         /*
 590          Get a function in the plotter given the index
 591         */
 592         pGraphicalFunction* pPlotter:: getFunction(int index)
 593         {
 594                 return m_plot->getFunction(index);
 595         }
 596         /*
 597          Adds  function to move with the bar min max
 598         */
 599         int pPlotter::addFunctionToMove(pGraphicalFunction * function)
 600         {
 601                 return m_plot->addFunctionToMove(function);
 602         }
 603
 604         /*
 605           move the functions that the user wants to move
 606           and that were setted in functionsToMove
 607           @param porcentageMinX:the porcentage that the minShowed
 608           of the funcntions have to be move
 609           @param porcentageMaxX:the porcentage that the maxShowed
 610           of the funcntions have to be move
 611
 612         */
 613         void pPlotter:: moveFunctions(float porcentageMinX,float porcentageMaxX)
 614         {
 615                 m_plot->moveFunctions(porcentageMinX,porcentageMaxX);
 616         }
 617         /*
 618         * deletes the function from the plotter
 619         */
 620         /*
 621         bool pPlotter::deleteFunction(pGraphicalFunction * function);
 622                 {
 623                         return m_plot->deleteFunction(function);
 624
 625                 }
 626
 627         */
 628         //--------------------
 629         // Color information
 630         //---------------------
 631         /**
 632                 Returns the number of points that the bar color has
 633         */
 634         int pPlotter::getColorPointsSize()
 635         {
 636                 return color_bar->getColorPointsSize();
 637         }
 638         /*
 639          Get the RGB values of the color point that is in the
 640          index given
 641         */
 642         void pPlotter::getBarColorDataAt(int index,double& x, int& red,int& green,int& blue)
 643         {
 644                 color_bar->getDataAt(index,x,red,green,blue);
 645         }
 646         /*
 647          add a color Point
 648          returns true if the point was succesfully added
 649          PRE: 0<=red<=255 0<=green<=255 0<=blue<=255
 650         */
 651         bool pPlotter::addColorPoint(int x,int red,int green, int blue)
 652         {
 653                 wxColour color= wxColour(red,green,blue);
 654                 return color_bar->addColorPoint((double)x, color);
 655         }
 656         void pPlotter::eraseColorPoints()
 657         {
 658                 int min=(int)color_bar->getMinValue();
 659                 int max=(int)color_bar->getMaxValue();
 660                 color_bar->reinitiateColorBar(min,max);
 661         }
 662
 663         //--------------------
 664         // bar Information
 665         //---------------------
 666         float pPlotter::getMaxShowedPorcentage()
 667         {
 668                 return barrange->getEndShowPorcentage();
 669         }
 670
 671         float pPlotter::getMinShowedPorcentage()
 672         {
 673                 return barrange->getStartShowPorcentage();
 674         }
 675
 676         float pPlotter::getActualShowedPorcentage()
 677         {
 678                 return barrange->getActualShowPorcentage();
 679         }
 680
 681         //--------------------
 682         // plotter Information
 683         //---------------------
 684         void pPlotter::setActual(pGraphicalFunction* nActual)
 685         {
 686                 m_plot->setActualFunction(nActual);
 687         }
 688         void pPlotter::update()
 689         {
 690                 //if it is a plotter of histograms
 691                 if(m_plot->getType()==2)
 692                 {
 693                         pGraphicalFunction* tf= m_plot->getActualFunction();
 694                         if(tf->getType()==2)
 695                         {
 696                                 tf->clearSplineVectors();
 697                                 tf->addSplinesPoints();
 698                                 tf->initializeSplineVectors();
 699                         }
 700                 }
 701
 702                 m_plot->UpdateAll();
 703         }
 704         //----------------------------
 705         //Handling Options Menu
 706         //----------------------------
 707
 708         void pPlotter::setPopUpMenu(bool startD,bool stopD,bool smooth,bool line, bool zoomIn,
 709                                           bool zoomOut,bool showPoints,bool noShowPoints,bool changeColor, bool addP,
 710                                           bool delPoint,bool load,bool save)
 711         {
 712                 m_plot->setPopUpMenu(startD, stopD, smooth, line,  zoomIn,
 713                                            zoomOut, showPoints, noShowPoints, changeColor,  addP,
 714                                            delPoint, load, save);
 715         }
 716
 717
 718         /*
 719                 if the user resize the window
 720         */
 721
 722
 723
 724         /*
 725         void pPlotter::OnSize( wxSizeEvent &WXUNUSED(event) )
 726         {
 727                 int scrX,scrY;
 728                 GetClientSize(&scrX,&scrY);
 729                 m_plot->SetSize(scrX,scrY);
 730
 731
 732                 pGraphicalFunction* actual=m_plot->getActualFunction();
 733                 if(actual!=NULL)
 734                 {
 735                         actual->setScreens(scrX,scrY);
 736                         actual->setScales();
 737                 }
 738
 739
 740         }
 741         */
 742
 743
 744 /**
 745 **      Returns two vectors, the grey level of the point and its value, the value is between [0,1]
 746 **/
 747 void pPlotter::GetValuesPointsFunction(std::vector<double>& greylevel,std::vector<double>& value, int histogramsize)
 748 {
 749         if(actualFunction != NULL)
 750         {
 751                 double* xval = actualFunction->getX_RealValues();
 752                 double* yval = actualFunction->getY_RealValues();
 753                 actualFunction->getScaleY();
 754                 for(int i = 0; i < actualFunction->getSizePoints();i++)
 755                 {
 756                         greylevel.push_back(xval[i]);
 757                         value.push_back(yval[i]/histogramsize);
 758                 } // for
 759         } // if
 760 }
 761
 762 /**
 763 **      Returns two vectors, the grey level of the point and its value, the red, green
 764 **      and blue value is between [0,1]
 765 **/
 766 void pPlotter::GetValuesColorPointsFunction(std::vector<double>& greylevel,
 767                                                                 std::vector<double>& red,
 768                                                                 std::vector<double>& green,
 769                                                                 std::vector<double>& blue)
 770 {
 771         if(color_bar != NULL)
 772         {
 773                 std::vector<pColorPoint*> colors;
 774       color_bar->getAddedColorsPointsList(colors);
 775                 for(int i = 0; i < colors.size();i++)
 776                 {
 777                         pColorPoint* pcolor     = colors[i];
 778                         greylevel.push_back(pcolor->getRealX());
 779                         wxColour colour                 = pcolor->getColor();
 780                         double _red                     = (double)(colour.Red())/255.0;
 781                         double _green                   = (double)(colour.Green())/255.0;
 782                         double _blue                    = (double)(colour.Blue())/255.0;
 783                         red.push_back(_red);
 784                         green.push_back(_green);
 785                         blue.push_back(_blue);
 786                 } // for
 787         } // if
 788 }
 789
 790
 791
 792