vismpe.h

Go to the documentation of this file.

#ifndef vismpe_h
#define vismpe_h

/*+
________________________________________________________________________

(C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
Author:    N. Hemstra
Date:        August 2002
RCS:        $Id$
________________________________________________________________________


-*/

#include "mousecursor.h"
#include "vissurveymod.h"
#include "vissurvobj.h"
#include "visobject.h"

namespace Attrib { class SelSpec; }
template <class T> class Selector;
class RegularSeisDataPack;
class ZAxisTransform;

namespace visBase
{
    class BoxDragger;
    class TextureChannels;
    class OrthogonalSlice;
    class Transformation;
};

namespace ColTab { class MapperSetup; class Sequence; }
namespace MPE { class Engine; };
class TaskRunner;


namespace visSurvey
{

mExpClass(visSurvey) MPEDisplay : public visBase::VisualObjectImpl, 
                    public visSurvey::SurveyObject
{
public:
                    MPEDisplay();
                    mDefaultFactoryInstantiation( 
                        visSurvey::SurveyObject,MPEDisplay,
                             "MPEDisplay", ::toUiString(sFactoryKeyword()));

    bool            isInlCrl() const    { return true; }
    bool            isOn() const;

    void            showBoxDragger(bool);
    bool            isBoxDraggerShown() const;
    
    void            showDragger(bool yn);
    bool            isDraggerShown() const;

    void            enablePicking(bool);
    bool            isPickingEnabled() const;
    
    void            setDraggerTransparency(float);
    float           getDraggerTransparency() const;
    
    void            setPlaneOrientation(int orient);
    int             getPlaneOrientation() const;

    bool            getPlanePosition(TrcKeyZSampling&) const;
    void            moveMPEPlane(int nrsteps);    

    void            updateBoxSpace();
    void            freezeBoxPosition(bool yn);

    TrcKeyZSampling     getTrcKeyZSampling(int attrib=-1) const;
   
    void            setSelSpec(int,const Attrib::SelSpec&);
    const char*         getSelSpecUserRef() const;
    const Attrib::SelSpec*      getSelSpec(int attrib,int version=0) const;

    const ColTab::MapperSetup*  getColTabMapperSetup(int, int version=0) const;
    void            setColTabMapperSetup(int,
                    const ColTab::MapperSetup&,TaskRunner*);
    
    const ColTab::Sequence*    getColTabSequence(int) const;
    bool            canSetColTabSequence() const;
    void            setColTabSequence(int,const ColTab::Sequence&,
                                      TaskRunner*);

    const MouseCursor*   getMouseCursor() const { return &mousecursor_; }

    void            getMousePosInfo( const visBase::EventInfo& ei,
                                     IOPar& iop ) const
                    { return SurveyObject::getMousePosInfo(ei,iop);}
    void            getMousePosInfo(const visBase::EventInfo&, Coord3&, 
                                  BufferString& val, BufferString& info) const;
    void            getObjectInfo(BufferString&) const;

    void            updateSeedOnlyPropagation(bool);
    void            updateMPEActiveVolume();
    void            removeSelectionInPolygon(const Selector<Coord3>&,
                                             TaskRunner*);

    virtual float       calcDist(const Coord3&) const;
    virtual float       maxDist() const;

    virtual void        fillPar(IOPar&) const;
    virtual bool        usePar( const IOPar&);

    NotifierAccess*     getMovementNotifier();
    
    Notifier<MPEDisplay>        boxDraggerStatusChange;
    Notifier<MPEDisplay>        planeOrientationChange;
        
    // methods for volume-based display
    int                 addSlice(int dim, bool show);
    visBase::OrthogonalSlice*   getSlice(int index);
    void                updateSlice();
    float               slicePosition(visBase::OrthogonalSlice*) const;
    float               getValue(const Coord3&) const;   
        
    void                removeChild(int displayid);
    void                getChildren(TypeSet<int>&) const;
        
    bool                setZAxisTransform(ZAxisTransform*,TaskRunner*);
    const ZAxisTransform*       getZAxisTransform() const;

    void                setRightHandSystem(bool yn);
   
    bool                setDataVolume(int attrib,const RegularSeisDataPack*,
                                      TaskRunner*);
    void                setTrcKeyZSampling(const TrcKeyZSampling&);
    
    const RegularSeisDataPack*  getCacheVolume(int attrib) const;
    bool                setDataPackID(int attrib,DataPack::ID,TaskRunner*);
    DataPack::ID        getDataPackID(int attrib) const;
    virtual DataPackMgr::ID     getDataPackMgrID() const
                                { return DataPackMgr::SeisID(); }
    
    virtual bool        allowsPicks() const;
    void                allowShading(bool yn );
    bool                hasPosModeManipulator() const           { return true; }
    void                showManipulator(bool yn);
    bool                isManipulated() const;
    bool                canResetManipulation() const;
    void                resetManipulation();
    void                acceptManipulation();
    BufferString        getManipulationString() const;
    NotifierAccess*     getManipulationNotifier();

    static int          cInLine()       { return 0; }
    static int          cCrossLine()    { return 1; }
    static int          cTimeSlice()    { return 2; }
   
    // texture channel-related methods

    SurveyObject::AttribFormat  getAttributeFormat(int attrib=-1) const;

    bool                canAddAttrib(int nrattribstoadd=1) const;
    bool                canRemoveAttrib() const;
    int                 nrAttribs() const;
    bool                addAttrib();
    bool                removeAttrib(int attrib);
    void                enableAttrib(int attrib,bool yn);
    bool                isAttribEnabled(int attrib) const;

    const char*         errMsg() const { return errmsg_.str(); }

    void                setDisplayTransformation(const mVisTrans*);

    
protected:
                        ~MPEDisplay();
    TrcKeyZSampling     getBoxPosition() const;
    void                setPlanePosition(const TrcKeyZSampling&);

    void                setSliceDimension(int slice,int dim);
    void                alignSliceToSurvey(visBase::OrthogonalSlice&);
        
    void                setSceneEventCatcher(visBase::EventCatcher*);

    // callback from boxdragger
    void                boxDraggerFinishCB(CallBacker*);

    // callbacks from MPE
    void                updateBoxPosition(CallBacker*);

    // methods for volume-based display
    TrcKeyZSampling     getTrcKeyZSampling(bool manippos,bool display,
                                        int attrib) const;
    
    void                triggerSel();
    void                triggerDeSel();

    bool                pickable() const        { return true; }
    bool                rightClickable() const  { return false; }
    bool                selectable() const      { return false; }  // check!
    bool                isSelected() const;
   
    void                turnOnSlice(bool);
    void                updateRanges(bool updateic,bool updatez);
   
    // callback from user
    void                mouseClickCB(CallBacker*);
    void                updateMouseCursorCB(CallBacker*);
    
    // other callbacks
    void                dataTransformCB(CallBacker*);
    void                sliceMoving(CallBacker*);
    
    // texture channel-related methods
    bool                updateFromCacheID(int attrib, TaskRunner* tr);

    MPE::Engine&                engine_;
    visBase::BoxDragger*        boxdragger_;
    visBase::EventCatcher*      sceneeventcatcher_;    
    MouseCursor                 mousecursor_;
    Notifier<MPEDisplay>        movement;    
    Attrib::SelSpec&            as_;
    bool                        manipulated_;
    int                         lasteventnr_;

    Attrib::SelSpec&            curtextureas_;
    TrcKeyZSampling             curtexturecs_;

    // data for volume-based display
    visBase::Transformation*    voltrans_;
    ObjectSet<visBase::OrthogonalSlice> slices_;
    DataPack::ID                cacheid_;
    const RegularSeisDataPack*  volumecache_;
    BufferString                sliceposition_;
    BufferString                slicename_;
    TrcKeyZSampling             csfromsession_;
    bool                        issliceshown_;
    bool                        allowshading_;
    int                         dim_;
    ZAxisTransform*             datatransform_;
   
    // texture channel-related data
    visBase::TextureChannels*   channels_;

    RefMan<const mVisTrans>     displaytrans_;
    Coord3                      curboxcenter_;
    Coord3                      curboxwidth_;

    // common keys
    static const char*          sKeyTransparency() { return "Transparency"; }
    static const char*          sKeyBoxShown()     { return "Box Shown"; }

    static const char*          sKeyBoxDepthKey()   { return "BoxDepthKey"; }
    static const char*          sKeyBoxPlaneKey()   { return "BoxPlaneKey"; }
    static const char*          sKeyInDepthBoxResize()
                                                { return "InDepthBoxResize"; }

    static const Color          reTrackColor;
    static const Color          eraseColor;
    static const Color          movingColor;
    static const Color          extendColor;

    // volume-related keys
    static const char*          sKeyNrSlices()  { return "Nr of slices"; }
    static const char*          sKeySlice()     { return "SliceID"; }
    static const char*          sKeyInline()    { return "Inline"; }
    static const char*          sKeyCrossLine() { return "Crossline"; }
    static const char*          sKeyTime()      { return "Time"; }

};

}; // namespace visSurvey

#endif