posidxpairvalset.h

Go to the documentation of this file.

#ifndef posidxpairvalset_h
#define posidxpairvalset_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril
 Date:          July 2004/Oct 2013
 RCS:           $Id$
________________________________________________________________________

-*/

#include "generalmod.h"
#include "posidxpair.h"
#include "sets.h"
#include "ranges.h"
#include "od_iosfwd.h"
namespace PosInfo { class CubeData; }
class TrcKeySampling;


namespace Pos
{
template <class IPT,class FT> class ValueIdxPair;
template <class IPT,class FT> class IdxPairValues;


mExpClass(General) IdxPairValueSet
{
public:

    typedef IdxPair::IdxType                    IdxType;
    typedef ValueIdxPair<IdxPair,float>         PairVal;
    typedef IdxPairValues<IdxPair,float>        DataRow;

                        IdxPairValueSet(int nr_vals,
                                        bool allow_duplicate_idxpairs);
                        IdxPairValueSet(const IdxPairValueSet&);
    virtual             ~IdxPairValueSet();
    IdxPairValueSet&    operator =(const IdxPairValueSet&);

    inline void         allowDuplicateIdxPairs( bool yn )
                        { allowdup_ = yn; if ( !yn ) removeDuplicateIdxPairs();}
    bool                allowsDuplicateIdxPairs() const { return allowdup_; }
    void                setEmpty();
    bool                append(const IdxPairValueSet&);
    void                remove(const IdxPairValueSet&);
    void                copyStructureFrom(const IdxPairValueSet&);

    struct SPos
    {
                        SPos( int ii=-1, int jj=-1 )
                            : i(ii), j(jj)      {}
        void            reset()                 { i = j = -1; }
        inline bool     operator ==( const SPos& p ) const
                                                { return i == p.i && j == p.j; }
        inline bool     operator !=( const SPos& p ) const
                                                { return i != p.i || j != p.j; }
        inline bool     operator>( const SPos& p ) const
                        { if ( i>p.i ) return true; return i==p.i && j>p.j; }
        inline bool     operator<( const SPos& p ) const
                        { if ( i<p.i ) return true; return i==p.i && j<p.j; }
        inline bool     isValid() const         { return i > -1 && j > -1; }

        int             i, j;
    };

    inline SPos         find( const IdxPair& ip ) const
                        { return findOccurrence( ip, 0 ); }
    SPos                findOccurrence(const IdxPair&,int occ=0) const;
    bool                next(SPos&,bool skip_duplicate_idxpairs=false) const;
    bool                prev(SPos&,bool skip_duplicate_idxpairs=false) const;
    bool                isValid(const IdxPair&) const;

    void                get(const SPos&,IdxPair&,float* v=0,
                                int mxnrvals=-1) const;
    IdxPair             getIdxPair(const SPos&) const;
    SPos                getPos(od_int64 global_idx) const;
    SPos                add(const IdxPair&,const float* vs=0);
    SPos                add(const DataRow&);
    void                set(SPos,const float* vs=0); 

                        // more get, set and add: see below

    inline int          nrVals() const          { return nrvals_; }
    inline int          nrFirst() const         { return frsts_.size(); }
    int                 nrSecond(IdxType firstidx) const;
    inline bool         isEmpty() const         { return nrFirst() < 1; }
    inline bool         includes( const IdxPair& ip ) const
                                                { return find(ip).j > -1; }
    bool                hasFirst(IdxType) const;
    bool                hasSecond(IdxType) const;
    IdxPair             firstIdxPair() const;
    od_int64            totalSize() const;
    Interval<IdxType>   firstRange() const;
    Interval<IdxType>   secondRange(IdxType firsidx=-1) const;
    Interval<float>     valRange(int valnr) const;

    void                remove(const SPos&);
    void                remove(const TypeSet<SPos>&);
    void                removeVal(int); 
    bool                insertVal(int); //<! Will add a 'column'
    bool                setNrVals(int,bool kp_data=true);
    int                 nrDuplicateIdxPairs() const;
    void                sortDuplicateIdxPairs(int value_nr,bool ascending=true);
    void                removeDuplicateIdxPairs();
    void                randomSubselect(od_int64 maxnr);

    void                extend(const IdxPairDelta& stepout,const IdxPairStep&);
    void                removeRange(int valnr,const Interval<float>&,
                                    bool inside=true);
    void                remove(const TrcKeySampling& hrg,bool inside);

                        // Convenience stuff
    SPos                add(const PairVal&);
    SPos                add(const IdxPair&,float);
    SPos                add(const IdxPair&,double);
    SPos                add(const IdxPair&,float,float);
    SPos                add(const IdxPair&,const TypeSet<float>&);
    void                add(const PosInfo::CubeData&);
    void                get(const SPos&,DataRow&) const;
    void                get(const SPos&,PairVal&) const;
    void                get(const SPos&,IdxPair&,float&) const;
    void                get(const SPos&,IdxPair&,float&,float&) const;
    void                get(const SPos&,IdxPair&,TypeSet<float>&,
                            int maxnrvals=-1) const; 
    void                set(const SPos&,float);
    void                set(const SPos&,float,float);
    void                set(const SPos&,const TypeSet<float>&);
    void                getColumn(int valnr,TypeSet<float>&,bool incudf) const;

                        // Slow! Can still come in handly for small sets
    void                fillPar(IOPar&,const char* key) const;
    void                usePar(const IOPar&,const char* key);

                        // Fast
    bool                getFrom(od_istream&,Pos::GeomID=mUdf(Pos::GeomID));
    bool                putTo(od_ostream&) const;

    bool                includes(const DataRow&) const;
    int                 nrPos(int lineidx) const; 
    inline float*       getVals( const SPos& pos )
                        { return valsets_[pos.i]->arr() + nrvals_*pos.j; }
    inline const float* getVals( const SPos& pos ) const
                        { return valsets_[pos.i]->arr() + nrvals_*pos.j; }
    inline float        getVal( const SPos& pos, int valnr ) const
                        { return getVals(pos)[valnr]; }
    bool                hasDuplicateIdxPairs() const;
    bool                haveDataRow(const DataRow&) const;

                        // aliases
    inline int          nrInls() const              { return nrFirst(); }
    inline int          nrCrls( IdxType inl ) const { return nrSecond(inl); }
    inline int          nrRows() const              { return nrFirst(); }
    inline int          nrCols( IdxType row ) const { return nrSecond(row); }
    bool                hasInl( IdxType inl ) const { return hasFirst(inl); }
    bool                hasCrl( IdxType crl ) const { return hasSecond(crl); }
    inline bool         hasRow( IdxType row ) const { return hasFirst(row); }
    inline bool         hasCol( IdxType col ) const { return hasSecond(col); }
    Interval<int>       inlRange() const            { return firstRange(); }
    Interval<int>       rowRange() const            { return firstRange(); }
    Interval<int>       crlRange( IdxType inl=-1 ) const
                                                    { return secondRange(inl); }
    Interval<int>       colRange( IdxType row=-1 ) const
                                                    { return secondRange(row); }

protected:

    const int                   nrvals_;
    TypeSet<IdxType>            frsts_;
    ObjectSet< TypeSet<IdxType> > scndsets_;
    ObjectSet< TypeSet<float> > valsets_;
    bool                        allowdup_;

    void                        addNew(SPos&,IdxType,const float*);
    void                        sortPart(TypeSet<IdxType>&,TypeSet<float>&,
                                         int,int,int,bool);

    void                        removeLine(int idx);

    inline IdxType              getFrst( const SPos& pos ) const
                                        { return frsts_[pos.i]; }
    inline IdxType              getScnd( const SPos& pos ) const
                                        { return (*scndsets_[pos.i])[pos.j]; }
    inline TypeSet<IdxType>&    getScndSet( const SPos& pos )
                                        { return *scndsets_[pos.i]; }
    inline const TypeSet<IdxType>& getScndSet( const SPos& pos ) const
                                        { return *scndsets_[pos.i]; }
    inline TypeSet<float>&      getValSet( const SPos& pos )
                                        { return *valsets_[pos.i]; }
    inline const TypeSet<float>& getValSet( const SPos& pos ) const
                                        { return *valsets_[pos.i]; }
    inline TypeSet<IdxType>&    getScndSet( int idx )
                                        { return *scndsets_[idx]; }
    inline const TypeSet<IdxType>& getScndSet( int idx ) const
                                        { return *scndsets_[idx]; }
    inline TypeSet<float>&      getValSet( int idx )
                                        { return *valsets_[idx]; }
    inline const TypeSet<float>& getValSet( int idx ) const
                                        { return *valsets_[idx]; }

    friend class                DataPointSet;
    friend class                PosVecDataSet;

};


} // namespace Pos


#endif