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
 226         if (actualFunction != NULL)
 227         {
 228                 barrange -> setActiveStateTo(true);
 229                 color_bar -> setActiveStateTo(true);
 230
 231                 text.Clear();
 232                 text = _T("minX=");
 233                 double realMin_X = actualFunction->getMinX();
 234                 text = text + realMin_X;
 235                 text = text + _T(" maxX=");
 236                 double realMax_X = actualFunction->getMaxX();
 237                 text = text + realMax_X;
 238
 239                 int minShowed = actualFunction->getMinXShowed();
 240                 int maxShowed = actualFunction->getMaxXShowed();
 241
 242                 barrange -> setRepresentedValues (realMin_X, realMax_X);
 243                 barrange->SetStart( minShowed );
 244                 barrange->SetEnd( maxShowed );
 245
 246
 247                 std::vector<pColorPoint *> actualColorPoints;
 248                 actualFunction -> getColorPoints(actualColorPoints);
 249                 if(actualColorPoints.empty())
 250                         color_bar ->reinitiateColorBar (realMin_X, realMax_X);
 251                 else
 252                         color_bar ->reinitiateColorBarTo(actualColorPoints);
 253
 254                 color_bar -> setVisibleRange (minShowed, maxShowed);
 255
 256                 // Refresh
 257                 color_bar -> RefreshForce();
 258                 barrange -> RefreshForce();
 259
 260                 sendTMessage(text);
 261         }
 262 }
 263
 264
 265 //*****************************************************************************************************
 266 // Color bar control methods
 267 //*****************************************************************************************************
 268
 269 //-----------------------------------------------------------------------------------------------------
 270 // Updating methods for occured events in the color bar
 271 //-----------------------------------------------------------------------------------------------------
 272 void  pPlotter :: onAdded_ColorPoint(wxCommandEvent& event)
 273 {
 274         text.Clear();
 275         text = _T( "Last event was on color bar: Color point added, total#");
 276
 277         actualFunction = m_plot->getActualFunction();
 278         if(actualFunction!=NULL)
 279         {
 280                 std::vector<pColorPoint *> actualColorPoints;
 281                 color_bar ->getAddedColorsPointsList(actualColorPoints);
 282                 actualFunction -> setColorPoints(actualColorPoints);
 283                 text << actualColorPoints.size();
 284
 285                 sendTMessage(text);
 286         }
 287 }
 288 void  pPlotter :: onRemoved_ColorPoint(wxCommandEvent& event)
 289 {
 290         text.Clear();
 291         text = _T( "Last event on color bar: Color point removed total#");
 292
 293         actualFunction = m_plot->getActualFunction();
 294         std::vector<pColorPoint *> actualColorPoints;
 295         color_bar ->getAddedColorsPointsList(actualColorPoints);
 296         actualFunction -> setColorPoints(actualColorPoints);
 297         text << actualColorPoints.size();
 298
 299         sendTMessage(text);
 300 }
 301 void  pPlotter :: onMoved_ColorPoint(wxCommandEvent& event)
 302 {
 303         text.Clear();
 304         text = _T( "Last event was on color bar: Color point moved to: ");
 305         int lastReal_X = (int)(color_bar->getLastMovedColorPoint())->getRealX();
 306         text << lastReal_X;
 307
 308         barrange ->setRealX_vertical_line (lastReal_X);
 309         barrange -> RefreshForce();
 310
 311         m_plot->setRealGuideX (lastReal_X);
 312         m_plot->UpdateAll();
 313
 314         sendTMessage(text);
 315 }
 316 void  pPlotter:: onChanged_ColorPoint(wxCommandEvent& event)
 317 {
 318     text.Clear();
 319         sendTMessage(_T("Last event was on color bar: Color point changed color"));
 320 }
 321
 322 void pPlotter :: onColorBar( wxCommandEvent& event )
 323 {
 324         if( (barrange->getRealX_vertical_line())!=-1)
 325         {
 326                 barrange ->setRealX_vertical_line (-1);
 327                 m_plot->setRealGuideX (-1);
 328
 329                 barrange -> RefreshForce();
 330                 m_plot->UpdateAll();
 331         }
 332 }
 333
 334 //*****************************************************************************************************
 335 // Plotter control methods
 336 //*****************************************************************************************************
 337
 338
 339 /*
 340 * Method called when actual function is changed
 341 */
 342 void pPlotter :: onChangeFunction (wxCommandEvent& event)
 343 {
 344         actualFunction = m_plot->getActualFunction();
 345
 346         if (actualFunction != NULL)
 347         {
 348                 if( !barrange->isActive() )
 349                 {
 350                         barrange -> setActiveStateTo(true);
 351                         color_bar -> setActiveStateTo(true);
 352                 }
 353
 354                 text.Clear();
 355                 text = _T("Last event was on plotter: function changed, minX=");
 356                 double realMin_X = actualFunction->getMinX();
 357                 text << realMin_X;
 358                 text << _T(" maxX=");
 359                 double realMax_X = actualFunction->getMaxX();
 360                 text << realMax_X;
 361
 362                 int minShowed = actualFunction->getMinXShowed();
 363                 int maxShowed = actualFunction->getMaxXShowed();
 364
 365                 barrange -> setRepresentedValues (realMin_X, realMax_X);
 366                 barrange->SetStart( minShowed );
 367                 barrange->SetEnd( maxShowed );
 368
 369                 std::vector<pColorPoint *> actualColorPoints;
 370                 actualFunction -> getColorPoints(actualColorPoints);
 371                 if(actualColorPoints.empty())
 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         }
 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
 495         float startP=(float)barrange->getStartShowPorcentage();
 496         float endP=(float)barrange->getEndShowPorcentage();
 497         m_plot->moveFunctions(startP,endP);
 498
 499         color_bar -> RefreshForce();
 500         m_plot -> UpdateAll();
 501
 502         sendTMessage(text);
 503 }
 504
 505 void pPlotter :: onSelectionEnd(wxCommandEvent& event)
 506 {
 507         if( (color_bar->getRealX_vertical_line())!=-1)
 508         {
 509                 color_bar ->setRealX_vertical_line (-1);
 510                 m_plot->setRealGuideX (-1);
 511
 512                 color_bar -> RefreshForce();
 513                 m_plot->UpdateAll();
 514         }
 515 }
 516 void  pPlotter :: onMovedBar(wxCommandEvent& event)
 517 {
 518         text.Clear();
 519         text = _T( "Last event was on min-max bar: Moved bar to min:" );
 520
 521         int realMin_X = barrange->GetStart();
 522         text +=  wxString::Format(_T("%d"),realMin_X);
 523         text +=  _T(" max:");
 524
 525         int realMax_X = barrange->GetEnd();
 526         text +=  wxString::Format(_T("%d"),realMax_X);
 527
 528         color_bar -> setVisibleRange (realMin_X, realMax_X);
 529
 530         float startP=(float)barrange->getStartShowPorcentage();
 531         float endP=(float)barrange->getEndShowPorcentage();
 532         m_plot->moveFunctions(startP,endP);
 533
 534         color_bar -> RefreshForce();
 535         m_plot -> UpdateAll();
 536
 537         sendTMessage(text);
 538 }
 539
 540 /*
 541         * Method for sending a text message to the container window
 542         * @param theText Is the text of the message
 543         */
 544 void pPlotter :: sendTMessage(wxString theText)
 545 {
 546         //Creating a message event
 547         wxCommandEvent puntualMSG_Event( wxEVT_NW_TEXT_MESAGGE, GetId() );
 548         puntualMSG_Event.SetEventObject(this);
 549         //Sending the event
 550         GetEventHandler()->ProcessEvent( puntualMSG_Event );
 551 }
 552
 553 /*
 554         * Sets the text message
 555         * @param nMessage Is the text message to set
 556         */
 557         void pPlotter :: setTextMessage(wxString nMessage)
 558         {
 559                 text = nMessage;
 560         }
 561
 562         /*
 563         * Gets the text message
 564         * @param text Is the actual text message
 565         */
 566         wxString pPlotter :: getTextMessage()
 567         {
 568                 return text;
 569         }
 570         /**
 571         * Add a function to the plotter
 572         * when the function doesnt come from window
 573         */
 574         int pPlotter:: addFunction(pGraphicalFunction * function)
 575         {
 576                 return m_plot->addFunction(function);
 577         }
 578         /**
 579         * Creates and returns a graphical funcion according to the indicated vectors.
 580         */
 581         pGraphicalFunction* pPlotter::getFunctionForVectors( double* vectorX, int sizeX,double * vectorY, int sizeY )
 582         {
 583                 return m_plot->getFunctionForVectors(vectorX,sizeX, vectorY, sizeY );
 584         }
 585                 /*
 586          Set Type
 587         */
 588         void pPlotter::setType(int t)
 589         {
 590                 m_plot->setType(t);
 591         }
 592         /*
 593          Get a function in the plotter given the index
 594         */
 595         pGraphicalFunction* pPlotter:: getFunction(int index)
 596         {
 597                 return m_plot->getFunction(index);
 598         }
 599         /*
 600          Adds  function to move with the bar min max
 601         */
 602         int pPlotter::addFunctionToMove(pGraphicalFunction * function)
 603         {
 604                 return m_plot->addFunctionToMove(function);
 605         }
 606
 607         /*
 608           move the functions that the user wants to move
 609           and that were setted in functionsToMove
 610           @param porcentageMinX:the porcentage that the minShowed
 611           of the funcntions have to be move
 612           @param porcentageMaxX:the porcentage that the maxShowed
 613           of the funcntions have to be move
 614
 615         */
 616         void pPlotter:: moveFunctions(float porcentageMinX,float porcentageMaxX)
 617         {
 618                 m_plot->moveFunctions(porcentageMinX,porcentageMaxX);
 619         }
 620         /*
 621         * deletes the function from the plotter
 622         */
 623         /*
 624         bool pPlotter::deleteFunction(pGraphicalFunction * function);
 625                 {
 626                         return m_plot->deleteFunction(function);
 627
 628                 }
 629
 630         */
 631         //--------------------
 632         // Color information
 633         //---------------------
 634         /**
 635                 Returns the number of points that the bar color has
 636         */
 637         int pPlotter::getColorPointsSize()
 638         {
 639                 return color_bar->getColorPointsSize();
 640         }
 641         /*
 642          Get the RGB values of the color point that is in the
 643          index given
 644         */
 645         void pPlotter::getBarColorDataAt(int index,double& x, int& red,int& green,int& blue)
 646         {
 647                 color_bar->getDataAt(index,x,red,green,blue);
 648         }
 649         /*
 650          add a color Point
 651          returns true if the point was succesfully added
 652          PRE: 0<=red<=255 0<=green<=255 0<=blue<=255
 653         */
 654         bool pPlotter::addColorPoint(int x,int red,int green, int blue)
 655         {
 656                 wxColour color= wxColour(red,green,blue);
 657                 return color_bar->addColorPoint((double)x, color);
 658         }
 659         void pPlotter::eraseColorPoints()
 660         {
 661                 int min=(int)color_bar->getMinValue();
 662                 int max=(int)color_bar->getMaxValue();
 663                 color_bar->reinitiateColorBar(min,max);
 664         }
 665
 666         //--------------------
 667         // bar Information
 668         //---------------------
 669         float pPlotter::getMaxShowedPorcentage()
 670         {
 671                 return barrange->getEndShowPorcentage();
 672         }
 673         float pPlotter::getMinShowedPorcentage()
 674         {
 675                 return barrange->getStartShowPorcentage();
 676         }
 677         float pPlotter::getActualShowedPorcentage()
 678         {
 679                 return barrange->getActualShowPorcentage();
 680         }
 681
 682         //--------------------
 683         // plotter Information
 684         //---------------------
 685         void pPlotter::setActual(pGraphicalFunction* nActual)
 686         {
 687                 m_plot->setActualFunction(nActual);
 688         }
 689         void pPlotter::update()
 690         {
 691                 //if it is a plotter of histograms
 692                 if(m_plot->getType()==2)
 693                 {
 694                         pGraphicalFunction* tf= m_plot->getActualFunction();
 695                         if(tf->getType()==2)
 696                         {
 697                                 tf->clearSplineVectors();
 698                                 tf->addSplinesPoints();
 699                                 tf->initializeSplineVectors();
 700                         }
 701                 }
 702
 703                 m_plot->UpdateAll();
 704         }
 705         //----------------------------
 706         //Handling Options Menu
 707         //----------------------------
 708
 709         void pPlotter::setPopUpMenu(bool startD,bool stopD,bool smooth,bool line, bool zoomIn,
 710                                           bool zoomOut,bool showPoints,bool noShowPoints,bool changeColor, bool addP,
 711                                           bool delPoint,bool load,bool save)
 712         {
 713                 m_plot->setPopUpMenu(startD, stopD, smooth, line,  zoomIn,
 714                                            zoomOut, showPoints, noShowPoints, changeColor,  addP,
 715                                            delPoint, load, save);
 716         }
 717
 718
 719         /*
 720                 if the user resize the window
 721         */
 722
 723
 724
 725         /*
 726         void pPlotter::OnSize( wxSizeEvent &WXUNUSED(event) )
 727         {
 728                 int scrX,scrY;
 729                 GetClientSize(&scrX,&scrY);
 730                 m_plot->SetSize(scrX,scrY);
 731
 732
 733                 pGraphicalFunction* actual=m_plot->getActualFunction();
 734                 if(actual!=NULL)
 735                 {
 736                         actual->setScreens(scrX,scrY);
 737                         actual->setScales();
 738                 }
 739
 740
 741         }
 742         */
 743
 744
 745 /**
 746 **      Returns two vectors, the grey level of the point and its value, the value is between [0,1]
 747 **/
 748 void pPlotter::GetValuesPointsFunction(std::vector<double>& greylevel,std::vector<double>& value, int histogramsize)
 749 {
 750         if(actualFunction != NULL){
 751                 double* xval = actualFunction->getX_RealValues();
 752                 double* yval = actualFunction->getY_RealValues();
 753
 754                 actualFunction->getScaleY();
 755                 for(int i = 0; i < actualFunction->getSizePoints();i++){
 756                         greylevel.push_back(xval[i]);
 757                         value.push_back(yval[i]/histogramsize);
 758                 }
 759         }
 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
 772         if(color_bar != NULL){
 773
 774                 std::vector<pColorPoint*> colors;
 775         color_bar->getAddedColorsPointsList(colors);
 776
 777                 for(int i = 0; i < colors.size();i++){
 778                         pColorPoint* pcolor = colors[i];
 779
 780                         greylevel.push_back(pcolor->getRealX());
 781                         wxColour colour = pcolor->getColor();
 782
 783                         double _red = (double)(colour.Red())/255.0;
 784                         double _green = (double)(colour.Green())/255.0;
 785                         double _blue = (double)(colour.Blue())/255.0;
 786
 787                         red.push_back(_red);
 788                         green.push_back(_green);
 789                         blue.push_back(_blue);
 790                 }
 791         }
 792 }
 793
 794
 795
 796