array2dinterpol.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Kristofer Tingdahl
 Date:          April 2009
 RCS:           $Id$
________________________________________________________________________
 
 
-*/
 
#include "algomod.h"
#include "paralleltask.h"
 
#include "arrayndalgo.h"
#include "enums.h"
#include "factory.h"
#include "odmemory.h"
#include "polygon.h"
#include "rowcol.h"
 
class TrcKeySampling;
template <class T> class Array2D;
namespace Stats { class CalcSetup; }
 
mExpClass(Algo) Array2DInterpol : public ParallelTask
{ mODTextTranslationClass(Array2DInterpol);
public:
    virtual                     ~Array2DInterpol();
                                mDefineFactoryInClass(Array2DInterpol,factory);
 
    enum FillType               { HolesOnly, ConvexHull, Full, Polygon };
                                mDeclareEnumUtils(FillType);
 
    void                        setFillType(FillType);
    FillType                    getFillType() const;
    void                        setRowStep(float r);
    void                        setColStep(float r);
    void                        setOrigin(const RowCol&);
    void                        setSampling(const TrcKeySampling&);
 
    void                        setMaxHoleSize(float);
    float                       getMaxHoleSize() const;
 
    void                        setClassification(bool);
    bool                        isClassification() const;
 
    void                        setMask(const Array2D<bool>*,
                                        OD::PtrPolicy = OD::UsePtr );
    virtual uiString            infoMsg() const
                                { return uiString::emptyString(); }
 
    mExpClass(Algo) ArrayAccess
    {
    public:
        virtual                 ~ArrayAccess()                          {}
        virtual void            set(od_int64 target, const od_int64* sources,
                                    const float* weights, int nrsrc,
                                    bool isclassification)              = 0;
        virtual bool            isDefined(od_int64) const               = 0;
        virtual int             getSize(char dim) const                 = 0;
    };
 
    virtual bool                nothingToFill() const   { return false; }
    virtual bool                setArray(Array2D<float>&,TaskRunner* =0);
    virtual bool                canUseArrayAccess() const { return false; }
    virtual bool                setArray(ArrayAccess&,TaskRunner* =0);
 
    void                        setTrendOrder(PolyTrend::Order ord);
    bool                        trimArray(int step,Array2D<char>& edgesmask);
 
    void                        doPolygonCrop();
 
    virtual bool                fillPar(IOPar&) const;
    virtual bool                usePar(const IOPar&);
 
    uiString                    uiMessage() const
                                { return uiStrings::sGridding(); }
 
    static const char*          sKeyFillType();
    static const char*          sKeyRowStep();
    static const char*          sKeyColStep();
    static const char*          sKeyOrigin();
    static const char*          sKeyNrRows();
    static const char*          sKeyNrCols();
    static const char*          sKeyNrCells();
    static const char*          sKeyMaxHoleSz();
    static const char*          sKeyPolyNrofNodes();
    static const char*          sKeyPolyNode();
    static const char*          sKeyCropPolygon();
 
protected:
                Array2DInterpol();
 
    bool        doPrepare(int);
    void        getNodesToFill(const bool* isdef, bool* shouldinterpol,
                               TaskRunner*) const;
    bool        isDefined(int idx) const;
    virtual void setFrom(od_int64 target, const od_int64* sources,
                        const float* weights, int nrsrc);
    void        floodFillArrFrom(int seed, const bool* isdef,
                                 bool* shouldinterpol) const;
    void        excludeBigHoles( const bool* isdef, bool* shouldinterpol )const;
    Array2D<float>*             arr_;
    ArrayAccess*                arrsetter_;
    float                       rowstep_;
    float                       colstep_;
    int                         nrrows_;
    int                         nrcols_;
    int                         nrcells_;
    RowCol                      origin_;
 
    FillType                    filltype_;
    float                       maxholesize_;
 
    const Array2D<bool>*        mask_;
    bool                        maskismine_;
    bool                        isclassification_;
    Stats::CalcSetup*           statsetup_;
 
    PolyTrend*                  trend_;
    ODPolygon<double>*          poly_;
    bool                        croppoly_;
};