Generated/html/datapointset_8h_source.html

#pragma once


/*+

________________________________________________________________________


 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt

 Author:        Bert

 Date:          Jan 2008

 RCS:           $Id$

________________________________________________________________________


-*/


#include "generalmod.h"

#include "binidvalset.h"

#include "color.h"

#include "datapackbase.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;

    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() 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() const           { return pos_.coord(); }

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

                        DataPointSet(const DataPointSet&);

    virtual             ~DataPointSet();

    DataPointSet&       operator =(const 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_; }

    bool                getRange(TrcKeyZSampling&) const;


    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* tr=0, bool filterAccept=true);

    void                addCol(const char* nm,const char* ref=0,

                                const UnitOfMeasure* un=0);


    // DataPack interface impl

    bool                simpleCoords() const            { return minimal_; }

    float               nrKBytes() const;

    void                dumpInfo(IOPar&) const;


protected:


    PosVecDataSet&              data_;

    TypeSet<BinIDValueSet::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;

};


mExpClass(General) DPSFromVolumeFiller : public ParallelTask

{ mODTextTranslationClass(DPSFromVolumeFiller)

public:

                                DPSFromVolumeFiller(DataPointSet&,int firstcol,

                                                    const SeisDataPack&,

                                                    int component);

                                ~DPSFromVolumeFiller();


    virtual uiString            uiMessage() const;

    virtual uiString            uiNrDoneText() 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 SeisDataPack&         sdp_;

    int                         component_;

    int                         firstcol_;


    bool                        hastrcdata_;

    bool                        hasstorage_;

    const TrcKeyZSampling*      sampling_;

};