posinfodetector.h

Go to the documentation of this file.

#pragma once
/*
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Bert Bril
 Date:          Oct 2008
________________________________________________________________________

*/

#include "generalmod.h"
#include "posinfo.h"
#include "coord.h"
#include "bufstring.h"
#include "uistring.h"
class TrcKeySampling;
class BinIDSorting;
class BinIDSortingAnalyser;


namespace PosInfo
{

mExpClass(General) CrdBidOffs
{ mODTextTranslationClass(CrdBidOffs);
public:
                CrdBidOffs()
                    : coord_(0,0), binid_(1,0), offset_(0)      {}
                CrdBidOffs( const Coord& c, int nr, float o=0 )
                    : coord_(c), binid_(1,nr), offset_(o)       {}
                CrdBidOffs( const Coord& c, const BinID& b, float o=0 )
                    : coord_(c), binid_(b), offset_(o)          {}
    bool        operator ==( const CrdBidOffs& cbo ) const
                { return binid_ == cbo.binid_
                      && mIsEqual(offset_,cbo.offset_,mDefEps); }

    Coord       coord_;
    BinID       binid_;
    float       offset_;
};


mExpClass(General) Detector
{ mODTextTranslationClass(Detector);
public:

    struct Setup
    {
                        Setup( bool istwod )
                            : is2d_(istwod), isps_(false)
                            , reqsorting_(false)                {}
        mDefSetupMemb(bool,is2d)
        mDefSetupMemb(bool,isps)
        mDefSetupMemb(bool,reqsorting)
    };

                        Detector(const Setup&);
                        Detector(const Detector&);
    Detector&           operator =(const Detector&);
                        ~Detector();

    bool                is2D() const            { return setup_.is2d_; }
    bool                isPS() const            { return setup_.isps_; }
    void                reInit();

    bool                add(const Coord&,const BinID&);
    bool                add(const Coord&,const BinID&,float offs);
    bool                add(const Coord&,int nr);
    bool                add(const Coord&,int nr,float offs);
    bool                add(const Coord&,const BinID&,int nr,float offs);
    bool                add(const CrdBidOffs&);


    bool                finish();
    bool                usable() const          { return errmsg_.isEmpty(); }
    uiString            errMsg() const          { return errmsg_; }
    void                appendResults(const Detector&); // after finish only
    void                mergeResults(const Detector&); // after finish only

    int                 nrPositions( bool uniq=true ) const
                        { return uniq ? nruniquepos_ : nrpos_; }

                        // available after finish()
    Coord               minCoord() const        { return mincoord_; }
    Coord               maxCoord() const        { return maxcoord_; }
    BinID               start() const           { return start_; }
    BinID               stop() const            { return stop_; }
    BinID               step() const            { return step_; }
    void                getTrcKeySampling(TrcKeySampling&) const;
    Interval<float>     offsRg() const          { return offsrg_; }
    float               avgDist() const         { return avgdist_; }
    CrdBidOffs          firstPosition() const   { return userCBO(firstcbo_); }
    CrdBidOffs          lastPosition() const    { return userCBO(lastcbo_); }
    bool                haveGaps( bool inldir=false ) const
                        { return inldir ? inlirreg_ : crlirreg_; }

    void                report(IOPar&) const;

    const BinIDSorting& sorting() const         { return sorting_; }
    bool                inlSorted() const;
    bool                crlSorted() const;
    void                getCubeData(CubeData&) const;
    uiString            getSurvInfo(TrcKeySampling&,Coord crd[3]) const;

    StepInterval<int>   getRange(bool inldir=false) const;
    bool                haveStep(bool) const; // to check during detection

protected:

    Setup               setup_;
    BinIDSorting&       sorting_;
    ObjectSet<LineData> lds_;
    int                 nruniquepos_;
    int                 nrpos_;
    Coord               mincoord_;
    Coord               maxcoord_;
    Interval<float>     offsrg_;
    int                 nroffsperpos_;
    bool                allstd_;
    BinID               start_;
    BinID               stop_;
    BinID               step_;
    bool                inlirreg_, crlirreg_;
    Interval<float>     distrg_;        
    float               avgdist_;       
    CrdBidOffs          firstcbo_;
    CrdBidOffs          lastcbo_;
    CrdBidOffs          llnstart_;      
    CrdBidOffs          llnstop_;       
    CrdBidOffs          firstduppos_;
    CrdBidOffs          firstaltnroffs_;

    BinIDSortingAnalyser* sortanal_;
    TypeSet<CrdBidOffs> cbobuf_;
    int                 curline_;
    int                 curseg_;
    CrdBidOffs          curcbo_;
    CrdBidOffs          prevcbo_;
    CrdBidOffs          curusrcbo_;
    CrdBidOffs          prevusrcbo_;
    CrdBidOffs          curlnstart_;
    int                 nroffsthispos_;
    uiString            errmsg_;

    bool                applySortAnal();
    void                addFirst(const PosInfo::CrdBidOffs&);
    bool                addNext(const PosInfo::CrdBidOffs&);
    void                addLine();
    void                addPos();
    void                setCur(const PosInfo::CrdBidOffs&);
    void                getBinIDRanges();
    int                 getStep(bool inl) const; 
    int                 getRawStep(bool,bool) const;
    uiString            createPositionString(const CrdBidOffs&) const;

    CrdBidOffs          workCBO(const CrdBidOffs&) const;
    CrdBidOffs          userCBO(const CrdBidOffs&) const;

};


} // namespace PosInfo