Generated/html/uidatapointsetcrossplot_8h_source.html

#pragma once


/*+

________________________________________________________________________


 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt

 Author:        Bert

 Date:          Mar 2008

 RCS:           $Id$

________________________________________________________________________


-*/


#include "uiiomod.h"

#include "uiaxishandler.h"

#include "uidatapointset.h"

#include "coltabsequence.h"

#include "coltabmapper.h"

#include "datapointset.h"

#include "uirgbarraycanvas.h"

#include "uiaxisdata.h"

#include "rowcol.h"

#include "linear.h"

#include "uidpscrossplottools.h"


class RowCol;

class MouseEvent;

class LinStats2D;

class Timer;

class uiDataPointSet;

class uiPolygonItem;

class uiLineItem;

class uiPolyLineItem;

class uiRectItem;

class uiGraphicsItemGroup;

class uiGraphicsItem;

class uiColTabItem;

class uiRect;

template <class T> class Array1D;

namespace Math { class Expression; }


mExpClass(uiIo) uiDataPointSetCrossPlotter : public uiRGBArrayCanvas

{ mODTextTranslationClass(uiDataPointSetCrossPlotter);

public:


    struct Setup

    {

                        Setup();


        mDefSetupMemb(bool,noedit)

        mDefSetupMemb(uiBorder,minborder)

        mDefSetupMemb(MarkerStyle2D,markerstyle) // None => uses drawPoint

        mDefSetupMemb(OD::LineStyle,xstyle)

        mDefSetupMemb(OD::LineStyle,ystyle)

        mDefSetupMemb(OD::LineStyle,y2style)

        mDefSetupMemb(bool,showcc)              // corr coefficient

        mDefSetupMemb(bool,showregrline)

        mDefSetupMemb(bool,showy1userdefpolyline)

        mDefSetupMemb(bool,showy2userdefpolyline)

    };


                        uiDataPointSetCrossPlotter(uiParent*,uiDataPointSet&,

                                                   const Setup&);

                        ~uiDataPointSetCrossPlotter();


    const Setup&        setup() const           { return setup_; }

    Setup&              setup()                 { return setup_; }


    void                setCols(DataPointSet::ColID x,

                                DataPointSet::ColID y,

                                DataPointSet::ColID y2);

    void                setOverlayY1Cols(DataPointSet::ColID y3);

    void                setOverlayY2Cols(DataPointSet::ColID y3);


    Notifier<uiDataPointSetCrossPlotter>        lineDrawn;

    Notifier<uiDataPointSetCrossPlotter>        mouseReleased;

    Notifier<uiDataPointSetCrossPlotter>        dataChgd;

    Notifier<uiDataPointSetCrossPlotter>        pointsSelected;

    Notifier<uiDataPointSetCrossPlotter>        removeRequest;

    Notifier<uiDataPointSetCrossPlotter>        selectionChanged;

    CNotifier<uiDataPointSetCrossPlotter,bool>  drawTypeChanged;

    CNotifier<uiDataPointSetCrossPlotter,Interval<float> > coltabRgChanged;

    DataPointSet::RowID selRow() const          { return selrow_; }

    bool                selRowIsY2() const      { return selrowisy2_; }


    void                dataChanged();


    mExpClass(uiIo) AxisData :  public uiAxisData

    { mODTextTranslationClass(AxisData);

        public:

                                AxisData(uiDataPointSetCrossPlotter&,

                                         uiRect::Side);


        void                    stop();

        void                    setCol(DataPointSet::ColID);


        void                    newColID();


        uiDataPointSetCrossPlotter& cp_;

        DataPointSet::ColID     colid_;

    };


    AxisData                    x_;

    AxisData                    y_;

    AxisData                    y2_;

    int                         getRow(const AxisData&,uiPoint) const;

    void                        drawData(const AxisData&,bool y2,

                                         bool rempts = false);

    void                        drawRegrLine(uiAxisHandler*,

                                             const Interval<int>&);


    void                        prepareItems(bool y2);

    void                        addItemIfNew(int itmidx,MarkerStyle2D&,

                                        uiGraphicsItemGroup*,uiAxisHandler&,

                                        uiDataPointSet::DRowID,bool);

    void                        setItem(uiGraphicsItem*,bool y2,const uiPoint&);

    void                        setAnnotEndTxt(uiAxisHandler&);

    int                         calcDensity(Array2D<float>*,bool chgdps=false,

                                            bool removesel=false,

                                            bool isy2=false, int areatyp=0,

                                            Interval<int>* cellsz = 0,

                                            Array2D<float>* freqdata = 0);

    int                         calculateDensity(Array2D<float>*,

                                                 bool chgdps=false,

                                                 bool removesel=false);

    void                        drawDensityPlot(bool removesel=false);

    bool                        drawPoints(uiGraphicsItemGroup*,

                                           const AxisData&,bool y2,

                                           MarkerStyle2D&,bool rempt = false);

    void                        removeSelectionItems();


    void                        setSceneSelectable( bool yn )

                                { selectable_ = yn; }

    bool                        isSceneSelectable() const

                                { return selectable_; }

    void                        setSelectable( bool y1, bool y2 );

    void                        removeSelections(bool relfrmselgrp = true);

    void                        deleteSelections();

    float                       getSelectedness(uiDataPointSet::DRowID,

                                                bool fory2);

    void                        checkSelection(uiDataPointSet::DRowID,

                                   uiGraphicsItem*,bool,const AxisData&,

                                   bool rempt = false);

    bool                        checkSelArea(const SelectionArea&) const;

    AxisData::AutoScalePars&    autoScalePars( int ax )

                                { return axisData(ax).autoscalepars_; }

    uiAxisHandler*              axisHandler( int ax )

                                { return axisData(ax).axis_; }

    const uiAxisHandler*        axisHandler( int ax ) const

                                { return axisData(ax).axis_; }

    const LinStats2D&           linStats( bool y1=true ) const

                                { return y1 ? lsy1_ : lsy2_; }


    AxisData&                   axisData( int ax )

                                { return ax ? (ax == 2 ? y2_ : y_) : x_; }

    const AxisData&             axisData( int ax ) const

                                { return ax ? (ax == 2 ? y2_ : y_) : x_; }


    friend class                uiDataPointSetCrossPlotWin;

    friend class                AxisData;


    LinePars&                   userdefy1lp_;

    LinePars&                   userdefy2lp_;


    BufferString&               userdefy1str_;

    BufferString&               userdefy2str_;


    BufferString&               y1rmserr_;

    BufferString&               y2rmserr_;


    void                        setMathObj(Math::Expression*);

    void                        setMathObjStr( const char* str )

                                                        { mathobjstr_ = str; }

    const OD::String&           mathObjStr() const      { return mathobjstr_; }

    Math::Expression*           mathObj() const         { return mathobj_; }

    void                        setModifiedColIds(

                                    const TypeSet<uiDataPointSet::DColID>& ids )

                                { modcolidxs_ = ids; }

    const TypeSet<int>&         modifiedColIds() const  { return modcolidxs_; }


    const DataPointSet&         dps() const             { return dps_; }

    DataPointSet&               dps()                   { return dps_; }


    const uiDataPointSet&       uidps() const           { return uidps_; }

    uiDataPointSet&             uidps()                 { return uidps_; }


    const TypeSet<RowCol>&      getSelectedCells()      { return selrowcols_; }


    int                         nrYSels() const         { return selyitems_; }

    int                         nrY2Sels() const        { return sely2items_; }


    TypeSet<Color>&             y1grpColors()           { return y1grpcols_; }

    TypeSet<Color>&             y2grpColors()           { return y2grpcols_; }


    void                        setColTab( const ColTab::Sequence& ctseq )

                                { ctab_ = ctseq; }

    void                        setCTMapper(const ColTab::MapperSetup&);

    void                        showY2(bool);

    void                        drawContent( bool withaxis = true );

    void                        drawColTabItem(bool isy1);

    bool                        isY2Shown() const;

    bool                        isY1Selectable() const

                                { return isy1selectable_; }

    bool                        isY2Selectable() const

                                { return isy2selectable_; }

    bool                        showY3() const          { return showy3_; }

    bool                        showY4() const          { return showy4_; }

    void                        setShowY3(bool);

    void                        setShowY4(bool);

    bool                        isADensityPlot() const { return isdensityplot_;}

    void                        setDensityPlot(bool yn,bool showy2);

    bool                        isRectSelection() const

                                { return rectangleselection_; }

    void                        setRectSelection( bool yn )

                                { rectangleselection_ = yn; }


    SelectionArea&              getCurSelArea();

    void                        setSelArea(const SelectionArea&,int selgrpidx);

    bool                        getSelArea(SelectionArea&,int selareaid);

    ObjectSet<SelectionGrp>&    selectionGrps()         { return selgrpset_; }

    const ObjectSet<SelectionGrp>& selectionGrps() const

                                { return selgrpset_; }

    int                         selAreaSize() const;

    int                         curGroup() const        { return curgrp_; }

    void                        reDrawSelections();

    TypeSet<Color>              selGrpCols() const;

    void                        setCurSelGrp(int grp)   { curselgrp_ = grp; }

    int                         curSelGrp() const       { return curselgrp_; }


    int                         getNewSelAreaID() const;

    bool                        isSelAreaValid(int id) const;

    int                         getSelGrpIdx(int selareaid) const;

    void                        setTRMsg( const uiString& msg )

                                { trmsg_ = msg; }

    int                         totalNrItems() const;

    void                        getRandRowids();

    void                        setMultiColMode(bool yn)

                                { multclron_ = yn; }

    bool                        isMultiColMode() const  { return multclron_; }

    void                        setCellSize( int sz )   { cellsize_ = sz; }

    int                         cellSize() const        { return cellsize_; }

    bool                        isSelectionValid(uiDataPointSet::DRowID);


    void                        setOverlayY1AttMapr(const ColTab::MapperSetup&);

    void                        setOverlayY2AttMapr(const ColTab::MapperSetup&);

    void                        setOverlayY1AttSeq(const ColTab::Sequence&);

    void                        setOverlayY2AttSeq(const ColTab::Sequence&);


    void                        setUserDefDrawType(bool dodrw,bool isy2,

                                                        bool drwln = false);

    void                        setUserDefPolyLine(TypeSet<uiWorldPoint>&,bool);

    void                        drawUserDefPolyLine(bool);


    void                        updateOverlayMapper(bool isy1);

    Color                       getOverlayColor(uiDataPointSet::DRowID,bool);


    int                         y3Colid() const         { return y3colid_; }

    int                         y4Colid() const         { return y4colid_; }

    const ColTab::Mapper&       y3Mapper() const        { return y3mapper_; }

    const ColTab::Mapper&       y4Mapper() const        { return y4mapper_; }

    const ColTab::Sequence&     y3CtSeq() const         { return y3ctab_; }

    const ColTab::Sequence&     y4CtSeq() const         { return y4ctab_; }


    float                       getVal(int colid,int rid) const;


protected:


    int                         y3colid_;

    int                         y4colid_;


    uiDataPointSet&             uidps_;

    DataPointSet&               dps_;

    Setup                       setup_;

    Math::Expression*           mathobj_;

    BufferString                mathobjstr_;

    uiString                    trmsg_;


    uiPolygonItem*              selectionpolygonitem_;

    uiRectItem*                 selectionrectitem_;

    uiGraphicsItemGroup*        yptitems_;

    uiGraphicsItemGroup*        y2ptitems_;

    uiGraphicsItemGroup*        selrectitems_;

    uiGraphicsItemGroup*        selpolyitems_;

    uiLineItem*                 regrlineitm_;

    uiPolyLineItem*             y1userdefpolylineitm_;

    uiPolyLineItem*             y2userdefpolylineitm_;

    uiColTabItem*               y1overlayctitem_;

    uiColTabItem*               y2overlayctitem_;


    ColTab::Sequence            ctab_;

    ColTab::Mapper              ctmapper_;

    ColTab::Sequence            y3ctab_;

    ColTab::Sequence            y4ctab_;

    ColTab::Mapper              y3mapper_;

    ColTab::Mapper              y4mapper_;

    LinStats2D&                 lsy1_;

    LinStats2D&                 lsy2_;

    Timer&                      timer_;

    bool                        showy3_;

    bool                        showy4_;

    bool                        selectable_;

    bool                        mousepressed_;

    bool                        rectangleselection_;

    bool                        isdensityplot_;

    bool                        drawuserdefline_;

    bool                        drawy1userdefpolyline_;

    bool                        drawy2userdefpolyline_;

    bool                        drawy2_;

    float                       plotperc_;

    int                         curgrp_;

    int                         selyitems_;

    int                         sely2items_;

    int                         curselarea_;

    int                         curselgrp_;

    int                         cellsize_;

    const DataPointSet::ColID   mincolid_;

    DataPointSet::RowID         selrow_;

    Interval<int>               usedxpixrg_;

    TypeSet<RowCol>             selrowcols_;

    TypeSet<Color>              y1grpcols_;

    TypeSet<Color>              y2grpcols_;

    TypeSet<uiWorldPoint>       y1userdefpts_;

    TypeSet<uiWorldPoint>       y2userdefpts_;

    Array1D<char>*              yrowidxs_;

    Array1D<char>*              y2rowidxs_;

    TypeSet<uiDataPointSet::DColID> modcolidxs_;

    bool                        selrowisy2_;

    uiPoint                     startpos_;


    ObjectSet<SelectionArea>    selareaset_;

    ObjectSet<SelectionGrp>     selgrpset_;

    bool                        isy1selectable_;

    bool                        isy2selectable_;

    bool                        multclron_;


    void                        initDraw();

    void                        setDraw();

    void                        calcStats();

    void                        setWorldSelArea(int);

    void                        reDrawSelArea();

    bool                        drawRID(uiDataPointSet::DRowID,

                                        uiGraphicsItemGroup*,

                                        const AxisData&,bool y2,

                                        MarkerStyle2D&,int idmidx,bool rempt);


    bool                        selNearest(const MouseEvent&);

    void                        reDrawCB(CallBacker*);

    void                        reSizeDrawCB(CallBacker*);

    void                        mouseClickedCB(CallBacker*);

    void                        mouseMoveCB(CallBacker*);

    void                        mouseReleasedCB(CallBacker*);

};