mi32/kriging.h

Go to the documentation of this file.

/******************************************************************
* \file mi32/kriging.h
* \brief Universal Kriging Algorithm Declarations and Structures
*
* \if NODOC
*
* $Id: kriging.h_v 1.5 2011/10/26 13:04:30 mju Exp $
*
* $Log: kriging.h_v $
* Revision 1.5  2011/10/26 13:04:30  mju
* Remove redundant hdr.
*
* Revision 1.4  2008/06/24 16:41:26  mju
* Use rect hdr.
*
* Revision 1.1  2007/03/08 23:51:00  vdronov
* Initial revision
* \endif
*******************************************************************/

#ifndef INC_MI32_KRIGING_H
#define INC_MI32_KRIGING_H

#ifndef  INC_MI32_RECT_H
#include <mi32/rect.h>
#endif

#ifndef  INC_MI32_VARIOGRAM_H
#include <mi32/variogram.h>
#endif

#ifndef  INC_MI32_QTREE_H
#include <mi32/qtree.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class MIMATRIX;
#endif // GENERATING_DOXYGEN_OUTPUT


class KRIGING {
public:

   enum DRIFTORDER {
      DRIFTORDER_OrdinaryKriging = 0,
      DRIFTORDER_Linear = 1,
      DRIFTORDER_Quadratic = 2,
      DRIFTORDER_Cubic = 3,
      DRIFTORDER_Quartic = 4,
      DRIFTORDER_Quintic = 5
      };

   enum DUPLICATE {
      DUPLICATE_KeepFirst = 0,
      DUPLICATE_Discard = 1,
      DUPLICATE_Minimum = 2,
      DUPLICATE_Average = 3,
      DUPLICATE_Maximum = 4,
      DUPLICATE_KeepLast = 5
      };

   KRIGING (
      );

   ~KRIGING (
      ) { Clear(); }

   ERRVALUE Init (
      const DOUBLE_ARRAY<DPOINT3D>& points,
      const DUPLICATE duplicate,
      const double tolerance
      );

   void Clear (
      );

   ERRVALUE CrossEstimate (
      const INT32 index,
      double& value,
      UINT8& computed
      );

   ERRVALUE CrossEvaluation (
      double& mean,
      double& stddev
      );

   ERRVALUE Estimate (
      const DPOINT2D& point,
      double& value,
      UINT8& computed,
      double* error = 0,
      double* drift = 0
      );

   DRIFTORDER GetDriftOrder (
      ) const { return m_DriftOrder; }

   DUPLICATE GetDuplicate (
      ) const { return m_Duplicate; }

   double GetHighTrimming (
      ) const { return m_HighTrimming; }

   INT32 GetMaximumPoints (
      ) const { return m_MaximumPoints; }

   INT32 GetMinimumPoints (
      ) const { return m_MinimumPoints; }

   double GetLowTrimming (
      ) const { return m_LowTrimming; }

   double GetTolerance (
      ) const { return m_Tolerance; }

   double GetSearchDistance (
      ) const { return m_SearchDistance; }

   const VARIOGRAM& GetVariogram (
      ) const { return m_Variogram; }

   VARIOGRAM& GetVariogram (
      ) { return m_Variogram; }

   bool IsInitialized (
      ) const { return m_IsInitialized; }

   void SetDriftOrder (
      const DRIFTORDER order
      ) { m_DriftOrder = order; }

   void SetHighTrimming (
      const double trimming
      );

   void SetMinimumPoints (
      const INT32 minimum
      ) { m_MinimumPoints = minimum; }

   void SetMaximumPoints (
      const INT32 maximum
      ) { m_MaximumPoints = maximum; }

   void SetLowTrimming (
      const double trimming
      );

   void SetSearchDistance (
      const double distance
      ) { m_SearchDistance = distance; m_SearchDistance2 = distance * distance; }

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT

   bool m_IsInitialized;

   DUPLICATE m_Duplicate;
   double m_Tolerance;

   VARIOGRAM m_Variogram;

   double m_SearchDistance;
   INT32 m_MinimumPoints;
   INT32 m_MaximumPoints;

   DRIFTORDER m_DriftOrder;

   double m_LowTrimming;
   double m_HighTrimming;


   DOUBLE_ARRAY<DPOINT3D> m_Points;
   QUADTREE m_QTree;
   DRECT3D m_Extents;


   struct ITEM {
      INT32 m_Index;
      double m_Distance;
      };

   double m_SearchDistance2; 
   double m_MaximumValue;
   double m_MinimumValue;

   SIMPLE_ARRAY<INT32> m_Indices;
   SIMPLE_ARRAY<ITEM> m_Items;
   DOUBLE_ARRAY<double> m_Values;

   static int CompareItems (const void *vp1, const void *vp2);
   static double MIpow (const double v, const int power);
   static void GetDriftCoefficients (const INT32 degree, const DPOINT2D& point, DOUBLE_ARRAY<double>& values);
   static double GetVariance (const MIMATRIX& B, const MIMATRIX& C);

   ERRVALUE FindNearestPoints (const DPOINT2D& point, SIMPLE_ARRAY<INT32>& indices);
   ERRVALUE PrepareMatrices (const DPOINT2D& point, const SIMPLE_ARRAY<INT32>& indices, MIMATRIX& M, MIMATRIX& B, MIMATRIX& C);
   double ComputeDrift (const MIMATRIX& C, const SIMPLE_ARRAY<INT32>& indices);
   double ComputeVariance (const MIMATRIX& B, const MIMATRIX& C);
   double Calculate (const MIMATRIX& C, const SIMPLE_ARRAY<INT32>& indices);
   double Trimming (const double value) { return bound(value, m_MinimumValue, m_MaximumValue); }
   #endif // GENERATING_DOXYGEN_OUTPUT
   };

#endif

---