pGraphicalFunction.h

Go to the documentation of this file.

#ifndef __pGraphicalFunction_h__
#define __pGraphicalFunction_h__

// ----------------------------------------------------------------------------
// WX headers inclusion.
// For compilers that support precompilation, includes <wx/wx.h>.
// ----------------------------------------------------------------------------

#include <wx/wxprec.h>
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif


//----------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------------


#include "pPlotterLayer.h"
#include "pFunctionPoint.h"
#include "pLogicalFunction.h"
#include "pColorPoint.h"
#include "vtkKochanekSpline.h"
#include <vector>
#include <iostream>
#include <fstream>

#define DEFECT_SCALE 1

#define MAX_SCALE 2

#define USER_SCALE 3

/*
 Types of Plotter
*/
/*
 Lets to the user to plot any number of the
 functions
*/
#define DEFAULT 1
/*
 Dont let draw on the plotter, but lets to edit
 the functions that are editables in the plotter
*/
#define HISTOGRAM 2

class pGraphicalFunction;
//----------------------------------------------------------------------------
// Class definition
//----------------------------------------------------------------------------


class pGraphicalFunction: public pPlotterLayer
{
public:

        //constructor 
        pGraphicalFunction(wxString name= wxEmptyString, int flags= mpALIGN_RIGHT);

        ~pGraphicalFunction( );
        
        //---------------------------
        //Virtual Mehods
        //---------------------------

        virtual int getXTraslation()
        {
                return xTraslation;
        }




        virtual int getmType()
        {
                return mType;
        }

        virtual int vGetType()
        {
                return _type;
        }

        virtual void getOffsets(int &offsetX,int &offSetY )
        {
                offsetX=(int)_offsetX;
                offsetY=(int)_offsetY;
        }
        
        /*
        * Get the factor zoom
        */
        virtual void getFactorZoom(float & fz)
        {
                fz=factorZoom;
        }


        /*
        * Get the value of fromWindow
        */
        virtual void getFromWindowV(bool &fw)
        {
                fw=fromWindow;
        }


        virtual void getIfActual(bool &actual)
        {
                actual=ifActual;
        }

        virtual void getMax(int & maxX, int &maxY)
        {
                maxX=(int)getMaxX();
            maxY=(int)getMaxY();
        }
        virtual void getMaxShowed(int & maxX, int &maxY)
        {
                maxX=(int)getMaxXShowed();
                maxY=(int)getMaxYShowed();
        }
        virtual void getMinShowed(int & minX, int &minY)
        {
                minX=(int)getMinXShowed();
                minY=(int)getMinYShowed();
        }

        virtual void getScreens(int & scrX, int & scrY)
        {
      scrX=screenX;
          scrY=screenY;
        }

        virtual void setScreens(int scrX,int scrY)
        {
                screenX=scrX;
                screenY=scrY;                   
        }
        
        virtual void getScales(double & scaleX,double & scaleY)
        {
                scaleX=_scaleX;
                scaleY=_scaleY;
        }
        
        
        virtual void getDrawing(bool &draw)
        {
                draw = drawing;
        }

        virtual void ifShowPoints(bool & show)
        {
                show = showPointsF;
        }

        virtual void Rewind()
        {
                                
                node = logicFunction->GetPointAt(0);
                
        }

        virtual bool GetNextXY(double & x, double & y) 
        {
                if(node)
                {
                        pFunctionPoint* p=(pFunctionPoint*)node->GetData();
                        x=p->getRealX();
                        y=p->getRealY();
                        node=node->GetNext();
                        return true;
                }
                return false;
        }
        virtual void GetPoints(wxList &points)
        {
                logicFunction->GetPoints(points);
                //points = realPoints;
        }  

        virtual void getMousePoint(int &x,int &y)
        {
                x=mousePoint.x;
                y=mousePoint.y;
        }

        virtual void getSize(int &size)
        {
                size=getSizePoints();
        }

        virtual void getDirection(bool &dir)
        {               
                logicFunction -> getDirection (dir);
        }

        //---------------------------
        // Methods
        //---------------------------
        /*
        * validate if the function has that point in a sensible area returning the index where the point was found or -1 if is in not part of the function: define the sensible area is  
        * x1-validPointRange<x<x1+validPointRange y1-validPointRange<y<y1+validPointRange
        */
        int validPointOnFunction(wxPoint realPoint);

        //returns the index in the list of the point  
        int getIndexOf(wxPoint realpoint);

        /*
        * This metohd returns the node of the point that is the movingPointIndex position in the list of points.
        * @param: int movingPointIndex, Is the index value of the searched node.
        * @return: Return a pointer to the node corresponding to the index value by parameter.
        */
        wxNode* GetPointAt( int movingPointIndex);

        /*
        * Includes a point between two existing points of the this function. The new point (x,y) was not defined when the function was created.
        *@ return Returns true is the point was succcesfully added to the funcion.
        */
        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);

        //bool hasPoint(wxPoint aAPoint);

        double * getX_RealValues();

        double* getY_RealValues();
        /*
        * This method orders the list of points taking into account that the last appended node in the list (realPoint) is the only one disordered.
        * @return Returns true if the last point included has a valid value for x and was ordered, according to the definition of function.
        */
        bool orderPoints();

        //wxNode * findPreviousNodeTo( int realX, int realY );

        bool deletePointAt(int index);
        /*
        * Returns the number of points that the function
        * has
        */
        int getSizePoints();
        /*
        * Set the scales of the function in x and y
        */
        void setScales();

        //----------------------------------
        // Asking if it has a point (x,y)
        //----------------------------------

        /*
        * returns true if the point is along the function
        * false otherway
        */
        bool isInFunction(int x, int y);
        /*
        * give us the point that is in the function and is exactly before
        * the point we are giving
        */
        wxNode* getBefore(pFunctionPoint* point);
        /*
        * Returns true if the point is in the line
        */
        bool isInLine(pFunctionPoint* before,pFunctionPoint* next, pFunctionPoint* point);
        double interpolateY(double m, int x1,int y1,int x);
        /*
         * Set Up startPoint, endPoint, maxY,maxX points        
        */
        void setUp();
        //----------------------------
        // Spline Methods
        //----------------------------
        /*
        * clear the spline vectors
        */
        void clearSplineVectors();


        /*
        Initiliaze xSpline and ySpline vectors
        */
        void initializeSplines();
        
        /*
        Add the (x,y) points of the function to the 
        spline
        */
        void addSplinesPoints();
        
        /*
         This Method adds the point calculated by
         the splines to the vectors
        */
        void initializeSplineVectors();
        
        /*
         get the spline point for t, in xKSpline and yKSpline
        */
        void GetSplinePoint(double t, double &x, double &y); 
        /*
         returns the xSpline to plotter
        */
        virtual std::vector<double> getXSpline()
        {
                return xSpline;
        }
        /*
         returns the ySpline to plotter
        */
        virtual std::vector<double> getYSpline()
        {
                return ySpline;
        }


        virtual int getOffsetPixelsXv()
        {
                return offsetPixelX;
        }       
        
        virtual int getOffsetPixelsYv()
        {
                return offsetPixelY;
        }

        //-----------------------
        // Persistence
        //-----------------------

        /*
         Save the points of the function
        */
        void save(wxString fileName);
        /*
         Load the points of a function 
        */
        void load(wxString fileName);

    //------------------------------
        // Getters and Setters
        //------------------------------

        //set if the function has to draw the points  
        void SetShowPoints(bool showPoints);

        //get the paramater showPointsF
        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)
        {
                drawing = d;
        }
        //get if the function is being drawed
        bool GetDrawing()
        {
                return drawing;
        }

        //set the mouse point
        void SetMousePoint(wxPoint p)
        { 
                mousePoint = p;
        }
        //get the mousePoint
        wxPoint getMousePoint()
        {
                return mousePoint;
        }
        void setActual(bool act);

        bool getActual();

        void setScaleWay(int typeS);

        int  getScaleWay();
        
        void setFromWindow(bool w)
        {
                fromWindow=w;
        }
        
        /*
        * Get the value of fromWindow
        */
        bool getFromWindow()
        {
                return fromWindow;
        }
        /*
        *  Set factor zoom
        */
        void setFactorZoom(float factor)
        {
                factorZoom=factor;
        }
        /*
        * Set editable
        */
        void setEditable(bool edit)
        {
                editable=edit;
        }
        bool getEditable()
        {
                return editable;
        }

        //----------------------------
        // Zoom
        //----------------------------

        /* 
         * Get boolean zoom
         */
        bool getZoomB()
        {
                return zoomIn;
        }
        /* *
         * Set boolean zoom
         * @param z: the new value
         */
        void setZoomIn(bool z)
        {
                zoomIn=z;
        }
        void setInitialDrawPoint(pFunctionPoint* initialPoint)
        {
                initialDrawingPoint=initialPoint;       
        }
        pFunctionPoint* getInitialDrawPoint()
        {
                return initialDrawingPoint;     
        }
        void setFinalDrawPoint(pFunctionPoint* finalPoint)
        {
                finalDrawingPoint=finalPoint;   
        }
        pFunctionPoint* getFinallDrawPoint()
        {
                return finalDrawingPoint;       
        }
        void zooming(int clickedX,int clickedY,int width);
        
        /*
        * This method sets the offset 
        */
        void setOffsets(int offx,int offy);
        
        /*
        *  This method sets the minShowedX 
        *  and the minShowedY, accordig to the offset in
        *  x-axis and y-axis respectively
        *  pre: _offsetX>=0,_offsetY>=0
        */
        void setMinShowed();

        int getMinXShowed()
        {
                return minShowedX;
        }
        int getMinYShowed()
        {
                return minShowedY;
        }
        int getMaxXShowed()
        {
                return maxShowedX;
        }
        int getMaxYShowed()
        {
                return maxShowedY;
        }
        void setMinShowedX(int msx)
        {
                minShowedX=msx;
        }
        void setMinShowedY(int msy)
        {
                minShowedY=msy;
        }
        void setMaxShowedX(int msx)
        {
                maxShowedX=msx;
        }
        void setMaxShowedY(int msy)
        {
                maxShowedY=msy;
        }

        //------------------------
        // Offsets in pixels 
        //------------------------
        
        int getOffsetPixelsX()
        {
                return offsetPixelX;
        }       
        
        int getOffsetPixelsY()
        {
                return offsetPixelY;
        }
        void setOffsetPixelX(int offX)
        {
                offsetPixelX=offX;
        }
        void setOffsetPixelY(int offY)
        {
                offsetPixelY=offY;
        }       

        

        /*
        * Sets the color points of the function by teh given parameter
        * @param colorVector Is the color points vector to set
        */
        void setColorPoints(std::vector<pColorPoint *> &colorVector);

        /*
        * Gets the color points of the function in the given parameter
        * @param colorVector Is the color points list to get the points
        */
        void getColorPoints(std::vector<pColorPoint *> &colorVector);
        /*
         Setter the mType
        */
        void setmType(int mt)
        {
                mType=mt;
        }
        //-----------------------
        //TRASLATION
        //-----------------------
        void setXTraslation(int xT)
        {
                 xTraslation=xT;
        }
        


private:

        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;
        /*
        * The list of the color points of the function associated to the color bar
        */
        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;
        
        
        /*
         Vectors where the spline is stored
        */
        std::vector<double> xSpline;
        
        std::vector<double>     ySpline;
        
        /*
          Kochanek splines
        */
        vtkKochanekSpline* xKSpline;

        vtkKochanekSpline* yKSpline;
        
        
        int offsetPixelX;
        int offsetPixelY;
        /*
         type of the meaning of the function
         DEFAULT=1; the  function  has no meaning
         HISTOGRAM=2. The function represents an histogram
        */

        int mType;

        /*
         is use for lets the user move the function
        */
        int xTraslation;

        DECLARE_CLASS (pGraphicalFunction)
};

#endif