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
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#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)  {}
 
    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(const BinID&) const;
    bool                includes(int inl,int crl) const;
    void                getRanges(Interval<int>& inl,Interval<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(const BinID&) 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);
 
    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