pPlotter.cxx

Go to the documentation of this file.
00001 //---------------------------------------------------------------------------------------------
00002 // Class definition include
00003 //---------------------------------------------------------------------------------------------
00004 #include "pPlotter.h"
00005 
00006 // --------------------------------------------------------------------------------------------
00007 // WX headers inclusion.
00008 // For compilers that support precompilation, includes <wx/wx.h>.
00009 // --------------------------------------------------------------------------------------------
00010 
00011 #ifndef WX_PRECOMP
00012 #include <wx/wx.h>
00013 #endif
00014 
00015 //---------------------------------------------------------------------------------------------
00016 // Class implementation
00017 //---------------------------------------------------------------------------------------------
00018 
00019 IMPLEMENT_CLASS(pPlotter, wxPanel)
00020 
00021 //------------------------------------------------------------------------------------------------------------
00022 // Generated events declaration and definition
00023 //------------------------------------------------------------------------------------------------------------
00024 BEGIN_DECLARE_EVENT_TYPES()
00025         DECLARE_EVENT_TYPE( wxEVT_NW_TEXT_MESAGGE, -1 ) 
00026 END_DECLARE_EVENT_TYPES()
00027 
00028 DEFINE_EVENT_TYPE( wxEVT_NW_TEXT_MESAGGE )
00029 
00030 // ----------------------------------------------------------------------------------------------------
00031 // Handdled events from pColorBar
00032 // ----------------------------------------------------------------------------------------------------
00033 DECLARE_EVENT_TYPE(wxEVT_ADDED_POINT, -1)
00034 DECLARE_EVENT_TYPE(wxEVT_REMOVED_POINT, -1)
00035 DECLARE_EVENT_TYPE(wxEVT_MOVED_POINT, -1)
00036 DECLARE_EVENT_TYPE(wxEVT_CHANGED_POINT, -1)
00037 DECLARE_EVENT_TYPE(wxEVT_ON_COLOR_BAR, -1)
00038 
00039 // ----------------------------------------------------------------------------------------------------
00040 // Handdled events from plotter
00041 // ----------------------------------------------------------------------------------------------------
00042 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_CHANGED_FUNCTION, -1)
00043 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_POINT_MOVE, -1)
00044 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_POINT_ADD, -1)
00045 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_POINT_DELETE, -1)
00046 DECLARE_EVENT_TYPE(wxEVT_PPLOTTER_GUIDELINES, -1)
00047 
00048 // ----------------------------------------------------------------------------------------------------
00049 // Handdled events from max-min barrange
00050 // ----------------------------------------------------------------------------------------------------
00051 DECLARE_EVENT_TYPE(wxEVT_TSBAR, -1)
00052 DECLARE_EVENT_TYPE(wxEVT_TSBAR_ACTUAL, -1)
00053 DECLARE_EVENT_TYPE(wxEVT_TSBAR_START, -1)
00054 DECLARE_EVENT_TYPE(wxEVT_TSBAR_END, -1)
00055 DECLARE_EVENT_TYPE(wxEVT_TSBAR_MOVED, -1)
00056 DECLARE_EVENT_TYPE(wxEVT_SELECTION_END, -1)
00057 
00058 
00059 // ----------------------------------------------------------------------------------------------------
00060 // EVENT TABLE (->Connect: analogous)
00061 //-----------------------------------------------------------------------------------------------------
00062 BEGIN_EVENT_TABLE(pPlotter, wxPanel)
00063         //OnSize
00064         //EVT_SIZE  (pPlotter::OnSize)
00065         
00066         // Connectting the handled envents for the plotter to the corresponding methods
00067         EVT_COMMAND  (-1,wxEVT_PPLOTTER_CHANGED_FUNCTION, pPlotter::onChangeFunction)
00068         EVT_COMMAND  (-1,wxEVT_PPLOTTER_POINT_MOVE, pPlotter::onMovePoint_Plotter)
00069         EVT_COMMAND  (-1,wxEVT_PPLOTTER_POINT_ADD, pPlotter::onAddedPoint_Plotter)
00070         EVT_COMMAND  (-1,wxEVT_PPLOTTER_POINT_DELETE, pPlotter::onRemovedPoint_Plotter)
00071         EVT_COMMAND  (-1,wxEVT_PPLOTTER_GUIDELINES, pPlotter::onGuideLines)
00072 
00073         // Connectting the handled envents for the color bar  to the corresponding methods
00074     EVT_COMMAND  (-1,wxEVT_ADDED_POINT, pPlotter :: onAdded_ColorPoint )
00075         EVT_COMMAND  (-1,wxEVT_REMOVED_POINT, pPlotter :: onRemoved_ColorPoint )
00076         EVT_COMMAND  (-1,wxEVT_MOVED_POINT, pPlotter :: onMoved_ColorPoint )
00077         EVT_COMMAND  (-1,wxEVT_CHANGED_POINT, pPlotter :: onChanged_ColorPoint )
00078         EVT_COMMAND  (-1,wxEVT_ON_COLOR_BAR, pPlotter :: onColorBar )
00079 
00080         // Connectting the handled envents from the max-min barrange  to the corresponding methods
00081         EVT_COMMAND  (-1,wxEVT_TSBAR, pPlotter::onBarrange)
00082         EVT_COMMAND  (-1,wxEVT_SELECTION_END, pPlotter::onSelectionEnd)
00083         EVT_COMMAND  (-1,wxEVT_TSBAR_MOVED, pPlotter::onMovedBar)
00084         EVT_COMMAND  (-1,wxEVT_TSBAR_ACTUAL, pPlotter:: onActualChange_Bar)
00085         EVT_COMMAND  (-1,wxEVT_TSBAR_START, pPlotter::onStartChange_Bar)
00086         EVT_COMMAND  (-1,wxEVT_TSBAR_END, pPlotter::onEndChange_Bar)
00087 
00088 END_EVENT_TABLE()
00089 
00090 
00091 //---------------------------------------------------------------------------------------------
00092 // Constructors & Destructors
00093 //---------------------------------------------------------------------------------------------
00094         /*
00095         * Creates an integrated plotter instance 
00096         * @param *parent Container window
00097         */
00098         pPlotter :: pPlotter  (wxWindow *parent,int nWidth, int nHeight)
00099         :wxPanel(parent,-1,wxDefaultPosition,wxDefaultSize,wxTAB_TRAVERSAL)
00100         {
00101                 SetBackgroundColour(wxColour(255,255,255));
00102                 m_plot = new pPlotterWindow( this, -1, wxPoint(0,0), wxSize(nWidth,nHeight), wxSUNKEN_BORDER );
00103                 
00104                 // Adding the axis layers to the plotter
00105                 m_plot->AddLayer( new pPlotterScaleX() );
00106                 m_plot->AddLayer( new pPlotterScaleY() );  
00107 
00108                 // Creating the log window
00109         /*
00110            
00111                 m_log = new wxTextCtrl( panel, -1, wxT("This is the log window.\n"), wxPoint(0,0), wxSize(400,100), wxTE_MULTILINE );
00112                 // Sharing the log window of the application with the plotter widget    
00113                 m_plot->setmLog(m_log);
00114                 
00115                 */
00116 
00117 
00118                 // Creating a function for the plotter with given points x-vector and y-vector
00119 
00120                 /*
00121                 double vectX_F1 [] = { 0, 20, 50, 80, 100, 115, 120, 210, 220,250 };
00122 
00123                 
00124 //              double vectX_F1 [] = { 0, 20, 50, 80, 100, 115, 120, 210, 220,250 };
00125 
00126                 double vectY_F1 [] = { 0, 40, 70, 100, 200, 100, 40, 170, 0, 50  };
00127                 pGraphicalFunction * f1 = m_plot ->getFunctionForVectors( vectX_F1, 10, vectY_F1, 10 ); 
00128                 // Including and drawing the created function in the plotter
00129                 if (f1)
00130                 {
00131                         m_plot->addFunction( f1 );
00132                         m_plot->addFunctionToMove(f1);
00133                         //m_plot->addFunctionToMove(f1);
00134                         wxPen mypen1(*wxBLUE, 2, wxDOT_DASH );
00135                         mypen1.SetWidth(2);
00136                         f1->SetPen( mypen1 );
00137                 }
00138                 */
00139                 
00140                 //=================== lines to sychronyze the bars width with the drawed plotter--------------------------
00141 
00142                 mpWindow* mplotWindow = ((mpWindow*)m_plot);
00143                 float minReal_X = 0; //(float)mplotWindow->getMinScrX();
00144                 float maxReal_X =(float)mplotWindow->getMaxScrX();
00145                 //float scrX=(float)mplotWindow->GetScrX()-100; // JPRx
00146                 //double scaleX=(scrX/(maxReal_X))* (mplotWindow->getZoomFactor()); // JPRx
00147                         
00148                 // Creating the color bar with values according to the plotter added widget
00149                 color_bar = new pColorBar(this, (m_plot->GetSize()).GetWidth(),40, true);
00150                 color_bar -> setRepresentedValues ((int)minReal_X, (int)maxReal_X);
00151                 color_bar -> setDeviceBlitStart (70,0);
00152                 color_bar -> setVisibleRange ((int)minReal_X,(int) maxReal_X);
00153                 color_bar -> setDeviceEndMargin (50);
00154                 
00155                 
00156                 // Creating the min-max barrange bar with values according to the plotter added widget
00157                 barrange = new mBarRange(this, (m_plot->GetSize()).GetWidth(),30);
00158                 barrange -> setVisibleLabels (false);
00159                 barrange -> setRepresentedValues (minReal_X, maxReal_X);
00160                 barrange -> setDeviceBlitStart (70,0);
00161                 barrange -> setDeviceEndMargin (50);
00162 
00163                 // Adding the components to the sizer 
00164                 /*
00165                 if(m_plot->getActualFunction())
00166                         setAll();
00167                 */      
00168                 wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
00169                 sizer->Add( m_plot, 4, wxEXPAND);       
00170                 sizer->Add( color_bar,0, wxEXPAND );
00171                 sizer->Add( barrange, 0, wxEXPAND );
00172 
00173                 // sizer->Add( m_log, 0, wxEXPAND);
00174                 
00175                 // Stablishing the layout and sizer of the panel
00176                 /*panel->*/SetAutoLayout(true);
00177                 /*panel->*/SetSizer(sizer);
00178                 /*panel->*/Layout();
00179 
00180                 /*panel->*/Refresh();
00181         }
00182 
00183 
00184         pPlotter :: ~pPlotter ()
00185         {
00186 
00187         }
00188 
00189 //---------------------------------------------------------------------------------------------
00190 // Methods
00191 //---------------------------------------------------------------------------------------------
00192 /*
00193 Set the bars according to the actual function 
00194 */
00195 
00196         void pPlotter::setAll()
00197 {
00198         actualFunction = m_plot->getActualFunction();
00199 
00200         if (actualFunction != NULL)
00201         {
00202                 barrange -> setActiveStateTo(true);
00203                 color_bar -> setActiveStateTo(true);
00204 
00205                 text.Clear();
00206                 text = _T("minX=");
00207                 double realMin_X = actualFunction->getMinX();
00208                 text = text + realMin_X;        
00209                 text = text + _T(" maxX=");
00210                 double realMax_X = actualFunction->getMaxX();
00211                 text = text + realMax_X;
00212 
00213                 int minShowed = actualFunction->getMinXShowed();
00214                 int maxShowed = actualFunction->getMaxXShowed();
00215 
00216                 barrange -> setRepresentedValues (realMin_X, realMax_X);
00217                 barrange->SetStart( minShowed );
00218                 barrange->SetEnd( maxShowed );
00219 
00220 
00221                 std::vector<pColorPoint *> actualColorPoints;
00222                 actualFunction -> getColorPoints(actualColorPoints);
00223                 if(actualColorPoints.empty())
00224                         color_bar ->reinitiateColorBar (realMin_X, realMax_X);
00225                 else
00226                         color_bar ->reinitiateColorBarTo(actualColorPoints);
00227 
00228                 color_bar -> setVisibleRange (minShowed, maxShowed);
00229                 
00230                 // Refresh
00231                 color_bar -> RefreshForce();
00232                 barrange -> RefreshForce();     
00233                 
00234                 sendTMessage(text);
00235         }
00236 }
00237 
00238         
00239 //*****************************************************************************************************
00240 // Color bar control methods
00241 //*****************************************************************************************************
00242 
00243 //-----------------------------------------------------------------------------------------------------
00244 // Updating methods for occured events in the color bar
00245 //-----------------------------------------------------------------------------------------------------
00246 void  pPlotter :: onAdded_ColorPoint(wxCommandEvent& event)
00247 {
00248         text.Clear();
00249         text = _T( "Last event was on color bar: Color point added, total#");
00250         
00251         actualFunction = m_plot->getActualFunction();
00252         if(actualFunction!=NULL)
00253         {               
00254                 std::vector<pColorPoint *> actualColorPoints;
00255                 color_bar ->getAddedColorsPointsList(actualColorPoints);
00256                 actualFunction -> setColorPoints(actualColorPoints);
00257                 text << actualColorPoints.size();
00258 
00259                 sendTMessage(text);
00260         }
00261 }
00262 void  pPlotter :: onRemoved_ColorPoint(wxCommandEvent& event)
00263 {       
00264         text.Clear();
00265         text = _T( "Last event on color bar: Color point removed total#");
00266 
00267         actualFunction = m_plot->getActualFunction();
00268         std::vector<pColorPoint *> actualColorPoints;
00269         color_bar ->getAddedColorsPointsList(actualColorPoints);
00270         actualFunction -> setColorPoints(actualColorPoints);
00271         text << actualColorPoints.size();
00272         
00273         sendTMessage(text);
00274 }
00275 void  pPlotter :: onMoved_ColorPoint(wxCommandEvent& event)
00276 {
00277         text.Clear();
00278         text = _T( "Last event was on color bar: Color point moved to: ");
00279         int lastReal_X = (int)(color_bar->getLastMovedColorPoint())->getRealX();
00280         text << lastReal_X;
00281         
00282         barrange ->setRealX_vertical_line (lastReal_X);
00283         barrange -> RefreshForce();
00284         
00285         m_plot->setRealGuideX (lastReal_X);
00286         m_plot->UpdateAll();
00287         
00288         sendTMessage(text);
00289 }
00290 void  pPlotter:: onChanged_ColorPoint(wxCommandEvent& event)
00291 {
00292     text.Clear();
00293         sendTMessage(_T("Last event was on color bar: Color point changed color"));
00294 }
00295 
00296 void pPlotter :: onColorBar( wxCommandEvent& event )
00297 {
00298         if( (barrange->getRealX_vertical_line())!=-1)
00299         {
00300                 barrange ->setRealX_vertical_line (-1); 
00301                 m_plot->setRealGuideX (-1);
00302 
00303                 barrange -> RefreshForce();
00304                 m_plot->UpdateAll();
00305         }
00306 }
00307 
00308 //*****************************************************************************************************
00309 // Plotter control methods
00310 //*****************************************************************************************************
00311 
00312 
00313 /*
00314 * Method called when actual function is changed
00315 */
00316 void pPlotter :: onChangeFunction (wxCommandEvent& event)
00317 {
00318         actualFunction = m_plot->getActualFunction();
00319         
00320         if (actualFunction != NULL)
00321         {
00322                 if( !barrange->isActive() )
00323                 {
00324                         barrange -> setActiveStateTo(true);
00325                         color_bar -> setActiveStateTo(true);
00326                 }
00327 
00328                 text.Clear();
00329                 text = _T("Last event was on plotter: function changed, minX=");
00330                 double realMin_X = actualFunction->getMinX();
00331                 text << realMin_X;      
00332                 text << _T(" maxX=");
00333                 double realMax_X = actualFunction->getMaxX();
00334                 text << realMax_X;
00335 
00336                 int minShowed = actualFunction->getMinXShowed();
00337                 int maxShowed = actualFunction->getMaxXShowed();
00338 
00339                 barrange -> setRepresentedValues (realMin_X, realMax_X);
00340                 barrange->SetStart( minShowed );
00341                 barrange->SetEnd( maxShowed );
00342                 
00343                 std::vector<pColorPoint *> actualColorPoints;
00344                 actualFunction -> getColorPoints(actualColorPoints);
00345                 if(actualColorPoints.empty())
00346                         color_bar ->reinitiateColorBar (realMin_X, realMax_X);
00347                 else
00348                         color_bar ->reinitiateColorBarTo(actualColorPoints);
00349 
00350                 color_bar -> setVisibleRange ((int)realMin_X, maxShowed);
00351                 
00352                 // Refresh
00353                 color_bar -> RefreshForce();
00354                 barrange -> RefreshForce();     
00355                 
00356                 sendTMessage(text);
00357         }
00358 }
00359 
00360 
00361 /*
00362 * Method called when a point is added to the actual function on the plotter
00363 */
00364 
00365 void pPlotter :: onAddedPoint_Plotter (wxCommandEvent& event)
00366 {
00367         text.Clear();
00368         m_plot->writeInText(text);
00369         sendTMessage(text);
00370 }
00371 
00372 /*
00373 * Method called when a point is removed to the actual function on the plotter
00374 */
00375 void pPlotter :: onRemovedPoint_Plotter (wxCommandEvent& event)
00376 {
00377         text.Clear();
00378         m_plot->writeInText(text);
00379         sendTMessage(text);     
00380 }
00381 
00382 /*
00383 * Method called when a point is moved from the actual function on the plotter
00384 */
00385 void pPlotter :: onMovePoint_Plotter (wxCommandEvent& event)
00386 {
00387         text.Clear();
00388         m_plot->writeInText(text);
00389         sendTMessage(text);
00390 }
00391 /*
00392 * Method called when turn off the guide line from the actual function on the plotter
00393 */
00394 void pPlotter::onGuideLines(wxCommandEvent& event)
00395 {
00396                 
00397 }
00398 
00399 
00400 
00401 //*****************************************************************************************************
00402 // Max-Min Barrange control methods
00403 //*****************************************************************************************************
00404 /*
00405 *
00406 */
00407 void  pPlotter::onBarrange(wxCommandEvent& event)
00408 {
00409                 
00410 }
00411 /*
00412 *
00413 */
00414 void  pPlotter::onActualChange_Bar(wxCommandEvent& event)
00415 {
00416         text.Clear();
00417         text = _T( "Last event was on min-max bar: Actual triangle moved to: " );
00418         int lastActual_X = barrange->GetActual();
00419 
00420         text << lastActual_X;
00421         
00422         color_bar ->setRealX_vertical_line (lastActual_X);
00423         m_plot->setRealGuideX (lastActual_X);
00424 
00425         color_bar -> RefreshForce();    
00426         m_plot->UpdateAll();
00427 
00428         sendTMessage(text);
00429 }
00430 
00431 /*
00432 * Method called when the start triangle is moved. Adjusts the plotter and color bar view-range.
00433 */
00434 void  pPlotter::onStartChange_Bar(wxCommandEvent& event)
00435 {
00436         text.Clear();
00437     
00438         text = _T( "Last event was on min-max bar: Start triangle moved to: ");
00439         int realMin_X = barrange->GetStart();
00440         text += wxString::Format(_T("%d"), realMin_X);  
00441         double realMax_X = m_plot->getMaxScrX();
00442         
00443         color_bar -> setVisibleRange (realMin_X, (int)realMax_X);
00444         
00445         m_plot->actualizeViewRange(realMin_X, (int)realMax_X);
00446         
00447         //setting the plotter for draw the functions that
00448         //it has to move.
00449         
00450         float startP=(float)barrange->getStartShowPorcentage();
00451         float endP=(float)barrange->getEndShowPorcentage();
00452         m_plot->moveFunctions(startP,endP);
00453         
00454         //Updating
00455         color_bar -> RefreshForce();
00456         m_plot -> UpdateAll();
00457         sendTMessage(text);
00458 }
00459 
00460 void  pPlotter::onEndChange_Bar(wxCommandEvent& event)
00461 {
00462         text.Clear();
00463         text += _T("Last event was on min-max bar: End  triangle moved to: ");
00464         int realMax_X = barrange->GetEnd();
00465         text += wxString::Format(_T("%d"),realMax_X);   
00466         double realMin_X = m_plot->getMinScrX();
00467         color_bar -> setVisibleRange ((int)realMin_X, realMax_X);
00468         m_plot->actualizeViewRange((int)realMin_X,realMax_X);
00469         
00470         float startP=(float)barrange->getStartShowPorcentage();
00471         float endP=(float)barrange->getEndShowPorcentage();
00472         m_plot->moveFunctions(startP,endP);
00473         
00474         color_bar -> RefreshForce();
00475         m_plot -> UpdateAll();
00476 
00477         sendTMessage(text);
00478 }
00479 
00480 void pPlotter :: onSelectionEnd(wxCommandEvent& event)
00481 {
00482         if( (color_bar->getRealX_vertical_line())!=-1)
00483         {
00484                 color_bar ->setRealX_vertical_line (-1);        
00485                 m_plot->setRealGuideX (-1);
00486 
00487                 color_bar -> RefreshForce();
00488                 m_plot->UpdateAll();    
00489         }
00490 }
00491 void  pPlotter :: onMovedBar(wxCommandEvent& event)
00492 {
00493         text.Clear();
00494         text = _T( "Last event was on min-max bar: Moved bar to min:" );
00495         
00496         int realMin_X = barrange->GetStart();
00497         text +=  wxString::Format(_T("%d"),realMin_X);  
00498         text +=  _T(" max:");
00499 
00500         int realMax_X = barrange->GetEnd();
00501         text +=  wxString::Format(_T("%d"),realMax_X);
00502 
00503         color_bar -> setVisibleRange (realMin_X, realMax_X);
00504         
00505         float startP=(float)barrange->getStartShowPorcentage();
00506         float endP=(float)barrange->getEndShowPorcentage();
00507         m_plot->moveFunctions(startP,endP);
00508         
00509         color_bar -> RefreshForce();
00510         m_plot -> UpdateAll();
00511 
00512         sendTMessage(text);
00513 }
00514 
00515 /*
00516         * Method for sending a text message to the container window
00517         * @param theText Is the text of the message
00518         */
00519 void pPlotter :: sendTMessage(wxString theText)
00520 {
00521         //Creating a message event 
00522         wxCommandEvent puntualMSG_Event( wxEVT_NW_TEXT_MESAGGE, GetId() );
00523         puntualMSG_Event.SetEventObject(this);
00524         //Sending the event
00525         GetEventHandler()->ProcessEvent( puntualMSG_Event );
00526 }
00527 
00528 /*
00529         * Sets the text message
00530         * @param nMessage Is the text message to set
00531         */
00532         void pPlotter :: setTextMessage(wxString nMessage)
00533         {
00534                 text = nMessage;
00535         }
00536 
00537         /*
00538         * Gets the text message
00539         * @param text Is the actual text message 
00540         */
00541         wxString pPlotter :: getTextMessage()
00542         {
00543                 return text;
00544         }
00549         int pPlotter:: addFunction(pGraphicalFunction * function)
00550         {
00551                 return m_plot->addFunction(function);  
00552         }
00556         pGraphicalFunction* pPlotter::getFunctionForVectors( double* vectorX, int sizeX,double * vectorY, int sizeY )
00557         {
00558                 return m_plot->getFunctionForVectors(vectorX,sizeX, vectorY, sizeY );
00559         }
00560                 /*
00561          Set Type
00562         */
00563         void pPlotter::setType(int t)
00564         {
00565                 m_plot->setType(t);
00566         }
00567         /*
00568          Get a function in the plotter given the index
00569         */
00570         pGraphicalFunction* pPlotter:: getFunction(int index)
00571         {
00572                 return m_plot->getFunction(index);
00573         }
00574         /*
00575          Adds  function to move with the bar min max
00576         */
00577         int pPlotter::addFunctionToMove(pGraphicalFunction * function)
00578         {
00579                 return m_plot->addFunctionToMove(function);
00580         }
00581         
00582         /*
00583           move the functions that the user wants to move
00584           and that were setted in functionsToMove
00585           @param porcentageMinX:the porcentage that the minShowed
00586           of the funcntions have to be move
00587           @param porcentageMaxX:the porcentage that the maxShowed
00588           of the funcntions have to be move
00589 
00590         */
00591         void pPlotter:: moveFunctions(float porcentageMinX,float porcentageMaxX)
00592         {
00593                 m_plot->moveFunctions(porcentageMinX,porcentageMaxX);
00594         }
00595         /*
00596         * deletes the function from the plotter
00597         */
00598         /*
00599         bool pPlotter::deleteFunction(pGraphicalFunction * function);
00600                 {
00601                         return m_plot->deleteFunction(function);
00602 
00603                 }
00604 
00605         */
00606         //--------------------
00607         // Color information
00608         //---------------------
00612         int pPlotter::getColorPointsSize()
00613         {
00614                 return color_bar->getColorPointsSize();
00615         }
00616         /*
00617          Get the RGB values of the color point that is in the
00618          index given
00619         */
00620         void pPlotter::getBarColorDataAt(int index,double& x, int& red,int& green,int& blue)
00621         {
00622                 color_bar->getDataAt(index,x,red,green,blue);
00623         }
00624         /*
00625          add a color Point 
00626          returns true if the point was succesfully added
00627          PRE: 0<=red<=255 0<=green<=255 0<=blue<=255
00628         */
00629         bool pPlotter::addColorPoint(int x,int red,int green, int blue)
00630         {
00631                 wxColour color= wxColour(red,green,blue);
00632                 return color_bar->addColorPoint((double)x, color);
00633         }
00634         void pPlotter::eraseColorPoints()
00635         {
00636                 int min=(int)color_bar->getMinValue();
00637                 int max=(int)color_bar->getMaxValue();
00638                 color_bar->reinitiateColorBar(min,max);
00639         }
00640 
00641         //--------------------
00642         // bar Information
00643         //---------------------
00644         float pPlotter::getMaxShowedPorcentage()
00645         {
00646                 return barrange->getEndShowPorcentage();
00647         }
00648         float pPlotter::getMinShowedPorcentage()
00649         {
00650                 return barrange->getStartShowPorcentage();
00651         }
00652         float pPlotter::getActualShowedPorcentage()
00653         {
00654                 return barrange->getActualShowPorcentage();
00655         }
00656         
00657         //--------------------
00658         // plotter Information
00659         //---------------------
00660         void pPlotter::setActual(pGraphicalFunction* nActual)
00661         {
00662                 m_plot->setActualFunction(nActual);
00663         }
00664         void pPlotter::update()
00665         {
00666                 //if it is a plotter of histograms
00667                 if(m_plot->getType()==2)
00668                 {
00669                         pGraphicalFunction* tf= m_plot->getActualFunction();
00670                         if(tf->getType()==2)
00671                         {
00672                                 tf->clearSplineVectors();
00673                                 tf->addSplinesPoints();
00674                                 tf->initializeSplineVectors();
00675                         }
00676                 }
00677 
00678                 m_plot->UpdateAll();
00679         }
00680         //----------------------------
00681         //Handling Options Menu
00682         //----------------------------
00683         
00684         void pPlotter::setPopUpMenu(bool startD,bool stopD,bool smooth,bool line, bool zoomIn,
00685                                           bool zoomOut,bool showPoints,bool noShowPoints,bool changeColor, bool addP,
00686                                           bool delPoint,bool load,bool save)
00687         {
00688                 m_plot->setPopUpMenu(startD, stopD, smooth, line,  zoomIn,
00689                                            zoomOut, showPoints, noShowPoints, changeColor,  addP,
00690                                            delPoint, load, save);
00691         }
00692 
00693 
00694         /*
00695                 if the user resize the window   
00696         */
00697         
00698         
00699         
00700         /*
00701         void pPlotter::OnSize( wxSizeEvent &WXUNUSED(event) )
00702         {
00703                 int scrX,scrY;
00704                 GetClientSize(&scrX,&scrY);
00705                 m_plot->SetSize(scrX,scrY);
00706                 
00707                 
00708                 pGraphicalFunction* actual=m_plot->getActualFunction();
00709                 if(actual!=NULL)
00710                 {               
00711                         actual->setScreens(scrX,scrY);
00712                         actual->setScales();
00713                 }
00714                 
00715                 
00716         }
00717         */
00718         
00719 
00723 void pPlotter::GetValuesPointsFunction(std::vector<double>& greylevel,std::vector<double>& value, int histogramsize)
00724 {
00725         if(actualFunction != NULL){
00726                 double* xval = actualFunction->getX_RealValues();
00727                 double* yval = actualFunction->getY_RealValues();
00728 
00729                 actualFunction->getScaleY();
00730                 for(int i = 0; i < actualFunction->getSizePoints();i++){
00731                         greylevel.push_back(xval[i]);
00732                         value.push_back(yval[i]/histogramsize);
00733                 }
00734         }
00735 }
00736 
00741 void pPlotter::GetValuesColorPointsFunction(std::vector<double>& greylevel,
00742                                                                 std::vector<double>& red,
00743                                                                 std::vector<double>& green,
00744                                                                 std::vector<double>& blue)
00745 {
00746 
00747         if(color_bar != NULL){
00748 
00749                 std::vector<pColorPoint*> colors;
00750         color_bar->getAddedColorsPointsList(colors);
00751 
00752                 for(int i = 0; i < colors.size();i++){
00753                         pColorPoint* pcolor = colors[i];
00754 
00755                         greylevel.push_back(pcolor->getRealX());
00756                         wxColour colour = pcolor->getColor();
00757                         
00758                         double _red = (double)(colour.Red())/255.0;
00759                         double _green = (double)(colour.Green())/255.0;
00760                         double _blue = (double)(colour.Blue())/255.0;
00761 
00762                         red.push_back(_red);
00763                         green.push_back(_green);
00764                         blue.push_back(_blue);
00765                 }               
00766         }
00767 }
00768 
00769 
00770 
00771 

Generated on Wed Jul 29 16:35:29 2009 for creaMaracasVisu_lib by  doxygen 1.5.3