trckeyzsampling.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 2002
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "basicmod.h"
#include "trckeysampling.h"
#include "enums.h"
 
 
mExpClass(Basic) TrcKeyZSampling
{
public:
 
                        TrcKeyZSampling();
                        TrcKeyZSampling(const TrcKeyZSampling&);
                        TrcKeyZSampling(bool settoSI);
 
    enum Dir            { Inl=0, Crl=1, Z=2 };
                        mDeclareEnumUtils(Dir)
    bool                is2D() const            { return hsamp_.is2D(); }
    Dir                 defaultDir() const;
    void                getDefaultNormal(Coord3&) const;
    bool                isFlat() const; 
 
    void                init(bool settoSI=true);
    inline void         setEmpty()              { init(false); }
    void                set2DDef();
    void                normalize();
    void                normalise();
 
    TrcKeySampling      hsamp_;
    StepInterval<float> zsamp_;
 
    int                 lineIdx(Pos::LineID) const;
    int                 trcIdx(Pos::TraceID) const;
    int                 zIdx(float z) const;
    int                 nrLines() const;
    int                 nrTrcs() const;
    int                 nrZ() const;
    od_int64            totalNr() const;
    int                 size(Dir d) const;
    float               zAtIndex( int idx ) const;
    bool                isEmpty() const;
    bool                isDefined() const;
    bool                includes(const TrcKeyZSampling&) const;
    bool                getIntersection(const TrcKeyZSampling&,
                                        TrcKeyZSampling&) const;
    void                include(const TrcKey&,float z);
    void                include(const TrcKeyZSampling&);
    void                limitTo(const TrcKeyZSampling&,bool ignoresteps=false);
    void                limitToWithUdf(const TrcKeyZSampling&);
    void                expand(int nrlines,int nrtrcs,int nrz);
 
    void                snapToSurvey();
    bool                operator==(const TrcKeyZSampling&) const;
    bool                operator!=(const TrcKeyZSampling&) const;
    TrcKeyZSampling&    operator=(const TrcKeyZSampling&);
 
    bool                usePar(const IOPar&);
    void                fillPar(IOPar&) const;
    static void         removeInfo(IOPar&);
    void                fillJSON(OD::JSON::Object&) const;
    bool                useJSON(const OD::JSON::Object&);
 
//Legacy, don't use
    inline int          inlIdx( int inl ) const { return lineIdx(inl); }
    inline int          crlIdx( int crl ) const { return trcIdx(crl); }
    void                include(const BinID& bid,float z);
 
    inline int          nrInl() const           { return nrLines(); }
    inline int          nrCrl() const           { return nrTrcs(); }
 
    mDeprecated("Use hsamp_ instead")   TrcKeySampling&         hrg;
    mDeprecated("Use zsamp_ instead")   StepInterval<float>&    zrg;
 
    void                shrinkTo(const TrcKeyZSampling& innertkzs,
                                 float releps=1e-4);
    void                growTo(const TrcKeyZSampling& outertkzs,
                               float releps=1e-4);
    bool                adjustTo(const TrcKeyZSampling& availabletkzs,
                                 bool falsereturnsdummy=false);
    bool                makeCompatibleWith(const TrcKeyZSampling& othertkzs);
    bool                isEqual(const TrcKeyZSampling&,
                                float zeps=mUdf(float)) const;
};
 
 
 
mExpClass(Basic) TrcKeyZSamplingSet : public TypeSet<TrcKeyZSampling>
{
 
};
 
 
inline TrcKeyZSampling::Dir direction( TrcKeyZSampling::Dir slctype, int dimnr )
{
    if ( dimnr == 0 )
        return slctype;
    else if ( dimnr == 1 )
        return slctype == TrcKeyZSampling::Inl ? TrcKeyZSampling::Crl
                                            : TrcKeyZSampling::Inl;
    else
        return slctype == TrcKeyZSampling::Z
                ? TrcKeyZSampling::Crl
                : TrcKeyZSampling::Z;
}
 
 
inline int dimension( TrcKeyZSampling::Dir slctype,
                      TrcKeyZSampling::Dir direction )
{
    if ( slctype == direction )
        return 0;
 
    else if ( direction == TrcKeyZSampling::Z )
        return 2;
    else if ( direction == TrcKeyZSampling::Inl )
        return 1;
 
    return slctype == TrcKeyZSampling::Z ? 2 : 1;
}
 
 
typedef TrcKeyZSampling CubeSampling;
 
namespace Pos
{
 
mGlobal(Basic) bool intersect(const StepInterval<int>&,
                              const StepInterval<int>&,
                              StepInterval<int>&);
mGlobal(Basic) bool intersectF(const StepInterval<float>&,
                               const StepInterval<float>&,
                               StepInterval<float>&);
 
}