trckeysampling.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

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

-*/

#include "basicmod.h"
#include "binid.h"
#include "ranges.h"
#include "typeset.h"
#include "trckey.h"

typedef TypeSet<TrcKey> TrcKeyPath;

mExpClass(Basic) TrcKeySampling
{
public:

                        TrcKeySampling();
                        TrcKeySampling(Pos::GeomID);
                        TrcKeySampling(const TrcKey&);
                        TrcKeySampling(const TrcKeySampling&);

    bool                is2D() const    { return TrcKey::is2D(survid_); }
    Pos::GeomID getGeomID() const;

    TrcKeySampling&     set(const Interval<int>& linerg,
                            const Interval<int>& trcnrrg);
    void                get(Interval<int>& linerg,Interval<int>& trcnrrg) const;
    TrcKeySampling      getLineChunk(int totalchunks,int chunknr) const;

    StepInterval<int>   lineRange() const;
    StepInterval<int>   trcRange() const;
    float               lineDistance() const;
    float               trcDistance() const;
    void                setLineRange(const Interval<int>&);
    void                setTrcRange(const Interval<int>&);

    bool                includes(const TrcKeySampling&,
                                 bool ignoresteps=false) const;
    bool                includes(const TrcKey&) const;
    bool                lineOK(Pos::LineID,bool ignoresteps=false) const;
    bool                trcOK(Pos::TraceID,bool ignoresteps=false) const;

    void                include(const TrcKey&);
    void                includeLine(Pos::LineID);
    void                includeTrc(Pos::TraceID);
    void                include(const TrcKeySampling&, bool ignoresteps=false );
    bool                isDefined() const;
    void                limitTo(const TrcKeySampling&,bool ignoresteps=false);
    void                limitToWithUdf(const TrcKeySampling&);
    void                shrinkTo(const TrcKeySampling& innertks);
    void                growTo(const TrcKeySampling& outertks);
    void                expand(int nrlines,int nrtrcs);

    inline int          lineIdx(Pos::LineID) const;
    inline int          trcIdx(Pos::TraceID) const;
    inline Pos::LineID  lineID(int) const;
    inline Pos::TraceID traceID(int) const;

    od_int64            globalIdx(const TrcKey&) const;
    od_int64            globalIdx(const BinID&) const;
    BinID               atIndex(int i0,int i1) const;
    BinID               atIndex(od_int64 globalidx) const;
    TrcKey              trcKeyAt(int i0,int i1) const;
    TrcKey              trcKeyAt(od_int64 globalidx) const;
    TrcKey              toTrcKey(const Coord&,float* distance=0) const;
    Coord               toCoord(const BinID&) const;
    TrcKey              center() const;
    int                 nrLines() const;
    int                 nrTrcs() const;
    od_int64            totalNr() const;
    bool                isEmpty() const;
    void                neighbors(od_int64 globalidx,TypeSet<od_int64>&) const;
    void                neighbors(const TrcKey&,TypeSet<TrcKey>&) const;
    bool                toNext(BinID&) const;

    void                init(bool settoSI=true);
    bool                init(Pos::GeomID);

    void                set2DDef();
    void                normalise();
    void                getRandomSet(int nr,TypeSet<TrcKey>&) const;

    bool                getInterSection(const TrcKeySampling&,
                                        TrcKeySampling&) const;

    BinID               getNearest(const BinID&) const;
    TrcKey              getNearest(const TrcKey&) const;
    void                snapToSurvey();
    bool                operator==(const TrcKeySampling&) const;
    bool                operator!=(const TrcKeySampling&) const;
    TrcKeySampling&     operator=(const TrcKeySampling&);

    bool                usePar(const IOPar&);   
    void                fillPar(IOPar&) const;  
    static void         removeInfo(IOPar&);
    void                toString(BufferString&) const; 

    Pos::SurvID         survid_;
    BinID               start_;
    BinID               stop_;
    BinID               step_;

    //Legacy. Will be removed
                        TrcKeySampling(bool settoSI);
    StepInterval<int>   inlRange() const        { return lineRange(); }
    StepInterval<int>   crlRange() const        { return trcRange(); }
    void                setInlRange(const Interval<int>& rg) {setLineRange(rg);}
    void                setCrlRange(const Interval<int>& rg) {setTrcRange(rg);}

    int                 nrInl() const { return nrLines(); }
    int                 nrCrl() const { return nrTrcs(); }

    int                 inlIdx( Pos::LineID lid ) const {return lineIdx(lid);}
    int                 crlIdx( Pos::TraceID tid ) const { return trcIdx(tid); }
    inline void         include( const BinID& bid )
                        { includeLine(bid.inl()); includeTrc(bid.crl()); }
    void                includeInl( int inl ) { includeLine(inl); }
    void                includeCrl( int crl ) { includeTrc(crl); }
    inline bool         includes(const BinID& bid,bool ignoresteps=false) const
                        { return lineOK(bid.inl(),ignoresteps) &&
                                 trcOK(bid.crl(),ignoresteps); }
    inline bool         inlOK( int inl ) const { return lineOK(inl); }
    inline bool         crlOK( int crl ) const { return trcOK(crl); }

    mDeprecated BinID&  start;
    mDeprecated BinID&  stop;
    mDeprecated BinID&  step;
private:
    bool                doLimitTo(StepInterval<int>&, const StepInterval<int>&,
                                  const bool ignoresteps,
                                  const bool nostephandling);
};


mExpClass(Basic) TrcKeySamplingSet : public TypeSet<TrcKeySampling>
{
public:

    void                        isOK() const;
    void                        add(Pos::GeomID);
    bool                        isPresent(Pos::GeomID);
};




mExpClass(Basic) TrcKeySamplingIterator
{
public:
                TrcKeySamplingIterator();
                TrcKeySamplingIterator(const TrcKeySampling&);

    void        setSampling(const TrcKeySampling&);
    void        setCurrentPos( od_int64 pos )           { curpos_ = pos; }
    void        reset();

    bool        next() const;

    TrcKey      curTrcKey() const;
    BinID       curBinID() const;

    od_int64    curIdx() const                          { return curpos_; }
    od_int64    totalNr() const                         { return totalnr_; }

    void        fillPar(IOPar&) const;
    void        usePar(const IOPar&);

protected:

    TrcKeySampling                      tks_;
    od_int64                            totalnr_;
    mutable Threads::Atomic<od_int64>   curpos_;
};




typedef TrcKeySampling HorSampling;
typedef TrcKeySamplingIterator  HorSamplingIterator;


inline int TrcKeySampling::lineIdx( Pos::LineID line ) const
{
    return step_.lineNr()
        ? (line-start_.lineNr()) / step_.lineNr()
        : (line==start_.lineNr() ? 0 : -1);
}


inline int TrcKeySampling::trcIdx( Pos::TraceID trcid ) const
{
    return step_.trcNr()
        ? (trcid-start_.trcNr()) / step_.trcNr()
        : (trcid==start_.trcNr() ? 0 : -1);
}


inline Pos::LineID TrcKeySampling::lineID( int lidx ) const
{
    return start_.lineNr() + step_.lineNr() * lidx;
}


inline Pos::TraceID TrcKeySampling::traceID( int tidx ) const
{
    return start_.trcNr() + step_.trcNr() * tidx;
}