lib/maracasVisuLib/src/interface/wxWindows/widgets/pPlotter/pGraphicalFunction.h

   1 /*# ---------------------------------------------------------------------
   2 #
   3 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   4 #                        pour la Sant�)
   5 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   6 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   7 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   8 #
   9 #  This software is governed by the CeCILL-B license under French law and
  10 #  abiding by the rules of distribution of free software. You can  use,
  11 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  12 #  license as circulated by CEA, CNRS and INRIA at the following URL
  13 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  14 #  or in the file LICENSE.txt.
  15 #
  16 #  As a counterpart to the access to the source code and  rights to copy,
  17 #  modify and redistribute granted by the license, users are provided only
  18 #  with a limited warranty  and the software's author,  the holder of the
  19 #  economic rights,  and the successive licensors  have only  limited
  20 #  liability.
  21 #
  22 #  The fact that you are presently reading this means that you have had
  23 #  knowledge of the CeCILL-B license and that you accept its terms.
  24 # ------------------------------------------------------------------------ */
  25
  26
  27
  28 #ifndef __pGraphicalFunction_h__
  29 #define __pGraphicalFunction_h__
  30
  31 // ----------------------------------------------------------------------------
  32 // WX headers inclusion.
  33 // For compilers that support precompilation, includes <wx/wx.h>.
  34 // ----------------------------------------------------------------------------
  35
  36 #include <wx/wxprec.h>
  37 #ifdef __BORLANDC__
  38 #pragma hdrstop
  39 #endif
  40 #ifndef WX_PRECOMP
  41 #include <wx/wx.h>
  42 #endif
  43
  44
  45 //----------------------------------------------------------------------------
  46 // Includes
  47 //----------------------------------------------------------------------------
  48
  49
  50 #include "pPlotterLayer.h"
  51 #include "pFunctionPoint.h"
  52 #include "pLogicalFunction.h"
  53 #include "pColorPoint.h"
  54 #include "vtkKochanekSpline.h"
  55 #include <vector>
  56 #include <iostream>
  57 #include <fstream>
  58
  59 /**
  60  this scale, scales each function with its maximum x, and maximum y
  61  in its points
  62 */
  63 #define DEFECT_SCALE 1
  64 /**
  65  this scale with the maximun x  and y of all the functions defined
  66 */
  67 #define MAX_SCALE 2
  68 /**
  69  this scales with the scale giving by the user of the widget
  70 */
  71 #define USER_SCALE 3
  72
  73 /*
  74  Types of Plotter
  75 */
  76 /*
  77  Lets to the user to plot any number of the
  78  functions
  79 */
  80 #define DEFAULT 1
  81 /*
  82  Dont let draw on the plotter, but lets to edit
  83  the functions that are editables in the plotter
  84 */
  85 #define HISTOGRAM 2
  86
  87 class pGraphicalFunction;
  88 //----------------------------------------------------------------------------
  89 // Class definition
  90 //----------------------------------------------------------------------------
  91
  92
  93 class pGraphicalFunction: public pPlotterLayer
  94 {
  95 public:
  96
  97         //constructor
  98         pGraphicalFunction(wxString name= wxEmptyString, int flags= mpALIGN_RIGHT);
  99
 100         ~pGraphicalFunction( );
 101
 102         //---------------------------
 103         //Virtual Mehods
 104         //---------------------------
 105
 106         /**
 107          Get the value of the traslation
 108         in the x-axis
 109         */
 110         virtual int getXTraslation()
 111         {
 112                 return xTraslation;
 113         }
 114
 115
 116
 117
 118         /**
 119          Get the type of the curve
 120          1=normal function
 121          2=Histogram
 122         */
 123         virtual int getmType()
 124         {
 125                 return mType;
 126         }
 127
 128         /**
 129          Get the type of the curve
 130          1=piecewise functio
 131          2= smooth
 132         */
 133         virtual int vGetType()
 134         {
 135                 return _type;
 136         }
 137
 138         /**
 139          Get _offsetX and _offsetY
 140         */
 141
 142         virtual void getOffsets(int &offsetX,int &offSetY )
 143         {
 144                 offsetX=(int)_offsetX;
 145                 offsetY=(int)_offsetY;
 146         }
 147
 148         /*
 149         * Get the factor zoom
 150         */
 151         virtual void getFactorZoom(float & fz)
 152         {
 153                 fz=factorZoom;
 154         }
 155
 156
 157         /*
 158         * Get the value of fromWindow
 159         */
 160         virtual void getFromWindowV(bool &fw)
 161         {
 162                 fw=fromWindow;
 163         }
 164
 165
 166         /**
 167         * if the function that is drawing is the actual
 168         */
 169         virtual void getIfActual(bool &actual)
 170         {
 171                 actual=ifActual;
 172         }
 173
 174         /**
 175         * get the max of the function in x and y
 176         */
 177         virtual void getMax(int & maxX, int &maxY)
 178         {
 179                 maxX=(int)getMaxX();
 180             maxY=(int)getMaxY();
 181         }
 182         /**
 183         * get the maxShowed of the function in x and y
 184         */
 185         virtual void getMaxShowed(int & maxX, int &maxY)
 186         {
 187                 maxX=(int)getMaxXShowed();
 188                 maxY=(int)getMaxYShowed();
 189         }
 190         /**
 191         * get the minShowed of the function in x and y
 192         */
 193         virtual void getMinShowed(int & minX, int &minY)
 194         {
 195                 minX=(int)getMinXShowed();
 196                 minY=(int)getMinYShowed();
 197         }
 198
 199         /**
 200         * Get screens of the function
 201         */
 202         virtual void getScreens(int & scrX, int & scrY)
 203         {
 204       scrX=screenX;
 205           scrY=screenY;
 206         }
 207
 208         /**
 209         * Set screens value
 210         */
 211         virtual void setScreens(int scrX,int scrY)
 212         {
 213                 screenX=scrX;
 214                 screenY=scrY;
 215         }
 216
 217         /**
 218         * Let us know the scale of the function
 219         */
 220         virtual void getScales(double & scaleX,double & scaleY)
 221         {
 222                 scaleX=_scaleX;
 223                 scaleY=_scaleY;
 224         }
 225
 226
 227         /**
 228         * Let us Know if the user has finished the drawing
 229         * that starts before.
 230         */
 231
 232         virtual void getDrawing(bool &draw)
 233         {
 234                 draw = drawing;
 235         }
 236
 237         /**
 238         Let us Know if the user want to see the points of the function
 239         of other color than the color of the lines
 240         */
 241         virtual void ifShowPoints(bool & show)
 242         {
 243                 show = showPointsF;
 244         }
 245
 246         /**
 247         *Rewind
 248         */
 249         virtual void Rewind()
 250         {
 251
 252                 node = logicFunction->GetPointAt(0);
 253
 254         }
 255
 256         /** Get locus value for next N.
 257         Override this function in your implementation.
 258         @param x Returns X value
 259         @param y Returns Y value
 260         */
 261         virtual bool GetNextXY(double & x, double & y)
 262         {
 263                 if(node)
 264                 {
 265                         pFunctionPoint* p=(pFunctionPoint*)node->GetData();
 266                         x=p->getRealX();
 267                         y=p->getRealY();
 268                         node=node->GetNext();
 269                         return true;
 270                 }
 271                 return false;
 272         }
 273
 274
 275
 276 //EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
 277 #if wxMAJOR_VERSION <= 2
 278         /**
 279         Get Point list of the funcion
 280         @param return points
 281         */
 282         virtual void GetPoints(wxList &points)
 283         {
 284                 logicFunction->GetPoints(points);
 285                 //points = realPoints;
 286         }
 287 #else
 288         /**
 289         Get Point list of the funcion
 290         @param return pointsPtr
 291         */
 292         virtual wxList* GetPointsPtr()
 293         {
 294                 return logicFunction->GetPointsPtr();
 295         }
 296 #endif
 297
 298
 299
 300         /**
 301         Get the point where the user
 302         made a click
 303         */
 304         virtual void getMousePoint(int &x,int &y)
 305         {
 306                 x = mousePoint.x;
 307                 y = mousePoint.y;
 308         }
 309
 310         /**
 311         * Get the number of points of the function
 312         */
 313         virtual void getSize(int &size)
 314         {
 315                 size=getSizePoints();
 316         }
 317
 318         /**
 319         * this method gets the direction of the drawing
 320         */
 321         virtual void getDirection(bool &dir)
 322         {
 323                 logicFunction -> getDirection (dir);
 324         }
 325
 326         //---------------------------
 327         // Methods
 328         //---------------------------
 329         /*
 330         * 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
 331         * x1-validPointRange<x<x1+validPointRange y1-validPointRange<y<y1+validPointRange
 332         */
 333         int validPointOnFunction(wxPoint realPoint);
 334
 335         //returns the index in the list of the point
 336         int getIndexOf(wxPoint realpoint);
 337
 338         /*
 339         * This metohd returns the node of the point that is the movingPointIndex position in the list of points.
 340         * @param: int movingPointIndex, Is the index value of the searched node.
 341         * @return: Return a pointer to the node corresponding to the index value by parameter.
 342         */
 343         wxNode* GetPointAt( int movingPointIndex);
 344
 345         /*
 346         * Includes a point between two existing points of the this function. The new point (x,y) was not defined when the function was created.
 347         *@ return Returns true is the point was succcesfully added to the funcion.
 348         */
 349         bool AddNewPoint(int x,int y);
 350
 351         /**
 352         * this method add a new logical point to the function, this point is one of those used to draw the function
 353         */
 354         bool AddPoint(int aX, int aY,bool order=true);
 355
 356         /**
 357         * deletes the point given by the  user  from the collection of logical points of the function
 358         */
 359         bool DeletePoint(int aX, int aY);
 360
 361         /**
 362         * 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.
 363         */
 364         bool changePoint(wxPoint newCoords, int movingIndexPoint);
 365
 366         /**
 367         * Evaluates if the given point belongs to the function.
 368         */
 369         //bool hasPoint(wxPoint aAPoint);
 370
 371         /**
 372         * Returns the real x values of the control points of the function. It dont includes the points calculated by interpolation.
 373         */
 374         double * getX_RealValues();
 375
 376         /**
 377         * Returns the real y values of the control points of the function. It dont includes the points calculated by interpolation.
 378         */
 379         double* getY_RealValues();
 380         /*
 381         * This method orders the list of points taking into account that the last appended node in the list (realPoint) is the only one disordered.
 382         * @return Returns true if the last point included has a valid value for x and was ordered, according to the definition of function.
 383         */
 384         bool orderPoints();
 385
 386         /**
 387         * This method get a pointer to the node in the real points list that is inmediately previous to the searched by parameter.
 388         * @pre The seached point (realX, realY) is not the first point of the list.
 389         * @param realX
 390         * @param realY
 391         */
 392         //wxNode * findPreviousNodeTo( int realX, int realY );
 393
 394         /**
 395         * Deletes a point of the function given its index
 396         */
 397         bool deletePointAt(int index);
 398         /*
 399         * Returns the number of points that the function
 400         * has
 401         */
 402         int getSizePoints();
 403         /*
 404         * Set the scales of the function in x and y
 405         */
 406         void setScales();
 407
 408         //----------------------------------
 409         // Asking if it has a point (x,y)
 410         //----------------------------------
 411
 412         /*
 413         * returns true if the point is along the function
 414         * false otherway
 415         */
 416         bool isInFunction(int x, int y);
 417         /*
 418         * give us the point that is in the function and is exactly before
 419         * the point we are giving
 420         */
 421         wxNode* getBefore(pFunctionPoint* point);
 422         /*
 423         * Returns true if the point is in the line
 424         */
 425         bool isInLine(pFunctionPoint* before,pFunctionPoint* next, pFunctionPoint* point);
 426         /**
 427         * give us the value of y in the line define by the arguments
 428         */
 429         double interpolateY(double m, int x1,int y1,int x);
 430         /*
 431          * Set Up startPoint, endPoint, maxY,maxX points
 432         */
 433         void setUp();
 434         //----------------------------
 435         // Spline Methods
 436         //----------------------------
 437         /*
 438         * clear the spline vectors
 439         */
 440         void clearSplineVectors();
 441
 442
 443         /*
 444         Initiliaze xSpline and ySpline vectors
 445         */
 446         void initializeSplines();
 447
 448         /*
 449         Add the (x,y) points of the function to the
 450         spline
 451         */
 452         void addSplinesPoints();
 453
 454         /*
 455          This Method adds the point calculated by
 456          the splines to the vectors
 457         */
 458         void initializeSplineVectors();
 459
 460         /*
 461          get the spline point for t, in xKSpline and yKSpline
 462         */
 463         void GetSplinePoint(double t, double &x, double &y);
 464         /*
 465          returns the xSpline to plotter
 466         */
 467         virtual std::vector<double> getXSpline()
 468         {
 469                 return xSpline;
 470         }
 471         /*
 472          returns the ySpline to plotter
 473         */
 474         virtual std::vector<double> getYSpline()
 475         {
 476                 return ySpline;
 477         }
 478
 479
 480         /**
 481         Gets the x-offset of the zoom
 482         in pixels
 483         */
 484         virtual int getOffsetPixelsXv()
 485         {
 486                 return offsetPixelX;
 487         }
 488
 489         /**
 490         Gets the offset of the zoom
 491         in pixels
 492         */
 493         virtual int getOffsetPixelsYv()
 494         {
 495                 return offsetPixelY;
 496         }
 497
 498         //-----------------------
 499         // Persistence
 500         //-----------------------
 501
 502         /*
 503          Save the points of the function
 504         */
 505         void save(wxString fileName);
 506         /*
 507          Load the points of a function
 508         */
 509         void load(wxString fileName);
 510
 511     //------------------------------
 512         // Getters and Setters
 513         //------------------------------
 514
 515         //set if the function has to draw the points
 516         void SetShowPoints(bool showPoints);
 517
 518         //get the paramater showPointsF
 519         bool getShowPoints();
 520
 521         void setScreenX(int scrX);
 522
 523         int getScreenX();
 524
 525         void setScreenY(int scrY);
 526
 527         int getScreenY();
 528
 529         void setStartX(double aStartX);
 530
 531         double getStartX();
 532
 533         void setStartY(double aStartY);
 534
 535         double getStartY();
 536
 537         void setEndX(double aEndX);
 538
 539         double getEndX();
 540
 541         void setEndY(double aEndY);
 542
 543         double getEndY();
 544
 545         void setScaleX(double aScaleX);
 546
 547         double getScaleX();
 548
 549         void setScaleY(double aScaleY);
 550
 551         double getScaleY();
 552
 553         void setMinX(double aMinX);
 554
 555         double getMinX();
 556
 557         void setMinY(double aMinY);
 558
 559         double getMinY();
 560
 561         void setMaxX(double aMaxX);
 562
 563         double getMaxX();
 564
 565         void setMaxY(double aMaxY);
 566
 567         double getMaxY();
 568
 569         void setOffsetX(double aOffsetX);
 570
 571         double getOffsetX();
 572
 573         void setOffsetY(double aOffsetY);
 574
 575         double getOffsetY();
 576
 577         void setType(int aType);
 578
 579         int getType();
 580
 581         int getValidPointRange();
 582
 583         void setValidPointRange(int theRange);
 584
 585         void SetDrawing(bool d)
 586         {
 587                 drawing = d;
 588         }
 589         //get if the function is being drawed
 590         bool GetDrawing()
 591         {
 592                 return drawing;
 593         }
 594
 595         //set the mouse point
 596         void SetMousePoint(wxPoint p)
 597         {
 598                 mousePoint = p;
 599         }
 600         //get the mousePoint
 601         wxPoint getMousePoint()
 602         {
 603                 return mousePoint;
 604         }
 605         /**
 606         * actual
 607         */
 608         void setActual(bool act);
 609
 610         bool getActual();
 611
 612         /**
 613         * SCALE WAY
 614         * DEFECT_SCALE 1
 615         * MAX_SCALE 2
 616         * USER_SCALE 3
 617         */
 618         void setScaleWay(int typeS);
 619
 620         int  getScaleWay();
 621
 622         /**
 623         * set fromWindow: it is set to true if the
 624         * function was created interactively
 625         */
 626         void setFromWindow(bool w)
 627         {
 628                 fromWindow=w;
 629         }
 630
 631         /*
 632         * Get the value of fromWindow
 633         */
 634         bool getFromWindow()
 635         {
 636                 return fromWindow;
 637         }
 638         /*
 639         *  Set factor zoom
 640         */
 641         void setFactorZoom(float factor)
 642         {
 643                 factorZoom=factor;
 644         }
 645         /*
 646         * Set editable
 647         */
 648         void setEditable(bool edit)
 649         {
 650                 editable=edit;
 651         }
 652         /**
 653         * Get editable
 654         */
 655         bool getEditable()
 656         {
 657                 return editable;
 658         }
 659
 660         //----------------------------
 661         // Zoom
 662         //----------------------------
 663
 664         /*
 665          * Get boolean zoom
 666          */
 667         bool getZoomB()
 668         {
 669                 return zoomIn;
 670         }
 671         /* *
 672          * Set boolean zoom
 673          * @param z: the new value
 674          */
 675         void setZoomIn(bool z)
 676         {
 677                 zoomIn=z;
 678         }
 679         /**
 680         * Set the initial drawing point
 681         * @param pFunctionPoint* initialPoint
 682         */
 683         void setInitialDrawPoint(pFunctionPoint* initialPoint)
 684         {
 685                 initialDrawingPoint=initialPoint;
 686         }
 687         /**
 688         * Get the initial drawing point
 689         * @return initialDrawingPoint
 690         */
 691         pFunctionPoint* getInitialDrawPoint()
 692         {
 693                 return initialDrawingPoint;
 694         }
 695         /**
 696         * Set the final drawing point
 697         * @param pFunctionPoint* finalPoint
 698         */
 699         void setFinalDrawPoint(pFunctionPoint* finalPoint)
 700         {
 701                 finalDrawingPoint=finalPoint;
 702         }
 703         /**
 704         * Get the final drawing point
 705         * @return finalDrawingPoint
 706         */
 707         pFunctionPoint* getFinallDrawPoint()
 708         {
 709                 return finalDrawingPoint;
 710         }
 711         /**
 712         This method set the initial point and the final point of drawing
 713         according with the width of the square around the point clicked
 714         @param clickedX
 715         @param clickedY
 716         @param width: width of the square
 717         */
 718
 719         void zooming(int clickedX,int clickedY,int width);
 720
 721         /*
 722         * This method sets the offset
 723         */
 724         void setOffsets(int offx,int offy);
 725
 726         /*
 727         *  This method sets the minShowedX
 728         *  and the minShowedY, accordig to the offset in
 729         *  x-axis and y-axis respectively
 730         *  pre: _offsetX>=0,_offsetY>=0
 731         */
 732         void setMinShowed();
 733
 734         /**
 735         Get the minX Showed
 736         */
 737         int getMinXShowed()
 738         {
 739                 return minShowedX;
 740         }
 741         /**
 742         Get the minY Showed
 743         */
 744         int getMinYShowed()
 745         {
 746                 return minShowedY;
 747         }
 748         /**
 749         Get the maxX Showed
 750         */
 751         int getMaxXShowed()
 752         {
 753                 return maxShowedX;
 754         }
 755         /**
 756         Get the maxY Showed
 757         */
 758         int getMaxYShowed()
 759         {
 760                 return maxShowedY;
 761         }
 762         /**
 763          Set the minShowedX
 764         */
 765         void setMinShowedX(int msx)
 766         {
 767                 minShowedX=msx;
 768         }
 769         /**
 770          Set the minShowedY
 771         */
 772         void setMinShowedY(int msy)
 773         {
 774                 minShowedY=msy;
 775         }
 776         /**
 777          Set the maxShowedX
 778         */
 779         void setMaxShowedX(int msx)
 780         {
 781                 maxShowedX=msx;
 782         }
 783         /**
 784          Set the minShowedY
 785         */
 786         void setMaxShowedY(int msy)
 787         {
 788                 maxShowedY=msy;
 789         }
 790
 791         //------------------------
 792         // Offsets in pixels
 793         //------------------------
 794
 795         /**
 796         Gets the x-offset of the zoom
 797         in pixels
 798         */
 799         int getOffsetPixelsX()
 800         {
 801                 return offsetPixelX;
 802         }
 803
 804         /**
 805         Gets the offset of the zoom
 806         in pixels
 807         */
 808         int getOffsetPixelsY()
 809         {
 810                 return offsetPixelY;
 811         }
 812         /**
 813          Set the x-offset of the zoom
 814         */
 815         void setOffsetPixelX(int offX)
 816         {
 817                 offsetPixelX=offX;
 818         }
 819         /**
 820          Set the y-offset of the zoom
 821         */
 822         void setOffsetPixelY(int offY)
 823         {
 824                 offsetPixelY=offY;
 825         }
 826
 827
 828
 829         /*
 830         * Sets the color points of the function by teh given parameter
 831         * @param colorVector Is the color points vector to set
 832         */
 833         void setColorPoints(std::vector<pColorPoint *> &colorVector);
 834
 835         /*
 836         * Gets the color points of the function in the given parameter
 837         * @param colorVector Is the color points list to get the points
 838         */
 839         void getColorPoints(std::vector<pColorPoint *> &colorVector);
 840         /*
 841          Setter the mType
 842         */
 843         void setmType(int mt)
 844         {
 845                 mType=mt;
 846         }
 847         //-----------------------
 848         //TRASLATION
 849         //-----------------------
 850         /**
 851          Set the value of the traslation
 852          in the x-axis
 853          @param xT value in pixels of the traslation in x-axis
 854         */
 855         void setXTraslation(int xT)
 856         {
 857                  xTraslation=xT;
 858         }
 859
 860
 861
 862 private:
 863
 864         /**
 865         * Represents the logical function asociated to this graphical function.
 866         */
 867         pLogicalFunction* logicFunction;
 868         /**
 869         * If the function has to showpoints
 870         */
 871         bool showPointsF;
 872
 873         /**
 874         * Is the initial discrete point on x axis of the drawed function.
 875         */
 876         double _startX;
 877         /**
 878         * Is the initial discrete point on y axis of the drawed function.
 879         */
 880         double _startY;
 881         /**
 882         * Is the last discrete point on x axis of the drawed function.
 883         */
 884         double _endX;
 885         /**
 886         * Is the last discrete point on y axis of the drawed function.
 887         */
 888         double _endY;
 889         /**
 890         * Is the x-scale percentage according to the context device.
 891         */
 892         double _scaleX;
 893         /**
 894         * Is the y-scale percentage according to the context device.
 895         */
 896         double _scaleY;
 897         /**
 898         * Is the minimun x-real value reacheable by the function.
 899         */
 900         double _minX;
 901         /**
 902         * Is the minimun y-real value reacheable by the function.
 903         */
 904         double _minY;
 905         /**
 906         * Is the maximun x-real value reacheable by the function.
 907         */
 908         double _maxX;
 909         /**
 910         * Is the maximun y-real value reacheable by the function.
 911         */
 912         double _maxY;
 913         /**
 914         * Is the logical x-offset of the drawed function.
 915         */
 916         double _offsetX;
 917         /**
 918         * Is the logical y-offset of the drawed function.
 919         */
 920         double _offsetY;
 921         /**
 922         * Is the way of how points are going to be connected. It could be smooth, line.
 923         */
 924         int _type;
 925         /**
 926         * The list of the function points
 927         */
 928         wxList realPoints;
 929         /*
 930         * The list of the color points of the function associated to the color bar
 931         */
 932         std::vector<pColorPoint *> f_colorPoints;
 933
 934         /**
 935         *  node of the realPoints where are we
 936         */
 937         wxNode* node;
 938         /**
 939         * Number that determines the radius range for the valid area the point (sensible radius). Default value 5.
 940         */
 941         int validPointRange;
 942
 943         /**
 944         * Indicates if the user is drawing the function
 945         */
 946         bool drawing;
 947
 948         /**
 949         * this is for the graphical function
 950         * Mouse Point
 951         */
 952         wxPoint mousePoint;
 953
 954         /**
 955         * The size of the screen in X
 956         */
 957         int screenX;
 958
 959         /**
 960         * The size of the screen in Y
 961         */
 962         int screenY;
 963         /**
 964           if is the actual
 965         */
 966         bool ifActual;
 967
 968         /**
 969          the way we scale
 970          DEFECT_SCALE 1
 971          MAX_SCALE 2
 972          USER_SCALE 3
 973         */
 974
 975         int scaleWay;
 976
 977         /**
 978          if the function comes from window
 979         */
 980     bool fromWindow;
 981         /**
 982         * factorZoom
 983         */
 984         float factorZoom;
 985         /**
 986         * The function is editable
 987         */
 988         bool editable;
 989          /**
 990          * if the user did a zoom in/out
 991          */
 992         bool zoomIn;
 993         /**
 994         * initial drawing point
 995         */
 996         pFunctionPoint* initialDrawingPoint;
 997         /**
 998         * final drawing point
 999         */
1000         pFunctionPoint* finalDrawingPoint;
1001         /**
1002          Minimum point showed to the user
1003          (zoom)X
1004         */
1005         int minShowedX;
1006         /**
1007          Maximum point showed to the user
1008          (zoom)X
1009         */
1010         int maxShowedX;
1011         /**
1012          Minimum point showed to the user
1013          (zoom)Y
1014         */
1015         int minShowedY;
1016         /**
1017          Maximum point showed to the user
1018          (zoom)X
1019         */
1020         int maxShowedY;
1021
1022
1023         /*
1024          Vectors where the spline is stored
1025         */
1026         std::vector<double> xSpline;
1027
1028         std::vector<double>     ySpline;
1029
1030         /*
1031           Kochanek splines
1032         */
1033         vtkKochanekSpline* xKSpline;
1034
1035         vtkKochanekSpline* yKSpline;
1036
1037
1038         /**
1039          offset in pixels where the user has clicked
1040          before changing the scale
1041         */
1042         int offsetPixelX;
1043         int offsetPixelY;
1044         /*
1045          type of the meaning of the function
1046          DEFAULT=1; the  function  has no meaning
1047          HISTOGRAM=2. The function represents an histogram
1048         */
1049
1050         int mType;
1051
1052         /*
1053          is use for lets the user move the function
1054         */
1055         int xTraslation;
1056
1057         DECLARE_CLASS (pGraphicalFunction)
1058 };
1059
1060 #endif
1061
1062