mpeengine.h

Go to the documentation of this file.

#ifndef mpeengine_h
#define mpeengine_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H. Bril
 Date:          23-10-1996
 RCS:           $Id: mpeengine.h 38753 2015-04-11 21:19:18Z nanne.hemstra@dgbes.com $
________________________________________________________________________

-*/

#include "mpeenginemod.h"

#include "attribsel.h"
#include "callback.h"
#include "datapack.h"
#include "emposid.h"
#include "survgeom.h"

class BufferStringSet;
class Executor;

namespace EM { class EMObject; }
namespace Geometry { class Element; }
template <class T> class Selector;

namespace MPE
{

class EMTracker;
class HorizonTrackerMgr;
class ObjectEditor;

mExpClass(MPEEngine) TrackSettingsValidator
{
public:
    virtual             ~TrackSettingsValidator()                       {}
    virtual bool        checkInVolumeTrackMode() const                  = 0;
    virtual bool        checkActiveTracker() const                      = 0;
    virtual bool        checkStoredData(Attrib::SelSpec&,MultiID&) const = 0;
    virtual bool        checkPreloadedData(const MultiID&) const        = 0;
};


mExpClass(MPEEngine) Engine : public CallBacker
{ mODTextTranslationClass(Engine)
    mGlobal(MPEEngine) friend Engine&           engine();

public:
                                Engine();
    virtual                     ~Engine();

    void                        init();

    const TrcKeyZSampling&      activeVolume() const;
    void                        setActiveVolume(const TrcKeyZSampling&);
    Notifier<Engine>            activevolumechange;

    void                        setActive2DLine(Pos::GeomID);
    Pos::GeomID                 activeGeomID() const;

    Notifier<Engine>            loadEMObject;
    MultiID                     midtoload;

    void                        updateSeedOnlyPropagation(bool);

    enum TrackState             { Started, Paused, Stopped };
    TrackState                  getState() const        { return state_; }
    bool                        startTracking(uiString&);
    bool                        startRetrack(uiString&);
    bool                        startFromEdges(uiString&);
    void                        stopTracking();
    bool                        trackingInProgress() const;
    void                        undo(uiString& errmsg);
    void                        redo(uiString& errmsg);
    bool                        canUnDo();
    bool                        canReDo();
    void                        enableTracking(bool yn);
    Notifier<Engine>            actionCalled;
    Notifier<Engine>            actionFinished;

    void                        removeSelectionInPolygon(
                                        const Selector<Coord3>&,
                                        TaskRunner*);
    void                        getAvailableTrackerTypes(BufferStringSet&)const;

    int                         nrTrackersAlive() const;
    int                         highestTrackerID() const;
    const EMTracker*            getTracker(int idx) const;
    EMTracker*                  getTracker(int idx);
    int                         getTrackerByObject(const EM::ObjectID&) const;
    int                         getTrackerByObject(const char*) const;
    int                         addTracker(EM::EMObject*);
    void                        removeTracker(int idx);
    Notifier<Engine>            trackeraddremove;
    void                        setActiveTracker(const EM::ObjectID&);
    void                        setActiveTracker(EMTracker*);
    EMTracker*                  getActiveTracker();

                                /*Attribute stuff */
    void                        setOneActiveTracker(const EMTracker*);
    void                        unsetOneActiveTracker();
    void                        getNeededAttribs(
                                TypeSet<Attrib::SelSpec>&) const;
    TrcKeyZSampling             getAttribCube(const Attrib::SelSpec&) const;
    int                         getCacheIndexOf(const Attrib::SelSpec&) const;
    DataPack::ID                getAttribCacheID(const Attrib::SelSpec&) const;
    bool                        hasAttribCache(const Attrib::SelSpec&) const;
    bool                        setAttribData( const Attrib::SelSpec&,
                                               DataPack::ID);
    bool                        cacheIncludes(const Attrib::SelSpec&,
                                              const TrcKeyZSampling&);
    void                        swapCacheAndItsBackup();

    bool                        pickingOnSameData(const Attrib::SelSpec& oldss,
                                                  const Attrib::SelSpec& newss,
                                                  uiString& error) const;
    bool                        isSelSpecSame(const Attrib::SelSpec& setupss,
                                        const Attrib::SelSpec& clickedss) const;

    void                        updateFlatCubesContainer(const TrcKeyZSampling&,
                                                         int idx,bool);
    ObjectSet<TrcKeyZSampling>* getTrackedFlatCubes(const int idx) const;
    DataPack::ID                getSeedPosDataPack(const TrcKey&,float z,
                                        int nrtrcs,
                                        const StepInterval<float>& zrg) const;

                                /*Editors */
    ObjectEditor*               getEditor(const EM::ObjectID&,bool create);
    void                        removeEditor(const EM::ObjectID&);

    void                        setValidator(TrackSettingsValidator*);
    const char*                 errMsg() const;

    BufferString                setupFileName(const MultiID&) const;

    void                        fillPar(IOPar&) const;
    bool                        usePar(const IOPar&);
    const TrcKeyPath*           activePath() const;
    void                        setActivePath(const TrcKeyPath*);
    int                         activeRandomLineID() const;
    void                        setActiveRandomLineID(int);
    void                        refTracker(EM::ObjectID);
    void                        unRefTracker(EM::ObjectID,bool nodel=false);
    bool                        hasTracker(EM::ObjectID) const;

    Notifier<Engine>            settingsChanged;

protected:

    BufferString                errmsg_;
    TrcKeyZSampling             activevolume_;

    Pos::GeomID                 activegeomid_;

    TrackState                  state_;
    ObjectSet<HorizonTrackerMgr> trackermgrs_;
    ObjectSet<EMTracker>        trackers_;
    ObjectSet<ObjectEditor>     editors_;

    const EMTracker*            oneactivetracker_;
    EMTracker*                  activetracker_;
    int                         undoeventid_;
    DataPackMgr&                dpm_;
    const TrcKeyPath*           rdmlinetkpath_;
    int                         rdlid_;
    TrackSettingsValidator*     validator_;

    bool                        prepareForTrackInVolume(uiString&);
    bool                        prepareForRetrack();
    bool                        trackInVolume();
    bool                        trackFromEdges();
    void                        trackingFinishedCB(CallBacker*);
    EM::EMObject*               getCurrentEMObject() const;


    struct CacheSpecs
    {
                                CacheSpecs(const Attrib::SelSpec& as,
                                        Pos::GeomID geomid=
                                        Survey::GeometryManager::cUndefGeomID())
                                    : attrsel_(as),geomid_(geomid)
                                {}

        Attrib::SelSpec         attrsel_;
        Pos::GeomID             geomid_;
    };

    TypeSet<DataPack::ID>       attribcachedatapackids_;
    ObjectSet<CacheSpecs>       attribcachespecs_;
    TypeSet<DataPack::ID>       attribbkpcachedatapackids_;
    ObjectSet<CacheSpecs>       attribbackupcachespecs_;

    mStruct(MPEEngine) FlatCubeInfo
    {
                                FlatCubeInfo()
                                :nrseeds_(1)
                                {
                                    flatcs_.setEmpty();
                                }
        TrcKeyZSampling         flatcs_;
        int                     nrseeds_;
    };

    ObjectSet<ObjectSet<FlatCubeInfo> > flatcubescontainer_;

    static const char*          sKeyNrTrackers(){ return "Nr Trackers"; }
    static const char*          sKeyObjectID()  { return "ObjectID"; }
    static const char*          sKeyEnabled()   { return "Is enabled"; }
    static const char*          sKeyTrackPlane(){ return "Track Plane"; }
    static const char*          sKeySeedConMode(){ return "Seed Connect Mode"; }

    void                        applClosingCB(CallBacker*);
};


mGlobal(MPEEngine) Engine&      engine();

} // namespace MPE

#endif