array2dinterpolimpl.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:          Feb 2009
________________________________________________________________________


-*/

#include "algomod.h"
#include "array2dinterpol.h"
#include "binid.h"
#include "rowcol.h"
#include "threadlock.h"

class RowCol;
class DAGTriangleTree;
class Triangle2DInterpolator;
class Extension2DInterpolExecutor;


mExpClass(Algo) InverseDistanceArray2DInterpol : public Array2DInterpol
{ mODTextTranslationClass(InverseDistanceArray2DInterpol);
public:
                mDefaultFactoryInstantiation(Array2DInterpol,
                        InverseDistanceArray2DInterpol,
                        "InverseDistance", tr("Inverse distance") )

                InverseDistanceArray2DInterpol();
                ~InverseDistanceArray2DInterpol();

    bool        setArray(Array2D<float>&,TaskRunner*);
    bool        canUseArrayAccess() const       { return true; }
    bool        setArray(ArrayAccess&,TaskRunner*);

    float       getSearchRadius() const         { return searchradius_; }
    void        setSearchRadius(float r)        { searchradius_ = r; }

    void        setStepSize(int n)              { stepsize_ = n; }
    int         getStepSize() const             { return stepsize_; }

    void        setNrSteps(int n)               { nrsteps_ = n; }
    int         getNrSteps() const              { return nrsteps_; }

    void        setCornersFirst(bool n)         { cornersfirst_ = n; }
    bool        getCornersFirst() const         { return cornersfirst_; }
    bool        nothingToFill() const           { return nrIterations()<1; }

    virtual bool        fillPar(IOPar&) const;
    virtual bool        usePar(const IOPar&);

    static const char*  sKeySearchRadius();
    static const char*  sKeyCornersFirst();
    static const char*  sKeyStepSize();
    static const char*  sKeyNrSteps();

protected:
    virtual bool        doWork(od_int64,od_int64,int);
    od_int64            nrIterations() const    { return totalnr_; }
    uiString            nrDoneText() const      { return tr("Nodes gridded"); }

    bool                doPrepare(int);
    virtual bool        initFromArray(TaskRunner*);
    od_int64            getNextIdx();
    void                reportDone(od_int64);

                                //settings
    int                         nrsteps_;
    int                         stepsize_;
    bool                        cornersfirst_;
    float                       searchradius_;

                                //workflow control stuff
    int                         nrthreads_;
    int                         nrthreadswaiting_;
    bool                        waitforall_;
    Threads::ConditionVar&      condvar_;
    bool                        shouldend_;
    int                         stepidx_;

    int                         nrinitialdefined_;
    int                         totalnr_;

                                //Working arrays
    bool*                       curdefined_;
    bool*                       nodestofill_;
    TypeSet<od_int64>           definedidxs_;           //Only when no radius
    TypeSet<RowCol>             neighbors_;             //Only when radius
    TypeSet<float>              neighborweights_;       //Only when radius


                                //Per support size
    TypeSet<od_int64>           addedwithcursuport_;
    int                         nraddedthisstep_;
    od_int64                    prevsupportsize_;

                                //perstep
    TypeSet<od_int64>           todothisstep_;
    TypeSet<od_int64>           nrsources_;     //linked to todothisstep or zero
};


mExpClass(Algo) TriangulationArray2DInterpol : public Array2DInterpol
{ mODTextTranslationClass(TriangulationArray2DInterpol);
public:
                mDefaultFactoryInstantiation(Array2DInterpol,
                        TriangulationArray2DInterpol,
                         "Triangulation", ::toUiString(sFactoryKeyword()))

                TriangulationArray2DInterpol();
                ~TriangulationArray2DInterpol();

    bool        setArray(Array2D<float>&,TaskRunner*);
    bool        canUseArrayAccess() const       { return true; }
    bool        setArray(ArrayAccess&,TaskRunner*);
    bool        nothingToFill() const           { return nrIterations()<1; }

    bool        doInterpolation() const         { return dointerpolation_; }
    void        doInterpolation(bool yn)        { dointerpolation_ = yn; }
    float       getMaxDistance() const          { return maxdistance_; }
    void        setMaxDistance(float r)         { maxdistance_ = r; }

    virtual bool        fillPar(IOPar&) const;
    virtual bool        usePar(const IOPar&);

    static const char*  sKeyDoInterpol();
    static const char*  sKeyMaxDistance();

protected:
    int                 minThreadSize() const   { return 10000; }
    bool                doWork(od_int64,od_int64,int);
    od_int64            nrIterations() const    { return totalnr_; }
    uiString            nrDoneText() const      { return tr("Nodes gridded"); }

    bool                doPrepare(int);
    virtual bool        initFromArray(TaskRunner*);
    void                getNextNodes(TypeSet<od_int64>&);

                                //triangulation stuff
    bool                        dointerpolation_;
    float                       maxdistance_;
    DAGTriangleTree*            triangulation_;
    Triangle2DInterpolator*     triangleinterpolator_;
    TypeSet<int>                coordlistindices_;

                                //Working arrays
    bool*                       curdefined_;
    bool*                       nodestofill_;
    od_int64                    curnode_;
    Threads::Lock               curnodelock_;

                                //Work control
    od_int64                    totalnr_;
    int                         corneridx_[4];
    float                       cornerval_[4];
    BinID                       cornerbid_[4];
};


mExpClass(Algo) ExtensionArray2DInterpol : public Array2DInterpol
{ mODTextTranslationClass(ExtensionArray2DInterpol);
public:
                mDefaultFactoryInstantiation(Array2DInterpol,
                    ExtensionArray2DInterpol, "Extension",
                     ::toUiString(sFactoryKeyword()))

                ExtensionArray2DInterpol();
                ~ExtensionArray2DInterpol();

    bool        canUseArrayAccess() const       { return true; }

    void        setNrSteps(int n)               { nrsteps_ = n; }
    od_int64    getNrSteps() const              { return nrsteps_; }

    bool        fillPar(IOPar&) const;
    bool        usePar(const IOPar&);

    static const char*  sKeyNrSteps();

protected:

    bool        doWork(od_int64,od_int64,int);
    od_int64    nrIterations() const            { return 1; }

    od_int64    nrsteps_;

    Extension2DInterpolExecutor* executor_;
    friend class Extension2DInterpolExecutor;
};