emhorizon3d.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Kristofer Tingdahl
 Date:          4-11-2002
 RCS:           $Id$
________________________________________________________________________
 
 
-*/
 
#include "earthmodelmod.h"
#include "emhorizon.h"
#include "binidsurface.h"
#include "task.h"
 
class BinIDValueSet;
class DataPointSet;
class BufferStringSet;
class TrcKeySampling;
class Scaler;
class ZAxisTransform;
namespace Pick { class Set; }
namespace Pos { class Provider3D; }
namespace Table { class FormatDesc; }
namespace Threads { class WorkManager; }
 
namespace EM
{
class SurfaceAuxData;
 
mExpClass(EarthModel) Horizon3DGeometry : public HorizonGeometry
{ mODTextTranslationClass(Horizon3DGeometry);
public:
                                Horizon3DGeometry(Surface&);
 
    const Geometry::BinIDSurface* sectionGeometry(const SectionID&) const;
    Geometry::BinIDSurface*     sectionGeometry(const SectionID&);
 
    bool                        removeSection(const SectionID&,bool hist);
    SectionID                   cloneSection(const SectionID&);
 
    bool                        isFullResolution() const;
    RowCol                      loadedStep() const;
    RowCol                      step() const;
    void                        setStep(const RowCol& step,
                                        const RowCol& loadedstep);
 
    PosID                       getPosID(const TrcKey&) const;
    TrcKey                      getTrcKey(const PosID&) const;
 
    bool                        enableChecks(bool yn);
    bool                        isChecksEnabled() const;
    bool                        isNodeOK(const PosID&) const;
 
    bool                        isAtEdge(const PosID& pid) const;
    PosID                       getNeighbor(const PosID&,const RowCol&) const;
    int                         getConnectedPos(const PosID&,
                                                TypeSet<PosID>*) const;
 
    bool                        getBoundingPolygon(const SectionID&,
                                                   Pick::Set&) const;
    void                        getDataPointSet( const SectionID&,
                                                  DataPointSet&,
                                                  float shift=0.0) const;
    void                        fillBinIDValueSet(const SectionID&,
                                                 BinIDValueSet&,
                                                 Pos::Provider3D* prov=0) const;
 
    EMObjectIterator*           createIterator(const EM::SectionID&,
                                               const TrcKeyZSampling* =0) const;
protected:
 
    Geometry::BinIDSurface*     createSectionGeometry() const;
 
    RowCol                      loadedstep_;
    RowCol                      step_;
    bool                        checksupport_;
};
 
 
mExpClass(EarthModel) Horizon3D : public Horizon
{ mDefineEMObjFuncs( Horizon3D );
public:
 
    virtual float               getZ(const TrcKey&) const;
    virtual bool                setZ(const TrcKey&,float z,bool addtohist);
    virtual bool                setZAndNodeSourceType(const TrcKey&,float z,
                                    bool addtohist, NodeSourceType type=Auto);
 
    virtual void                setNodeSourceType(const TrcKey&,NodeSourceType);
    virtual void                setNodeSourceType(const PosID&,NodeSourceType);
    virtual bool                isNodeSourceType(const PosID&,
                                                 NodeSourceType) const;
    virtual bool                isNodeSourceType(const TrcKey&,
                                                 NodeSourceType) const;
    virtual bool                isNodeLocked(const PosID&)const;
    
    bool                        hasNodeSourceType(const PosID&) const;
 
    virtual bool                hasZ(const TrcKey&) const;
    virtual Coord3              getCoord(const TrcKey&) const;
    virtual void                setAttrib(const TrcKey&,int attr,int yn,
                                          bool addtohist);
    virtual bool                isAttrib(const TrcKey&,int attr) const;
 
    virtual float               getZValue(const Coord&,bool allow_udf=true,
                                          int nr=0) const;
 
    TrcKeySampling              range() const;
    Interval<float>             getZRange() const;
 
    void                        removeAll();
    Horizon3DGeometry&          geometry();
    const Horizon3DGeometry&    geometry() const;
 
    virtual void                setArray(const SectionID&,const BinID& start,
                                        const BinID& step, Array2D<float>* arr,
                                        bool takeover);
    static Horizon3D*           createWithConstZ(float z,const TrcKeySampling&);
    Array2D<float>*             createArray2D(SectionID,
                                              const ZAxisTransform* zt=0) const;
    bool                        setArray2D(const Array2D<float>&,SectionID,
                                           bool onlyfillundefs,
                                           const char* histdesc,bool trimundef);
    bool                        setArray2D(Array2D<float>*,const BinID& origin,
                                           const BinID& step,
                                           bool takeoverarr=true);
    Executor*                   importer(const ObjectSet<BinIDValueSet>&,
                                         const TrcKeySampling& hs);
    Executor*                   auxDataImporter(const ObjectSet<BinIDValueSet>&,
                                        const BufferStringSet& attribnms,int,
                                        const TrcKeySampling& hs);
 
 
    Pos::GeomID                 getSurveyGeomID() const { return survgeomid_; }
    void                        setSurveyGeomID(Pos::GeomID);
 
    uiString                    getUserTypeStr() const { return userTypeStr(); }
    static uiString             userTypeStr()
                                { return tr("3D Horizon"); }
 
    void                        initAllAuxData(float val=mUdf(float));
    SurfaceAuxData&             auxdata;
 
    void                        initTrackingAuxData(float val=mUdf(float));
    void                        initTrackingArrays();
    void                        updateTrackingSampling();
    bool                        saveParentArray();
    bool                        readParentArray();
    bool                        saveNodeArrays();
    bool                        readNodeArrays();
 
    TrcKeySampling              getTrackingSampling() const;
    void                        setParent(const TrcKey&,const TrcKey& parent);
    TrcKey                      getParent(const TrcKey&) const;
    void                        getParents(const TrcKey&,
                                           TypeSet<TrcKey>&) const;
    bool                        selectChildren(const TrcKey&);
    Array2D<char>*              getChildren() const;
    void                        deleteChildren();
    void                        resetChildren();
    void                        setNodeLocked(const TrcKey&,bool locked);
    bool                        isNodeLocked(const TrcKey&) const;
    void                        lockAll();
    void                        unlockAll();
    const Array2D<char>*        getLockedNodes() const;
 
    void                        setParentColor(const Color&);
    const Color&                getParentColor() const;
 
    virtual bool                setPos(const EM::PosID&,const Coord3&,
                                       bool addtohistory);
    virtual bool                setPos(const EM::SectionID&,const EM::SubID&,
                                       const Coord3&,bool addtohistory);
protected:
    enum                        ArrayType{Parents,Children,LockNode,NodeSource};
 
    void                        fillPar(IOPar&) const;
    bool                        usePar(const IOPar&);
    void                        fillDisplayPar(IOPar&) const;
    bool                        useDisplayPar(const IOPar&);
 
    const IOObjContext&         getIOObjContext() const;
    void                        initNodeArraysSize(const StepInterval<int>&,
                                                   const StepInterval<int>&);
    void                        setNodeArraySize(const StepInterval<int>&,
                                     const StepInterval<int>&,ArrayType);
    void                        updateNodeSourceArray(const TrcKeySampling,
                                                      ArrayType);
    Array2D<char>*              getNodeSourceArray(ArrayType) const;
    void                        setNodeSourceArray(Array2D<char>*,ArrayType);
    void                        createNodeSourceArray(const StepInterval<int>&,
                                                const StepInterval<int>&,
                                                ArrayType);
    TrcKeySampling              getSectionTrckeySampling() const;
 
    friend class                EMManager;
    friend class                EMObject;
    Horizon3DGeometry           geometry_;
 
    TrcKeySampling              trackingsamp_;
    Array2D<char>*              lockednodes_;
    Array2D<char>*              children_;
    Array2D<od_int64>*          parents_;
 
    Color                       parentcolor_;
 
    Pos::GeomID                 survgeomid_;
    Array2D<char>*              nodesource_;
    bool                        arrayinited_;
 
public:
    /*mDeprecated*/ float       getZ(const BinID&) const;
    /*mDeprecated*/ bool        setZ(const BinID&,float z,bool addtohist);
    Array2D<char>*              getChildren(const TrcKey&) const
                                { return getChildren(); }
    TrcKey::SurvID              getSurveyID() const { return getSurveyGeomID();}
 
    static Color                sDefaultSelectionColor();
    static Color                sDefaultLockColor();
};
 
 
mExpClass(EarthModel) ChildFinder : public SequentialTask
{
friend class FindTask;
friend class Horizon3D;
protected:
                        ChildFinder(const TrcKeySampling& tks,
                                    const Array2D<od_int64>& parents,
                                    Array2D<char>& children );
                        ~ChildFinder();
 
 
    void                addTask(od_int64);
    void                taskFinished(CallBacker*);
    int                 nextStep();
 
    Threads::WorkManager&       twm_;
    int                         queueid_;
    const Array2D<od_int64>&    parents_;
    Array2D<char>&              children_;
    TrcKeySampling              tks_;
 
    Threads::Atomic<int>        nrtodo_;
    Threads::Atomic<int>        nrdone_;
 
    Threads::Lock               addlock_;
    Threads::Lock               finishlock_;
};
 
} // namespace EM