datapointset.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:          Jan 2008
________________________________________________________________________

-*/

#include "generalmod.h"
#include "binidvalset.h"
#include "color.h"
#include "datapackbase.h"
#include "valseries.h"
class DataColDef;
class BinIDValueSet;
class PosVecDataSet;
class UnitOfMeasure;
class BufferStringSet;
class TaskRunner;
class TrcKeyZSampling;

namespace Pos { class Filter; class Provider; }


mExpClass(General) DataPointSet : public PointDataPack
{
public:

    typedef int                 RowID;
    typedef int                 ColID;
    typedef BinIDValueSet::SPos SPos;

    class DataRow;

    mExpClass(General) Pos
    {
    public:
                        Pos() : offsx_(0), offsy_(0), z_(0), nr_(0)     {}
                        Pos( const BinID& bid, float _z )
                            : binid_(bid), nr_(0), z_(_z)
                            , offsx_(0), offsy_(0)              {}
                        Pos(const Coord&,float z);
                        Pos(const Coord3&);

        bool            operator ==(const Pos& pos) const
                        { return binid_==pos.binid_ && offsx_ ==pos.offsx_
                                && offsy_==pos.offsy_ && z_==pos.z_; }
        const BinID&    binID() const   { return binid_; }
        Coord           coord(::Pos::SurvID) const;
        float           z() const       { return z_; }

        void            set( const BinID& bid )
                        { binid_ = bid; offsx_ = offsy_ = 0; }
        void            set(const Coord&);
        void            set(const Coord3&);

        BinID           binid_;
        float           z_;
        int             nr_;                    

        float           binIDOffSet( bool inx ) const
                        { return inx ? offsx_ : offsy_; }
        void            setBinIDOffset( bool inx, float o )
                        { (inx ? offsx_ : offsy_) = o; }
        void            setBinIDOffsets( float ox, float oy )
                        { offsx_ = ox; offsy_ = oy; }

    protected:

        float           offsx_, offsy_;
        void            setOffs(const Coord&);
        friend class    DataRow;

    };

    mExpClass(General) DataRow
    {
    public:
                        DataRow()
                            : grp_(1)                   { setSel(false); }
                        DataRow( const Pos& p, unsigned short grp=1,
                                   bool issel=false )
                            : pos_(p), grp_((short)grp)
                                                        { setSel( issel ); }

        bool                    operator ==(const DataRow& dr) const
                                { return pos_==dr.pos_ && grp_==dr.grp_
                                        && data_==dr.data_; }
        const BinID&            binID() const           { return pos_.binID(); }
        Coord                   coord(::Pos::SurvID survid) const
                                { return pos_.coord(survid); }
        const TypeSet<float>&   data() const            { return data_; }
        unsigned short          group() const;
        bool                    isSel() const           { return grp_ > 0; }
        bool                    isInactive() const      { return grp_ == 0; }
        void                    setSel( bool yn )
                                { if ( (grp_ >= 0) != yn ) grp_ = -grp_; }
        void                    setGroup(unsigned short grp);
        void                    getBVSValues(TypeSet<float>&,bool is2d,
                                             bool ismini) const;

        Pos             pos_;
        TypeSet<float>  data_;
        short           grp_;
    };

                        DataPointSet(const TypeSet<DataRow>&,
                                     const ObjectSet<DataColDef>&,
                                     bool is2d,bool minimal=false);
                        DataPointSet(const TypeSet<DataRow>&,
                                     const BufferStringSet& valnms,
                                     bool is2d,bool minimal=false);
                        DataPointSet(const PosVecDataSet&,bool is2d,
                                        bool minimal=false);
                        DataPointSet(const DataPointSet&,const ::Pos::Filter&);
                        mDeclMonitorableAssignment(DataPointSet);
    bool                is2D() const            { return is2d_; }
    bool                isMinimal() const       { return minimal_; }
    bool                isEmpty() const         { return bvsidxs_.isEmpty(); }
    void                setEmpty();
    void                clearData(); 

    int                 nrCols() const;
    int                 nrFixedCols() const     { return nrfixedcols_; }
    const char*         colName(ColID) const;
    const UnitOfMeasure* unit(ColID) const;
    const DataColDef&   colDef( ColID i ) const { return gtColDef(i); }
    ColID               indexOf(const char*) const;
    bool                validColID(ColID) const;

                        // size, binID, coord, z and trcNr impl PointDataPack
    int                 size() const            { return bvsidxs_.size(); }
    BinID               binID(RowID) const;
    Coord               coord(RowID) const;
    float               z(RowID) const;
    int                 trcNr(RowID) const;

    Pos                 pos(RowID) const;
    DataRow             dataRow(RowID) const;
    float               value(ColID,RowID) const;
    bool                setValue(ColID,RowID,float);
    float*              getValues(RowID);
    const float*        getValues(RowID) const;
    unsigned short      group(RowID) const;
    bool                isSelected(RowID) const;
    int                 selGroup(RowID) const;
    bool                isInactive( RowID rid ) const { return group(rid) == 0;}

    void                setGroup(RowID,unsigned short);
    void                setSelected(RowID,int selgrp);
    void                setInactive(RowID,bool);

    int                 nrActive() const;
    void                purgeInactive();
    void                purgeSelected(bool selected_rows=true);

    RowID               find(const Pos&) const;
    RowID               find(const Pos&,float horradius,float deltaz) const;
    RowID               findFirst(const Coord&) const;
    RowID               findFirst(const BinID&) const;

    const PosVecDataSet& dataSet() const                { return data_; }
    const BinIDValueSet& bivSet() const { return const_cast<DataPointSet*>
                                          (this)->bivSet(); }
    BinIDValueSet&      bivSet();
    PosVecDataSet&      dataSet()               { return data_; }

    DataPointSet*       getSubselected(int maxsz,
                            const TypeSet<int>* selected_cols=0,
                            bool allow_udf_values=true,
                            const ObjectSet<Interval<float> >* value_ranges=0)
                                                        const;
    void                randomSubselect(int maxsz);

    int                 bivSetIdx( ColID idx ) const
                                                { return idx+nrfixedcols_; }

    void                dataChanged()                   { calcIdxs(); }
    void                addRow(const DataRow&);
    bool                setRow(const DataRow&);
    RowID               getRowID(BinIDValueSet::SPos) const;
    DataColDef&         colDef( ColID i )               { return gtColDef(i); }
    BinIDValueSet::SPos bvsPos( RowID rid ) const       { return bvsidxs_[rid];}

                        // Building from scratch
                        DataPointSet(bool is2d,bool minimal=false);
    bool                extractPositions(::Pos::Provider&,
                                     const ObjectSet<DataColDef>&,
                                     const ::Pos::Filter* f=0,
                                     TaskRunner* tskr=0);
    void                addCol(const char* nm,const char* ref=0,
                                const UnitOfMeasure* un=0);

    bool                simpleCoords() const            { return minimal_; }

protected:

    virtual             ~DataPointSet();

    PosVecDataSet&      data_;
    TypeSet<SPos>       bvsidxs_;
    bool                is2d_;
    bool                minimal_;

    void                initPVDS();
    void                init(const TypeSet<DataRow>&,
                             const ObjectSet<DataColDef>&);
    void                calcIdxs();

    static const int    groupcol_;
    const int           nrfixedcols_;

    DataColDef&         gtColDef(ColID) const;

    virtual float       gtNrKBytes() const;
    virtual void        doDumpInfo(IOPar&) const;

};


mExpClass(General) DPSValueSeries : public ValueSeries<float>
{
public:

    typedef DataPointSet::ColID ColID;
    typedef DataPointSet::RowID RowID;

                                DPSValueSeries( const DataPointSet& dps,
                                                ColID colid )
                                    : dps_(dps), colid_(colid)
                                { dps_.ref(); }
                                DPSValueSeries( const DPSValueSeries& oth )
                                    : dps_(oth.dps_), colid_(oth.colid_)
                                { dps_.ref(); }
                                ~DPSValueSeries()
                                { dps_.unRef();}

    virtual ValueSeries<float>* clone() const
                                { return new DPSValueSeries(*this); }
    virtual float               value( od_int64 idx ) const
                                { return dps_.value( colid_, (RowID)idx ); }

protected:

    const DataPointSet&         dps_;
    ColID                       colid_;

};


mExpClass(General) DPSFromVolumeFiller : public ParallelTask
{ mODTextTranslationClass(DPSFromVolumeFiller)
public:
                                DPSFromVolumeFiller(DataPointSet&,int firstcol,
                                                    const VolumeDataPack&,
                                                    int component);
                                ~DPSFromVolumeFiller();

    virtual uiString            message() const;
    virtual uiString            nrDoneText() const;

    void                        setSampling(const TrcKeyZSampling*);

protected:
    virtual od_int64            nrIterations() const;
    virtual bool                doWork(od_int64 start,od_int64 stop,int thridx);

    DataPointSet&               dps_;
    const VolumeDataPack&       vdp_;
    int                         component_;
    int                         firstcol_;

    bool                        hastrcdata_;
    bool                        hasstorage_;
    const TrcKeyZSampling*      sampling_;
};