trckeyzsampling.h

Go to the documentation of this file.

#ifndef trckeyzsampling_h
#define trckeyzsampling_h

/*+
________________________________________________________________________

 (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                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&);

//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 TrcKeySampling&         hrg;
    mDeprecated 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;


#endif