posinfo.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:          2005 / Mar 2008
________________________________________________________________________

-*/

#include "basicmod.h"
#include "manobjectset.h"
#include "typeset.h"
#include "trckeyzsampling.h"
#include "indexinfo.h"
#include "binid.h"
#include "od_iosfwd.h"


namespace PosInfo
{

mExpClass(Basic) LineData
{
public:
    typedef StepInterval<int>   Segment;

                                LineData( int i ) : linenr_(i)  {}
    bool                        operator ==(const LineData&) const;
    bool                        operator !=( const LineData& oth ) const
                                { return !(*this == oth); }

    const int                   linenr_;
    TypeSet<Segment>            segments_;

    int                         size() const;
    int                         segmentOf(int) const;
    Interval<int>               range() const;
    void                        merge(const LineData&,bool incl);

    int                         nearestSegment(double) const;

};


mExpClass(Basic) CubeDataPos
{
public:
                CubeDataPos( int iln=0, int isn=0, int sidx=-1 )
                    : lidx_(iln), segnr_(isn), sidx_(sidx)      {}

    int         lidx_;
    int         segnr_;
    int         sidx_;

    void        toPreStart()    { lidx_ = segnr_ = 0; sidx_ = -1; }
    void        toStart()       { lidx_ = segnr_ = sidx_ = 0; }
    bool        isValid() const { return lidx_>=0 && segnr_>=0 && sidx_>=0; }

};


mExpClass(Basic) CubeData : public ManagedObjectSet<LineData>
{
public:

                        CubeData()              {}
                        CubeData( BinID start, BinID stop, BinID step )
                                                { generate(start,stop,step); }
                        CubeData( const CubeData& cd )
                            : ManagedObjectSet<LineData>()
                                                { *this = cd; }
    CubeData&           operator =( const CubeData& cd )
                        { copyContents(cd); return *this; }

    int                 totalSize() const;
    int                 totalSizeInside(const TrcKeySampling& hrg) const;
    virtual int         indexOf(int inl,int* newidx=0) const;
    bool                includes(int inl,int crl) const;
    bool                getInlRange(StepInterval<int>&,bool sorted=true) const;
    bool                getCrlRange(StepInterval<int>&,bool sorted=true) const;

    bool                isValid(const CubeDataPos&) const;
    bool                isValid(od_int64 globalidx,const TrcKeySampling&) const;
    bool                toNext(CubeDataPos&) const;
    BinID               binID(const CubeDataPos&) const;
    CubeDataPos         cubeDataPos(const BinID&) const;

    bool                haveInlStepInfo() const         { return size() > 1; }
    bool                haveCrlStepInfo() const;
    bool                isFullyRectAndReg() const;
    bool                isCrlReversed() const;

    void                limitTo(const TrcKeySampling&);
    void                merge(const CubeData&,bool incl);
    void                generate(BinID start,BinID stop,BinID step,
                                 bool allowreversed=false);
    void                fillBySI(bool work=false);

    bool                read(od_istream&,bool asc);
    bool                write(od_ostream&,bool asc) const;

    virtual int         indexOf( const LineData* l ) const
                        { return ObjectSet<LineData>::indexOf( l ); }

protected:

    void                copyContents(const CubeData&);

};


mExpClass(Basic) SortedCubeData : public CubeData
{
public:
                        SortedCubeData()                                {}
                        SortedCubeData( const BinID& start, const BinID& stop,
                                  const BinID& step )
                            : CubeData(start,stop,step)         {}
                        SortedCubeData( const SortedCubeData& cd )
                            : CubeData( cd )
                                                                { *this = cd; }
                        SortedCubeData( const CubeData& cd )    { *this = cd; }
    SortedCubeData&     operator =( const SortedCubeData& scd )
                        { copyContents(scd); return *this; }
    SortedCubeData&     operator =( const CubeData& cd )
                        { copyContents(cd); return *this; }

    virtual int         indexOf(int inl,int* newidx=0) const;

    SortedCubeData&     add(LineData*);

    virtual int         indexOf( const LineData* l ) const
                        { return CubeData::indexOf( l ); }

protected:

    virtual CubeData&   doAdd(LineData*);

};


mExpClass(Basic) CubeDataFiller
{
public:
                        CubeDataFiller(CubeData&);
                        ~CubeDataFiller();

    void                add(const BinID&);
    void                finish(); // automatically called on delete

protected:

    CubeData&           cd_;
    LineData*           ld_;
    LineData::Segment   seg_;
    int                 prevcrl;

    void                initLine();
    void                finishLine();
    LineData*           findLine(int);

};


mExpClass(Basic) CubeDataIterator
{
public:

                        CubeDataIterator( const CubeData& cd )
                            : cd_(cd)   {}

    inline bool         next( BinID& bid )
                        {
                            const bool rv = cd_.toNext( cdp_ );
                            bid = binID(); return rv;
                        }
    inline void         reset()         { cdp_.toPreStart(); }
    inline BinID        binID() const   { return cd_.binID( cdp_ ); }

    const CubeData&     cd_;
    CubeDataPos         cdp_;

};


} // namespace PosInfo