gridder2d.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Y.C.Liu & K. Tingdahl
 Date:          January 2008
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
 
#include "algomod.h"
#include "arrayndalgo.h"
#include "mathfunc.h"
#include "factory.h"
#include "coord.h"
#include "positionlist.h"
 
class DAGTriangleTree;
template <class T> class LinSolver;
class Triangle2DInterpolator;
 
 
mExpClass(Algo) Gridder2D
{
public:
                        mDefineFactoryInClass(Gridder2D,factory);
 
 
    virtual             ~Gridder2D();
    virtual Gridder2D*  clone() const                           = 0;
    virtual bool        operator==(const Gridder2D&) const;
    virtual bool        wantsAllPoints() const { return true; }
    virtual bool        isPointUsable(const Coord& cpt,
                                      const Coord& dpt) const;
    virtual void        setGridArea(const Interval<float>&,
                                    const Interval<float>&) {}
    bool                setPoints(const TypeSet<Coord>&);
                        /*<!Points are assumed to remain in mem through
                            getValue(). Points should correspond to the
                            values in setValues. Don't re-set it unless they
                            have changed, as it may lead to substantial
                            computations. */
    bool                setPoints(const TypeSet<Coord>&,TaskRunner*);
    const TypeSet<Coord>* getPoints() const { return points_; }
    virtual void        setTrend(PolyTrend::Order);
                        /*<!Not a processing parameter, requires the input data
                          (points & values) to be set. Needs to be called again
                          each time either the values are changed */
    bool                setValues(const TypeSet<float>&);
                        /*<!Values are assumed to remain in mem at
                            getValue(). Values should correspond to the
                            coords in setPoints */
    virtual float       getValue(const Coord&,const TypeSet<double>* weights=0,
                                 const TypeSet<int>* relevantpoints=0) const;
 
    virtual void        fillPar(IOPar&) const;
    virtual bool        usePar(const IOPar&);
 
    virtual bool        allPointsAreRelevant() const                       =0;
 
    virtual bool        getWeights(const Coord&,
                                   TypeSet<double>& weights,
                                   TypeSet<int>& relevantpoints) const     =0;
    virtual bool        areWeightsValuesDependent() const       { return false;}
 
protected:
                                Gridder2D();
                                Gridder2D(const Gridder2D&);
 
    const TypeSet<float>*       values_;
    const TypeSet<Coord>*       points_;
    PolyTrend*                  trend_;
 
    TypeSet<int>                usedpoints_;
 
    virtual bool                pointsChangedCB(CallBacker*)    { return true; }
    virtual void                valuesChangedCB(CallBacker*)    {}
    float                       getDetrendedValue(int idx) const;
                                /*<!Input values corrected from the trend*/
    bool                        isAtInputPos(const Coord&,int&idx) const;
};
 
 
mExpClass(Algo) InverseDistanceGridder2D : public Gridder2D
{ mODTextTranslationClass(InverseDistanceGridder2D);
public:
    mDefaultFactoryInstantiation( Gridder2D,
                                InverseDistanceGridder2D,
                                "InverseDistance", tr("Inverse distance") );
 
                InverseDistanceGridder2D();
                InverseDistanceGridder2D(const InverseDistanceGridder2D&);
 
    Gridder2D*          clone() const;
 
    static uiString     searchRadiusErrMsg();
    static const char*  sKeySearchRadius()      { return "SearchRadius"; }
 
    bool                operator==(const Gridder2D&) const;
 
    void                setSearchRadius(float);
    float               getSearchRadius() const { return radius_; }
 
    bool                wantsAllPoints() const { return false; }
    bool                allPointsAreRelevant() const;
    bool                isPointUsable(const Coord&,const Coord&) const;
    bool                getWeights(const Coord&,TypeSet<double>& weights,
                                   TypeSet<int>& relevantpoints) const;
 
    bool                usePar(const IOPar&);
    void                fillPar(IOPar&) const;
 
protected:
 
    float               radius_;
};
 
 
mExpClass(Algo) TriangulatedGridder2D : public Gridder2D
{ mODTextTranslationClass(TriangulatedGridder2D);
public:
    mDefaultFactoryInstantiation( Gridder2D,
                                TriangulatedGridder2D,
                                "Triangulated", tr("Triangulation") );
 
                        TriangulatedGridder2D();
                        TriangulatedGridder2D(
                                const TriangulatedGridder2D&);
                        ~TriangulatedGridder2D();
    Gridder2D*          clone() const;
 
 
    void                setGridArea(const Interval<float>&,
                                    const Interval<float>&);
 
    bool                allPointsAreRelevant() const;
    bool                getWeights(const Coord&,TypeSet<double>& weights,
                                   TypeSet<int>& relevantpoints) const;
 
protected:
 
    DAGTriangleTree*            triangles_;
    Triangle2DInterpolator*     interpolator_;
    Interval<float>             xrg_;
    Interval<float>             yrg_;
 
    Coord                       center_;
 
    bool                pointsChangedCB(CallBacker*);
};
 
 
 
mExpClass(Algo) RadialBasisFunctionGridder2D : public Gridder2D
{ mODTextTranslationClass(RadialBasisFunctionGridder2D)
public:
    mDefaultFactoryInstantiation( Gridder2D,
                                RadialBasisFunctionGridder2D,
                                "RadialBasicFunction",
                                tr("Radial Basis Function") );
 
                        RadialBasisFunctionGridder2D();
                        RadialBasisFunctionGridder2D(
                                const RadialBasisFunctionGridder2D&);
                        ~RadialBasisFunctionGridder2D();
    Gridder2D*          clone() const;
 
    static const char*  sKeyIsMetric()          { return "IsMetric"; }
 
    bool                operator==(const Gridder2D&) const;
 
    void                setMetricTensor(double m11,double m12,double m22);
 
    bool                allPointsAreRelevant() const;
    bool                getWeights(const Coord&,TypeSet<double>& weights,
                                   TypeSet<int>& relevantpoints) const;
    bool                areWeightsValuesDependent() const      { return true; }
    float               getValue(const Coord&,const TypeSet<double>* weights=0,
                                 const TypeSet<int>* relevantpoints=0) const;
 
protected:
 
    bool                ismetric_;
    double              m11_;
    double              m12_;
    double              m22_;
 
    TypeSet<double>*    globalweights_;
    LinSolver<double>*  solv_;
 
    bool                updateSolver();
                        //will be removed after 6.2
 
    bool                updateSolver(TaskRunner*);
    bool                updateSolution();
    double              getRadius(const Coord& pos1,const Coord& pos2) const;
    static double       evaluateRBF(double radius,double scale=1.);
 
    bool                pointsChangedCB(CallBacker*);
    void                valuesChangedCB(CallBacker*);
    bool                setWeights(const Coord&,TypeSet<double>& weights,
                                   TypeSet<int>* usedpoints=0) const;
};