Generated/html/vissurvobj_8h_source.html

#pragma once


/*+

________________________________________________________________________


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

 Author:        Kristofer Tingdahl

 Date:          4-11-2002

 RCS:           $Id$

________________________________________________________________________


-*/


#include "vissurveymod.h"

#include "color.h"

#include "trckeyzsampling.h"

#include "datapack.h"

#include "gendefs.h"

#include "multiid.h"

#include "position.h"

#include "ranges.h"

#include "survinfo.h"

#include "vissurvscene.h"

#include "factory.h"

#include "attribsel.h"


class DataPointSet;

class NotifierAccess;

class RegularSeisDataPack;

class SeisTrcBuf;

class ZAxisTransform;

class TaskRunner;


namespace ColTab  { class MapperSetup; class Sequence; }

namespace OD { class LineStyle; }


namespace visBase

{

    class Transformation;

    class EventInfo;

    class TextureChannels;

    class TextureChannel2RGBA;

}


namespace Attrib { class SelSpec; }

namespace Survey { class Geometry3D; }


namespace visSurvey

{


mExpClass(visSurvey) SurveyObject

{

public:

    void                        doRef();

    void                        doUnRef();


                                mDefineFactoryInClass(SurveyObject,factory)


    virtual void                set3DSurvGeom(const Survey::Geometry3D*);

    const Survey::Geometry3D*   get3DSurvGeom() const { return s3dgeom_; }

    virtual const char*         get3DSurvGeomName() const;

    virtual Pos::GeomID         getGeomID() const;


    virtual Coord3              getNormal(const Coord3& pos) const

                                { return Coord3::udf(); }

    virtual float               calcDist(const Coord3& pos) const

                                { return mUdf(float); }

                                /*<\Calculates distance between pick and

                                    object.

                                    \note The distance is in display space.

                                    \param pos Position to be checked in

                                           displayspace.

                                 \ */

    virtual float               maxDist() const         { return sDefMaxDist();}

                                /*<\Returns maximum allowed distance between

                                    pick and object. If calcDist() > maxDist()

                                    pick will not be displayed. */

    virtual bool                allowsPicks() const     { return false; }

                                /*<\Returns whether picks can be created

                                    on object. */

    virtual bool                isPicking() const       { return false; }

                                /*<\Returns true if object is in a mode

                                    where clicking on other objects are

                                    handled by object itself, and not passed

                                    on to selection manager .*/

    virtual void                getPickingMessage( BufferString& msg ) const

                                { msg = "Picking"; }


    virtual void                snapToTracePos(Coord3&) const {}

                                //<\Snaps coordinate to a trace position


    virtual NotifierAccess*     getMovementNotifier()   { return 0; }

    virtual void                otherObjectsMoved(

                                    const ObjectSet<const SurveyObject>&,

                                    int whichobj ) {}

    virtual void                setTranslation(const Coord3&) {}

    virtual Coord3              getTranslation() const

                                { return Coord3(0,0,0); }


    virtual void                getChildren( TypeSet<int>& ) const      {}


    virtual bool                canDuplicate() const    { return false;}

    virtual SurveyObject*       duplicate(TaskRunner*) const    { return 0; }


    virtual MultiID             getMultiID() const { return MultiID::udf(); }


    virtual bool                hasPosModeManipulator() const   { return false;}

    virtual void                showManipulator(bool yn)        {}

    virtual bool                isManipulatorShown() const      { return false;}

    virtual bool                isManipulated() const           { return false;}

    virtual bool                canResetManipulation() const    { return false;}

    virtual void                resetManipulation()             {}

    virtual void                acceptManipulation()            {}

    virtual BufferString        getManipulationString() const   { return ""; }

    virtual NotifierAccess*     getManipulationNotifier()       { return 0; }

    virtual void                enableEditor(bool yn)           {}


    virtual bool                allowMaterialEdit() const       { return false;}

    virtual const OD::LineStyle* lineStyle() const { return 0; }

    virtual void                setLineStyle(const OD::LineStyle&) {}

    virtual void                getLineWidthBounds(int& min,int& max);

    virtual bool                hasSpecificLineColor() const { return false; }

    virtual void                setOnlyAtSectionsDisplay(bool)          {}

    virtual bool                displayedOnlyAtSections() const { return false;}


    virtual bool                hasColor() const        { return false;}

    virtual bool                usesColor() const       { return hasColor(); }

    virtual void                setColor(Color)         {}

    virtual Color               getColor() const

                                { return Color::DgbColor(); }


    Color                       getBackgroundColor() const;

    virtual void                setAnnotColor(Color)                    {}

    virtual Color               getAnnotColor() const

                                { return Color::DgbColor(); }


    virtual int                 nrResolutions() const           { return 1; }

    virtual BufferString        getResolutionName(int) const;

    virtual int                 getResolution() const           { return 0; }

    virtual void                setResolution(int,TaskRunner*)  {}


    virtual visBase::TextureChannels* getChannels() const       { return 0; }

    virtual visBase::TextureChannel2RGBA* getChannels2RGBA()    { return 0; }

    const visBase::TextureChannel2RGBA*   getChannels2RGBA() const;

    virtual bool                setChannels2RGBA(visBase::TextureChannel2RGBA*)

                                { return false; }


    enum AttribFormat           { None, Cube, Traces, RandomPos, OtherFormat };

    virtual AttribFormat        getAttributeFormat(int attrib=-1) const;

    virtual bool                canHaveMultipleAttribs() const { return false; }

    virtual int                 nrAttribs() const;

    virtual bool                canAddAttrib(int nrattribstoadd=1) const;

    virtual bool                addAttrib()                { return false; }

    virtual bool                canRemoveAttrib() const;

    virtual bool                removeAttrib(int attrib)   { return false; }

    virtual bool                swapAttribs(int a0,int a1) { return false; }

    virtual void                setAttribTransparency(int,unsigned char) {}

    virtual unsigned char       getAttribTransparency(int) const { return 0; }

    virtual const ColTab::MapperSetup*  getColTabMapperSetup(int attrib,

                                                           int version=0) const;

    void                        getChannelName(int,uiString&) const;

    virtual void                setColTabMapperSetup(int,

                                     const ColTab::MapperSetup&,TaskRunner*);

    virtual const ColTab::Sequence* getColTabSequence(int) const { return 0; }

    virtual bool                canSetColTabSequence() const    { return false;}

    virtual void                setColTabSequence(int,const ColTab::Sequence&,

                                                  TaskRunner*);

    virtual bool                canHandleColTabSeqTrans(int) const;


    virtual void                enableTextureInterpolation(bool)        {}

    virtual bool                textureInterpolationEnabled() const

                                { return true; }

    virtual bool                canEnableTextureInterpolation() const

                                { return false; }


    virtual bool                isAngle(int attrib) const        {return false;}

    virtual void                setAngleFlag(int attrib,bool yn)        {}

    virtual void                enableAttrib(int attrib,bool yn)        {}

    virtual bool                isAttribEnabled(int attrib) const {return true;}

    bool                        isAnyAttribEnabled() const;

    virtual bool                hasSingleColorFallback() const { return false; }

    virtual Pol2D3D             getAllowedDataType() const      {return Only3D;}


    virtual const TypeSet<float>* getHistogram(int attrib) const { return 0; }


    virtual bool                canRemoveSelection() const      { return false;}

    virtual bool                removeSelections(TaskRunner*)   { return false;}

    virtual void                clearSelections()               {}


    virtual void                   setSelSpec(int,const Attrib::SelSpec&);

    virtual void                   setSelSpecs(int attrib,

                                               const TypeSet<Attrib::SelSpec>&);


    virtual const Attrib::SelSpec* getSelSpec(int attrib,int version=0) const

                                   { return 0; }

    virtual const TypeSet<Attrib::SelSpec>* getSelSpecs( int attrib ) const

                                            { return 0; }


    virtual bool                canHaveMultipleTextures() const { return false;}

    virtual int                 nrTextures(int attrib) const    { return 0; }

    virtual void                selectTexture(int attrib,int texture) {}

    virtual int                 selectedTexture(int attrib) const { return 0; }

    virtual void                allowShading(bool)              {}

    virtual void                getMousePosInfo(const visBase::EventInfo&,

                                            Coord3& xyzpos,

                                            BufferString& val,

                                            BufferString& info) const

                                { val = mUdf(float); info = ""; }

    virtual void                getMousePosInfo(const visBase::EventInfo&,

                                                IOPar&) const;

    virtual const MouseCursor*  getMouseCursor() const          { return 0; }


    virtual void                updateMouseCursorCB(CallBacker*)        {}


    virtual void                getObjectInfo(BufferString&) const      {}


                                // Data via DataPacks

    virtual bool                setDataPackID(int attrib,DataPack::ID,

                                              TaskRunner*)

                                { return false; }

    virtual DataPack::ID        getDataPackID(int attrib) const { return -1; }

    virtual DataPack::ID        getDisplayedDataPackID(int attrib) const

                                { return -1; }

    virtual DataPackMgr::ID     getDataPackMgrID() const        { return -1; }


                                //Volume data

    virtual TrcKeyZSampling     getTrcKeyZSampling( int attrib ) const

                                { TrcKeyZSampling cs; return cs; }

    virtual bool                setDataVolume(int attrib,

                                              const RegularSeisDataPack*,

                                              TaskRunner*)

                                { return false; }

    virtual const RegularSeisDataPack* getCacheVolume(int attr) const

                                { return 0; }


                                //Trace-data

    virtual void                getTraceKeyPath(TrcKeyPath&,

                                                TypeSet<Coord>* = 0) const {}

    virtual void                getDataTraceBids(TypeSet<BinID>&) const {}

    virtual Interval<float>     getDataTraceRange() const

                                { return Interval<float>(0,0); }


    virtual void                getRandomPos(DataPointSet&,TaskRunner*) const {}

    virtual void                getRandomPosCache(int attrib,

                                                  DataPointSet&) const  {}

    virtual void                setRandomPosData( int attrib,

                                                  const DataPointSet*,

                                                  TaskRunner*)          {}

    virtual void                readAuxData()                           {}


    virtual void                setScene(Scene* scn);

    virtual const Scene*        getScene() const        { return scene_; }

    virtual Scene*              getScene()              { return scene_; }

    virtual int                 getSceneID() const      { return scene_->id(); }


    virtual bool                setZAxisTransform(ZAxisTransform*,TaskRunner*)

                                {return false;}

    virtual const ZAxisTransform* getZAxisTransform() const      {return 0;}

    virtual bool                alreadyTransformed(int attrib) const;


    virtual void                annotateNextUpdateStage(bool yn);

    int                         getUpdateStageNr() const;


    virtual void                lock( bool yn )         { locked_ = yn; }

    virtual bool                isLocked() const        { return locked_; }

    virtual NotifierAccess*     getLockNotifier()       { return 0; }

    virtual void                fillPar(IOPar&) const;

    virtual bool                usePar(const IOPar&);


    virtual bool                canBDispOn2DViewer() const      { return false;}

    virtual bool                isVerticalPlane() const         { return true;}

    virtual bool                isInlCrl() const                { return false;}

    virtual void                turnOnSelectionMode(bool) {}


    static float                sDefMaxDist();


                                //Old

    static const char*          sKeyColTabID()  { return "Colortable ID"; }


                                //Current

    static const char*          sKeySequence()  { return "Sequence"; }

    static const char*          sKeyMapper()    { return "Mapper"; }

    static const char*          sKeyTextTrans() { return "Trans"; }

    static const char*          sKeyTC2RGBA()   { return "TC2RGBA"; }

    static const char*          sKeyNrAttribs() { return "Nr Attribs"; }

    static const char*          sKeyNrVersions(){ return "Nr Versions"; }

    static const char*          sKeySelTexture(){ return "Selected Texture"; }

    static const char*          sKeyAttribs()   { return "Attrib "; }

    static const char*          sKeyLocked()    { return "Locked"; }

    static const char*          sKeySurvey()    { return "Survey"; }


    void                        setUserRefs( int attrib, BufferStringSet* nms )

                                { delete (userrefs_.validIdx(attrib) ?

                                         userrefs_.replace(attrib,nms) : nms); }


    void                        setSaveInSessionsFlag( bool yn )

                                { saveinsessionsflag_ = yn; }

    bool                        getSaveInSessionsFlag() const

                                { return saveinsessionsflag_; }


    virtual bool                canBeRemoved() const { return true; }


protected:

                                SurveyObject();

                                ~SurveyObject();


    void                        initAdaptiveMouseCursor(CallBacker* eventcb,

                                                int objid,int inplanedragkeys,

                                                MouseCursor&);


    static int                  cValNameOffset()        { return 12; }


    mutable BufferString        errmsg_;

    Scene*                      scene_;

    int                         updatestagenr_;

    bool                        locked_;

    ObjectSet<BufferStringSet>  userrefs_;


    const Survey::Geometry3D*   s3dgeom_;

    BufferString                survname_; //Only from IOPar

    bool                        saveinsessionsflag_;


};


} // namespace visSurvey