gmInterpolator.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/

#ifndef _GEMA_INTERPOLATOR_H_
#define _GEMA_INTERPOLATOR_H_

#include "gmCoreConfig.h"
#include "gmVector.h"
#include "gmMatrix.h"

#include <QVariant>

class GmValueAccessor;
class GmElement;
class GmMesh;
class GmPluginLoader;

class GmInterpolatorCoordinateSetBinding;
class GmInterpolatorGaussCoordinateSetBinding;
class GmInterpolatorInputDataBinding;
class GmInterpolatorOutputDataBinding;
class GmInterpolatorOutputMultiDataBinding;
class GmInterpolatorOutputCoordinateBinding;


enum GmInterpolatorKind
{
  GM_NODE_TO_POINT_INTERPOLATOR,       
  GM_GAUSS_TO_NODE_INTERPOLATOR,       
  GM_GAUSS_TO_POINT_INTERPOLATOR,      
  GM_POINTCLOUD_TO_POINT_INTERPOLATOR, 
  GM_GAUSS_TO_NODE_INTERPOLATOR_H,     
};

enum GmInterpolatorType
{
  GM_NN_INTERPOLATOR,

  GM_IDW_INTERPOLATOR,

  GM_MLS_INTERPOLATOR,  

  GM_SHAPE_INTERPOLATOR,

  GM_LSHAPE_INTERPOLATOR,

  // IMPORTANT: When adding new enum values, please remember to also update 
  //            GmInterpolator::interpolatorTypeToStr(),
  //            GmInterpolator::strToInterpolatorType() and 
  //            GmInterpolator::interpolatorObjectFromType()

  //-------- NO INSERTION BELOW THIS LINE ----------
  GM_NUM_INTERPOLATORS,   
  GM_NO_INTERPOLATOR,     
  GM_DEFAULT_INTERPOLATOR 
};

class GMC_API_EXPORT GmInterpolatorObject
{
public:
  virtual GmInterpolatorType type() const = 0;

  virtual bool typeParamIsValid(const QVariant& v) const { return !v.isValid(); }

  virtual QString typeParamToStr(const QVariant& v) const { Q_UNUSED(v); return ""; }

  virtual bool supportsInterpolatorKind(GmInterpolatorKind kind) const = 0;

  virtual bool requiresElement() const { return false; }

  virtual bool requiresMesh() const { return false; }

  virtual bool requiresNaturalCoordinates() const { return false; }

  virtual bool interpolationWeights(GmInterpolatorCoordinateSetBinding* pointSet, const GmVector& coord,
                                    const QVariant& typeParam, GmVector& weights) const;

  virtual bool distanceBasedWeights(GmInterpolatorCoordinateSetBinding* pointSet, const GmVector& coord,
                                    const GmVector& squaredDistances, const QVariant& typeParam,
                                    GmVector& weights) const
  {
    Q_UNUSED(pointSet); Q_UNUSED(coord); Q_UNUSED(squaredDistances); Q_UNUSED(typeParam); Q_UNUSED(weights);
    // This function should be reimplemented if interpolationWeights() was not reimplemented
    assert(0);
    return false;
  }

  virtual const GmMatrix& gaussToNodesExtrapolationMatrix(GmInterpolatorGaussCoordinateSetBinding* pointSet, const 
                                                          QVariant& typeParam, GmMatrix& weights) const
  {
    Q_UNUSED(pointSet); Q_UNUSED(typeParam);
    assert(0);
    return weights;
  }

protected:
  friend class GmInterpolator;

  GmInterpolatorObject() {}
};

class GMC_API_EXPORT GmInterpolator
{
public:
  virtual ~GmInterpolator() {}

  bool isValid() const { return _interp; }

  const GmInterpolatorObject* interpolatorObject() const { return _interp; }

  const GmMesh* mesh() const { return _mesh; }

  QString interpolatorTypeToStr() const { return _interp ? interpolatorTypeToStr(_interp->type(), _interpParam) : QObject::tr("invalid"); }

  static bool initInterpolators();

  static QString interpolatorTypeToStr(GmInterpolatorType type, const QVariant& typeParam);
  static int     strToInterpolatorType(QString str, bool acceptsNo = false);

  static bool validInterpolatorForKind(GmInterpolatorType type, const QVariant& typeParam, GmInterpolatorKind kind);

protected:
  GmInterpolator(GmInterpolatorKind kind, GmInterpolatorType type, const QVariant& typeParam,
                 const GmValueAccessor* coordAccessor, const GmMesh* mesh, bool skipTests = false);

  bool interpolate(GmInterpolatorCoordinateSetBinding* pointSet, GmInterpolatorInputDataBinding* inData,
                   GmInterpolatorOutputDataBinding* outData, const GmInterpolatorOutputCoordinateBinding& coord) const;

  void gaussToNodesInterpolate(GmInterpolatorGaussCoordinateSetBinding* pointSet, GmInterpolatorInputDataBinding* inData,
                               GmInterpolatorOutputMultiDataBinding* outData) const;

  static void scalarVectorListToVector(const QList<GmVector>& vectorList, GmVector& scalarVector);

  static const GmInterpolatorObject* interpolatorObjectFromType(GmInterpolatorType type);

#ifdef ENABLE_TESTS
  // Allows test function to call interpolatorObjectFromType()
  friend Q_DECL_EXPORT void TEST_InterpolatorCoordinateBindings(GmPluginLoader*, const GmLogCategory&, GmLogLevel);
#endif

  const GmInterpolatorObject* _interp;      
  QVariant                    _interpParam; 
  const GmValueAccessor*      _coordAc;     
  const GmMesh*               _mesh;        

private:
  static const GmInterpolatorObject* _iObjects[GM_NUM_INTERPOLATORS];  
};

#endif