visrandomtrackdisplay.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        N. Hemstra
 Date:          January 2003
 RCS:           $Id$
________________________________________________________________________
 
 
-*/
 
#include "mousecursor.h"
#include "vissurveymod.h"
#include "vismultiattribsurvobj.h"
#include "ranges.h"
 
class TrcKeyZSampling;
 
namespace visBase
{
    class EventCatcher;
    class PolyLine;
    class RandomTrackDragger;
    class MarkerSet;
    class TexturePanelStrip;
}
 
namespace Geometry
{
    class RandomLine;
}
 
 
namespace visSurvey
{
 
class Scene;
 
mExpClass(visSurvey) RandomTrackDisplay : public MultiTextureSurveyObject
 
{ mODTextTranslationClass(RandomTrackDisplay);
public:
                                RandomTrackDisplay();
                                mDefaultFactoryInstantiation(
                                    visSurvey::SurveyObject,RandomTrackDisplay,
                                    "RandomTrackDisplay",
                                    toUiString(sFactoryKeyword()));
 
    void                        setRandomLineID(int id);
    int                         getRandomLineID() const;
    Geometry::RandomLine*       getRandomLine();
 
    int                         nameNr() const { return namenr_; }
    bool                        isInlCrl() const { return true; }
 
    int                         nrResolutions() const   { return 3; }
    void                        setResolution(int,TaskRunner*);
 
    bool                        hasPosModeManipulator() const   { return true; }
    void                        showManipulator(bool yn);
    bool                        isManipulatorShown() const;
    bool                        isManipulated() const;
    bool                        canResetManipulation() const { return true; }
    void                        resetManipulation();
    void                        acceptManipulation();
    BufferString                getManipulationString() const;
 
    bool                        canDuplicate() const            { return true; }
    SurveyObject*               duplicate(TaskRunner*) const;
    MultiID                     getMultiID() const;
 
    bool                        allowMaterialEdit() const { return true; }
 
    SurveyObject::AttribFormat  getAttributeFormat(int attrib) const;
 
    TypeSet<BinID>*             getPath()               { return &trcspath_; }
    void                        getDataTraceBids(TypeSet<BinID>&) const;
 
    void                        getTraceKeyPath(TrcKeyPath&,
                                                TypeSet<Coord>*) const;
    Interval<float>             getDataTraceRange() const;
    TypeSet<Coord>              getTrueCoords() const;
 
    bool                        setDataPackID(int attrib,DataPack::ID,
                                                TaskRunner*);
    DataPack::ID                getDataPackID(int attrib) const;
    DataPack::ID                getDisplayedDataPackID(int attrib) const;
    virtual DataPackMgr::ID     getDataPackMgrID() const
                                { return DataPackMgr::SeisID(); }
 
    bool                        canAddNode(int nodenr) const;
    void                        addNode(int nodenr);
    int                         nrNodes() const;
    void                        addNode(const BinID&);
    void                        insertNode(int,const BinID&);
    void                        setNodePos(int,const BinID&);
    BinID                       getNodePos(int) const;
    BinID                       getManipNodePos(int) const;
    void                        getAllNodePos(TypeSet<BinID>&) const;
    TypeSet<BinID>*             getNodes()              { return &nodes_; }
    void                        removeNode(int);
    void                        removeAllNodes();
    bool                        setNodePositions(const TypeSet<BinID>&);
    void                        lockGeometry(bool);
    bool                        isGeometryLocked() const;
 
    TrcKeyZSampling             getTrcKeyZSampling(int attrib) const;
    void                        setDepthInterval(const Interval<float>&);
    Interval<float>             getDepthInterval() const;
 
    const MouseCursor*          getMouseCursor() const { return &mousecursor_; }
 
    void                        getMousePosInfo(const visBase::EventInfo&,
                                                IOPar&) const;
    void                        getMousePosInfo(const visBase::EventInfo&,
                                                Coord3&, BufferString&,
                                                BufferString&) const;
 
    int                         getSelNodeIdx() const   { return selnodeidx_; }
 
    virtual NotifierAccess*     getMovementNotifier()   { return &moving_; }
    NotifierAccess*             getManipulationNotifier() {return &nodemoving_;}
 
    int                         getClosestPanelIdx(const Coord&) const;
    Coord3                      getNormal(const Coord3&) const;
    virtual float               calcDist(const Coord3&) const;
    virtual bool                allowsPicks() const             { return true; }
 
    virtual void                fillPar(IOPar&) const;
    virtual bool                usePar(const IOPar&);
 
    bool                        canBDispOn2DViewer() const      { return true; }
    void                        setSceneEventCatcher(visBase::EventCatcher*);
    visBase::TexturePanelStrip* getTexturePanelStrip() const
                                { return panelstrip_; }
    BufferString                getRandomLineName() const;
 
 
    Notifier<RandomTrackDisplay> moving_;
    Notifier<RandomTrackDisplay> nodemoving_;
 
    const char*                 errMsg() const { return errmsg_.str(); }
    void                        setPolyLineMode(bool yn);
    bool                        createFromPolyLine();
    void                        setColor(Color);
 
    bool                        setZAxisTransform(ZAxisTransform*,TaskRunner*);
    const ZAxisTransform*       getZAxisTransform() const;
 
    void                        setDisplayTransformation(const mVisTrans*);
    const mVisTrans*            getDisplayTransformation() const;
 
    virtual void                annotateNextUpdateStage(bool yn);
    virtual void                setPixelDensity(float);
    const TrcKeyPath*           getTrcKeyPath()
                                { return &trckeypath_; }
 
    static const char*          sKeyPanelDepthKey()  { return "PanelDepthKey"; }
    static const char*          sKeyPanelPlaneKey()  { return "PanelPlaneKey"; }
    static const char*          sKeyPanelRotateKey() { return "PanelRotateKey";}
 
protected:
                                ~RandomTrackDisplay();
 
    bool                        getCacheValue(int attrib,int version,
                                              const Coord3&,float&) const;
 
    void                        addCache();
    void                        removeCache(int);
    void                        swapCache(int,int);
    void                        emptyCache(int);
    bool                        hasCache(int) const;
 
    void                        getDataTraceBids(TypeSet<BinID>&,
                                                 TypeSet<int>* segments) const;
    BinID                       proposeNewPos(int node) const;
    void                        updateChannels(int attrib,TaskRunner*);
    void                        createTransformedDataPack(int attrib,
                                                          TaskRunner* =0);
    void                        setNodePos(int,const BinID&,bool check);
 
    BinID                       snapPosition(const BinID&) const;
    bool                        checkPosition(const BinID&) const;
 
    void                        geomChangeCB(CallBacker*);
    void                        nodeMoved(CallBacker*);
    void                        draggerRightClick(CallBacker*);
 
    void                        pickCB(CallBacker*);
    bool                        checkValidPick(const visBase::EventInfo&,
                                               const Coord3& pos) const;
    void                        setPickPos(const Coord3& pos);
    void                        removePickPos(const Coord3&);
    void                        dataTransformCB(CallBacker*);
    void                        updateRanges(bool,bool);
 
    void                        updatePanelStripPath();
    void                        setPanelStripZRange(const Interval<float>&);
    float                       appliedZRangeStep() const;
    void                        draggerMoveFinished(CallBacker*);
    void                        updateMouseCursorCB(CallBacker*);
 
    int                         nrgeomchangecbs_;
 
    Geometry::RandomLine*       rl_;
    visBase::TexturePanelStrip* panelstrip_;
 
    visBase::RandomTrackDragger* dragger_;
 
    visBase::PolyLine*          polyline_;
    visBase::MarkerSet*         markerset_;
 
    visBase::EventCatcher*      eventcatcher_;
    MouseCursor                 mousecursor_;
 
    int                         selnodeidx_;
    TypeSet<DataPack::ID>       datapackids_;
    TypeSet<DataPack::ID>       transfdatapackids_;
    TypeSet<BinID>              trcspath_;
    TypeSet<BinID>              nodes_;
 
    ZAxisTransform*             datatransform_;
    Interval<float>             depthrg_;
    int                         voiidx_;
 
    TrcKeyPath                  trckeypath_;
    int                         pickstartnodeidx_;
    bool                        ispicking_;
    int                         oldstyledoubleclicked_;
 
    struct UpdateStageInfo
    {
        float                   oldzrgstart_;
        float                   mapfactor_;     // obsolete
    };
    UpdateStageInfo             updatestageinfo_;
 
    bool                        lockgeometry_;
    bool                        ismanip_;
    int                         namenr_;
    bool                        polylinemode_;
    bool                        interactivetexturedisplay_;
    int                         originalresolution_;
 
    static const char*          sKeyTrack();
    static const char*          sKeyNrKnots();
    static const char*          sKeyKnotPrefix();
    static const char*          sKeyDepthInterval();
    static const char*          sKeyLockGeometry();
 
    void                        updateTexOriginAndScale(
                                            int attrib,const TrcKeyPath&,
                                            const StepInterval<float>& zrg);
public:
 
    bool                        getSelMousePosInfo(const visBase::EventInfo&,
                                                   Coord3&, BufferString&,
                                                   BufferString&) const;
    const TypeSet<BinID>*       getPath() const         { return &trcspath_; }
 
protected:
    int                         getClosestPanelIdx(const Coord&,
                                                   double* fracptr) const;
    void                        mouseCB(CallBacker*);
    bool                        isPicking() const;
    void                        removePickPos(int polyidx);
 
    void                        addNodeInternal(const BinID&);
    void                        insertNodeInternal(int,const BinID&);
    void                        removeNodeInternal(int);
    void                        movingNodeInternal(int selnodeidx);
    void                        finishNodeMoveInternal();
    void                        geomNodeMoveCB( CallBacker*);
    void                        setNodePositions(const TypeSet<BinID>&,
                                                 bool onlyinternal);
 
    bool                        isMappingTraceOfBid(BinID bid,int trcidx,
                                                    bool forward=true) const;
 
    void                        snapZRange(Interval<float>&);
};
 
} // namespace visSurvey