pGraphicalFunction Class Reference

#include <pGraphicalFunction.h>

Inheritance diagram for pGraphicalFunction:

Collaboration diagram for pGraphicalFunction:

List of all members.

Public Member Functions

pGraphicalFunction (wxString name=wxEmptyString, int flags=0x00)

~pGraphicalFunction ()

virtual int getXTraslation ()

virtual int getmType ()

virtual int vGetType ()

virtual void getOffsets (int &offsetX, int &offSetY)

virtual void getFactorZoom (float &fz)

virtual void getFromWindowV (bool &fw)

virtual void getIfActual (bool &actual)

virtual void getMax (int &maxX, int &maxY)

virtual void getMaxShowed (int &maxX, int &maxY)

virtual void getMinShowed (int &minX, int &minY)

virtual void getScreens (int &scrX, int &scrY)

virtual void setScreens (int scrX, int scrY)

virtual void getScales (double &scaleX, double &scaleY)

virtual void getDrawing (bool &draw)

virtual void ifShowPoints (bool &show)

virtual void Rewind ()

virtual bool GetNextXY (double &x, double &y)

virtual void GetPoints (wxList &points)

virtual void getMousePoint (int &x, int &y)

virtual void getSize (int &size)

virtual void getDirection (bool &dir)

int validPointOnFunction (wxPoint realPoint)

int getIndexOf (wxPoint realpoint)

wxNode * GetPointAt (int movingPointIndex)

bool AddNewPoint (int x, int y)

bool AddPoint (int aX, int aY, bool order=true)

bool DeletePoint (int aX, int aY)

bool changePoint (wxPoint newCoords, int movingIndexPoint)

double * getX_RealValues ()

double * getY_RealValues ()

bool orderPoints ()

bool deletePointAt (int index)

int getSizePoints ()

void setScales ()

bool isInFunction (int x, int y)

wxNode * getBefore (pFunctionPoint *point)

bool isInLine (pFunctionPoint *before, pFunctionPoint *next, pFunctionPoint *point)

double interpolateY (double m, int x1, int y1, int x)

void setUp ()

void clearSplineVectors ()

void initializeSplines ()

void addSplinesPoints ()

void initializeSplineVectors ()

void GetSplinePoint (double t, double &x, double &y)

virtual std::vector< double > getXSpline ()

virtual std::vector< double > getYSpline ()

virtual int getOffsetPixelsXv ()

virtual int getOffsetPixelsYv ()

void save (wxString fileName)

void load (wxString fileName)

void SetShowPoints (bool showPoints)

bool getShowPoints ()

void setScreenX (int scrX)

int getScreenX ()

void setScreenY (int scrY)

int getScreenY ()

void setStartX (double aStartX)

double getStartX ()

void setStartY (double aStartY)

double getStartY ()

void setEndX (double aEndX)

double getEndX ()

void setEndY (double aEndY)

double getEndY ()

void setScaleX (double aScaleX)

double getScaleX ()

void setScaleY (double aScaleY)

double getScaleY ()

void setMinX (double aMinX)

double getMinX ()

void setMinY (double aMinY)

double getMinY ()

void setMaxX (double aMaxX)

double getMaxX ()

void setMaxY (double aMaxY)

double getMaxY ()

void setOffsetX (double aOffsetX)

double getOffsetX ()

void setOffsetY (double aOffsetY)

double getOffsetY ()

void setType (int aType)

int getType ()

int getValidPointRange ()

void setValidPointRange (int theRange)

void SetDrawing (bool d)

bool GetDrawing ()

void SetMousePoint (wxPoint p)

wxPoint getMousePoint ()

void setActual (bool act)

bool getActual ()

void setScaleWay (int typeS)

int getScaleWay ()

void setFromWindow (bool w)

bool getFromWindow ()

void setFactorZoom (float factor)

void setEditable (bool edit)

bool getEditable ()

bool getZoomB ()

void setZoomIn (bool z)

void setInitialDrawPoint (pFunctionPoint *initialPoint)

pFunctionPoint * getInitialDrawPoint ()

void setFinalDrawPoint (pFunctionPoint *finalPoint)

pFunctionPoint * getFinallDrawPoint ()

void zooming (int clickedX, int clickedY, int width)

void setOffsets (int offx, int offy)

void setMinShowed ()

int getMinXShowed ()

int getMinYShowed ()

int getMaxXShowed ()

int getMaxYShowed ()

void setMinShowedX (int msx)

void setMinShowedY (int msy)

void setMaxShowedX (int msx)

void setMaxShowedY (int msy)

int getOffsetPixelsX ()

int getOffsetPixelsY ()

void setOffsetPixelX (int offX)

void setOffsetPixelY (int offY)

void setColorPoints (std::vector< pColorPoint * > &colorVector)

void getColorPoints (std::vector< pColorPoint * > &colorVector)

void setmType (int mt)

void setXTraslation (int xT)

bool initializePolygon (wxPoint *points, double x1, double y1, double x2, double y2)

void draw (wxDC &dc, mpWindow &w, double x1, double y1, double x2, double y2)

void drawSplineCurve (wxDC &dc, mpWindow &w)

void drawLineToMousePoint (wxDC &dc, mpWindow &w)

void drawFunction (wxDC &dc, mpWindow &w)

void drawPoints (wxDC &dc, mpWindow &w)

virtual void Plot (wxDC &dc, mpWindow &w)

virtual bool HasBBox ()

virtual double GetMinX ()

virtual double GetMaxX ()

virtual double GetMinY ()

virtual double GetMaxY ()

wxString GetName () const

const wxFont & GetFont () const

const wxPen & GetPen () const

void SetName (wxString name)

void SetFont (wxFont &font)

void SetPen (wxPen &pen)

Protected Attributes

int m_flags

Holds label alignment.

wxList points

double scaleX

double scaleY

int offsetX

int offsetY

wxFont m_font

Layer's font.

wxPen m_pen

Layer's pen.

wxString m_name

Layer's name.

Private Attributes

pLogicalFunction * logicFunction

bool showPointsF

double _startX

double _startY

double _endX

double _endY

double _scaleX

double _scaleY

double _minX

double _minY

double _maxX

double _maxY

double _offsetX

double _offsetY

int _type

wxList realPoints

std::vector< pColorPoint * > f_colorPoints

wxNode * node

int validPointRange

bool drawing

wxPoint mousePoint

int screenX

int screenY

bool ifActual

int scaleWay

bool fromWindow

float factorZoom

bool editable

bool zoomIn

pFunctionPoint * initialDrawingPoint

pFunctionPoint * finalDrawingPoint

int minShowedX

int maxShowedX

int minShowedY

int maxShowedY

std::vector< double > xSpline

std::vector< double > ySpline

vtkKochanekSpline * xKSpline

vtkKochanekSpline * yKSpline

int offsetPixelX

int offsetPixelY

int mType

int xTraslation

Detailed Description

Definition at line 68 of file pGraphicalFunction.h.

Constructor & Destructor Documentation

pGraphicalFunction::pGraphicalFunction	(	wxString	name = `wxEmptyString`,
		int	flags = `0x00`
	)

Definition at line 27 of file pGraphicalFunction.cxx.

References DEFAULT.

00028 {
00029         SetName(name);
00030         showPointsF = false;
00031         validPointRange = 5;
00032         logicFunction = new pLogicalFunction ();
00033         fromWindow=false;
00034         factorZoom=1;
00035         drawing=false;
00036         editable=true;
00037         ifActual=false;
00038         zoomIn=false;
00039         setOffsetX(0);
00040         setOffsetY(0);
00041         initialDrawingPoint=NULL;
00042         finalDrawingPoint=NULL;
00043         //type=1 means that is going to be a piecewise function
00044         _type=1;
00045         xKSpline=NULL;
00046         yKSpline=NULL;
00047         offsetPixelX=0;
00048         offsetPixelY=0;
00049         xTraslation=0;
00050         mType=DEFAULT;
00051 }

pGraphicalFunction::~pGraphicalFunction ( )

Is the destructor!!!

Definition at line 56 of file pGraphicalFunction.cxx.

00057 {
00058         
00059 }

Member Function Documentation

bool pGraphicalFunction::AddNewPoint	(	int	x,
		int	y
	)

Definition at line 140 of file pGraphicalFunction.cxx.

References fromWindow, logicFunction, pLogicalFunction::setEndPoints(), pLogicalFunction::setStartPoints(), and setUp().

Referenced by pPlotterWindow::onAddNewPoint(), and pPlotterWindow::onAddPoint().

00141 {
00142         bool added= logicFunction -> AddNewPoint ( x, y );
00143         if(!fromWindow)
00144          setUp();
00145         else
00146         {
00147                 logicFunction->setEndPoints();
00148                 logicFunction->setStartPoints();
00149         }
00150         return added;
00151 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool pGraphicalFunction::AddPoint	(	int	aX,
		int	aY,
		bool	order = `true`
	)

this method add a new logical point to the function, this point is one of those used to draw the function

Definition at line 160 of file pGraphicalFunction.cxx.

References fromWindow, logicFunction, pLogicalFunction::setEndPoints(), pLogicalFunction::setStartPoints(), and setUp().

Referenced by HistogramWidget::addPointToTransferenceFunction(), and pPlotterWindow::onAddPoint().

00161 {       
00162         bool added=false;
00163         if (logicFunction!=NULL){
00164                 added=logicFunction -> AddPoint( aX, aY,order );
00165                 if(!fromWindow)
00166                         setUp();
00167                 else
00168                 {
00169                         logicFunction->setEndPoints();
00170                         logicFunction->setStartPoints();
00171                 } // if fromWindow
00172         } // if logicFunction
00173         return added;
00174 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::addSplinesPoints ( )

Definition at line 371 of file pGraphicalFunction.cxx.

References pLogicalFunction::GetPointAt(), pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), logicFunction, node, xKSpline, and yKSpline.

Referenced by initializeSplines(), pPlotterWindow::onAddNewPoint(), pPlotterWindow::onAddPoint(), pPlotterWindow::onChangeActual(), pPlotterWindow::onDeletePoint(), pPlotterWindow::onMouseMove(), and pPlotter::update().

00372         {
00373                 xKSpline->RemoveAllPoints();
00374                 yKSpline->RemoveAllPoints();
00375                 wxNode *node= logicFunction->GetPointAt(0);
00376                 pFunctionPoint* p;
00377                 int i=0;
00378                 while(node)
00379                 {
00380                         p=(pFunctionPoint*)node->GetData();
00381                         xKSpline->AddPoint(i,p->getRealX());
00382                         yKSpline->AddPoint(i,p->getRealY());
00383                         i++;
00384                         node=node->GetNext();
00385                 }
00386         }

Here is the call graph for this function:

Here is the caller graph for this function:

bool pGraphicalFunction::changePoint	(	wxPoint	newCoords,
		int	movingIndexPoint
	)

Change de coordinates of the given point if it is possible and return the result of the invoked action. True if it was possible to do the change.

Change de coordinates of the given index point to the newCoords, if it is possible and return the result of the invoked action. Return TRUE if it was possible to do the change. A valid change is when the new x value of the point is still between the previous and next point, when condition.

Definition at line 214 of file pGraphicalFunction.cxx.

References fromWindow, logicFunction, pLogicalFunction::setEndPoints(), pLogicalFunction::setStartPoints(), and setUp().

Referenced by pPlotterWindow::onMouseMove().

00215 {
00216         bool added= (logicFunction -> changePoint( newCoords, movingIndexPoint ));
00217         if(!fromWindow)
00218          setUp();
00219         else
00220         {
00221                 logicFunction->setEndPoints();
00222                 logicFunction->setStartPoints();
00223         }
00224         return added;
00225 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::clearSplineVectors ( )

Definition at line 348 of file pGraphicalFunction.cxx.

References xSpline, and ySpline.

Referenced by pPlotterWindow::onAddNewPoint(), pPlotterWindow::onAddPoint(), pPlotterWindow::onChangeActual(), pPlotterWindow::onDeletePoint(), pPlotterWindow::onLine(), pPlotterWindow::onMouseMove(), and pPlotter::update().

00349         {
00350                 xSpline.clear();
00351                 ySpline.clear();
00352         }

Here is the caller graph for this function:

bool pGraphicalFunction::DeletePoint	(	int	aX,
		int	aY
	)

deletes the point given by the user from the collection of logical points of the function

deletes the point given by the user from the collection of logical points of the function is not used

Definition at line 181 of file pGraphicalFunction.cxx.

References fromWindow, logicFunction, pLogicalFunction::setEndPoints(), pLogicalFunction::setStartPoints(), and setUp().

Referenced by pPlotterWindow::DeletePointFunction().

00182 {
00183         bool added= logicFunction -> DeletePoint( aX, aY );     
00184         if(!fromWindow)
00185          setUp();
00186         else
00187         {
00188                 logicFunction->setEndPoints();
00189                 logicFunction->setStartPoints();
00190         }
00191         return added;
00192 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool pGraphicalFunction::deletePointAt ( int index )

This method get a pointer to the node in the real points list that is inmediately previous to the searched by parameter.

Precondition:: The seached point (realX, realY) is not the first point of the list.

Parameters:

	realX
	realY	Deletes a point of the function given its index

deletes a point of the functio given its index

Definition at line 197 of file pGraphicalFunction.cxx.

References fromWindow, logicFunction, pLogicalFunction::setEndPoints(), pLogicalFunction::setStartPoints(), and setUp().

Referenced by HistogramWidget::erasePointsTransferenceFunction(), and pPlotterWindow::onDeletePoint().

00198 {
00199         bool added=logicFunction -> deletePointAt( index );
00200         if(!fromWindow)
00201          setUp();
00202         else
00203         {
00204                 logicFunction->setEndPoints();
00205                 logicFunction->setStartPoints();
00206         }
00207         return added;
00208 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pPlotterLayer::draw	(	wxDC &	dc,
		mpWindow &	w,
		double	x1,
		double	y1,
		double	x2,
		double	y2
	)			`[inherited]`

Definition at line 44 of file pPlotterLayer.cxx.

Referenced by pPlotterLayer::drawFunction(), and pPlotterLayer::drawSplineCurve().

00045 {
00046         
00047         //intercepts
00048         float m=((float)(y2-y1))/(x2-x1);
00049         float x0=-y1/m+x1;
00050         float y0=-m*x1+y1;      
00051 
00052 
00053         //analyzing the curve
00054 
00055                 if(x1<=0 && x2>=0)
00056                 {
00057                         if(y2>=0 && y1>=0)
00058                                         dc.DrawLine(0,y0, x2,y2);
00059 
00060                         else if(y2<=0 && y1>=0)
00061                         {
00062                                 if(y0>=0 && x0>=0)
00063                                         dc.DrawLine(0,y0,x0,0 );
00064                         }
00065                         else if(y2>=0 && y1<=0)
00066                         {
00067                                 if(y0>=0) 
00068                                 dc.DrawLine(0,y0,x2,y2 );
00069                         }
00070         
00071                 }
00072 
00073                 if(x1>=0 && x2>=0)
00074                 {
00075                         if(y1>=0 && y2>=0 )
00076                                 dc.DrawLine(x1,y1, x2,y2);
00077                         else if(y1>=0 && y2<=0)
00078                                 dc.DrawLine(x1,y1,x0,0 );
00079                         else if(y1<=0 && y2>=0) 
00080                                         dc.DrawLine(x0,0,x2,y2);
00081                 }
00082                 
00083                 
00084 }

Here is the caller graph for this function:

void pPlotterLayer::drawFunction	(	wxDC &	dc,
		mpWindow &	w
	)			`[inherited]`

Draw le lines between the points of the function

Draw the lines between the points of the function

Definition at line 285 of file pPlotterLayer.cxx.

References pPlotterLayer::draw(), pPlotterLayer::getMaxShowed(), pPlotterLayer::getMinShowed(), pPlotterLayer::getmType(), pPlotterLayer::getOffsetPixelsXv(), pPlotterLayer::getOffsetPixelsYv(), pPlotterLayer::GetPoints(), pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), pPlotterLayer::initializePolygon(), pPlotterLayer::offsetX, pPlotterLayer::offsetY, pPlotterLayer::points, pPlotterLayer::Rewind(), pPlotterLayer::scaleX, and pPlotterLayer::scaleY.

Referenced by pPlotterLayer::Plot().

00286 {
00287 
00288         
00289         int scrwX,scrwY,offsetpx,offsetpy,maxX,minX,maxY,minY;
00290         wxPoint* ppoints=NULL;
00291 
00292         /*
00293         This is the offset of every point scale to the window
00294         pixel
00295         */
00296         offsetpx=getOffsetPixelsXv();
00297         offsetpy=getOffsetPixelsYv();   
00298 
00299         Rewind();
00300         
00301         dc.GetSize(&scrwX, &scrwY);
00302         
00303         //Lines between the points
00304         
00305         GetPoints(points);
00306 
00307         // type of plotter
00308         int type=getmType();
00309         /***********/
00310         getMaxShowed(maxX,maxY);
00311         getMinShowed(minX,minY);
00312         /***********/
00313 
00314         //traslation
00315         //int xTraslation=getXTraslation(); //JPRx
00316         wxNode* node= points.GetFirst();
00317         // int i=1;//points.GetCount()+1; //JPRx
00318         int j=2;
00319         /*
00320          Fill it if it is an histogram
00321         */
00322         wxPoint point;
00323         // pFunctionPoint* pointk; //JPRx
00324         if(type==2)
00325         {
00326                 /*
00327                 Fill the function if it represented an histogram
00328           */
00329                 ppoints=(wxPoint*)malloc(sizeof(int)*2*(points.GetCount()+2));
00330                 //initialize points
00331                 point.x=-5000;
00332                 point.y=-5000;
00333                 ppoints[0]=point;
00334                 ppoints[1]=point;
00335 
00336         }
00337         
00338         
00339         while (node!=NULL && node->GetNext()!=NULL)
00340         { 
00341                 pFunctionPoint* pointi=(pFunctionPoint*)node->GetData();
00342                                 wxNode* nextNode=node->GetNext();
00343                 pFunctionPoint* pointj=(pFunctionPoint*)nextNode->GetData();
00344                                                 
00345                 // we do the offset
00346                 int pxi=(pointi->getRealX()-minX)-offsetX;
00347                 int pyi=(pointi->getRealY()-minY)-offsetY;
00348                 int pxj=(pointj->getRealX()-minX)-offsetX;
00349                 int pyj=(pointj->getRealY()-minY)-offsetY;
00350 
00351 
00352                 int cxi=pxi* scaleX + offsetpx; //+ xTraslation;
00353                 int cxj=pxj* scaleX + offsetpx; //+ xTraslation;
00354                 int cyi=pyi* scaleY+ offsetpy ;
00355                 int cyj=pyj* scaleY+ offsetpy ;
00356                 //dc.DrawLine(pxi* scaleX + offsetpx,pyi* scaleY+ offsetpy, pxj* scaleX + offsetpx,pyj* scaleY+ offsetpy );
00357                 if(type!=2)
00358                         draw(dc,w,pxi* scaleX + offsetpx,pyi* scaleY+ offsetpy, pxj* scaleX + offsetpx,pyj* scaleY+ offsetpy );
00359                         //dc.DrawLine(pxi* scaleX + offsetpx,pyi* scaleY+ offsetpy, pxj* scaleX + offsetpx,pyj* scaleY+ offsetpy );
00360                 else if(type==2)
00361                 {
00362                         if(!initializePolygon(ppoints,cxi,cyi,cxj,cyj) && ((cxi<=0 && cxj>=0)||(cxi>=0 && cxj>=0)))
00363                         {
00364                                         point.x=cxj;
00365                                         point.y=cyj;
00366                                         ppoints[j]=point;
00367                                         j++;
00368                 
00369                         }
00370                 }
00371                 
00372                 node=node->GetNext();
00373 
00374         } 
00375         if(type==2)
00376         {
00377                 //point.x=vx.at(size-1)* scaleX + offsetpx;
00378                 point.x=ppoints[j-1].x;
00379                 point.y=0;
00380                 //ppoints[vx.size()]=point;
00381                 ppoints[j]=point;
00382                 /*
00383                 Fill the function if it represented an histogram
00384           */
00385                 //ppoints=(wxPoint*)malloc(sizeof(int)*2*(vx.size()+1));
00386                 //settings for fill
00387                 //point.x=vx.at(0)*scaleX + offsetpx;
00388                 point.x=ppoints[0].x;
00389                 point.y=0;
00390                 //ppoints[vx.size()+1]=point;
00391                 ppoints[j+1]=point;
00392 
00393                 dc.SetBrush(wxBrush( wxColour(239,238,242) ,wxSOLID  ));
00394                 dc.SetPen(wxPen( wxColour(0,0,0) ,1,wxSOLID  ));
00395                 //dc.DrawPolygon(vx.size()+2,ppoints,0,0);
00396                 dc.DrawPolygon(j+2,ppoints,0,0);
00397 
00398         }
00399         
00400 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pPlotterLayer::drawLineToMousePoint	(	wxDC &	dc,
		mpWindow &	w
	)			`[inherited]`

Draw the line between the last point of the function and the position of the mouse

Definition at line 453 of file pPlotterLayer.cxx.

References mpWindow::drawGuideLines(), pPlotterLayer::getDirection(), pPlotterLayer::getMaxShowed(), pPlotterLayer::getMinShowed(), pPlotterLayer::getMousePoint(), pPlotterLayer::getOffsetPixelsXv(), pPlotterLayer::getOffsetPixelsYv(), pPlotterLayer::GetPoints(), pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), pPlotterLayer::getSize(), pPlotterLayer::offsetX, pPlotterLayer::offsetY, pPlotterLayer::points, pPlotterLayer::Rewind(), pPlotterLayer::scaleX, and pPlotterLayer::scaleY.

Referenced by pPlotterLayer::Plot().

00454 {
00455         int x,y,sizeP,maxX,maxY,minX,minY;
00456         bool direction;
00457         
00458         Rewind();
00459         
00460         getMousePoint(x,y);
00461         getDirection(direction);
00462         getSize(sizeP);
00463         //Lines betwen the points
00464         GetPoints(points);
00465 
00466         wxNode *node=points.GetLast();
00467         wxNode *node1=points.GetFirst();
00468         
00469         
00470         /*
00471         This is the offset of every point scale to the window
00472         pixel
00473         */
00474         int offsetpx = getOffsetPixelsXv();
00475         int offsetpy = getOffsetPixelsYv();
00476         /***********/
00477         getMaxShowed(maxX,maxY);
00478         getMinShowed(minX,minY);
00479         /***********/
00480         //traslation
00481 //      int xTraslation=getXTraslation(); //EED
00482         
00483         if(node)
00484         {
00485                 pFunctionPoint* lastPoint=(pFunctionPoint*)node->GetData();
00486                 pFunctionPoint* firstPoint=(pFunctionPoint*)node1->GetData();
00487 
00488                 //LeftDrawing
00489                 if(lastPoint->getRealX()<x && direction && sizeP >=2)
00490                         
00491                         dc.DrawLine((lastPoint->getRealX()-minX-offsetX)*scaleX + offsetpx,(lastPoint->getRealY()-minY-offsetY)*scaleY+ offsetpy, (x-minX)*scaleX + offsetpx, (y-minY)*scaleY + offsetpy);
00492                 
00493                 //right drawing
00494                 else if(firstPoint->getRealX()>x && !direction && sizeP >=2 )
00495                         
00496                         dc.DrawLine((firstPoint->getRealX()-minX-offsetX)*scaleX+ offsetpx,(firstPoint->getRealY()-minY-offsetY)*scaleY+ offsetpy,(x-minX)*scaleX+ offsetpx, (y-minY)*scaleY+ offsetpy);
00497                 
00498                 //just a point
00499                 else if(sizeP==1 )
00500                 {
00501                         dc.DrawLine((lastPoint->getRealX()-minX-offsetX)*scaleX + offsetpx,(lastPoint->getRealY()-minY-offsetY)*scaleY+ offsetpy, (x-minX)*scaleX+ offsetpx, (y-minY)*scaleY+ offsetpy);
00502                 }
00503         }                       
00504         
00505         if( w.drawGuideLines() )  
00506         {
00507                 dc.SetPen(wxPen(  wxColour(255,0,0),1,wxDOT ));
00508                 // Drawing the horizontal guide line    
00509                 dc.DrawLine( 0, (y-minY)*scaleY + offsetpy, (x-minX)*scaleX + offsetpx, (y-minY)*scaleY + offsetpy);                                    
00510                 // Drawing the vertical guide line      
00511                 dc.DrawLine( (x-minX)*scaleX + offsetpx,0, (x-minX)*scaleX + offsetpx, (y-minY)*scaleY + offsetpy);     
00512         }
00513 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pPlotterLayer::drawPoints	(	wxDC &	dc,
		mpWindow &	w
	)			`[inherited]`

Draw the points of the function

Definition at line 405 of file pPlotterLayer.cxx.

References pPlotterLayer::getMaxShowed(), pPlotterLayer::getMinShowed(), pPlotterLayer::GetNextXY(), pPlotterLayer::getOffsetPixelsXv(), pPlotterLayer::getOffsetPixelsYv(), MOVE, pPlotterLayer::offsetX, pPlotterLayer::offsetY, pPlotterLayer::points, pPlotterLayer::Rewind(), pPlotterLayer::scaleX, and pPlotterLayer::scaleY.

Referenced by pPlotterLayer::Plot().

00406 {
00407         
00408         Rewind();
00409         double x, y;
00410         int minX,maxX,minY,maxY;
00411 
00412         
00413         /*
00414         This is the offset of every point scale to the window
00415         pixel
00416         */
00417         int offsetpx=getOffsetPixelsXv();
00418         int offsetpy=getOffsetPixelsYv();
00419         //traslation
00420 //      int xTraslation=getXTraslation();  //EED
00421         /*wxPen mypen(*wxBLACK, 5, wxSOLID);
00422         dc.SetPen(mypen);*/
00423         /***********/
00424         getMaxShowed(maxX,maxY);
00425         getMinShowed(minX,minY);
00426         /***********/
00427         //we have to draw the points
00428 
00429         while (GetNextXY(x, y))
00430         {
00431                 //GetNextXY(x, y);
00432                 //set the points of the polygons
00433                 wxPoint points[4];
00434                 dc.SetBrush(wxBrush( wxColour(255,0,0),wxSOLID  ));
00435                 //dc.SetPen(wxPen(wxColour(0,0,0),1,wxSOLID) );
00436                 points[0].x=((x-minX-offsetX)*scaleX + offsetpx-MOVE);
00437                 points[0].y=((y-minY-offsetY)*scaleY+ offsetpy-MOVE);
00438                 points[1].x=((x-minX-offsetX)*scaleX+ offsetpx+MOVE);
00439                 points[1].y=((y-minY-offsetY)*scaleY+ offsetpy-MOVE);
00440                 points[2].x=((x-minX-offsetX)*scaleX+ offsetpx+MOVE);
00441                 points[2].y=((y-minY-offsetY)*scaleY+ offsetpy+MOVE);
00442                 points[3].x=((x-minX-offsetX)*scaleX+ offsetpx-MOVE);
00443                 points[3].y=((y-minY-offsetY)*scaleY+ offsetpy+MOVE);
00444                 if((x-minX-offsetX)*scaleX >=0 && (y-minY-offsetY/*w.getMinScrY()*/)*scaleY>=0)
00445                 dc.DrawPolygon(4,points,0,0);
00446         }
00447 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pPlotterLayer::drawSplineCurve	(	wxDC &	dc,
		mpWindow &	w
	)			`[inherited]`

Draw the function with th spline points

Definition at line 90 of file pPlotterLayer.cxx.

References pPlotterLayer::draw(), pPlotterLayer::getMaxShowed(), pPlotterLayer::getMinShowed(), pPlotterLayer::getmType(), pPlotterLayer::getOffsetPixelsXv(), pPlotterLayer::getOffsetPixelsYv(), pPlotterLayer::getXSpline(), pPlotterLayer::getYSpline(), pPlotterLayer::initializePolygon(), pPlotterLayer::offsetX, pPlotterLayer::offsetY, pPlotterLayer::scaleX, and pPlotterLayer::scaleY.

Referenced by pPlotterLayer::Plot().

00091 {
00092         std::vector<double> vx=getXSpline();
00093         std::vector<double> vy=getYSpline();
00094         wxPoint* ppoints;
00095         
00096         int /*counter=0,*/ minX,maxX,minY,maxY; // JPRx
00097         /*
00098         This is the offset of every point scale to the window
00099         pixel
00100         */
00101         int offsetpx=getOffsetPixelsXv();
00102         int offsetpy=getOffsetPixelsYv();
00103         
00104         // type of plotter
00105         int type=getmType();
00106  
00107         wxPoint point;
00108         /***********/
00109         getMaxShowed(maxX,maxY);
00110         getMinShowed(minX,minY);
00111         /***********/
00112 
00113         
00114         if(type==2)
00115         {
00116          /*
00117                 Fill the function if it represented an histogram
00118           */
00119                 ppoints=(wxPoint*)malloc(sizeof(int)*2*(vx.size()+2));
00120                 //initialize points
00121                 point.x=-5000;
00122                 point.y=-5000;
00123                 ppoints[0]=point;
00124                 ppoints[1]=point;
00125         }
00126         
00127         int size=vx.size();
00128         int j=2;
00129 
00130         for(int i=0;(i+1)< size;i++)
00131         {
00132                 
00133                 
00134                 double cxi=(vx.at(i)-minX-offsetX)*scaleX+offsetpx;
00135                 double cyi=(vy.at(i)-minY-offsetY)*scaleY+offsetpy;
00136                 
00137                 double cxj=(vx.at(i+1)-minX-offsetX)*scaleX+offsetpx;
00138                 double cyj=(vy.at(i+1)-minY-offsetY)*scaleY+offsetpy;
00139                 
00140                 
00141                 if(type!=2)     
00142                         draw(dc,w,cxi,cyi,cxj,cyj);
00143                 else if(type==2)
00144                 {
00145                         if(!initializePolygon(ppoints,cxi,cyi,cxj,cyj) && ((cxi<=0 && cxj>=0)||(cxi>=0 && cxj>=0)))
00146                         {
00147                                         point.x=cxj;
00148                                         point.y=cyj;
00149                                         ppoints[j]=point;
00150                                         j++;
00151                 
00152                         }
00153                 }
00154                 
00155         }
00156         if(type==2)
00157         {
00158                 //point.x=vx.at(size-1)* scaleX + offsetpx;
00159                 point.x=ppoints[j-1].x;
00160                 point.y=0;
00161                 //ppoints[vx.size()]=point;
00162                 ppoints[j]=point;
00163                 /*
00164                 Fill the function if it represented an histogram
00165           */
00166                 //ppoints=(wxPoint*)malloc(sizeof(int)*2*(vx.size()+1));
00167                 //settings for fill
00168                 //point.x=vx.at(0)*scaleX + offsetpx;
00169                 point.x=ppoints[0].x;
00170                 point.y=0;
00171                 //ppoints[vx.size()+1]=point;
00172                 ppoints[j+1]=point;
00173 
00174                 dc.SetBrush(wxBrush( wxColour(239,238,242) ,wxSOLID  ));
00175                 dc.SetPen(wxPen( wxColour(0,0,0) ,1,wxSOLID  ));
00176                 //dc.DrawPolygon(vx.size()+2,ppoints,0,0);
00177                 dc.DrawPolygon(j+2,ppoints,0,0);
00178         }
00179         
00180         
00181 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool pGraphicalFunction::getActual ( )

Definition at line 603 of file pGraphicalFunction.cxx.

References ifActual.

Referenced by pPlotterWindow::moveFunctions(), pPlotterWindow::onChangeActual(), pPlotterWindow::onMyZoomIn(), and pPlotterWindow::onMyZoomOut().

00604 {
00605         return ifActual;
00606 }

Here is the caller graph for this function:

wxNode * pGraphicalFunction::getBefore ( pFunctionPoint * point )

Definition at line 283 of file pGraphicalFunction.cxx.

References pLogicalFunction::GetPointAt(), pFunctionPoint::getRealX(), logicFunction, and node.

Referenced by isInFunction().

00284 {
00285         int minDiference=10000000;
00286         wxNode* node=logicFunction->GetPointAt(0);
00287         wxNode* before=NULL;
00288         while(node)
00289         {
00290                 pFunctionPoint* before1=(pFunctionPoint*)node->GetData();
00291                 int beforeX=before1->getRealX();
00292                 int pointX=point->getRealX();
00293                 if(beforeX<pointX)
00294                 {
00295                   int minDiference1=pointX-beforeX;
00296                   if(minDiference1<minDiference)
00297                   {
00298                           minDiference=minDiference1;
00299                           before=node;
00300                   }
00301                 }
00302                 node=node->GetNext();
00303         }
00304         return before;
00305 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::getColorPoints ( std::vector< pColorPoint * > & colorVector )

Definition at line 838 of file pGraphicalFunction.cxx.

References f_colorPoints, pColorPoint::getColor(), pColorPoint::getRealX(), and pColorPoint::isTemporalColor().

00839 {
00840         int i = 0;      
00841         while(i<(int)(f_colorPoints.size()))
00842         {
00843                 pColorPoint * originaslPoint = f_colorPoints[i];
00844                 pColorPoint * copyPoint = new pColorPoint(originaslPoint->getRealX(), originaslPoint->getColor(), originaslPoint->isTemporalColor());
00845                 colorVector.push_back(copyPoint);               
00846                 i++;
00847         }
00848 }

Here is the call graph for this function:

virtual void pGraphicalFunction::getDirection ( bool & dir ) [inline, virtual]

this method gets the direction of the drawing

Reimplemented from pPlotterLayer.

Definition at line 280 of file pGraphicalFunction.h.

References logicFunction.

00281         {               
00282                 logicFunction -> getDirection (dir);
00283         }

bool pGraphicalFunction::GetDrawing ( ) [inline]

Definition at line 549 of file pGraphicalFunction.h.

References drawing.

00550         {
00551                 return drawing;
00552         }

virtual void pGraphicalFunction::getDrawing ( bool & draw ) [inline, virtual]

Let us Know if the user has finished the drawing that starts before.

Reimplemented from pPlotterLayer.

Definition at line 207 of file pGraphicalFunction.h.

References drawing.

00208         {
00209                 draw = drawing;
00210         }

bool pGraphicalFunction::getEditable ( ) [inline]

Get editable

Definition at line 614 of file pGraphicalFunction.h.

References editable.

Referenced by pPlotterWindow::onChangeActual(), and pPlotterWindow::onMouseMove().

00615         {
00616                 return editable;
00617         }

Here is the caller graph for this function:

double pGraphicalFunction::getEndX ( )

Definition at line 677 of file pGraphicalFunction.cxx.

References pLogicalFunction::getEndX(), and logicFunction.

00677                                    {
00678         return logicFunction->getEndX();
00679 }

Here is the call graph for this function:

double pGraphicalFunction::getEndY ( )

Definition at line 686 of file pGraphicalFunction.cxx.

References pLogicalFunction::getEndY(), and logicFunction.

00686                                    {
00687         return logicFunction->getEndY();
00688 }

Here is the call graph for this function:

virtual void pGraphicalFunction::getFactorZoom ( float & fz ) [inline, virtual]

Reimplemented from pPlotterLayer.

Definition at line 126 of file pGraphicalFunction.h.

References factorZoom.

00127         {
00128                 fz=factorZoom;
00129         }

pFunctionPoint* pGraphicalFunction::getFinallDrawPoint ( ) [inline]

Get the final drawing point

Returns:: finalDrawingPoint

Definition at line 666 of file pGraphicalFunction.h.

References finalDrawingPoint.

00667         {
00668                 return finalDrawingPoint;       
00669         }

const wxFont& mpLayer::GetFont ( ) const [inline, inherited]

Get font set for this layer.

Returns:: Font

Definition at line 175 of file mathplot.h.

00175 { return m_font; }

bool pGraphicalFunction::getFromWindow ( ) [inline]

Definition at line 593 of file pGraphicalFunction.h.

References fromWindow.

Referenced by pPlotterWindow::onChangeActual(), and pPlotterWindow::onStartDrawing().

00594         {
00595                 return fromWindow;
00596         }

Here is the caller graph for this function:

virtual void pGraphicalFunction::getFromWindowV ( bool & fw ) [inline, virtual]

Definition at line 135 of file pGraphicalFunction.h.

References fromWindow.

00136         {
00137                 fw=fromWindow;
00138         }

virtual void pGraphicalFunction::getIfActual ( bool & actual ) [inline, virtual]

if the function that is drawing is the actual

Reimplemented from pPlotterLayer.

Definition at line 144 of file pGraphicalFunction.h.

References ifActual.

00145         {
00146                 actual=ifActual;
00147         }

int pGraphicalFunction::getIndexOf ( wxPoint realpoint )

Definition at line 99 of file pGraphicalFunction.cxx.

References logicFunction.

00100 {
00101         return logicFunction -> getIndexOf( realpoint );        
00102 }

pFunctionPoint* pGraphicalFunction::getInitialDrawPoint ( ) [inline]

Get the initial drawing point

Returns:: initialDrawingPoint

Definition at line 650 of file pGraphicalFunction.h.

References initialDrawingPoint.

00651         {
00652                 return initialDrawingPoint;     
00653         }

virtual void pGraphicalFunction::getMax	(	int &	maxX,
		int &	maxY
	)			`[inline, virtual]`

get the max of the function in x and y

Reimplemented from pPlotterLayer.

Definition at line 152 of file pGraphicalFunction.h.

References getMaxX(), and getMaxY().

00153         {
00154                 maxX=(int)getMaxX();
00155             maxY=(int)getMaxY();
00156         }

Here is the call graph for this function:

virtual void pGraphicalFunction::getMaxShowed	(	int &	maxX,
		int &	maxY
	)			`[inline, virtual]`

get the maxShowed of the function in x and y

Reimplemented from pPlotterLayer.

Definition at line 160 of file pGraphicalFunction.h.

References getMaxXShowed(), and getMaxYShowed().

00161         {
00162                 maxX=(int)getMaxXShowed();
00163                 maxY=(int)getMaxYShowed();
00164         }

Here is the call graph for this function:

virtual double mpLayer::GetMaxX ( ) [inline, virtual, inherited]

Get inclusive right border of bounding box.

Returns:: Value

Definition at line 120 of file mathplot.h.

Referenced by mpWindow::UpdateBBox().

00120 { return  1.0; }

Here is the caller graph for this function:

double pGraphicalFunction::getMaxX ( )

Definition at line 744 of file pGraphicalFunction.cxx.

References pLogicalFunction::getMaxX(), and logicFunction.

Referenced by HistogramWidget::getActualShowedPorcentage(), getMax(), HistogramWidget::getMaxShowedPorcentage(), HistogramWidget::getMinShowedPorcentage(), pPlotterWindow::InitFunctionForVectors(), pPlotterWindow::moveFunctions(), pPlotter::onChangeFunction(), and pPlotter::setAll().

00745 {
00746         return logicFunction->getMaxX();
00747 }

Here is the call graph for this function:

Here is the caller graph for this function:

int pGraphicalFunction::getMaxXShowed ( ) [inline]

Get the maxX Showed

Definition at line 710 of file pGraphicalFunction.h.

References maxShowedX.

Referenced by getMaxShowed(), pPlotterWindow::moveFunctions(), pPlotterWindow::onChangeActual(), pPlotter::onChangeFunction(), pPlotterWindow::setActualScales(), and pPlotter::setAll().

00711         {
00712                 return maxShowedX;
00713         }

Here is the caller graph for this function:

virtual double mpLayer::GetMaxY ( ) [inline, virtual, inherited]

Get inclusive top border of bounding box.

Returns:: Value

Definition at line 130 of file mathplot.h.

Referenced by mpWindow::UpdateBBox().

00130 { return  1.0; }

Here is the caller graph for this function:

double pGraphicalFunction::getMaxY ( )

Definition at line 755 of file pGraphicalFunction.cxx.

References pLogicalFunction::getMaxY(), and logicFunction.

Referenced by getMax(), pPlotterWindow::InitFunctionForVectors(), and pPlotterWindow::moveFunctions().

00755                                    {
00756         return logicFunction->getMaxY();
00757 }

Here is the call graph for this function:

Here is the caller graph for this function:

int pGraphicalFunction::getMaxYShowed ( ) [inline]

Get the maxY Showed

Definition at line 717 of file pGraphicalFunction.h.

References maxShowedY.

Referenced by getMaxShowed(), pPlotterWindow::moveFunctions(), pPlotterWindow::onChangeActual(), and pPlotterWindow::setActualScales().

00718         {
00719                 return maxShowedY;
00720         }

Here is the caller graph for this function:

virtual void pGraphicalFunction::getMinShowed	(	int &	minX,
		int &	minY
	)			`[inline, virtual]`

get the minShowed of the function in x and y

Reimplemented from pPlotterLayer.

Definition at line 168 of file pGraphicalFunction.h.

References getMinXShowed(), and getMinYShowed().

00169         {
00170                 minX=(int)getMinXShowed();
00171                 minY=(int)getMinYShowed();
00172         }

Here is the call graph for this function:

virtual double mpLayer::GetMinX ( ) [inline, virtual, inherited]

Get inclusive left border of bounding box.

Returns:: Value

Definition at line 115 of file mathplot.h.

Referenced by mpWindow::UpdateBBox().

00115 { return -1.0; }

Here is the caller graph for this function:

double pGraphicalFunction::getMinX ( )

Definition at line 721 of file pGraphicalFunction.cxx.

References pLogicalFunction::getMinX(), and logicFunction.

Referenced by HistogramWidget::getActualShowedPorcentage(), HistogramWidget::getMaxShowedPorcentage(), HistogramWidget::getMinShowedPorcentage(), pPlotterWindow::InitFunctionForVectors(), pPlotterWindow::moveFunctions(), pPlotter::onChangeFunction(), and pPlotter::setAll().

00722 {
00723         return logicFunction->getMinX();
00724 }

Here is the call graph for this function:

Here is the caller graph for this function:

int pGraphicalFunction::getMinXShowed ( ) [inline]

Get the minX Showed

Definition at line 696 of file pGraphicalFunction.h.

References minShowedX.

Referenced by getMinShowed(), pPlotterWindow::moveFunctions(), pPlotterWindow::onChangeActual(), pPlotter::onChangeFunction(), pPlotterWindow::setActualScales(), and pPlotter::setAll().

00697         {
00698                 return minShowedX;
00699         }

Here is the caller graph for this function:

virtual double mpLayer::GetMinY ( ) [inline, virtual, inherited]

Get inclusive bottom border of bounding box.

Returns:: Value

Definition at line 125 of file mathplot.h.

Referenced by mpWindow::UpdateBBox().

00125 { return -1.0; }

Here is the caller graph for this function:

double pGraphicalFunction::getMinY ( )

Definition at line 732 of file pGraphicalFunction.cxx.

References pLogicalFunction::getMinY(), and logicFunction.

Referenced by pPlotterWindow::InitFunctionForVectors(), and pPlotterWindow::moveFunctions().

00732                                    {
00733         return logicFunction->getMinY();
00734 }

Here is the call graph for this function:

Here is the caller graph for this function:

int pGraphicalFunction::getMinYShowed ( ) [inline]

Get the minY Showed

Definition at line 703 of file pGraphicalFunction.h.

References minShowedY.

Referenced by getMinShowed(), pPlotterWindow::moveFunctions(), pPlotterWindow::onChangeActual(), and pPlotterWindow::setActualScales().

00704         {
00705                 return minShowedY;
00706         }

Here is the caller graph for this function:

wxPoint pGraphicalFunction::getMousePoint ( ) [inline]

Definition at line 560 of file pGraphicalFunction.h.

References mousePoint.

00561         {
00562                 return mousePoint;
00563         }

virtual void pGraphicalFunction::getMousePoint	(	int &	x,
		int &	y
	)			`[inline, virtual]`

Get the point where the user made a click

Reimplemented from pPlotterLayer.

Definition at line 263 of file pGraphicalFunction.h.

References mousePoint.

00264         {
00265                 x=mousePoint.x;
00266                 y=mousePoint.y;
00267         }

virtual int pGraphicalFunction::getmType ( ) [inline, virtual]

Get the type of the curve 1=normal function 2=Histogram

Reimplemented from pPlotterLayer.

Definition at line 98 of file pGraphicalFunction.h.

References mType.

00099         {
00100                 return mType;
00101         }

wxString mpLayer::GetName ( ) const [inline, inherited]

Get layer name.

Returns:: Name

Definition at line 170 of file mathplot.h.

00170 { return m_name; }

virtual bool pGraphicalFunction::GetNextXY	(	double &	x,
		double &	y
	)			`[inline, virtual]`

Get locus value for next N. Override this function in your implementation.

Parameters:

	x	Returns X value
	y	Returns Y value

Reimplemented from pPlotterLayer.

Definition at line 236 of file pGraphicalFunction.h.

References pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), and node.

00237         {
00238                 if(node)
00239                 {
00240                         pFunctionPoint* p=(pFunctionPoint*)node->GetData();
00241                         x=p->getRealX();
00242                         y=p->getRealY();
00243                         node=node->GetNext();
00244                         return true;
00245                 }
00246                 return false;
00247         }

Here is the call graph for this function:

int pGraphicalFunction::getOffsetPixelsX ( ) [inline]

Gets the x-offset of the zoom in pixels

Definition at line 758 of file pGraphicalFunction.h.

References offsetPixelX.

Referenced by pPlotterWindow::onChangeActual(), pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and pPlotterWindow::onStartDrawing().

00759         {
00760                 return offsetPixelX;
00761         }

Here is the caller graph for this function:

virtual int pGraphicalFunction::getOffsetPixelsXv ( ) [inline, virtual]

Gets the x-offset of the zoom in pixels

Reimplemented from pPlotterLayer.

Definition at line 443 of file pGraphicalFunction.h.

References offsetPixelX.

00444         {
00445                 return offsetPixelX;
00446         }

int pGraphicalFunction::getOffsetPixelsY ( ) [inline]

Gets the offset of the zoom in pixels

Definition at line 767 of file pGraphicalFunction.h.

References offsetPixelY.

Referenced by pPlotterWindow::onChangeActual(), pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and pPlotterWindow::onStartDrawing().

00768         {
00769                 return offsetPixelY;
00770         }

Here is the caller graph for this function:

virtual int pGraphicalFunction::getOffsetPixelsYv ( ) [inline, virtual]

Gets the offset of the zoom in pixels

Reimplemented from pPlotterLayer.

Definition at line 452 of file pGraphicalFunction.h.

References offsetPixelY.

00453         {
00454                 return offsetPixelY;
00455         }

virtual void pGraphicalFunction::getOffsets	(	int &	offsetX,
		int &	offSetY
	)			`[inline, virtual]`

Get _offsetX and _offsetY

Reimplemented from pPlotterLayer.

Definition at line 117 of file pGraphicalFunction.h.

References _offsetX, _offsetY, and pPlotterLayer::offsetY.

00118         {
00119                 offsetX=(int)_offsetX;
00120                 offsetY=(int)_offsetY;
00121         }

double pGraphicalFunction::getOffsetX ( )

Definition at line 768 of file pGraphicalFunction.cxx.

References _offsetX.

Referenced by pPlotterWindow::onChangeActual(), pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and pPlotterWindow::onStartDrawing().

00769 {
00770         
00771         return this->_offsetX;
00772 }

Here is the caller graph for this function:

double pGraphicalFunction::getOffsetY ( )

Definition at line 780 of file pGraphicalFunction.cxx.

References _offsetY.

Referenced by pPlotterWindow::onChangeActual(), pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and pPlotterWindow::onStartDrawing().

00780                                        {
00781         return this->_offsetY;
00782 }

Here is the caller graph for this function:

const wxPen& mpLayer::GetPen ( ) const [inline, inherited]

Get pen set for this layer.

Returns:: Pen

Definition at line 180 of file mathplot.h.

00180 { return m_pen;  }

wxNode * pGraphicalFunction::GetPointAt ( int movingPointIndex )

Definition at line 109 of file pGraphicalFunction.cxx.

References logicFunction.

Referenced by HistogramWidget::getTransferenceFunctionPoint(), and pPlotterWindow::onMouseMove().

00110 {
00111         return logicFunction -> GetPointAt ( movingPointIndex );        
00112 }

Here is the caller graph for this function:

virtual void pGraphicalFunction::GetPoints ( wxList & points ) [inline, virtual]

Get Point list of the funcion

Parameters:

return

points

Reimplemented from pPlotterLayer.

Definition at line 252 of file pGraphicalFunction.h.

References pLogicalFunction::GetPoints(), and logicFunction.

00253         {
00254                 logicFunction->GetPoints(points);
00255                 //points = realPoints;
00256         }

Here is the call graph for this function:

virtual void pGraphicalFunction::getScales	(	double &	scaleX,
		double &	scaleY
	)			`[inline, virtual]`

Let us know the scale of the function

Reimplemented from pPlotterLayer.

Definition at line 195 of file pGraphicalFunction.h.

References _scaleX, and _scaleY.

00196         {
00197                 scaleX=_scaleX;
00198                 scaleY=_scaleY;
00199         }

int pGraphicalFunction::getScaleWay ( )

Definition at line 618 of file pGraphicalFunction.cxx.

References scaleWay.

00619 {
00620  return scaleWay;
00621 }

double pGraphicalFunction::getScaleX ( )

Definition at line 698 of file pGraphicalFunction.cxx.

References _scaleX.

00699 {
00700         return this->_scaleX;
00701 }

double pGraphicalFunction::getScaleY ( )

Definition at line 709 of file pGraphicalFunction.cxx.

References _scaleY.

00709                                      {
00710         return this->_scaleY;
00711 }

virtual void pGraphicalFunction::getScreens	(	int &	scrX,
		int &	scrY
	)			`[inline, virtual]`

Get screens of the function

Reimplemented from pPlotterLayer.

Definition at line 177 of file pGraphicalFunction.h.

References screenX, and screenY.

00178         {
00179       scrX=screenX;
00180           scrY=screenY;
00181         }

int pGraphicalFunction::getScreenX ( )

Definition at line 631 of file pGraphicalFunction.cxx.

References screenX.

00632 {
00633   return this->screenX;
00634 }

int pGraphicalFunction::getScreenY ( )

Definition at line 639 of file pGraphicalFunction.cxx.

References screenY.

00640 {
00641   return this->screenY;
00642 }

bool pGraphicalFunction::getShowPoints ( )

Definition at line 67 of file pGraphicalFunction.cxx.

References showPointsF.

Referenced by pPlotterWindow::onChangeActual(), and pPlotterWindow::onStartDrawing().

00068 {
00069         return showPointsF;
00070 }

Here is the caller graph for this function:

virtual void pGraphicalFunction::getSize ( int & size ) [inline, virtual]

Get the number of points of the function

Reimplemented from pPlotterLayer.

Definition at line 272 of file pGraphicalFunction.h.

References getSizePoints().

00273         {
00274                 size=getSizePoints();
00275         }

Here is the call graph for this function:

int pGraphicalFunction::getSizePoints ( )

Definition at line 814 of file pGraphicalFunction.cxx.

References pLogicalFunction::getSizePoints(), and logicFunction.

Referenced by HistogramWidget::erasePointsTransferenceFunction(), getSize(), HistogramWidget::getSizeTransferenceFunction(), pPlotterWindow::onDeletePoint(), pPlotterWindow::onMouseMove(), pPlotterWindow::onStopDrawing(), and zooming().

00815 {
00816         return logicFunction->getSizePoints();
00817 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::GetSplinePoint	(	double	t,
		double &	x,
		double &	y
	)

Definition at line 411 of file pGraphicalFunction.cxx.

References pLogicalFunction::getSizePoints(), logicFunction, xKSpline, and yKSpline.

Referenced by initializeSplineVectors().

00412         {
00413                 if (logicFunction->getSizePoints()==0)
00414                 {
00415                         x = 0;
00416                         y = 0;
00417                 }
00418                 if (logicFunction->getSizePoints()>=2)
00419                 {
00420                         x = xKSpline->Evaluate(t);
00421                         y = yKSpline->Evaluate(t);
00422                 }
00423         }

Here is the call graph for this function:

Here is the caller graph for this function:

double pGraphicalFunction::getStartX ( )

Definition at line 654 of file pGraphicalFunction.cxx.

References pLogicalFunction::getStartX(), and logicFunction.

00655 {
00656         return logicFunction->getStartX();
00657 }

Here is the call graph for this function:

double pGraphicalFunction::getStartY ( )

Definition at line 665 of file pGraphicalFunction.cxx.

References pLogicalFunction::getStartY(), and logicFunction.

00665                                      {
00666         return logicFunction->getStartY();
00667 }

Here is the call graph for this function:

int pGraphicalFunction::getType ( )

Definition at line 793 of file pGraphicalFunction.cxx.

References _type.

Referenced by pPlotterWindow::addFunction(), pPlotterWindow::onAddNewPoint(), pPlotterWindow::onAddPoint(), pPlotterWindow::onChangeActual(), pPlotterWindow::onDeletePoint(), pPlotterWindow::onMouseMove(), and pPlotter::update().

00793                                   {
00794         return this->_type;
00795 }

Here is the caller graph for this function:

int pGraphicalFunction::getValidPointRange ( )

Definition at line 800 of file pGraphicalFunction.cxx.

References validPointRange.

00801 {
00802         return validPointRange;
00803 }

double * pGraphicalFunction::getX_RealValues ( )

Evaluates if the given point belongs to the function. Returns the real x values of the control points of the function. It dont includes the points calculated by interpolation.

Definition at line 239 of file pGraphicalFunction.cxx.

References logicFunction.

00240 {
00241         return (logicFunction -> getX_RealValues( ));   
00242 }

virtual std::vector<double> pGraphicalFunction::getXSpline ( ) [inline, virtual]

Reimplemented from pPlotterLayer.

Definition at line 426 of file pGraphicalFunction.h.

References xSpline.

00427         {
00428                 return xSpline;
00429         }

virtual int pGraphicalFunction::getXTraslation ( ) [inline, virtual]

Get the value of the traslation in the x-axis

Reimplemented from pPlotterLayer.

Definition at line 85 of file pGraphicalFunction.h.

References xTraslation.

00086         {
00087                 return xTraslation;
00088         }

double * pGraphicalFunction::getY_RealValues ( )

Returns the real y values of the control points of the function. It dont includes the points calculated by interpolation.

Definition at line 247 of file pGraphicalFunction.cxx.

References logicFunction.

00248 {  
00249 
00250         return (logicFunction -> getY_RealValues());    
00251 }

virtual std::vector<double> pGraphicalFunction::getYSpline ( ) [inline, virtual]

Reimplemented from pPlotterLayer.

Definition at line 433 of file pGraphicalFunction.h.

References ySpline.

00434         {
00435                 return ySpline;
00436         }

bool pGraphicalFunction::getZoomB ( ) [inline]

Definition at line 626 of file pGraphicalFunction.h.

References zoomIn.

00627         {
00628                 return zoomIn;
00629         }

virtual bool mpLayer::HasBBox ( ) [inline, virtual, inherited]

Check whether this layer has a bounding box. The default implementation returns TRUE. Overide and return FALSE if your mpLayer implementation should be ignored by the calculation of the global bounding box for all layers in a mpWindow.

Return values:

	TRUE	Has bounding box
	FALSE	Has not bounding box

Reimplemented in mpScaleX, mpScaleY, pPlotterScaleX, and pPlotterScaleY.

Definition at line 110 of file mathplot.h.

Referenced by mpWindow::UpdateBBox().

00110 { return TRUE; }

Here is the caller graph for this function:

virtual void pGraphicalFunction::ifShowPoints ( bool & show ) [inline, virtual]

Let us Know if the user want to see the points of the function of other color than the color of the lines

Reimplemented from pPlotterLayer.

Definition at line 216 of file pGraphicalFunction.h.

References showPointsF.

00217         {
00218                 show = showPointsF;
00219         }

bool pPlotterLayer::initializePolygon	(	wxPoint *	points,
		double	x1,
		double	y1,
		double	x2,
		double	y2
	)			`[inherited]`

Definition at line 187 of file pPlotterLayer.cxx.

Referenced by pPlotterLayer::drawFunction(), and pPlotterLayer::drawSplineCurve().

00188 {
00189         bool setted=false;
00190 
00191                 //intercepts
00192         float m=((float)(y2-y1))/(x2-x1);
00193         float x0=-y1/m+x1;
00194         float y0=-m*x1+y1;      
00195 
00196         if(points[0].x<=0&& points[1].x<=0 && points[0].y<=0&& points[1].y<=0)
00197         {
00198         
00199                 //int offsetpx=getOffsetPixelsXv(); //JPRx      
00200 
00201                 //analyzing the curve
00202 
00203                         if(x1<=0 && x2>=0)
00204                         {
00205                                 if(y2>=0 && y1>=0)
00206                                 {
00207                                                 //dc.DrawLine(0,y0, x2,y2);
00208                                                 points[0].x=0;
00209                                                 points[0].y=y0;
00210                                                 points[1].x=x2;
00211                                                 points[1].y=y2;
00212                                                 setted=true;                                    
00213                                         
00214                                 }
00215                                 else if(y2<=0 && y1>=0)
00216                                 {
00217                                         if(y0>=0 && x0>=0)
00218                                         {
00219                                                 //dc.DrawLine(0,y0,x0,0 );
00220                                                 points[0].x=0;
00221                                                 points[0].y=y0;
00222                                                 points[1].x=x0;
00223                                                 points[1].y=0;
00224                                                 setted=true;    
00225 
00226                                         }
00227                                                 
00228                                 }
00229                                 else if(y2>=0 && y1<=0)
00230                                 {       
00231                                         if(y0>=0) 
00232                                         {       
00233                                                 //dc.DrawLine(0,y0,x2,y2 );
00234                                                 points[0].x=0;
00235                                                 points[0].y=y0;
00236                                                 points[1].x=x2;
00237                                                 points[1].y=y2;
00238                                                 setted=true;    
00239                                         }
00240                                 }
00241                 
00242                         }
00243 
00244                         if(x1>=0 && x2>=0)
00245                         {
00246                                 if(y1>=0 && y2>=0 )
00247                                 {
00248                                         //dc.DrawLine(x1,y1, x2,y2);
00249                                         points[0].x=x1;
00250                                         points[0].y=y1;
00251                                         points[1].x=x2;
00252                                         points[1].y=y2;
00253                                         setted=true;    
00254                                 }
00255                                 else if(y1>=0 && y2<=0)
00256                                 {
00257                                         //dc.DrawLine(x1,y1,x0,0 );
00258                                         points[0].x=x1;
00259                                         points[0].y=y1;
00260                                         points[1].x=x0;
00261                                         points[1].y=0;
00262                                         setted=true;    
00263                                 }
00264                                 else if(y1<=0 && y2>=0) 
00265                                 {       
00266                                         //dc.DrawLine(x0,0,x2,y2);
00267                                         points[0].x=x0;
00268                                         points[0].y=0;
00269                                         points[1].x=x2;
00270                                         points[1].y=y2;
00271                                         setted=true;    
00272                                 }
00273                         }
00274                         else
00275                         return setted;
00276         }
00277         else
00278                 return setted;
00279         return setted; 
00280 }

Here is the caller graph for this function:

void pGraphicalFunction::initializeSplines ( )

Definition at line 357 of file pGraphicalFunction.cxx.

References addSplinesPoints(), xKSpline, and yKSpline.

Referenced by pPlotterWindow::addFunction(), and pPlotterWindow::onSplinePoints().

00358         {
00359                 if(xKSpline==NULL)
00360                         xKSpline = vtkKochanekSpline::New();
00361                 if(yKSpline==NULL)
00362                         yKSpline= vtkKochanekSpline::New();
00363                 addSplinesPoints();
00364 
00365         }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::initializeSplineVectors ( )

Definition at line 391 of file pGraphicalFunction.cxx.

References pLogicalFunction::getSizePoints(), GetSplinePoint(), logicFunction, xSpline, and ySpline.

Referenced by pPlotterWindow::addFunction(), pPlotterWindow::onAddNewPoint(), pPlotterWindow::onAddPoint(), pPlotterWindow::onChangeActual(), pPlotterWindow::onDeletePoint(), pPlotterWindow::onMouseMove(), pPlotterWindow::onSplinePoints(), and pPlotter::update().

00392         {
00393                 double x=0,y=0,t,delta;
00394                 int i,np,nps;
00395                 //realPoints.DeleteC  
00396 
00397                 np = logicFunction->getSizePoints();
00398                 nps = 100;
00399                 delta=( double ) ( np ) / ( double ) ( nps );
00400                 for( i = 0; i < nps; i++ )
00401                 {
00402                   t = delta * (double)i;
00403                   GetSplinePoint(t,x,y);
00404                   xSpline.push_back(x);
00405                   ySpline.push_back(y);
00406                 }
00407         }

Here is the call graph for this function:

Here is the caller graph for this function:

double pGraphicalFunction::interpolateY	(	double	m,
		int	x1,
		int	y1,
		int	x
	)

give us the value of y in the line define by the arguments

Definition at line 331 of file pGraphicalFunction.cxx.

00332 {
00333         return m*(x-x1)+y1;
00334 }

bool pGraphicalFunction::isInFunction	(	int	x,
		int	y
	)

Definition at line 261 of file pGraphicalFunction.cxx.

References getBefore(), and isInLine().

Referenced by pPlotterWindow::onChangeActual(), and pPlotterWindow::onMouseMove().

00262 {
00263         wxNode* before;
00264         wxNode* next;
00265         pFunctionPoint* point= new pFunctionPoint(x,y);
00266         bool inLine;
00267         before=getBefore(point);
00268 
00269         if(before && before->GetNext())
00270         {
00271                 next = before->GetNext();
00272                 //next = (before->GetNext())->GetNext();
00273                 inLine= isInLine((pFunctionPoint*)before->GetData(),(pFunctionPoint*)next->GetData(),point);
00274         }
00275         else 
00276                 inLine=false;
00277         return inLine;
00278 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool pGraphicalFunction::isInLine	(	pFunctionPoint *	before,
		pFunctionPoint *	next,
		pFunctionPoint *	point
	)

Definition at line 309 of file pGraphicalFunction.cxx.

References pFunctionPoint::getRealX(), and pFunctionPoint::getRealY().

Referenced by isInFunction().

00310 {
00311         int x1,x2,x,y1,y2,y;
00312         
00313         x1=(float)before->getRealX();
00314         x2=(float)next->getRealX();
00315         y1=(float)before->getRealY();
00316         y2=(float)next->getRealY();
00317         x=(float)point->getRealX();
00318         y=(float)point->getRealY();
00319 
00320         
00321         float d1= (float)sqrt(pow(float(x1-x),2)+ pow(float(y1-y),2));
00322         float d2= (float)sqrt(pow(float(x2-x),2)+ pow(float(y2-y),2));
00323         float d=(float)sqrt(pow(float(x2-x1),2)+ pow(float(y2-y1),2));
00324         if(d1+d2<=(d*1.1) && d1<=d && d2<=d)
00325                 return true;
00326         return false;
00327 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::load ( wxString fileName )

Definition at line 583 of file pGraphicalFunction.cxx.

References pLogicalFunction::getMaxX(), pLogicalFunction::getMaxY(), pLogicalFunction::getMinX(), pLogicalFunction::getMinY(), pLogicalFunction::load(), logicFunction, setMaxShowedX(), setMaxShowedY(), setMinShowedX(), setMinShowedY(), and pLogicalFunction::setUp().

Referenced by pPlotterWindow::onLoad().

00584 {
00585         logicFunction->load(fileName);
00586         logicFunction->setUp();
00587         setMaxShowedX(logicFunction->getMaxX());
00588         setMinShowedX(logicFunction->getMinX());
00589         setMaxShowedY(logicFunction->getMaxY());
00590         setMinShowedY(logicFunction->getMinY());
00591 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool pGraphicalFunction::orderPoints ( )

void pPlotterLayer::Plot	(	wxDC &	dc,
		mpWindow &	w
	)			`[virtual, inherited]`

Layer plot handler. This implementation will plot the locus in the visible area and put a label according to the aligment specified.

Implements mpLayer.

Reimplemented in pPlotterScaleX, and pPlotterScaleY.

Definition at line 521 of file pPlotterLayer.cxx.

References pPlotterLayer::drawFunction(), pPlotterLayer::drawLineToMousePoint(), pPlotterLayer::drawPoints(), pPlotterLayer::drawSplineCurve(), pPlotterLayer::getDrawing(), pPlotterLayer::getFactorZoom(), pPlotterLayer::getIfActual(), pPlotterLayer::getMaxShowed(), pPlotterLayer::getMinShowed(), pPlotterLayer::getOffsetPixelsXv(), pPlotterLayer::getOffsets(), mpWindow::getRealGuideX(), mpWindow::getRealGuideY(), pPlotterLayer::ifShowPoints(), mpLayer::m_pen, pPlotterLayer::offsetX, pPlotterLayer::offsetY, pPlotterLayer::scaleX, pPlotterLayer::scaleY, mpWindow::SetScaleX(), mpWindow::SetScaleY(), and pPlotterLayer::vGetType().

00522 {
00523         bool show,drawing,actual;
00524         int scrwX,scrwY,maxX,maxY,minX,minY,type;
00525         float factorZoom;
00526         
00527         ifShowPoints(show);
00528         getDrawing(drawing);
00529         type=vGetType();
00530         
00531         dc.SetPen( m_pen);
00532         
00533         /*
00534          * Managing the scale and zoom
00535          */
00536         
00537         dc.GetSize(&scrwX, &scrwY);
00538         getIfActual(actual);
00539         //getMax(maxX, maxY);
00540         /***********/
00541         getMaxShowed(maxX,maxY);
00542         getMinShowed(minX,minY);
00543         /***********/
00544         getFactorZoom(factorZoom);
00545         getOffsets(offsetX,offsetY);
00546         /*
00547         maxX=w.getMaxScrX();
00548         maxY=w.getMaxScrY();
00549         minX=w.getMinScrX();
00550         minY=w.getMinScrY();
00551         */
00552         if((maxX-minX)!=0 && (maxY-minY)!=0)
00553         {
00554                 
00555                 scaleX=(((double)scrwX-100)/(maxX-minX))*factorZoom;
00556                 scaleY=(((double)scrwY-50)/(maxY-minY))*factorZoom;
00557                 
00558                 if(actual)
00559                 {
00560                         w.SetScaleX(scaleX);
00561                         w.SetScaleY(scaleY);
00562                         //w.setMinScrX(offsetX);
00563                         //w.setMinScrY(offsetY);
00564                 }
00565                 
00566         }
00567         /*
00568                 Managing the drawing
00569         */
00570         int orgx=70;
00571 
00572         
00573 //EED 14Mai2009
00574 //      int orgy=w.GetScrY()-40;
00575 //      dc.SetDeviceOrigin( orgx ,orgy);
00576 //      dc.SetAxisOrientation(true,true);
00577         
00578         int orgy = 40;  
00579         dc.SetDeviceOrigin( orgx ,orgy);
00580         dc.SetAxisOrientation(true,false);
00581 
00582         
00583 
00584         //if the user dont want to see the points of the function and if he stops drawing
00585         //we have to draw the function
00586         if(!show && !drawing && type==1)
00587                 drawFunction(dc,w);
00588         else if(!show && !drawing && type==2)
00589                 drawSplineCurve(dc,w);
00590         //we just draw the point that the user just clicked
00591         else if(drawing && type==1)
00592         { 
00593                 drawFunction(dc,w);
00594                 drawLineToMousePoint(dc,w);
00595                 drawPoints(dc,w);
00596         }
00597         else if(drawing && type==1)
00598         {
00599                 drawSplineCurve(dc,w);
00600                 drawLineToMousePoint(dc,w);
00601                 drawPoints(dc,w);
00602         }
00603         else if(show && type==1)
00604         {
00605                 drawFunction(dc,w);
00606                 drawPoints(dc,w);
00607         }
00608         else if(show && type==2)
00609         {
00610                 drawSplineCurve(dc,w);
00611                 drawPoints(dc,w);
00612         }
00613 
00614         // Drawing the guides according to real values entered according to the integrated interaction (IS NOT WORKING!!!)
00615         if ( actual )
00616         {
00617                 dc.SetPen(wxPen(  wxColour(255,0,0),1,wxDOT ));
00618                 int offsetpx = getOffsetPixelsXv();
00619 //              int offsetpy = getOffsetPixelsYv();  //EED
00620 
00621                 int realX_guide = w.getRealGuideX();
00622                 if( realX_guide!=-1 )
00623                 {
00624                 dc.DrawLine( (realX_guide/*-w.getMinScrX()*/-offsetX)*scaleX + offsetpx, 0, (realX_guide/*-w.getMinScrX()*/-offsetX)*scaleX + offsetpx, scrwY);                 
00625                 }
00626                         
00627                 int realY_guide = w.getRealGuideY();
00628                 if( realY_guide!=-1 )
00629                 {
00630                         dc.DrawLine( 0,(realY_guide/*-w.getMinScrY()*/-offsetX)*scaleX + offsetpx, scrwX, (realY_guide/*-w.getMinScrY()*/-offsetX)*scaleX + offsetpx);
00631                 }
00632         }
00633    
00634 }

Here is the call graph for this function:

virtual void pGraphicalFunction::Rewind ( ) [inline, virtual]

Rewind

Reimplemented from pPlotterLayer.

Definition at line 224 of file pGraphicalFunction.h.

References pLogicalFunction::GetPointAt(), logicFunction, and node.

00225         {
00226                                 
00227                 node = logicFunction->GetPointAt(0);
00228                 
00229         }

Here is the call graph for this function:

void pGraphicalFunction::save ( wxString fileName )

Definition at line 574 of file pGraphicalFunction.cxx.

References logicFunction, and pLogicalFunction::save().

Referenced by pPlotterWindow::onSave().

00575 {
00576         
00577         logicFunction->save(fileName);
00578 
00579 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setActual ( bool act )

actual

Definition at line 599 of file pGraphicalFunction.cxx.

References ifActual.

Referenced by HistogramWidget::drawTransferenceFunction(), pPlotterWindow::onLoad(), pPlotterWindow::onStartDrawing(), and pPlotterWindow::setActualFunction().

00600 {
00601   ifActual=act;
00602 }

Here is the caller graph for this function:

void pGraphicalFunction::setColorPoints ( std::vector< pColorPoint * > & colorVector )

Definition at line 823 of file pGraphicalFunction.cxx.

References f_colorPoints.

00824 {
00825         f_colorPoints.clear();
00826         int i = 0;      
00827         while(i<(int)(colorVector.size()))
00828         {
00829                 f_colorPoints.push_back(colorVector[i]);                
00830                 i++;
00831         }
00832 }

void pGraphicalFunction::SetDrawing ( bool d ) [inline]

Definition at line 544 of file pGraphicalFunction.h.

References drawing.

Referenced by pPlotterWindow::onLoad(), pPlotterWindow::onStartDrawing(), and pPlotterWindow::onStopDrawing().

00545         {
00546                 drawing = d;
00547         }

Here is the caller graph for this function:

void pGraphicalFunction::setEditable ( bool edit ) [inline]

Definition at line 607 of file pGraphicalFunction.h.

References editable.

Referenced by HistogramWidget::drawHistogram(), and Histogram::drawHistogram().

00608         {
00609                 editable=edit;
00610         }

Here is the caller graph for this function:

void pGraphicalFunction::setEndX ( double aEndX )

Definition at line 671 of file pGraphicalFunction.cxx.

References _endX, logicFunction, and pLogicalFunction::setEndX().

Referenced by setUp().

00672 {
00673         logicFunction->setEndX(aEndX);
00674         this->_endX = aEndX;
00675 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setEndY ( double aEndY )

Definition at line 681 of file pGraphicalFunction.cxx.

References _endY, logicFunction, and pLogicalFunction::setEndY().

Referenced by setUp().

00681                                              {
00682         logicFunction->setEndY(aEndY);
00683         this->_endY = aEndY;
00684 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setFactorZoom ( float factor ) [inline]

Definition at line 600 of file pGraphicalFunction.h.

References factorZoom.

Referenced by pPlotterWindow::onLoad(), pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and pPlotterWindow::onStartDrawing().

00601         {
00602                 factorZoom=factor;
00603         }

Here is the caller graph for this function:

void pGraphicalFunction::setFinalDrawPoint ( pFunctionPoint * finalPoint ) [inline]

Set the final drawing point

Parameters:

pFunctionPoint*

finalPoint

Definition at line 658 of file pGraphicalFunction.h.

References finalDrawingPoint.

00659         {
00660                 finalDrawingPoint=finalPoint;   
00661         }

void mpLayer::SetFont ( wxFont & font ) [inline, inherited]

Set layer font

Parameters:

font

Font, will be copied to internal class member

Definition at line 190 of file mathplot.h.

00190 { m_font = font; }

void pGraphicalFunction::setFromWindow ( bool w ) [inline]

set fromWindow: it is set to true if the function was created interactively

Definition at line 585 of file pGraphicalFunction.h.

References fromWindow.

Referenced by pPlotterWindow::onLoad(), and pPlotterWindow::onStartDrawing().

00586         {
00587                 fromWindow=w;
00588         }

Here is the caller graph for this function:

void pGraphicalFunction::setInitialDrawPoint ( pFunctionPoint * initialPoint ) [inline]

Set the initial drawing point

Parameters:

pFunctionPoint*

initialPoint

Definition at line 642 of file pGraphicalFunction.h.

References initialDrawingPoint.

00643         {
00644                 initialDrawingPoint=initialPoint;       
00645         }

void pGraphicalFunction::setMaxShowedX ( int msx ) [inline]

Set the maxShowedX

Definition at line 738 of file pGraphicalFunction.h.

References maxShowedX.

Referenced by pPlotterWindow::actualizeViewRange(), pPlotterWindow::InitFunctionForVectors(), load(), pPlotterWindow::moveFunctions(), and pPlotterWindow::onStartDrawing().

00739         {
00740                 maxShowedX=msx;
00741         }

Here is the caller graph for this function:

void pGraphicalFunction::setMaxShowedY ( int msy ) [inline]

Set the minShowedY

Definition at line 745 of file pGraphicalFunction.h.

References maxShowedY.

Referenced by pPlotterWindow::InitFunctionForVectors(), load(), and pPlotterWindow::onStartDrawing().

00746         {
00747                 maxShowedY=msy;
00748         }

Here is the caller graph for this function:

void pGraphicalFunction::setMaxX ( double aMaxX )

Definition at line 738 of file pGraphicalFunction.cxx.

References _maxX, logicFunction, and pLogicalFunction::setMaxX().

Referenced by pPlotterWindow::onStartDrawing(), and setUp().

00739 {
00740         logicFunction->setMaxX(aMaxX);
00741         this->_maxX = aMaxX;
00742 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setMaxY ( double aMaxY )

Definition at line 749 of file pGraphicalFunction.cxx.

References _maxY, logicFunction, and pLogicalFunction::setMaxY().

Referenced by pPlotterWindow::onStartDrawing(), and setUp().

00750 {
00751         logicFunction->setMaxY(aMaxY);
00752         this->_maxY = aMaxY;
00753 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setMinShowed ( )

Definition at line 535 of file pGraphicalFunction.cxx.

References _offsetX, _offsetY, pLogicalFunction::GetPointAt(), pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), logicFunction, node, setMinShowedX(), and setMinShowedY().

00536         {
00537                 bool firstX=false,firstY=false;
00538                 
00539                 wxNode* node=logicFunction->GetPointAt(0);
00540                 pFunctionPoint* p;
00541 
00542                 //float middleWX=(((float)(screenX-100))/2)/scaleX; // JPRx
00543                 //float middleWY=(((float)(screenY-50))/2)/scaleY; // JPRx
00544                 
00545                 //node=node->GetNext(); 
00546                 while(node)
00547                 {
00548                         p=(pFunctionPoint*)node->GetData();
00549                         int px=p->getRealX();
00550                         int py=p->getRealY();
00551                         int x=(px-_offsetX);//+middleWX;
00552                         int y=(py-_offsetY);//+middleWY;
00553                         if(!firstX && x>=0)
00554                         {
00555                                 firstX=true;
00556                                 setMinShowedX(px);
00557                         }
00558                         if(!firstY && y>=0)
00559                         {
00560                                 firstY=true;
00561                                 setMinShowedY(py);
00562                         }       
00563                         node=node->GetNext();
00564                 }
00565         }

Here is the call graph for this function:

void pGraphicalFunction::setMinShowedX ( int msx ) [inline]

Set the minShowedX

Definition at line 724 of file pGraphicalFunction.h.

References minShowedX.

Referenced by pPlotterWindow::actualizeViewRange(), pPlotterWindow::InitFunctionForVectors(), load(), pPlotterWindow::moveFunctions(), pPlotterWindow::onStartDrawing(), and setMinShowed().

00725         {
00726                 minShowedX=msx;
00727         }

Here is the caller graph for this function:

void pGraphicalFunction::setMinShowedY ( int msy ) [inline]

Set the minShowedY

Definition at line 731 of file pGraphicalFunction.h.

References minShowedY.

Referenced by pPlotterWindow::InitFunctionForVectors(), load(), pPlotterWindow::onStartDrawing(), and setMinShowed().

00732         {
00733                 minShowedY=msy;
00734         }

Here is the caller graph for this function:

void pGraphicalFunction::setMinX ( double aMinX )

Definition at line 715 of file pGraphicalFunction.cxx.

References _minX, logicFunction, and pLogicalFunction::setMinX().

Referenced by pPlotterWindow::onStartDrawing(), and setUp().

00716 {
00717         logicFunction->setMinX(aMinX);
00718         this->_minX = aMinX;
00719 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setMinY ( double aMinY )

Definition at line 726 of file pGraphicalFunction.cxx.

References _minY, logicFunction, and pLogicalFunction::setMinY().

Referenced by pPlotterWindow::onStartDrawing(), and setUp().

00727 {
00728         logicFunction->setMinY(aMinY);
00729         this->_minY = aMinY;
00730 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::SetMousePoint ( wxPoint p ) [inline]

Definition at line 555 of file pGraphicalFunction.h.

References mousePoint.

Referenced by pPlotterWindow::onMouseMove().

00556         { 
00557                 mousePoint = p;
00558         }

Here is the caller graph for this function:

void pGraphicalFunction::setmType ( int mt ) [inline]

Definition at line 802 of file pGraphicalFunction.h.

References mType.

Referenced by HistogramWidget::drawHistogram(), and Histogram::drawHistogram().

00803         {
00804                 mType=mt;
00805         }

Here is the caller graph for this function:

void mpLayer::SetName ( wxString name ) [inline, inherited]

Set layer name

Parameters:

name

Name, will be copied to internal class member

Definition at line 185 of file mathplot.h.

00185 { m_name = name; }

void pGraphicalFunction::setOffsetPixelX ( int offX ) [inline]

Set the x-offset of the zoom

Definition at line 774 of file pGraphicalFunction.h.

References offsetPixelX.

Referenced by pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and setOffsets().

00775         {
00776                 offsetPixelX=offX;
00777         }

Here is the caller graph for this function:

void pGraphicalFunction::setOffsetPixelY ( int offY ) [inline]

Set the y-offset of the zoom

Definition at line 781 of file pGraphicalFunction.h.

References offsetPixelY.

Referenced by pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and setOffsets().

00782         {
00783                 offsetPixelY=offY;
00784         }

Here is the caller graph for this function:

void pGraphicalFunction::setOffsets	(	int	offx,
		int	offy
	)

Definition at line 507 of file pGraphicalFunction.cxx.

References _offsetX, _offsetY, _scaleX, _scaleY, minShowedX, minShowedY, offsetPixelX, offsetPixelY, setOffsetPixelX(), setOffsetPixelY(), setOffsetX(), setOffsetY(), and setScales().

Referenced by pPlotterWindow::onMyZoomIn(), and pPlotterWindow::onMyZoomOut().

00508         {
00509                 int xS,yS;
00510 
00511                 setScales();
00512                 
00513                 xS=(offx-offsetPixelX)/_scaleX+_offsetX + minShowedX;
00514                 yS=(offy-offsetPixelY)/_scaleY+_offsetY+ minShowedY;
00515                 
00516                 setOffsetX(xS);
00517                 setOffsetY(yS);
00518                         
00519                 //setMinShowedX(xS);
00520                 //setMinShowedY(yS);
00521 
00522                 setOffsetPixelX(offx);
00523                 setOffsetPixelY(offy);
00524                 //setMinShowed();
00525         }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setOffsetX ( double aOffsetX )

Definition at line 762 of file pGraphicalFunction.cxx.

References _offsetX, logicFunction, and pLogicalFunction::setOffsetX().

Referenced by pPlotterWindow::actualizeViewRange(), pPlotterWindow::moveFunctions(), pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and setOffsets().

00763 {
00764         logicFunction->setOffsetX(aOffsetX);
00765         this->_offsetX = aOffsetX;
00766 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setOffsetY ( double aOffsetY )

Definition at line 774 of file pGraphicalFunction.cxx.

References _offsetY, logicFunction, and pLogicalFunction::setOffsetY().

Referenced by pPlotterWindow::onMyZoomIn(), pPlotterWindow::onMyZoomOut(), and setOffsets().

00775 {
00776         logicFunction->setOffsetY(aOffsetY);
00777         this->_offsetY = aOffsetY;
00778 }

Here is the call graph for this function:

Here is the caller graph for this function:

void mpLayer::SetPen ( wxPen & pen ) [inline, inherited]

Set layer pen

Parameters:

pen

Pen, will be copied to internal class member

Definition at line 195 of file mathplot.h.

Referenced by HistogramWidget::drawHistogram(), Histogram::drawHistogram(), HistogramWidget::drawTransferenceFunction(), pPlotterWindow::onChangeColor(), pPlotterWindow::onLoad(), and pPlotterWindow::onStartDrawing().

00195 { m_pen  = pen;  }

Here is the caller graph for this function:

void pGraphicalFunction::setScales ( )

Definition at line 117 of file pGraphicalFunction.cxx.

References factorZoom, logicFunction, maxShowedX, maxShowedY, minShowedX, minShowedY, pPlotterLayer::scaleX, pPlotterLayer::scaleY, screenX, screenY, pLogicalFunction::setScaleX(), setScaleX(), pLogicalFunction::setScaleY(), and setScaleY().

Referenced by HistogramWidget::OnSize(), pPlotterWindow::setActualScales(), setOffsets(), and zooming().

00118 {
00119         //int dx= logicFunction->getMaxX()-logicFunction->getMinX();
00120         //int dy= logicFunction->getMaxY()-logicFunction->getMinY();
00121         int dx= maxShowedX-minShowedX;
00122         int dy= maxShowedY-minShowedY;
00123         
00124         
00125         if(dx!=0 && dy!=0)
00126         {
00127                 double scaleX=(((float)(screenX-100))/dx)*factorZoom;
00128                 double scaleY=(((float)(screenY-50))/dy)*factorZoom;
00129                 setScaleX(scaleX);
00130                 setScaleY(scaleY);
00131                 logicFunction->setScaleX(scaleX);
00132                 logicFunction->setScaleY(scaleY);
00133 
00134         }
00135 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setScaleWay ( int typeS )

SCALE WAY DEFECT_SCALE 1 MAX_SCALE 2 USER_SCALE 3

Definition at line 613 of file pGraphicalFunction.cxx.

References scaleWay.

Referenced by pPlotterWindow::onStartDrawing().

00614 {
00615   scaleWay=typeS;
00616 }

Here is the caller graph for this function:

void pGraphicalFunction::setScaleX ( double aScaleX )

Definition at line 692 of file pGraphicalFunction.cxx.

References _scaleX, logicFunction, and pLogicalFunction::setScaleX().

Referenced by setScales().

00693 {
00694         logicFunction->setScaleX(aScaleX);
00695         this->_scaleX = aScaleX;
00696 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setScaleY ( double aScaleY )

Definition at line 703 of file pGraphicalFunction.cxx.

References _scaleY, logicFunction, and pLogicalFunction::setScaleY().

Referenced by setScales().

00704 {
00705         logicFunction->setScaleY(aScaleY);
00706         this->_scaleY = aScaleY;
00707 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void pGraphicalFunction::setScreens	(	int	scrX,
		int	scrY
	)			`[inline, virtual]`

Set screens value

Reimplemented from pPlotterLayer.

Definition at line 186 of file pGraphicalFunction.h.

References screenX, and screenY.

Referenced by HistogramWidget::OnSize(), and pPlotterWindow::setActualScales().

00187         {
00188                 screenX=scrX;
00189                 screenY=scrY;                   
00190         }

Here is the caller graph for this function:

void pGraphicalFunction::setScreenX ( int scrX )

Definition at line 627 of file pGraphicalFunction.cxx.

References screenX.

Referenced by pPlotterWindow::onMouseMove(), pPlotterWindow::onMyZoomIn(), and pPlotterWindow::onMyZoomOut().

00628 {
00629   this->screenX=scrX;
00630 }

Here is the caller graph for this function:

void pGraphicalFunction::setScreenY ( int scrY )

Definition at line 635 of file pGraphicalFunction.cxx.

References screenY.

Referenced by pPlotterWindow::onMouseMove(), pPlotterWindow::onMyZoomIn(), and pPlotterWindow::onMyZoomOut().

00636 {
00637   this->screenY=scrY;
00638 }

Here is the caller graph for this function:

void pGraphicalFunction::SetShowPoints ( bool showPoints )

Definition at line 62 of file pGraphicalFunction.cxx.

References showPointsF.

Referenced by HistogramWidget::drawTransferenceFunction(), pPlotterWindow::onNoShowPoints(), pPlotterWindow::onShowPoints(), and pPlotterWindow::onStartDrawing().

00063 {
00064         showPointsF = showPoints;
00065 }

Here is the caller graph for this function:

void pGraphicalFunction::setStartX ( double aStartX )

Definition at line 648 of file pGraphicalFunction.cxx.

References _startX, pLogicalFunction::getStartX(), logicFunction, and pLogicalFunction::setStartX().

Referenced by setUp().

00648                                                  {
00649         
00650         logicFunction->setStartX(aStartX);
00651         this->_startX =logicFunction->getStartX();
00652 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setStartY ( double aStartY )

Definition at line 659 of file pGraphicalFunction.cxx.

References _startY, logicFunction, and pLogicalFunction::setStartY().

Referenced by setUp().

00660 {
00661         logicFunction->setStartY(aStartY);
00662         this->_startY = aStartY;
00663 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setType ( int aType )

Definition at line 787 of file pGraphicalFunction.cxx.

References _type, logicFunction, and pLogicalFunction::setType().

Referenced by HistogramWidget::drawHistogram(), Histogram::drawHistogram(), HistogramWidget::drawTransferenceFunction(), pPlotterWindow::onLine(), and pPlotterWindow::onSplinePoints().

00788 {
00789         logicFunction->setType(aType);
00790         this->_type = aType;
00791 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setUp ( )

Definition at line 74 of file pGraphicalFunction.cxx.

References pLogicalFunction::getEndX(), pLogicalFunction::getEndY(), pLogicalFunction::getMaxX(), pLogicalFunction::getMaxY(), pLogicalFunction::getMinX(), pLogicalFunction::getMinY(), pLogicalFunction::getStartX(), pLogicalFunction::getStartY(), logicFunction, setEndX(), setEndY(), setMaxX(), setMaxY(), setMinX(), setMinY(), setStartX(), setStartY(), and pLogicalFunction::setUp().

Referenced by AddNewPoint(), AddPoint(), changePoint(), DeletePoint(), and deletePointAt().

00075 {
00076         logicFunction->setUp();
00077         setMaxX(logicFunction->getMaxX());
00078         setMinX(logicFunction->getMinX());
00079         setMaxY(logicFunction->getMaxY());
00080         setMinY(logicFunction->getMinY());
00081         setStartX(logicFunction->getStartX());
00082         setEndX(logicFunction->getEndX());
00083         setStartY(logicFunction->getStartY());
00084         setEndY(logicFunction->getEndY());
00085         
00086 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pGraphicalFunction::setValidPointRange ( int theRange )

Definition at line 805 of file pGraphicalFunction.cxx.

References logicFunction, pLogicalFunction::setValidPointRange(), and validPointRange.

00806 {
00807         logicFunction->setValidPointRange(theRange);
00808         validPointRange = theRange;
00809 }

Here is the call graph for this function:

void pGraphicalFunction::setXTraslation ( int xT ) [inline]

Set the value of the traslation in the x-axis

Parameters:

xT

value in pixels of the traslation in x-axis

Definition at line 814 of file pGraphicalFunction.h.

References xTraslation.

00815         {
00816                  xTraslation=xT;
00817         }

void pGraphicalFunction::setZoomIn ( bool z ) [inline]

Definition at line 634 of file pGraphicalFunction.h.

References zoomIn.

00635         {
00636                 zoomIn=z;
00637         }

int pGraphicalFunction::validPointOnFunction ( wxPoint realPoint )

Definition at line 92 of file pGraphicalFunction.cxx.

References logicFunction.

Referenced by pPlotterWindow::onAddPoint(), pPlotterWindow::onDeletePoint(), and pPlotterWindow::onMouseMove().

00093 {
00094         return (logicFunction -> validPointOnFunction (realPoint));
00095 }

Here is the caller graph for this function:

virtual int pGraphicalFunction::vGetType ( ) [inline, virtual]

Get the type of the curve 1=piecewise functio 2= smooth

Reimplemented from pPlotterLayer.

Definition at line 108 of file pGraphicalFunction.h.

References _type.

00109         {
00110                 return _type;
00111         }

void pGraphicalFunction::zooming	(	int	clickedX,
		int	clickedY,
		int	width
	)

This method set the initial point and the final point of drawing according with the width of the square around the point clicked

Parameters:

	clickedX
	clickedY
	width,:	width of the square

This method set the initial point and the final point of drawing according with the width of the square around the point clicked

Parameters:

	clickedX
	clickedY
	width,:	width of the square Note: all the parameters are pixels Pre: screenX, screenY, zoom are set! with the actual data. DEPRECATED!

Definition at line 439 of file pGraphicalFunction.cxx.

References _offsetX, _offsetY, _scaleX, _scaleY, finalDrawingPoint, pLogicalFunction::GetPointAt(), pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), getSizePoints(), initialDrawingPoint, logicFunction, setScales(), and zoomIn.

00440 {
00441         int xS,yS,x1,x2,y1,y2;
00442         setScales();
00443         xS=clickedX/_scaleX+_offsetX;
00444         yS=clickedY/_scaleY+_offsetY;
00445         //square
00446         x1=(clickedX-width)/_scaleX+_offsetX;
00447         x2=(clickedX+width)/_scaleX+_offsetX;
00448         y1=(clickedY-width)/_scaleY+_offsetY;
00449         y2=(clickedY+width)/_scaleY+_offsetY;
00450 
00451         int numberPoints=getSizePoints();
00452         pFunctionPoint* point;
00453         wxNode* p;
00454         bool inSquare=false,first=false;
00455         
00456         //if the user made a zoom
00457         if(zoomIn)
00458         {
00459                 int i;
00460                 for(i=0; i<numberPoints;i++)
00461                 {
00462                         p=logicFunction->GetPointAt(i);
00463                         point=(pFunctionPoint*)p->GetData();
00464                         int rx=point->getRealX();
00465                         int ry=point->getRealY();
00466                         inSquare= rx>=x1 && rx<=x2; //&& ry>=y1 && ry<=y2;
00467                         if(inSquare)
00468                         {
00469                                 if(!first)
00470                                 {
00471                                         initialDrawingPoint=point;
00472                                         _offsetX=rx;
00473                                         _offsetY=ry;
00474                                         first=true;
00475                                 }
00476                                 finalDrawingPoint=point;
00477                         }
00478                 }
00479         }       
00480         else
00481         {
00482                 //We extend the range of vision in x and y,20 and 10 respectively
00483                 if((_offsetX-20)>=0)
00484                 {
00485                         _offsetX=_offsetX-20;
00486                 }
00487                 else
00488                         _offsetX=0;
00489                 if((_offsetY-10)>=0)
00490                 {
00491                         _offsetY=_offsetY-10;
00492                 }
00493                 else
00494                         _offsetY=0;
00495         }
00496 }

Here is the call graph for this function:

Member Data Documentation

double pGraphicalFunction::_endX [private]

Is the last discrete point on x axis of the drawed function.

Definition at line 843 of file pGraphicalFunction.h.

Referenced by setEndX().

double pGraphicalFunction::_endY [private]

Is the last discrete point on y axis of the drawed function.

Definition at line 847 of file pGraphicalFunction.h.

Referenced by setEndY().

double pGraphicalFunction::_maxX [private]

Is the maximun x-real value reacheable by the function.

Definition at line 867 of file pGraphicalFunction.h.

Referenced by setMaxX().

double pGraphicalFunction::_maxY [private]

Is the maximun y-real value reacheable by the function.

Definition at line 871 of file pGraphicalFunction.h.

Referenced by setMaxY().

double pGraphicalFunction::_minX [private]

Is the minimun x-real value reacheable by the function.

Definition at line 859 of file pGraphicalFunction.h.

Referenced by setMinX().

double pGraphicalFunction::_minY [private]

Is the minimun y-real value reacheable by the function.

Definition at line 863 of file pGraphicalFunction.h.

Referenced by setMinY().

double pGraphicalFunction::_offsetX [private]

Is the logical x-offset of the drawed function.

Definition at line 875 of file pGraphicalFunction.h.

Referenced by getOffsets(), getOffsetX(), setMinShowed(), setOffsets(), setOffsetX(), and zooming().

double pGraphicalFunction::_offsetY [private]

Is the logical y-offset of the drawed function.

Definition at line 879 of file pGraphicalFunction.h.

Referenced by getOffsets(), getOffsetY(), setMinShowed(), setOffsets(), setOffsetY(), and zooming().

double pGraphicalFunction::_scaleX [private]

Is the x-scale percentage according to the context device.

Definition at line 851 of file pGraphicalFunction.h.

Referenced by getScales(), getScaleX(), setOffsets(), setScaleX(), and zooming().

double pGraphicalFunction::_scaleY [private]

Is the y-scale percentage according to the context device.

Definition at line 855 of file pGraphicalFunction.h.

Referenced by getScales(), getScaleY(), setOffsets(), setScaleY(), and zooming().

double pGraphicalFunction::_startX [private]

Is the initial discrete point on x axis of the drawed function.

Definition at line 835 of file pGraphicalFunction.h.

Referenced by setStartX().

double pGraphicalFunction::_startY [private]

Is the initial discrete point on y axis of the drawed function.

Definition at line 839 of file pGraphicalFunction.h.

Referenced by setStartY().

int pGraphicalFunction::_type [private]

Is the way of how points are going to be connected. It could be smooth, line.

Definition at line 883 of file pGraphicalFunction.h.

Referenced by getType(), setType(), and vGetType().

bool pGraphicalFunction::drawing [private]

Indicates if the user is drawing the function

Definition at line 905 of file pGraphicalFunction.h.

Referenced by GetDrawing(), getDrawing(), and SetDrawing().

bool pGraphicalFunction::editable [private]

The function is editable

Definition at line 947 of file pGraphicalFunction.h.

Referenced by getEditable(), and setEditable().

std::vector<pColorPoint *> pGraphicalFunction::f_colorPoints [private]

Definition at line 891 of file pGraphicalFunction.h.

Referenced by getColorPoints(), and setColorPoints().

float pGraphicalFunction::factorZoom [private]

factorZoom

Definition at line 943 of file pGraphicalFunction.h.

Referenced by getFactorZoom(), setFactorZoom(), and setScales().

pFunctionPoint* pGraphicalFunction::finalDrawingPoint [private]

final drawing point

Definition at line 959 of file pGraphicalFunction.h.

Referenced by getFinallDrawPoint(), setFinalDrawPoint(), and zooming().

bool pGraphicalFunction::fromWindow [private]

if the function comes from window

Definition at line 939 of file pGraphicalFunction.h.

Referenced by AddNewPoint(), AddPoint(), changePoint(), DeletePoint(), deletePointAt(), getFromWindow(), getFromWindowV(), and setFromWindow().

bool pGraphicalFunction::ifActual [private]

if is the actual

Definition at line 925 of file pGraphicalFunction.h.

Referenced by getActual(), getIfActual(), and setActual().

pFunctionPoint* pGraphicalFunction::initialDrawingPoint [private]

initial drawing point

Definition at line 955 of file pGraphicalFunction.h.

Referenced by getInitialDrawPoint(), setInitialDrawPoint(), and zooming().

pLogicalFunction* pGraphicalFunction::logicFunction [private]

Represents the logical function asociated to this graphical function.

Definition at line 826 of file pGraphicalFunction.h.

Referenced by AddNewPoint(), AddPoint(), addSplinesPoints(), changePoint(), DeletePoint(), deletePointAt(), getBefore(), getDirection(), getEndX(), getEndY(), getIndexOf(), getMaxX(), getMaxY(), getMinX(), getMinY(), GetPointAt(), GetPoints(), getSizePoints(), GetSplinePoint(), getStartX(), getStartY(), getX_RealValues(), getY_RealValues(), initializeSplineVectors(), load(), Rewind(), save(), setEndX(), setEndY(), setMaxX(), setMaxY(), setMinShowed(), setMinX(), setMinY(), setOffsetX(), setOffsetY(), setScales(), setScaleX(), setScaleY(), setStartX(), setStartY(), setType(), setUp(), setValidPointRange(), validPointOnFunction(), and zooming().

int pPlotterLayer::m_flags [protected, inherited]

Holds label alignment.

Definition at line 224 of file pPlotterLayer.h.

wxFont mpLayer::m_font [protected, inherited]

Layer's font.

Definition at line 198 of file mathplot.h.

Referenced by pPlotterScaleY::Plot(), pPlotterScaleX::Plot(), mpScaleY::Plot(), mpScaleX::Plot(), mpFXY::Plot(), mpFY::Plot(), and mpFX::Plot().

wxString mpLayer::m_name [protected, inherited]

Layer's name.

Definition at line 200 of file mathplot.h.

Referenced by mpScaleY::Plot(), mpScaleX::Plot(), mpFXY::Plot(), mpFY::Plot(), and mpFX::Plot().

wxPen mpLayer::m_pen [protected, inherited]

Layer's pen.

Definition at line 199 of file mathplot.h.

Referenced by pPlotterScaleY::Plot(), pPlotterScaleX::Plot(), pPlotterLayer::Plot(), mpScaleY::Plot(), mpScaleX::Plot(), mpFXY::Plot(), mpFY::Plot(), and mpFX::Plot().

int pGraphicalFunction::maxShowedX [private]

Maximum point showed to the user (zoom)X

Definition at line 969 of file pGraphicalFunction.h.

Referenced by getMaxXShowed(), setMaxShowedX(), and setScales().

int pGraphicalFunction::maxShowedY [private]

Maximum point showed to the user (zoom)X

Definition at line 979 of file pGraphicalFunction.h.

Referenced by getMaxYShowed(), setMaxShowedY(), and setScales().

int pGraphicalFunction::minShowedX [private]

Minimum point showed to the user (zoom)X

Definition at line 964 of file pGraphicalFunction.h.

Referenced by getMinXShowed(), setMinShowedX(), setOffsets(), and setScales().

int pGraphicalFunction::minShowedY [private]

Minimum point showed to the user (zoom)Y

Definition at line 974 of file pGraphicalFunction.h.

Referenced by getMinYShowed(), setMinShowedY(), setOffsets(), and setScales().

wxPoint pGraphicalFunction::mousePoint [private]

this is for the graphical function Mouse Point

Definition at line 911 of file pGraphicalFunction.h.

Referenced by getMousePoint(), and SetMousePoint().

int pGraphicalFunction::mType [private]

Definition at line 1009 of file pGraphicalFunction.h.

Referenced by getmType(), and setmType().

wxNode* pGraphicalFunction::node [private]

node of the realPoints where are we

Definition at line 896 of file pGraphicalFunction.h.

Referenced by addSplinesPoints(), getBefore(), GetNextXY(), Rewind(), and setMinShowed().

int pGraphicalFunction::offsetPixelX [private]

offset in pixels where the user has clicked before changing the scale

Definition at line 1001 of file pGraphicalFunction.h.

Referenced by getOffsetPixelsX(), getOffsetPixelsXv(), setOffsetPixelX(), and setOffsets().

int pGraphicalFunction::offsetPixelY [private]

Definition at line 1002 of file pGraphicalFunction.h.

Referenced by getOffsetPixelsY(), getOffsetPixelsYv(), setOffsetPixelY(), and setOffsets().

int pPlotterLayer::offsetX [protected, inherited]

offset X

Definition at line 244 of file pPlotterLayer.h.

Referenced by pPlotterLayer::drawFunction(), pPlotterLayer::drawLineToMousePoint(), pPlotterLayer::drawPoints(), pPlotterLayer::drawSplineCurve(), pPlotterScaleX::Plot(), and pPlotterLayer::Plot().

int pPlotterLayer::offsetY [protected, inherited]

offset Y

Definition at line 249 of file pPlotterLayer.h.

Referenced by pPlotterLayer::drawFunction(), pPlotterLayer::drawLineToMousePoint(), pPlotterLayer::drawPoints(), pPlotterLayer::drawSplineCurve(), getOffsets(), pPlotterScaleY::Plot(), and pPlotterLayer::Plot().

wxList pPlotterLayer::points [protected, inherited]

Definition at line 231 of file pPlotterLayer.h.

Referenced by pPlotterLayer::drawFunction(), pPlotterLayer::drawLineToMousePoint(), and pPlotterLayer::drawPoints().

wxList pGraphicalFunction::realPoints [private]

The list of the function points

Definition at line 887 of file pGraphicalFunction.h.

int pGraphicalFunction::scaleWay [private]

the way we scale DEFECT_SCALE 1 MAX_SCALE 2 USER_SCALE 3

Definition at line 934 of file pGraphicalFunction.h.

Referenced by getScaleWay(), and setScaleWay().

double pPlotterLayer::scaleX [protected, inherited]

Definition at line 235 of file pPlotterLayer.h.

Referenced by pPlotterLayer::drawFunction(), pPlotterLayer::drawLineToMousePoint(), pPlotterLayer::drawPoints(), pPlotterLayer::drawSplineCurve(), pPlotterScaleX::Plot(), pPlotterLayer::Plot(), and setScales().

double pPlotterLayer::scaleY [protected, inherited]

Definition at line 239 of file pPlotterLayer.h.

Referenced by pPlotterLayer::drawFunction(), pPlotterLayer::drawLineToMousePoint(), pPlotterLayer::drawPoints(), pPlotterLayer::drawSplineCurve(), pPlotterScaleY::Plot(), pPlotterLayer::Plot(), and setScales().

int pGraphicalFunction::screenX [private]

The size of the screen in X

Definition at line 916 of file pGraphicalFunction.h.

Referenced by getScreens(), getScreenX(), setScales(), setScreens(), and setScreenX().

int pGraphicalFunction::screenY [private]

The size of the screen in Y

Definition at line 921 of file pGraphicalFunction.h.

Referenced by getScreens(), getScreenY(), setScales(), setScreens(), and setScreenY().

bool pGraphicalFunction::showPointsF [private]

If the function has to showpoints

Definition at line 830 of file pGraphicalFunction.h.

Referenced by getShowPoints(), ifShowPoints(), and SetShowPoints().

int pGraphicalFunction::validPointRange [private]

Number that determines the radius range for the valid area the point (sensible radius). Default value 5.

Definition at line 900 of file pGraphicalFunction.h.

Referenced by getValidPointRange(), and setValidPointRange().

vtkKochanekSpline* pGraphicalFunction::xKSpline [private]

Definition at line 992 of file pGraphicalFunction.h.

Referenced by addSplinesPoints(), GetSplinePoint(), and initializeSplines().

std::vector<double> pGraphicalFunction::xSpline [private]

Definition at line 985 of file pGraphicalFunction.h.

Referenced by clearSplineVectors(), getXSpline(), and initializeSplineVectors().

int pGraphicalFunction::xTraslation [private]

Definition at line 1014 of file pGraphicalFunction.h.

Referenced by getXTraslation(), and setXTraslation().

vtkKochanekSpline* pGraphicalFunction::yKSpline [private]

Definition at line 994 of file pGraphicalFunction.h.

Referenced by addSplinesPoints(), GetSplinePoint(), and initializeSplines().

std::vector<double> pGraphicalFunction::ySpline [private]

Definition at line 987 of file pGraphicalFunction.h.

Referenced by clearSplineVectors(), getYSpline(), and initializeSplineVectors().

bool pGraphicalFunction::zoomIn [private]

if the user did a zoom in/out

Definition at line 951 of file pGraphicalFunction.h.

Referenced by getZoomB(), setZoomIn(), and zooming().

The documentation for this class was generated from the following files:

/Users/davila/Creatis/creaMaracasVisu/lib/maracasVisuLib/src/interface/wxWindows/widgets/pPlotter/pGraphicalFunction.h
/Users/davila/Creatis/creaMaracasVisu/lib/maracasVisuLib/src/interface/wxWindows/widgets/pPlotter/pGraphicalFunction.cxx


Public Member Functions
	pGraphicalFunction (wxString name=wxEmptyString, int flags=0x00)
	~pGraphicalFunction ()
virtual int	getXTraslation ()
virtual int	getmType ()
virtual int	vGetType ()
virtual void	getOffsets (int &offsetX, int &offSetY)
virtual void	getFactorZoom (float &fz)
virtual void	getFromWindowV (bool &fw)
virtual void	getIfActual (bool &actual)
virtual void	getMax (int &maxX, int &maxY)
virtual void	getMaxShowed (int &maxX, int &maxY)
virtual void	getMinShowed (int &minX, int &minY)
virtual void	getScreens (int &scrX, int &scrY)
virtual void	setScreens (int scrX, int scrY)
virtual void	getScales (double &scaleX, double &scaleY)
virtual void	getDrawing (bool &draw)
virtual void	ifShowPoints (bool &show)
virtual void	Rewind ()
virtual bool	GetNextXY (double &x, double &y)
virtual void	GetPoints (wxList &points)
virtual void	getMousePoint (int &x, int &y)
virtual void	getSize (int &size)
virtual void	getDirection (bool &dir)
int	validPointOnFunction (wxPoint realPoint)
int	getIndexOf (wxPoint realpoint)
wxNode *	GetPointAt (int movingPointIndex)
bool	AddNewPoint (int x, int y)
bool	AddPoint (int aX, int aY, bool order=true)
bool	DeletePoint (int aX, int aY)
bool	changePoint (wxPoint newCoords, int movingIndexPoint)
double *	getX_RealValues ()
double *	getY_RealValues ()
bool	orderPoints ()
bool	deletePointAt (int index)
int	getSizePoints ()
void	setScales ()
bool	isInFunction (int x, int y)
wxNode *	getBefore (pFunctionPoint *point)
bool	isInLine (pFunctionPoint before, pFunctionPoint next, pFunctionPoint *point)
double	interpolateY (double m, int x1, int y1, int x)
void	setUp ()
void	clearSplineVectors ()
void	initializeSplines ()
void	addSplinesPoints ()
void	initializeSplineVectors ()
void	GetSplinePoint (double t, double &x, double &y)
virtual std::vector< double >	getXSpline ()
virtual std::vector< double >	getYSpline ()
virtual int	getOffsetPixelsXv ()
virtual int	getOffsetPixelsYv ()
void	save (wxString fileName)
void	load (wxString fileName)
void	SetShowPoints (bool showPoints)
bool	getShowPoints ()
void	setScreenX (int scrX)
int	getScreenX ()
void	setScreenY (int scrY)
int	getScreenY ()
void	setStartX (double aStartX)
double	getStartX ()
void	setStartY (double aStartY)
double	getStartY ()
void	setEndX (double aEndX)
double	getEndX ()
void	setEndY (double aEndY)
double	getEndY ()
void	setScaleX (double aScaleX)
double	getScaleX ()
void	setScaleY (double aScaleY)
double	getScaleY ()
void	setMinX (double aMinX)
double	getMinX ()
void	setMinY (double aMinY)
double	getMinY ()
void	setMaxX (double aMaxX)
double	getMaxX ()
void	setMaxY (double aMaxY)
double	getMaxY ()
void	setOffsetX (double aOffsetX)
double	getOffsetX ()
void	setOffsetY (double aOffsetY)
double	getOffsetY ()
void	setType (int aType)
int	getType ()
int	getValidPointRange ()
void	setValidPointRange (int theRange)
void	SetDrawing (bool d)
bool	GetDrawing ()
void	SetMousePoint (wxPoint p)
wxPoint	getMousePoint ()
void	setActual (bool act)
bool	getActual ()
void	setScaleWay (int typeS)
int	getScaleWay ()
void	setFromWindow (bool w)
bool	getFromWindow ()
void	setFactorZoom (float factor)
void	setEditable (bool edit)
bool	getEditable ()
bool	getZoomB ()
void	setZoomIn (bool z)
void	setInitialDrawPoint (pFunctionPoint *initialPoint)
pFunctionPoint *	getInitialDrawPoint ()
void	setFinalDrawPoint (pFunctionPoint *finalPoint)
pFunctionPoint *	getFinallDrawPoint ()
void	zooming (int clickedX, int clickedY, int width)
void	setOffsets (int offx, int offy)
void	setMinShowed ()
int	getMinXShowed ()
int	getMinYShowed ()
int	getMaxXShowed ()
int	getMaxYShowed ()
void	setMinShowedX (int msx)
void	setMinShowedY (int msy)
void	setMaxShowedX (int msx)
void	setMaxShowedY (int msy)
int	getOffsetPixelsX ()
int	getOffsetPixelsY ()
void	setOffsetPixelX (int offX)
void	setOffsetPixelY (int offY)
void	setColorPoints (std::vector< pColorPoint * > &colorVector)
void	getColorPoints (std::vector< pColorPoint * > &colorVector)
void	setmType (int mt)
void	setXTraslation (int xT)
bool	initializePolygon (wxPoint *points, double x1, double y1, double x2, double y2)
void	draw (wxDC &dc, mpWindow &w, double x1, double y1, double x2, double y2)
void	drawSplineCurve (wxDC &dc, mpWindow &w)
void	drawLineToMousePoint (wxDC &dc, mpWindow &w)
void	drawFunction (wxDC &dc, mpWindow &w)
void	drawPoints (wxDC &dc, mpWindow &w)
virtual void	Plot (wxDC &dc, mpWindow &w)
virtual bool	HasBBox ()
virtual double	GetMinX ()
virtual double	GetMaxX ()
virtual double	GetMinY ()
virtual double	GetMaxY ()
wxString	GetName () const
const wxFont &	GetFont () const
const wxPen &	GetPen () const
void	SetName (wxString name)
void	SetFont (wxFont &font)
void	SetPen (wxPen &pen)
Protected Attributes
int	m_flags
	Holds label alignment.
wxList	points
double	scaleX
double	scaleY
int	offsetX
int	offsetY
wxFont	m_font
	Layer's font.
wxPen	m_pen
	Layer's pen.
wxString	m_name
	Layer's name.
Private Attributes
pLogicalFunction *	logicFunction
bool	showPointsF
double	_startX
double	_startY
double	_endX
double	_endY
double	_scaleX
double	_scaleY
double	_minX
double	_minY
double	_maxX
double	_maxY
double	_offsetX
double	_offsetY
int	_type
wxList	realPoints
std::vector< pColorPoint * >	f_colorPoints
wxNode *	node
int	validPointRange
bool	drawing
wxPoint	mousePoint
int	screenX
int	screenY
bool	ifActual
int	scaleWay
bool	fromWindow
float	factorZoom
bool	editable
bool	zoomIn
pFunctionPoint *	initialDrawingPoint
pFunctionPoint *	finalDrawingPoint
int	minShowedX
int	maxShowedX
int	minShowedY
int	maxShowedY
std::vector< double >	xSpline
std::vector< double >	ySpline
vtkKochanekSpline *	xKSpline
vtkKochanekSpline *	yKSpline
int	offsetPixelX
int	offsetPixelY
int	mType
int	xTraslation