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
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "basicmod.h"
#include "binid.h"
#include "ranges.h"
#include "typeset.h"
#include "trckey.h"
 
namespace OD
{
    namespace JSON
    {
        class Object;
    };
};
 
typedef TypeSet<TrcKey> TrcKeyPath;
 
mExpClass(Basic) TrcKeySampling
{
public:
 
                        TrcKeySampling();
                        TrcKeySampling(const TrcKeySampling&);
                        TrcKeySampling(Pos::GeomID);
 
    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                includes(const TrcKey&,bool ignoresteps) const;
    bool                lineOK(Pos::LineID) const;
    bool                trcOK(Pos::TraceID) const;
 
    bool                lineOK(Pos::LineID,bool ignoresteps) const;
    bool                trcOK(Pos::TraceID,bool ignoresteps) 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                expand(int nrlines,int nrtrcs);
 
    int                 lineIdx(Pos::LineID) const;
    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=nullptr) 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;
 
    void                init(bool settoSI=true);
    bool                init(Pos::GeomID);
    void                init(const TrcKey&);
 
    void                set2DDef();
    void                normalize();
    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                fillJSON(OD::JSON::Object&) const;
    bool                useJSON(const OD::JSON::Object&);
    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 ) const
                        { return lineOK(bid.inl()) && trcOK(bid.crl()); }
    inline bool         inlOK( int inl ) const { return lineOK(inl); }
    inline bool         crlOK( int crl ) const { return trcOK(crl); }
 
    inline bool         includes(const BinID& bid, bool ignoresteps) const
                        { return lineOK(bid.inl(), ignoresteps ) &&
                                 trcOK(bid.crl(), ignoresteps ); }
 
    mDeprecated("Use start_ instead") BinID&            start;
    mDeprecated("Use stop_ instead")  BinID&            stop;
    mDeprecated("Use step_ instead")  BinID&            step;
 
    void                shrinkTo(const TrcKeySampling& innertks);
    void                growTo(const TrcKeySampling& outertks);
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() : tks_( true ) { reset(); }
                TrcKeySamplingIterator( const TrcKeySampling& hs )
                { setSampling( hs ); }
 
    void        setSampling(const TrcKeySampling&);
 
    void        reset();
    void        setNextPos(const TrcKey& trk) { curpos_ = tks_.globalIdx(trk); }
    bool        next(TrcKey&) const;
    bool        next(BinID&) const;
 
    od_int64    curIdx() const               { return curpos_; }
    TrcKey      curTrcKey() const            { return tks_.atIndex( curIdx() );}
 
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;
}