visvolumedisplay.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:          August 2002
________________________________________________________________________


-*/


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


class MarchingCubesSurface;
class RegularSeisDataPack;
class TaskRunner;
class TrcKeyZSampling;
class ZAxisTransform;
class ZAxisTransformer;
template <class T> class Array3D;

namespace Attrib { class SelSpec; }

namespace visBase
{
    class MarchingCubesSurface;
    class Material;
    class BoxDragger;
    class VolumeRenderScalarField;
    class OrthogonalSlice;
    class TextureChannel2RGBA;
}


namespace visSurvey
{

class Scene;

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

    bool                        isInlCrl() const { return true; }

    static int                  cInLine()               { return 2; }
    static int                  cCrossLine()            { return 1; }
    static int                  cTimeSlice()            { return 0; }

    int                         addSlice(int dim);
    void                        showVolRen(bool yn);
    bool                        isVolRenShown() const;
    int                         volRenID() const;

    int                         addIsoSurface(TaskRunner* = 0,
                                              bool updateisosurface = true);
    void                        removeChild(int displayid);

    visBase::MarchingCubesSurface* getIsoSurface(int idx);
    void                        updateIsoSurface(int,TaskRunner* = 0);
    int                         getNrIsoSurfaces();
    int                         getIsoSurfaceIdx(
                                    const visBase::MarchingCubesSurface*) const;
    float                       defaultIsoValue() const;
    float                       isoValue(
                                    const visBase::MarchingCubesSurface*) const;
                                /*<Set isovalue and do update. */
    void                        setIsoValue(
                                    const visBase::MarchingCubesSurface*,
                                    float,TaskRunner* =0);

                                /*<Seed based settings. set only, no update. */
    char                        isFullMode(
                                    const visBase::MarchingCubesSurface*)const;
                                /*<Return -1 if undefined, 1 if full,
                                   0 if seed based. */
    void                        setFullMode(
                                    const visBase::MarchingCubesSurface*,
                                    bool full=1);
                                /*<If 0, it is seed based. */
    char                        seedAboveIsovalue(
                                    const visBase::MarchingCubesSurface*) const;
                                /*<-1 undefined, 1 above, 0 below. */
    void                        setSeedAboveIsovalue(
                                    const visBase::MarchingCubesSurface*,bool);
    DBKey                       getSeedsID(
                                    const visBase::MarchingCubesSurface*) const;
    void                        setSeedsID(const visBase::MarchingCubesSurface*,
                                           DBKey);

    bool                        turnOn(bool yn);
    bool                        isOn() const;
    bool                        hasPosModeManipulator() const   { return true; }
    void                        showManipulator(bool yn);
    bool                        isManipulatorShown() const;
    bool                        isManipulated() const;
    bool                        canResetManipulation() const;
    void                        resetManipulation();
    void                        acceptManipulation();
    NotifierAccess*             getMovementNotifier() { return &boxMoving; }
    NotifierAccess*             getManipulationNotifier() { return &boxMoving; }
    BufferString                getManipulationString() const;

    SurveyObject::AttribFormat  getAttributeFormat(int attrib) const;
    const TypeSet<Attrib::SelSpec>* getSelSpecs(int attrib) const;
    const Attrib::SelSpec*      getSelSpec(int attrib,int version=0) const;
    void                        setSelSpecs(int attrib,
                                            const TypeSet<Attrib::SelSpec>&);

    bool                        canHaveMultipleAttribs() const { return true; }
    int                         nrAttribs() const;
    bool                        canAddAttrib(int nrattribstoadd=1) const;
    bool                        addAttrib();
    bool                        canRemoveAttrib() const;
    bool                        removeAttrib(int attrib);
    bool                        swapAttribs(int attrib0,int attrib1);
    void                        enableAttrib(int attrib,bool yn);
    bool                        isAttribEnabled(int attrib) const;
    void                        setAttribTransparency(int attrib,unsigned char);
    unsigned char               getAttribTransparency(int attrib) const;

    bool                        setChannels2RGBA(visBase::TextureChannel2RGBA*);

    visBase::TextureChannel2RGBA*       getChannels2RGBA();
    const visBase::TextureChannel2RGBA* getChannels2RGBA() const;

    float                       slicePosition(visBase::OrthogonalSlice*) const;
    void                        setSlicePosition(visBase::OrthogonalSlice*,
                                                    const TrcKeyZSampling&);
    TrcKeyZSampling             sliceSampling(visBase::OrthogonalSlice*) const;
    visBase::OrthogonalSlice*   getSelectedSlice() const;

    float                       getValue(int attrib,const Coord3&) const;

    TrcKeyZSampling             getTrcKeyZSampling(int attrib) const;
    TrcKeyZSampling             getTrcKeyZSampling(bool manippos,
                                                   bool displayspace,
                                                   int attrib) const;
    void                        setTrcKeyZSampling(const TrcKeyZSampling&,
                                                bool dragmode=false);
    bool                        setDataVolume(int attrib,
                                              const RegularSeisDataPack*,
                                              TaskRunner*);
    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(); }

    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                        getTreeObjectInfo(uiString&) const;

    const ColTab::Mapper&       getColTabMapper(int attrib) const;
    void                        setColTabMapper(int attr,const ColTab::Mapper&,
                                                TaskRunner*);
    const ColTab::Sequence&     getColTabSequence(int attrib) const;
    void                        setColTabSequence(int attrib,
                                        const ColTab::Sequence&,TaskRunner*);
    bool                        canSetColTabSequence() const;

    void                        setMaterial(visBase::Material*);
    bool                        allowMaterialEdit() const       { return true; }
    virtual bool                allowsPicks() const;
    bool                        canDuplicate() const    { return usesShading();}
    visSurvey::SurveyObject*    duplicate(TaskRunner*) const;

    static bool                 canUseVolRenShading();
    void                        allowShading(bool yn);
    bool                        usesShading() const;

    void                        getChildren(TypeSet<int>&) const;

    bool                        setZAxisTransform(ZAxisTransform*,TaskRunner*);
    const ZAxisTransform*       getZAxisTransform() const;

    void                        setRightHandSystem(bool yn);

    virtual void                fillPar(IOPar&) const;
    virtual bool                usePar(const IOPar&);
    const uiString&             errMsg() const { return errmsg_; }

    bool                        writeVolume(int attrib,const char* fnm) const;

    void                        setDisplayTransformation(const mVisTrans*);

    bool                        canEnableTextureInterpolation() const;
    bool                        textureInterpolationEnabled() const;
    void                        enableTextureInterpolation(bool);

    static const char*          sKeyVolDepthKey()       { return "VolDepthKey";}
    static const char*          sKeyVolPlaneKey()       { return "VolPlaneKey";}
    static const char*          sKeyInDepthVolResize()
                                                { return "InDepthVolResize"; }

protected:
                                ~VolumeDisplay();

    Notifier<VolumeDisplay>     boxMoving;

    bool                        updateSeedBasedSurface(int,TaskRunner* = 0);
    void                        materialChange(CallBacker*);
    void                        updateIsoSurfColor();
    bool                        pickable() const { return true; }
    bool                        rightClickable() const { return true; }
    bool                        selectable() const { return true; }
    bool                        isSelected() const;
    const MouseCursor*          getMouseCursor() const { return &mousecursor_; }
    void                        setScene(Scene*);
    void                        updateAttribEnabling();
    void                        getObjectInfoText(uiString& info,
                                                  bool compact) const;

    visBase::BoxDragger*                        boxdragger_;
    visBase::VolumeRenderScalarField*           scalarfield_;
    visBase::TextureChannel2RGBA*               texchannel2rgba_;
/* OSG_TODO: Replace VolrenDisplay with OSG equivalent
    visBase::VolrenDisplay*                     volren_;
*/
    ObjectSet<visBase::OrthogonalSlice>         slices_;
    ObjectSet<visBase::MarchingCubesSurface>    isosurfaces_;
    struct IsosurfaceSetting
    {
                                IsosurfaceSetting();
        bool                    operator==(const IsosurfaceSetting&) const;
        IsosurfaceSetting&      operator=(const IsosurfaceSetting&);

        float                   isovalue_;
        char                    mode_;
        char                    seedsaboveisoval_;
        DBKey                   seedsid_;
    };

    TypeSet<IsosurfaceSetting>  isosurfsettings_;
    TypeSet<char>               sections_;

    void                        draggerStartCB(CallBacker*);
    void                        draggerMoveCB(CallBacker*);
    void                        draggerFinishCB(CallBacker*);
    void                        updateDraggerLimits(bool dragmode=false);
    bool                        keepdraggerinsidetexture_;
    TrcKeyZSampling             draggerstartcs_;
    TrcKeyZSampling             texturecs_;

    void                        sliceMoving(CallBacker*);
    void                        setData(const RegularSeisDataPack*,
                                        int datatype=0);

    void                        dataTransformCB(CallBacker*);
    void                        updateRanges(bool updateic,bool updatez);
    void                        updateMouseCursorCB(CallBacker*);
    void                        setSceneEventCatcher(visBase::EventCatcher*);

    ZAxisTransform*             datatransform_;
    ZAxisTransformer*           datatransformer_;

    struct AttribData
    {
                                                AttribData();
                                                ~AttribData();

        TypeSet<Attrib::SelSpec>*               as_;
        ConstRefMan<RegularSeisDataPack>        cache_;
    };

    ObjectSet<AttribData>       attribs_;

    BufferString                sliceposition_;
    BufferString                slicename_;
    TrcKeyZSampling             csfromsession_;

    MouseCursor                 mousecursor_;
    visBase::EventCatcher*      eventcatcher_;

    bool                        isinited_;
    bool                        ismanip_;
    bool                        onoffstatus_;

    ConstRefMan<mVisTrans>      displaytrans_;

    static const char*          sKeyVolumeID();
    static const char*          sKeyInline();
    static const char*          sKeyCrossLine();
    static const char*          sKeyTime();
    static const char*          sKeyVolRen();
    static const char*          sKeyNrSlices();
    static const char*          sKeySlice();
    static const char*          sKeyTexture();

    static const char*          sKeyNrIsoSurfaces();
    static const char*          sKeyIsoValueStart();
    static const char*          sKeyIsoOnStart();
    static const char*          sKeySurfMode();
    static const char*          sKeySeedsMid();
    static const char*          sKeySeedsAboveIsov();
};

} // namespace visSurvey