uifunctiondisplay.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert
 Date:          Apr 2008
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "uitoolsmod.h"
#include "uigraphicsview.h"
#include "draw.h"
 
class uiAxisHandler;
class uiGraphicsItem;
class uiGraphicsItemGroup;
class uiGraphicsScene;
class uiLineItem;
class uiPolygonItem;
class uiPolyLineItem;
class uiRectItem;
class uiTextItem;
 
mExpClass(uiTools) uiFunctionDisplay : public uiGraphicsView
{ mODTextTranslationClass(uiFunctionDisplay)
public:
 
    struct Setup
    {
                                Setup()
                                    : xrg_(mUdf(float),mUdf(float))
                                    , yrg_(mUdf(float),mUdf(float))
                                    , y2rg_(mUdf(float),mUdf(float))
                                    , bgcol_(Color::White())
                                    , ycol_(200,160,140)
                                    , y2col_(140,160,200)
                                    , ywidth_(2)
                                    , y2width_(2)
                                    , canvaswidth_(400)
                                    , canvasheight_(250)
                                    , border_(20,20,20,10)
                                    , annotx_(true)
                                    , annoty_(true)
                                    , annoty2_(true)
                                    , noxaxis_(false)
                                    , noyaxis_(false)
                                    , noy2axis_(false)
                                    , noxgridline_(false)
                                    , noygridline_(false)
                                    , noy2gridline_(false)
                                    , pointsz_(0)
                                    , ptsnaptol_(0.01)
                                    , editable_(false)
                                    , curvzvaly_(1)
                                    , curvzvaly2_(0)
                                    , fillbelow_(false)
                                    , fillbelowy2_(false)
                                    , drawscattery1_(false)
                                    , drawscattery2_(false)
                                    , markerstyley1_(MarkerStyle2D::Square,3,
                                                     ycol_)
                                    , markerstyley2_(MarkerStyle2D::Square,3,
                                                     y2col_)
                                    , markerfilly1_(false)
                                    , markerfilly2_(false)
                                    , drawborder_(false)
                                    , fixdrawrg_(true)
                                    , borderstyle_(OD::LineStyle())
                                    , closepolygon_(true)
                                    , drawliney_(true)
                                    , useyscalefory2_(false)
                                    , xannotinint_(false)
                                    , yannotinint_(false)
                                    , drawliney2_(true) {}
 
        mDefSetupMemb(Interval<float>,xrg)      
        mDefSetupMemb(Interval<float>,yrg)      
        mDefSetupMemb(Interval<float>,y2rg)     
        mDefSetupMemb(Color,bgcol)              
        mDefSetupMemb(Color,ycol)
        mDefSetupMemb(Color,y2col)
        mDefSetupMemb(int,ywidth)
        mDefSetupMemb(int,y2width)
        mDefSetupMemb(int,canvaswidth)
        mDefSetupMemb(int,canvasheight)
        mDefSetupMemb(uiBorder,border)
        mDefSetupMemb(int,curvzvaly)
        mDefSetupMemb(int,curvzvaly2)
        mDefSetupMemb(bool,annotx)
        mDefSetupMemb(bool,annoty)
        mDefSetupMemb(bool,annoty2)
        mDefSetupMemb(bool,noxaxis)
        mDefSetupMemb(bool,noyaxis)
        mDefSetupMemb(bool,noy2axis)
        mDefSetupMemb(bool,noxgridline)
        mDefSetupMemb(bool,noygridline)
        mDefSetupMemb(bool,noy2gridline)
        mDefSetupMemb(int,pointsz)              
        mDefSetupMemb(bool,editable)            
        mDefSetupMemb(bool,fillbelow)           
        mDefSetupMemb(bool,fillbelowy2)         
        mDefSetupMemb(bool,drawliney)           
        mDefSetupMemb(bool,drawliney2)          
        mDefSetupMemb(bool,drawscattery1)               
        mDefSetupMemb(bool,drawscattery2)               
        mDefSetupMemb(MarkerStyle2D,markerstyley1)
        mDefSetupMemb(MarkerStyle2D,markerstyley2)
        mDefSetupMemb(bool,markerfilly1)
        mDefSetupMemb(bool,markerfilly2)
        mDefSetupMemb(bool,closepolygon)
        mDefSetupMemb(bool,drawborder)
        mDefSetupMemb(bool,useyscalefory2)
        mDefSetupMemb(OD::LineStyle,borderstyle)
        mDefSetupMemb(float,ptsnaptol)          
        mDefSetupMemb(bool,fixdrawrg)
        mDefSetupMemb(bool,xannotinint)
        mDefSetupMemb(bool,yannotinint)
 
        Setup&          drawline( bool yn )
                        { drawliney_ = drawliney2_ = yn; return *this; }
        Setup&          drawgridlines( bool yn )
                        { noxgridline_ = noygridline_ = noy2gridline_ = !yn;
                          return *this; }
        Setup&          drawscatter( bool yn )
                        { drawscattery1_ = drawscattery2_ = yn; return *this; }
        Setup&          annot( bool yn )
                        { annotx_ = annoty_ = annoty2_ = yn; return *this; }
        Setup&          axes( bool yn )
                        { noxaxis_ = noyaxis_ = noy2axis_ = !yn; return *this; }
 
    };
 
                                uiFunctionDisplay(uiParent*,const Setup&);
                                ~uiFunctionDisplay();
 
    void                        setTitle(const uiString&);
    void                        setVals(const float* xvals,
                                        const float* yvals,int sz);
    void                        setVals(const Interval<float>&,
                                        const float* yvals,int sz);
    void                        setY2Vals(const float* xvals,
                                          const float* yvals,int sz);
    void                        setY2Vals(const Interval<float>&,
                                        const float* yvals,int sz);
    void                        setMarkValue(float,bool is_x);
    void                        setMark2Value(float,bool is_x);
    void                        setEmpty(); 
 
    const TypeSet<float>&       xVals() const   { return xvals_; }
    const TypeSet<float>&       yVals() const   { return yvals_; }
    uiAxisHandler*              xAxis()         { return xax_; }
    uiAxisHandler*              yAxis( bool y2) { return y2 ? y2ax_ : yax_; }
    const uiAxisHandler*        xAxis() const   { return xax_; }
    const uiAxisHandler*        yAxis( bool y2) const
                                                { return y2 ? y2ax_ : yax_; }
    Setup&                      setup()         { return setup_; }
 
    Geom::Point2D<float>        getFuncXY(int xpix,bool y2) const;
    Geom::Point2D<float>        getXYFromPix(const Geom::Point2D<int>& pix,
                                             bool y2) const;
 
    int                         size() const    { return xvals_.size(); }
 
    Notifier<uiFunctionDisplay> pointSelected;
    Notifier<uiFunctionDisplay> pointChanged;
    int                         selPt() const   { return selpt_; }
 
    void                        gatherInfo(bool y2=false);
    void                        draw();
 
    void                        dump(od_ostream&,bool y2) const;
 
protected:
 
    Setup                       setup_;
    uiAxisHandler*              xax_;
    uiAxisHandler*              yax_;
    uiAxisHandler*              y2ax_;
    uiGraphicsItem*             ypolyitem_;
    uiGraphicsItem*             y2polyitem_;
    uiPolygonItem*              ypolygonitem_;
    uiPolygonItem*              y2polygonitem_;
    uiPolyLineItem*             ypolylineitem_;
    uiPolyLineItem*             y2polylineitem_;
    uiRectItem*                 borderrectitem_;
    uiGraphicsItemGroup*        ymarkeritems_;
    uiGraphicsItemGroup*        y2markeritems_;
    uiLineItem*                 xmarklineitem_;
    uiLineItem*                 ymarklineitem_;
    uiLineItem*                 xmarkline2item_;
    uiLineItem*                 ymarkline2item_;
    uiTextItem*                 titleitem_;
 
    TypeSet<float>              xvals_;
    TypeSet<float>              yvals_;
    TypeSet<float>              y2xvals_;
    TypeSet<float>              y2yvals_;
    float                       xmarklineval_;
    float                       ymarklineval_;
    float                       xmarkline2val_;
    float                       ymarkline2val_;
    int                         selpt_;
    bool                        mousedown_;
 
    void                        mousePress(CallBacker*);
    void                        mouseRelease(CallBacker*);
    void                        mouseMove(CallBacker*);
    void                        mouseDClick(CallBacker*);
    void                        addPoint(const uiPoint&);
 
    void                        cleanUp();
    void                        setUpAxis(bool y2);
    void                        getPointSet(TypeSet<uiPoint>&,bool y2);
    void                        drawYCurve(const TypeSet<uiPoint>&);
    void                        drawY2Curve(const TypeSet<uiPoint>&,bool havy2);
    void                        drawMarker(const TypeSet<uiPoint>&,
                                           bool y2=false);
    void                        drawMarkLine(uiAxisHandler*,float,Color,
                                             uiLineItem*&);
    void                        drawBorder();
    void                        drawMarkLines();
    bool                        setSelPt();
    void                        reSized( CallBacker* );
    void                        saveImageAs( CallBacker* );
    void                        getAxisRanges(const TypeSet<float>& vals,
                                              const Interval<float>& setuprg,
                                              Interval<float>&) const;
 
    virtual void                drawData();
};