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 GmDiscontinuitySet;
 
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 
};
 
 
/*
  Enum class used for selection of cell's subset when interpolating
  discontinuous elements (continuum x interface)
  The first option ignores the new behavior and is equivalent
  to not using subsets
*/
enum class GmInterpolatorSubset {
    GM_SUBSET_ALL = 0,
    GM_SUBSET_CONTINUUM,
    GM_SUBSET_INTERFACE,
    GM_SUBSET_COUNT,
};
 
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 QVector<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