array2dbitmap.h

Go to the documentation of this file.

#ifndef array2dbitmap_h
#define array2dbitmap_h
/*+
________________________________________________________________________

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

-*/

#include "generalmod.h"
#include "generalmod.h"
#include "ranges.h"
#include "arraynd.h"
#include "dataclipper.h"


typedef Array2D<char>   A2DBitMap;
#define A2DBitMapImpl   Array2DImpl<char>

mStruct(General) A2DBitMapGenPars
{
                A2DBitMapGenPars()
                  : nointerpol_(false)
                  , autoscale_(true)
                  , clipratio_(0.025,0.025)
                  , midvalue_( mUdf(float) )
                  , scale_(0,1)                 {}

    bool        nointerpol_;    
    bool        autoscale_;     
    Interval<float> clipratio_; 
    float       midvalue_;      
    Interval<float> scale_;     

    static char cNoFill();      

};


mExpClass(General) A2DBitMapInpData
{
public:

                        A2DBitMapInpData( const Array2D<float>& d )
                            : data_(d) { collectData(); }
    virtual             ~A2DBitMapInpData()                     {}

    const Array2D<float>& data() const  { return data_; }
    Interval<float>     scale(const Interval<float>& clipratio,
                              float midval) const;
    virtual float       midVal() const;

    void                collectData(); 

protected:
    DataClipper                 clipper_;

    const Array2D<float>&       data_;
};


mExpClass(General) A2DBitMapPosSetup
{
public:

                        A2DBitMapPosSetup(const Array2DInfo&,float* dim0pos=0);
                                // If passed, dim0pos becomes mine
    virtual             ~A2DBitMapPosSetup();

    void                setDim0Positions(float* dim0positions);
    void                setDim1Positions(float,float);
    inline const float* dim0Positions() const
                        { return dim0pos_; }
    inline const Interval<float>& dim1Positions() const
                        { return dim1pos_; }
    int                 dimSize( int dim ) const
                        { return dim ? szdim1_ : szdim0_; }

    void                setDimRange( int dim, const Interval<float>& r )
                        { (dim ? dim1rg_ : dim0rg_) = r; }      
    inline const Interval<float>& dimRange( int dim ) const
                        { return dim ? dim1rg_ : dim0rg_; }
    inline float        dim0MedianDist() const  { return dim0mediandist_; }

    void                setBitMapSizes(int,int) const;
    inline int          nrXPix() const          { return nrxpix_; }
    inline int          nrYPix() const          { return nrypix_; }
    void                setPixSizes(int,int);
    int                 availableXPix() const   { return availablenrxpix_; }
    int                 availableYPix() const   { return availablenrypix_; }

    inline float        getPixPerDim( int dim ) const
                        { return dim ? pixperdim1_ : pixperdim0_; }
    inline float        getPixOffs( int dim, float pos ) const
                        { return (pos - (dim ? dim1rg_ : dim0rg_).start)
                                 * getPixPerDim( dim ); }

    int                 getPix(int dim,float) const;
                        // Nr of pixels from (0,0), always inside bitmap
    bool                isInside(int dim,float) const;
                        // Is position in dim inside bitmap?

protected:

    float*              dim0pos_;
    Interval<float>     dim1pos_;
    int                 szdim0_;
    int                 szdim1_;

    Interval<float>     dim0rg_;
    Interval<float>     dim1rg_;
    float               dim0mediandist_;

    // Vars for current bitmap
    int                 nrxpix_;
    int                 nrypix_;
    int                 availablenrxpix_;
    int                 availablenrypix_;
    float               pixperdim0_;
    float               pixperdim1_;

};


mExpClass(General) A2DBitMapGenerator
{
public:

    virtual             ~A2DBitMapGenerator()   { delete &pars_; }

    void                setBitMap(A2DBitMap&);
    A2DBitMap&          bitmap()                { return *bitmap_; }
    const A2DBitMap&    bitmap() const          { return *bitmap_; }
    int                 bitmapSize(int dim) const;

    static void         initBitMap(A2DBitMap&); 
    void                initBitMap()
                        { if ( bitmap_ ) initBitMap( *bitmap_ ); }
    void                setPixSizes(int,int);

    void                fill();

    A2DBitMapGenPars&           pars()          { return pars_; }
    const A2DBitMapGenPars&     pars() const    { return pars_; }
    const A2DBitMapInpData&     data() const    { return data_; }
    const A2DBitMapPosSetup&    setup() const   { return setup_; }

    const Interval<float>       getScaleRange() const   { return scalerg_; }

protected:

                                A2DBitMapGenerator(const A2DBitMapInpData&,
                                                   const A2DBitMapPosSetup&,
                                                   A2DBitMapGenPars&);

    const A2DBitMapInpData&     data_;
    const A2DBitMapPosSetup&    setup_;
    A2DBitMapGenPars&           pars_;
    A2DBitMap*                  bitmap_;

                                // handy, duplicated from respective objects
    int                         szdim0_;
    int                         szdim1_;
    const float*                dim0pos_;
    Interval<float>             dim1pos_;
    Interval<float>             dim0rg_;
    Interval<float>             dim1rg_;
    float                       dim0perpix_;
    float                       dim1perpix_;
    Interval<float>             scalerg_;
    float                       scalewidth_;

    virtual void                doFill()                = 0;
};


#endif