pLogicalFunction Class Reference

#include <pLogicalFunction.h>

List of all members.

Public Member Functions
	pLogicalFunction ()
	~pLogicalFunction ()
void	GetPoints (wxList &points)
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 ()
void	setStartPoints ()
void	setEndPoints ()
void	setMaxPoints ()
void	setMinPoints ()
void	setUp ()
void	save (wxString fileName)
void	load (wxString fileName)
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)
bool	deletePointAt (int index)
int	getSizePoints ()
void	getDirection (bool &dir)
Private Attributes
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
double	x_Values [50]
double	y_Values [50]
int	validPointRange
bool	leftToRigthDef

---

Detailed Description

Definition at line 40 of file pLogicalFunction.h.

---

Constructor & Destructor Documentation

pLogicalFunction::pLogicalFunction

(

)

Definition at line 29 of file pLogicalFunction.cxx.

{

        realPoints.DeleteContents(TRUE); 
        validPointRange = 5;
        leftToRigthDef = true;
        _maxX=0;
        _maxY=0;
        _minX=0;
        _minY=0;
}

pLogicalFunction::~pLogicalFunction

(

)

Is the destructor!!!

Definition at line 43 of file pLogicalFunction.cxx.

References realPoints.

{
        realPoints.DeleteContents(TRUE);
}

---

Member Function Documentation

void pLogicalFunction::GetPoints

(

wxList &

points

)

[inline]

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

Parameters:

	x	Returns X value
	y	Returns Y value Get Point list of the funcion
	return	points

Definition at line 84 of file pLogicalFunction.h.

References realPoints.

Referenced by pGraphicalFunction::GetPoints().

        {
                points = realPoints;
        }  

Here is the caller graph for this function:

int pLogicalFunction::validPointOnFunction

(

wxPoint

realPoint

)

Definition at line 51 of file pLogicalFunction.cxx.

References _scaleX, _scaleY, pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), realPoints, and SENSIBLE_REGION.

{
        int pointIndex = -1;
        wxNode* node= realPoints.GetFirst();
        while(node && pointIndex==-1)
        {
                pFunctionPoint* point=(pFunctionPoint*)node->GetData();
                int x = point->getRealX();
                int y = point->getRealY();
                double  vx=SENSIBLE_REGION/_scaleX;
                double vy=SENSIBLE_REGION/_scaleY;

                bool isInXRange= realPoint.x <= x + vx + SENSIBLE_REGION  && realPoint.x >= x - vx-SENSIBLE_REGION;
                bool isInYRange= realPoint.y <= y + vy + SENSIBLE_REGION && realPoint.y >= y - vy-SENSIBLE_REGION;
                if(isInXRange && isInYRange)
                        pointIndex = realPoints.IndexOf(point);

                node = node->GetNext();
        }
        return pointIndex;
}

Here is the call graph for this function:

int pLogicalFunction::getIndexOf

(

wxPoint

realpoint

)

Definition at line 78 of file pLogicalFunction.cxx.

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

{
        wxNode* node= realPoints.GetFirst();
        while(node)
        {
                pFunctionPoint* point=(pFunctionPoint*)node->GetData();
                if(point->getRealX()==realpoint.x && point->getRealY()==realpoint.y )
                {
                        return realPoints.IndexOf(point);
                }

                node= node->GetNext();
        }
        return -1;

}

Here is the call graph for this function:

wxNode * pLogicalFunction::GetPointAt

(

int

movingPointIndex

)

Definition at line 100 of file pLogicalFunction.cxx.

References realPoints.

Referenced by pGraphicalFunction::addSplinesPoints(), changePoint(), deletePointAt(), pGraphicalFunction::getBefore(), pGraphicalFunction::Rewind(), pGraphicalFunction::setMinShowed(), and pGraphicalFunction::zooming().

{
        if(!realPoints.IsEmpty())
        {       
                wxNode* node= realPoints.Item(movingPointIndex);
                return node;
        }
        else
                return NULL;
}

Here is the caller graph for this function:

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

Definition at line 115 of file pLogicalFunction.cxx.

References orderPoints(), and realPoints.

{
        pFunctionPoint * newPoint = new pFunctionPoint ( x, y);
        bool includedPoint = realPoints.Append(newPoint)!=NULL;
        if(includedPoint)
        {
            bool order=orderPoints();
                return order; 
        }
        return includedPoint;
}

Here is the call graph for this function:

bool pLogicalFunction::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 248 of file pLogicalFunction.cxx.

References pFunctionPoint::getRealX(), leftToRigthDef, orderPoints(), and realPoints.

Referenced by load().

{       
        pFunctionPoint * newPoint = new pFunctionPoint (aX, aY);
        wxNode* lastNode = realPoints.GetLast();
        bool addedPoint = false;
        if (lastNode)
        {
                pFunctionPoint* lastPoint = (pFunctionPoint*)lastNode->GetData();               
                if( lastPoint->getRealX() != aX )
                {
                        addedPoint = realPoints.Append(newPoint)!=NULL;
                        //In case that the definition of points is being done backwards.
                        if( (aX < (lastPoint->getRealX()) ) && addedPoint )
                        {
                                if( realPoints.GetCount() == 2 )
                                {
                                        leftToRigthDef = false;                                 
                                }
                        if(order)
                                addedPoint = orderPoints();     
                        
                        }
                        else
                        {
                                if( realPoints.GetCount() == 2 )
                                {
                                        leftToRigthDef = true;                                  
                                }                       
                        }
                }                
        }
        else
        {
                addedPoint = realPoints.Append(newPoint)!=NULL;         
        }
        
        return addedPoint;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool pLogicalFunction::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 USE

Definition at line 414 of file pLogicalFunction.cxx.

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

{
        wxNode* node= realPoints.GetFirst();
        while(node)
        {
                pFunctionPoint* point=(pFunctionPoint*)node->GetData();
                if(point->getRealX()==aX && point->getRealY()==aY)
                {
                        realPoints.Erase(node);
                        return true;
                }
                node= node->GetNext();
        }

        return false;
}

Here is the call graph for this function:

bool pLogicalFunction::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 460 of file pLogicalFunction.cxx.

References GetPointAt(), pFunctionPoint::getRealX(), and realPoints.

{
        wxNode* changingNode = GetPointAt(movingIndexPoint);
        bool validChange = false; 
        int newX = newCoords.x;
        int newY = newCoords.y;
        pFunctionPoint* changingPoint = (pFunctionPoint*)changingNode -> GetData();
        bool hasPrevious = movingIndexPoint>0;
        bool hasNext = movingIndexPoint < realPoints.size()-1;
        
        wxNode* prevNode = hasPrevious ? changingNode ->GetPrevious() : NULL;
        wxNode* nextNode = hasNext ? changingNode -> GetNext() : NULL;
        
        if( hasPrevious )
        {
                pFunctionPoint* prevPoint = (pFunctionPoint*)prevNode -> GetData();
                if ( hasNext )
                {
                        pFunctionPoint* nextPoint = (pFunctionPoint*) nextNode -> GetData();
                        validChange = ((prevPoint->getRealX()) < newX) && ((nextPoint->getRealX()) > newX);
                        if ( (prevPoint->getRealX()) > newX )
                        {
                                newX = prevPoint->getRealX()+1;
                                validChange = true;
                        }
                        else if ( (nextPoint->getRealX()) < newX )
                        {
                                newX = nextPoint->getRealX()-1;
                                validChange = true;
                        }
                }
                else
                {
                        // Is the last point of the function.
                        if ( (prevPoint->getRealX()) < newX )
                        {
                                validChange = true;
                        }
                        else
                        {
                                newX = prevPoint->getRealX();
                                validChange = true;
                        }
                }               
        }       
        else
        {
                if ( hasNext )
                {
                        // Is the first point of the function.
                        pFunctionPoint* nextPoint = (pFunctionPoint*) nextNode -> GetData();
                        if ((nextPoint->getRealX()) > newX )
                        {
                                validChange = true;
                        }
                        else
                        {
                                newX = nextPoint->getRealX();
                                validChange = true;
                        }
                }               
        }
        if( validChange )
        {
                changingPoint -> setRealX( newX );
                changingPoint -> setRealY( newY );
        }
        return validChange;
}

Here is the call graph for this function:

double * pLogicalFunction::getX_RealValues

(

)

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

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 553 of file pLogicalFunction.cxx.

References realPoints, and x_Values.

{
        wxNode *nextNode = realPoints.GetFirst();
        int size = realPoints.GetCount();
        double * x_Values;
        int i=0;

        x_Values= new double[size];

        while (nextNode)
        {
                pFunctionPoint* nextPoint = (pFunctionPoint*)nextNode->GetData();
                x_Values[i] = nextPoint-> getRealX();
                nextNode = nextNode->GetNext();
                i++;
        }
        return x_Values;
}

double * pLogicalFunction::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 575 of file pLogicalFunction.cxx.

References realPoints, and y_Values.

{  
        wxNode *nextNode = realPoints.GetFirst();
        int i =0;
        int size = realPoints.GetCount();
        double * y_Values;

        y_Values= new double[size];

        while (nextNode)
        {
                pFunctionPoint*  nextPoint = (pFunctionPoint*)nextNode->GetData();
                y_Values[i] = nextPoint-> getRealY();
                nextNode = nextNode->GetNext();
                i++;
        }
        return y_Values;
}

bool pLogicalFunction::orderPoints

(

)

Definition at line 130 of file pLogicalFunction.cxx.

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

Referenced by AddNewPoint(), and AddPoint().

{
        bool lastOrdered = false;
        bool validToContinue = false;

        wxNode* lastNodeIncluded = realPoints.GetLast();

        wxNode* node = realPoints.GetFirst();
        pFunctionPoint* lastPointIncluded = (pFunctionPoint*)lastNodeIncluded -> GetData();             
        int xToOrder = lastPointIncluded -> getRealX();
        int actualX;
        int nextX;

        // Used for validating 'leftToRigthDef'
        pFunctionPoint* ordFirstPoint = (pFunctionPoint*)realPoints.GetFirst()-> GetData();
        pFunctionPoint* ordLastPoint = (pFunctionPoint*)(lastNodeIncluded->GetPrevious())-> GetData();


        // Normal drawing
        if (leftToRigthDef)
        {
                validToContinue = ordFirstPoint->getRealX() < xToOrder; 
        }
        else
        {
                //validToContinue =ordFirstPoint->getRealX() >  xToOrder;
                validToContinue =ordLastPoint->getRealX() >  xToOrder;
        }

        if ( validToContinue)
        {               

                while( node && !lastOrdered )
                {
                        pFunctionPoint* prevPoint =(pFunctionPoint*)node->GetData();
                        actualX = prevPoint ->getRealX();
                        if( actualX == xToOrder)
                        {
                                realPoints.DeleteNode(lastNodeIncluded);
                                lastOrdered = false;
                        }
                        else if ( actualX < xToOrder )
                        {
                                //firstNode
                                wxNode* nextNode = node->GetNext();
                                pFunctionPoint* nextPoint;
                                if( nextNode != lastNodeIncluded )                      
                                {
                                        nextPoint = (pFunctionPoint*)nextNode -> GetData();     
                                        nextX = nextPoint->getRealX();
                                        int nextIndex = realPoints.IndexOf(nextPoint);
                                        if( nextX > xToOrder )
                                        {
                                                //we need to change the direction in memory of our node
                                                pFunctionPoint* pointToInsert=new pFunctionPoint(lastPointIncluded->getRealX(),lastPointIncluded->getRealY());
                                                // The last inserted point is ordered like: prevPoint - lastPointIncluded - nextPoint
                                                lastOrdered = (realPoints.Insert(nextIndex, pointToInsert))!= NULL;
                                                bool lastNodeDeleted=realPoints.DeleteNode(lastNodeIncluded);
                                                return lastOrdered && lastNodeDeleted;

                                        }

                                }
                                else 
                                {
                                        lastOrdered = true;
                                }
                        }
                        else 
                        {
                                //firstNode
                                wxNode* prevNode = node->GetPrevious();
                                int insertIndex=realPoints.IndexOf(prevPoint);
                                pFunctionPoint* prPoint;
                                if(prevNode)
                                {
                                        prPoint = (pFunctionPoint*)prevNode -> GetData();       
                                        int beforeX =prPoint->getRealX();
                                        if( beforeX < xToOrder)
                                        {
                                                //we need to change the direction in memory of our node
                                                pFunctionPoint* pointToInsert=new pFunctionPoint(lastPointIncluded->getRealX(),lastPointIncluded->getRealY());
                                                // The last inserted point is ordered like: prevPoint - lastPointIncluded - nextPoint
                                                lastOrdered = (realPoints.Insert(insertIndex, pointToInsert))!= NULL;
                                                bool lastNodeDeleted=realPoints.DeleteNode(lastNodeIncluded);
                                                return lastOrdered && lastNodeDeleted;
                                        }
                                }
                                //is just the second point
                                else
                                {
                                        //we need to change the direction in memory of our node
                                        pFunctionPoint* pointToInsert=new pFunctionPoint(lastPointIncluded->getRealX(),lastPointIncluded->getRealY());
                                        // The last inserted point is ordered like: prevPoint - lastPointIncluded - nextPoint
                                        lastOrdered = (realPoints.Insert(insertIndex, pointToInsert))!= NULL;
                                        bool lastNodeDeleted=realPoints.DeleteNode(lastNodeIncluded);
                                        return lastOrdered && lastNodeDeleted;
                                }
                        }

                        node = node->GetNext();
                }

        }
        else
        {
                bool lastNodeDeleted = realPoints.DeleteNode(lastNodeIncluded);
                lastOrdered = lastOrdered && lastNodeDeleted;
        }
        return lastOrdered;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pLogicalFunction::setStartPoints

(

)

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	IS NOT USED

Definition at line 306 of file pLogicalFunction.cxx.

References pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), realPoints, setStartX(), and setStartY().

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

{
  wxNode* first=realPoints.GetFirst();
  if(first)
        {
          pFunctionPoint* startPoint=(pFunctionPoint*)first->GetData();
          setStartX(startPoint->getRealX());
          setStartY(startPoint->getRealY());
        }
  else
  {
          setStartX(-1);
          setStartY(-1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pLogicalFunction::setEndPoints

(

)

Definition at line 324 of file pLogicalFunction.cxx.

References pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), realPoints, setEndX(), and setEndY().

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

{
  wxNode* last=realPoints.GetLast();
  if(last)
  {
          pFunctionPoint* lastPoint=(pFunctionPoint*)last->GetData();
          setEndX(lastPoint->getRealX());
          setEndY(lastPoint->getRealY());
  }
  else
  {
          setEndX(-1);
          setEndY(-1);
  
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pLogicalFunction::setMaxPoints

(

)

Definition at line 378 of file pLogicalFunction.cxx.

References pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), realPoints, setMaxX(), and setMaxY().

Referenced by setUp().

{
    int maxX,maxY;  
        wxNode* node=realPoints.GetFirst();
        if(node)
        {
                pFunctionPoint* point=(pFunctionPoint*)node->GetData();
                maxX=point->getRealX();
                maxY=point->getRealY();
                wxNode* nextNode=node->GetNext();
                while(nextNode)
                        {
                                point=(pFunctionPoint*)nextNode->GetData();
                                int x=point->getRealX();
                                int y=point->getRealY();
                                if(x>maxX)
                                        maxX=x;
                                if(y>maxY)
                                        maxY=y;
                                nextNode=nextNode->GetNext();
                        }
                setMaxX(maxX);
                setMaxY(maxY);
        }
        else
        {
                setMaxX(0);
                setMaxY(0);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pLogicalFunction::setMinPoints

(

)

Definition at line 344 of file pLogicalFunction.cxx.

References pFunctionPoint::getRealX(), pFunctionPoint::getRealY(), realPoints, setMinX(), and setMinY().

Referenced by setUp().

{
    int minX,minY;  
        wxNode* node=realPoints.GetFirst();
        if(node)
        {
                pFunctionPoint* point=(pFunctionPoint*)node->GetData();
                minX=point->getRealX();
                minY=point->getRealY();
                wxNode* nextNode=node->GetNext();
                while(nextNode)
                        {
                                point=(pFunctionPoint*)nextNode->GetData();
                                int x=point->getRealX();
                                int y=point->getRealY();
                                if(x<minX)
                                        minX=x;
                                if(y<minY)
                                        minY=y;
                                nextNode=nextNode->GetNext();
                        }
                setMinX(minX);
                setMinY(minY);
        }
        else
        {
                setMinX(0);
                setMinY(0);
        }
                
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pLogicalFunction::setUp

(

)

Definition at line 290 of file pLogicalFunction.cxx.

References setEndPoints(), setMaxPoints(), setMinPoints(), and setStartPoints().

Referenced by pGraphicalFunction::load(), and pGraphicalFunction::setUp().

{
        //sets the start point of the function
        setStartPoints();
        //set the Last point of the function
        setEndPoints();
        //set the min value in x and y between all the points of the function
        setMinPoints();
        //set the max value in x and y between all the points of the function
        setMaxPoints();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pLogicalFunction::save

(

wxString

fileName

)

Definition at line 605 of file pLogicalFunction.cxx.

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

Referenced by pGraphicalFunction::save().

{

        std::ofstream file;
        file.open( (const char*)(fileName.mb_str()) );
        if(file.is_open())
        {
                file << getSizePoints()<< std::endl;
                wxNode* node= realPoints.GetFirst();
                pFunctionPoint* p;
                while(node)
                {
                        p=(pFunctionPoint*)node->GetData();
                        file <<p->getRealX()<<"\t"<<p->getRealY()<<std::endl;
                        node=node->GetNext();
                }
        }
        file.close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pLogicalFunction::load

(

wxString

fileName

)

Definition at line 627 of file pLogicalFunction.cxx.

References AddPoint().

Referenced by pGraphicalFunction::load().

{
        std::string line;
        std::ifstream file;
        file.open( (const char*)(fileName.mb_str()) );
        
        if(file.is_open())
        {
                std::getline(file,line);
                int nPoints=atoi(line.c_str());
                int i=0;
                while(!file.eof() && i<nPoints)
                {
                        std::getline(file,line);
                        int pos=line.find("\t");
                        int size=line.size();
                        std::string x=line.substr(0,pos);
                        std::string y=line.substr(pos+1,size);
                        int x0=atoi(x.c_str());
                        int y0=atoi(y.c_str());
                        AddPoint(x0,y0);
                        i++;

                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pLogicalFunction::setStartX

(

double

aStartX

)

Definition at line 662 of file pLogicalFunction.cxx.

References _startX.

Referenced by setStartPoints(), and pGraphicalFunction::setStartX().

                                               {
        this->_startX = aStartX;
}

Here is the caller graph for this function:

double pLogicalFunction::getStartX

(

)

Definition at line 666 of file pLogicalFunction.cxx.

References _startX.

Referenced by pGraphicalFunction::getStartX(), pGraphicalFunction::setStartX(), and pGraphicalFunction::setUp().

                                   {
        return this->_startX;
}

Here is the caller graph for this function:

void pLogicalFunction::setStartY

(

double

aStartY

)

Definition at line 670 of file pLogicalFunction.cxx.

References _startY.

Referenced by setStartPoints(), and pGraphicalFunction::setStartY().

                                               {
        this->_startY = aStartY;
}

Here is the caller graph for this function:

double pLogicalFunction::getStartY

(

)

Definition at line 674 of file pLogicalFunction.cxx.

References _startY.

Referenced by pGraphicalFunction::getStartY(), and pGraphicalFunction::setUp().

                                   {
        return this->_startY;
}

Here is the caller graph for this function:

void pLogicalFunction::setEndX

(

double

aEndX

)

Definition at line 681 of file pLogicalFunction.cxx.

References _endX.

Referenced by setEndPoints(), and pGraphicalFunction::setEndX().

                                           {
        this->_endX = aEndX;
}

Here is the caller graph for this function:

double pLogicalFunction::getEndX

(

)

Definition at line 685 of file pLogicalFunction.cxx.

References _endX.

Referenced by pGraphicalFunction::getEndX(), and pGraphicalFunction::setUp().

                                 {
        return this->_endX;
}

Here is the caller graph for this function:

void pLogicalFunction::setEndY

(

double

aEndY

)

Definition at line 689 of file pLogicalFunction.cxx.

References _endY.

Referenced by setEndPoints(), and pGraphicalFunction::setEndY().

                                           {
        this->_endY = aEndY;
}

Here is the caller graph for this function:

double pLogicalFunction::getEndY

(

)

Definition at line 693 of file pLogicalFunction.cxx.

References _endY.

Referenced by pGraphicalFunction::getEndY(), and pGraphicalFunction::setUp().

                                 {
        return this->_endY;
}

Here is the caller graph for this function:

void pLogicalFunction::setScaleX

(

double

aScaleX

)

Definition at line 699 of file pLogicalFunction.cxx.

References _scaleX.

Referenced by pGraphicalFunction::setScales(), and pGraphicalFunction::setScaleX().

                                               {
        this->_scaleX = aScaleX;
}

Here is the caller graph for this function:

double pLogicalFunction::getScaleX

(

)

Definition at line 703 of file pLogicalFunction.cxx.

References _scaleX.

                                   {
        return this->_scaleX;
}

void pLogicalFunction::setScaleY

(

double

aScaleY

)

Definition at line 707 of file pLogicalFunction.cxx.

References _scaleY.

Referenced by pGraphicalFunction::setScales(), and pGraphicalFunction::setScaleY().

                                               {
        this->_scaleY = aScaleY;
}

Here is the caller graph for this function:

double pLogicalFunction::getScaleY

(

)

Definition at line 711 of file pLogicalFunction.cxx.

References _scaleY.

                                   {
        return this->_scaleY;
}

void pLogicalFunction::setMinX

(

double

aMinX

)

Definition at line 717 of file pLogicalFunction.cxx.

References _minX.

Referenced by setMinPoints(), and pGraphicalFunction::setMinX().

                                           {
        this->_minX = aMinX;
}

Here is the caller graph for this function:

double pLogicalFunction::getMinX

(

)

Definition at line 721 of file pLogicalFunction.cxx.

References _minX.

Referenced by pGraphicalFunction::getMinX(), pGraphicalFunction::load(), and pGraphicalFunction::setUp().

                                 {
        return this->_minX;
}

Here is the caller graph for this function:

void pLogicalFunction::setMinY

(

double

aMinY

)

Definition at line 725 of file pLogicalFunction.cxx.

References _minY.

Referenced by setMinPoints(), and pGraphicalFunction::setMinY().

                                           {
        this->_minY = aMinY;
}

Here is the caller graph for this function:

double pLogicalFunction::getMinY

(

)

Definition at line 729 of file pLogicalFunction.cxx.

References _minY.

Referenced by pGraphicalFunction::getMinY(), pGraphicalFunction::load(), and pGraphicalFunction::setUp().

                                 {
        return this->_minY;
}

Here is the caller graph for this function:

void pLogicalFunction::setMaxX

(

double

aMaxX

)

Definition at line 735 of file pLogicalFunction.cxx.

References _maxX.

Referenced by setMaxPoints(), and pGraphicalFunction::setMaxX().

                                           {
        this->_maxX = aMaxX;
}

Here is the caller graph for this function:

double pLogicalFunction::getMaxX

(

)

Definition at line 739 of file pLogicalFunction.cxx.

References _maxX.

Referenced by pGraphicalFunction::getMaxX(), pGraphicalFunction::load(), and pGraphicalFunction::setUp().

                                 {
        return this->_maxX;
}

Here is the caller graph for this function:

void pLogicalFunction::setMaxY

(

double

aMaxY

)

Definition at line 743 of file pLogicalFunction.cxx.

References _maxY.

Referenced by setMaxPoints(), and pGraphicalFunction::setMaxY().

                                           {
        this->_maxY = aMaxY;
}

Here is the caller graph for this function:

double pLogicalFunction::getMaxY

(

)

Definition at line 747 of file pLogicalFunction.cxx.

References _maxY.

Referenced by pGraphicalFunction::getMaxY(), pGraphicalFunction::load(), and pGraphicalFunction::setUp().

                                 {
        return this->_maxY;
}

Here is the caller graph for this function:

void pLogicalFunction::setOffsetX

(

double

aOffsetX

)

Definition at line 754 of file pLogicalFunction.cxx.

References _offsetX.

Referenced by pGraphicalFunction::setOffsetX().

                                                 {
        this->_offsetX = aOffsetX;
}

Here is the caller graph for this function:

double pLogicalFunction::getOffsetX

(

)

Definition at line 758 of file pLogicalFunction.cxx.

References _offsetX.

                                     {
        return this->_offsetX;
}

void pLogicalFunction::setOffsetY

(

double

aOffsetY

)

Definition at line 762 of file pLogicalFunction.cxx.

References _offsetY.

Referenced by pGraphicalFunction::setOffsetY().

                                                  {
        this->_offsetY = aOffsetY;
}

Here is the caller graph for this function:

double pLogicalFunction::getOffsetY

(

)

Definition at line 766 of file pLogicalFunction.cxx.

References _offsetY.

                                     {
        return this->_offsetY;
}

void pLogicalFunction::setType

(

int

aType

)

Definition at line 773 of file pLogicalFunction.cxx.

References _type.

Referenced by pGraphicalFunction::setType().

                                         {
        this->_type = aType;
}

Here is the caller graph for this function:

int pLogicalFunction::getType

(

)

Definition at line 777 of file pLogicalFunction.cxx.

References _type.

                                {
        return this->_type;
}

int pLogicalFunction::getValidPointRange

(

)

Definition at line 784 of file pLogicalFunction.cxx.

References validPointRange.

{
        return validPointRange;
}

void pLogicalFunction::setValidPointRange

(

int

theRange

)

Definition at line 789 of file pLogicalFunction.cxx.

References validPointRange.

Referenced by pGraphicalFunction::setValidPointRange().

{
        validPointRange = theRange;
}

Here is the caller graph for this function:

bool pLogicalFunction::deletePointAt

(

int

index

)

Deletes a point of the function given its index

deletes a point of the functio given its index

Definition at line 434 of file pLogicalFunction.cxx.

References GetPointAt(), and realPoints.

{
        if(index!=-1)  
        {       
                wxNode* node=GetPointAt(index);
                
                if(node)//point!=NULL)
                {
                        //pFunctionPoint* point=(pFunctionPoint*)node->GetData(); // JPRx
                        bool deleted=realPoints.DeleteNode(node);
                        //delete point;
                        //delete node;
                        /*
                        if(index==0)
                                realPoints=realPoints.;
                        */
                        return deleted;
                }
        }
        return false;
}

Here is the call graph for this function:

int pLogicalFunction::getSizePoints

(

)

Definition at line 797 of file pLogicalFunction.cxx.

References realPoints.

Referenced by pGraphicalFunction::getSizePoints(), pGraphicalFunction::GetSplinePoint(), pGraphicalFunction::initializeSplineVectors(), and save().

{
        return realPoints.GetCount();
}

Here is the caller graph for this function:

void pLogicalFunction::getDirection

(

bool &

dir

)

Definition at line 801 of file pLogicalFunction.cxx.

References leftToRigthDef.

{
        dir = leftToRigthDef;
}

---

Member Data Documentation

double pLogicalFunction::_startX [private]

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

Definition at line 279 of file pLogicalFunction.h.

Referenced by getStartX(), and setStartX().

double pLogicalFunction::_startY [private]

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

Definition at line 283 of file pLogicalFunction.h.

Referenced by getStartY(), and setStartY().

double pLogicalFunction::_endX [private]

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

Definition at line 287 of file pLogicalFunction.h.

Referenced by getEndX(), and setEndX().

double pLogicalFunction::_endY [private]

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

Definition at line 291 of file pLogicalFunction.h.

Referenced by getEndY(), and setEndY().

double pLogicalFunction::_scaleX [private]

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

Definition at line 295 of file pLogicalFunction.h.

Referenced by getScaleX(), setScaleX(), and validPointOnFunction().

double pLogicalFunction::_scaleY [private]

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

Definition at line 299 of file pLogicalFunction.h.

Referenced by getScaleY(), setScaleY(), and validPointOnFunction().

double pLogicalFunction::_minX [private]

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

Definition at line 303 of file pLogicalFunction.h.

Referenced by getMinX(), and setMinX().

double pLogicalFunction::_minY [private]

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

Definition at line 307 of file pLogicalFunction.h.

Referenced by getMinY(), and setMinY().

double pLogicalFunction::_maxX [private]

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

Definition at line 311 of file pLogicalFunction.h.

Referenced by getMaxX(), and setMaxX().

double pLogicalFunction::_maxY [private]

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

Definition at line 316 of file pLogicalFunction.h.

Referenced by getMaxY(), and setMaxY().

double pLogicalFunction::_offsetX [private]

Is the logical x-offset of the drawed function.

Definition at line 321 of file pLogicalFunction.h.

Referenced by getOffsetX(), and setOffsetX().

double pLogicalFunction::_offsetY [private]

Is the logical y-offset of the drawed function.

Definition at line 325 of file pLogicalFunction.h.

Referenced by getOffsetY(), and setOffsetY().

int pLogicalFunction::_type [private]

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

Definition at line 329 of file pLogicalFunction.h.

Referenced by getType(), and setType().

wxList pLogicalFunction::realPoints [private]

The list of the function points

Definition at line 333 of file pLogicalFunction.h.

Referenced by AddNewPoint(), AddPoint(), changePoint(), DeletePoint(), deletePointAt(), getIndexOf(), GetPointAt(), GetPoints(), getSizePoints(), getX_RealValues(), getY_RealValues(), orderPoints(), save(), setEndPoints(), setMaxPoints(), setMinPoints(), setStartPoints(), validPointOnFunction(), and ~pLogicalFunction().

double pLogicalFunction::x_Values[50] [private]

x-values

Definition at line 338 of file pLogicalFunction.h.

Referenced by getX_RealValues().

double pLogicalFunction::y_Values[50] [private]

y-values

Definition at line 342 of file pLogicalFunction.h.

Referenced by getY_RealValues().

int pLogicalFunction::validPointRange [private]

node of the realPoints where are we Number that determines the radius range for the valid area the point (sensible radius). Default value 5.

Definition at line 351 of file pLogicalFunction.h.

Referenced by getValidPointRange(), and setValidPointRange().

bool pLogicalFunction::leftToRigthDef [private]

Indicates the way the function is being drawed when defining it. So that it is true if the direction is from left-to-right, and false if it is from right-to-left. It is initialized when the second point is included in the funcion.

Definition at line 357 of file pLogicalFunction.h.

Referenced by AddPoint(), getDirection(), and orderPoints().

---

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

• C:/Creatis/creaMaracasVisu/lib/maracasVisuLib/src/interface/wxWindows/widgets/pPlotter/pLogicalFunction.h
• C:/Creatis/creaMaracasVisu/lib/maracasVisuLib/src/interface/wxWindows/widgets/pPlotter/pLogicalFunction.cxx

---