gmInterpolatorInputBindings.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_INPUT_BINDINGS_H_
#define _GEMA_INTERPOLATOR_INPUT_BINDINGS_H_
 
#include "gmCoreConfig.h"
 
#include "gmGaussAccessor.h"
 
class GmInterpolatorInputDataBinding
{
public:
  virtual int numSrcs() = 0;
 
  virtual int size() const = 0;
 
  virtual int valueSize(int srcIndex) const = 0;
 
  virtual void reset() = 0;
 
  virtual bool next() = 0;
 
  virtual const double* value(int srcIndex) = 0;
 
  virtual void coordinate(GmCRVector& coord) = 0;
};
 
class  GmInterpolatorInOutDataBinding : public GmInterpolatorInputDataBinding
{
public:
 
  virtual void setValue(int srcIndex, const double* value) = 0;
};
 
// --------------------------------------------------
// Values provided by a node accessor
// --------------------------------------------------
 
template <class Base, class Ac>
class GmInterpolatorNodeDataBinding : public Base
{
public:
  GmInterpolatorNodeDataBinding(GmInterpolatorNodeCoordinateSetBinding* pointSet, Ac nodeAc)
    : _pointSet(pointSet), _valueAc(nodeAc), _currIndex(-1) { assert(pointSet && nodeAc); }
 
  // See comments on the base class
  virtual int numSrcs() { return 1; }
 
  // See comments on the base class
  virtual int size() const { return _pointSet->size(); }
 
  // See comments on the base class
  virtual int valueSize(int srcIndex) const { Q_UNUSED(srcIndex);  assert(srcIndex == 0); return _valueAc->valueSize(); }
 
  // See comments on the base class
  virtual void reset() { _pointSet->reset(); _pointSet->next(_currCoord, &_currIndex); }
 
  // See comments on the base class
  virtual bool next() { assert(_currIndex >= 0); return _pointSet->next(_currCoord, &_currIndex); }
 
  // See comments on the base class
  virtual const double* value(int srcIndex) { Q_UNUSED(srcIndex); assert(srcIndex == 0); assert(_currIndex >= 0); return _valueAc->value(_currIndex); }
 
  // See comments on the base class
  virtual void coordinate(GmCRVector& coord) { coord.setMemory(_currCoord.memptr(), _currCoord.n_rows); };
 
protected:
  GmInterpolatorNodeCoordinateSetBinding* _pointSet;  
  Ac                                      _valueAc;   
  int                                     _currIndex; 
  GmCRVector                              _currCoord; 
};
 
typedef GmInterpolatorNodeDataBinding<GmInterpolatorInputDataBinding, const GmValueAccessor*> GmInterpolatorNodeInputDataBinding;
 
class GmInterpolatorNodeInOutDataBinding : public GmInterpolatorNodeDataBinding<GmInterpolatorInOutDataBinding, GmValueAccessor*>
{
public:
  GmInterpolatorNodeInOutDataBinding(GmInterpolatorNodeCoordinateSetBinding* pointSet, GmValueAccessor* nodeAc)
    : GmInterpolatorNodeDataBinding<GmInterpolatorInOutDataBinding, GmValueAccessor*>(pointSet, nodeAc) {}
 
  // See comments on the base class
  virtual void setValue(int srcIndex, const double* value) 
  { 
    Q_UNUSED(srcIndex); assert(srcIndex == 0); assert(_currIndex >= 0); 
    _valueAc->setValue(_currIndex, value);
  }
};
 
template <class Base, class Ac>
class GmInterpolatorMNodeDataBinding : public Base
{
public:
  GmInterpolatorMNodeDataBinding(GmInterpolatorNodeCoordinateSetBinding* pointSet, const QVector<Ac>& nodeAccessors)
    : _pointSet(pointSet), _valueAcList(nodeAccessors), _currIndex(-1) { assert(pointSet && !nodeAccessors.isEmpty()); }
 
  // See comments on the base class
  virtual int numSrcs() { return _valueAcList.size(); }
 
  // See comments on the base class
  virtual int size() const { return _pointSet->size(); }
 
  // See comments on the base class
  virtual int valueSize(int srcIndex) const { assert(srcIndex >= 0 && srcIndex < _valueAcList.size()); return _valueAcList.at(srcIndex)->valueSize(); }
 
  // See comments on the base class
  virtual void reset() { _pointSet->reset(); _pointSet->next(_currCoord, &_currIndex); }
 
  // See comments on the base class
  virtual bool next() { assert(_currIndex >= 0); return _pointSet->next(_currCoord, &_currIndex); }
 
  // See comments on the base class
  virtual const double* value(int srcIndex) { assert(srcIndex >= 0 && srcIndex < _valueAcList.size()); assert(_currIndex >= 0); return _valueAcList.at(srcIndex)->value(_currIndex); }
 
  // See comments on the base class
  virtual void coordinate(GmCRVector& coord) { coord.setMemory(_currCoord.memptr(), _currCoord.n_rows); };
 
protected:
  GmInterpolatorNodeCoordinateSetBinding* _pointSet;    
  QVector<Ac>                               _valueAcList; 
  int                                     _currIndex;   
  GmCRVector                              _currCoord;   
};
 
typedef GmInterpolatorMNodeDataBinding<GmInterpolatorInputDataBinding, const GmValueAccessor*> GmInterpolatorMNodeInputDataBinding;
 
class GmInterpolatorMNodeInOutDataBinding : public GmInterpolatorMNodeDataBinding<GmInterpolatorInOutDataBinding, GmValueAccessor*>
{
public:
  GmInterpolatorMNodeInOutDataBinding(GmInterpolatorNodeCoordinateSetBinding* pointSet, const QVector<GmValueAccessor*>& nodeAccessors)
    : GmInterpolatorMNodeDataBinding<GmInterpolatorInOutDataBinding, GmValueAccessor*>(pointSet, nodeAccessors) {}
 
  // See comments on the base class
  virtual void setValue(int srcIndex, const double* value)
  {
    assert(srcIndex >= 0 && srcIndex < _valueAcList.size()); assert(_currIndex >= 0);
    _valueAcList.at(srcIndex)->setValue(_currIndex, value);
  }
};
 
// --------------------------------------------------
// Values provided by a Gauss accessor
// --------------------------------------------------
 
template <class Base, class Ac>
class GmInterpolatorGaussDataBinding : public Base
{
public:
  GmInterpolatorGaussDataBinding(GmInterpolatorGaussCoordinateSetBinding* pointSet, Ac gaussAc)
    : _pointSet(pointSet), _valueAc(gaussAc), _currElem(NULL), _currIp(-1) { assert(pointSet && gaussAc); }
 
  // See comments on the base class
  virtual int numSrcs() { return 1; }
 
  // See comments on the base class
  virtual int size() const { return _pointSet->size(); }
 
  // See comments on the base class
  virtual int valueSize(int srcIndex) const { Q_UNUSED(srcIndex);  assert(srcIndex == 0); return _valueAc->valueSize(); }
 
  // See comments on the base class
  virtual void reset() { _pointSet->reset(); _pointSet->next(_currCoord, &_currElem, &_currIp); }
 
  // See comments on the base class
  virtual bool next() { assert(_currElem); return _pointSet->next(_currCoord, &_currElem, &_currIp); }
 
  // See comments on the base class
  virtual const double* value(int srcIndex) 
  { 
    Q_UNUSED(srcIndex); 
    assert(srcIndex == 0); 
    assert(_currElem); 
    if(_valueAc->info()->canStoreFunctions())
    {
      GmVector ipCoord;
      _pointSet->ipNaturalCoord(_currElem, _currIp, ipCoord);
      return _valueAc->valueAt(_currElem, _currIp, &ipCoord);
    }
    else
      return _valueAc->valueAt(_currElem, _currIp, NULL); 
  }
 
  // See comments on the base class
  virtual void coordinate(GmCRVector& coord) { coord.setMemory(_currCoord.memptr(), _currCoord.n_rows); };
 
protected:
  GmInterpolatorGaussCoordinateSetBinding* _pointSet;  
  Ac                                       _valueAc;   
  const GmElement*                         _currElem;  
  int                                      _currIp;    
  GmCRVector                               _currCoord; 
};
 
typedef GmInterpolatorGaussDataBinding<GmInterpolatorInputDataBinding, const GmGaussAccessor*> GmInterpolatorGaussInputDataBinding;
 
class GmInterpolatorGaussInOutDataBinding : public GmInterpolatorGaussDataBinding<GmInterpolatorInOutDataBinding, GmGaussAccessor*>
{
public:
  GmInterpolatorGaussInOutDataBinding(GmInterpolatorGaussCoordinateSetBinding* pointSet, GmGaussAccessor* gaussAc)
    : GmInterpolatorGaussDataBinding<GmInterpolatorInOutDataBinding, GmGaussAccessor*>(pointSet, gaussAc) {}
 
  // See comments on the base class
  virtual void setValue(int srcIndex, const double* value)
  {
    Q_UNUSED(srcIndex); assert(srcIndex == 0); assert(_currElem);
    _valueAc->setValue(_currElem, _currIp, value);
  }
};
 
template <class Base, class Ac>
class GmInterpolatorMGaussDataBinding : public Base
{
public:
  GmInterpolatorMGaussDataBinding(GmInterpolatorGaussCoordinateSetBinding* pointSet, const QVector<Ac>& gaussAccessors)
    : _pointSet(pointSet), _valueAcList(gaussAccessors), _currElem(NULL), _currIp(-1) { assert(pointSet && !gaussAccessors.isEmpty()); }
 
  // See comments on the base class
  virtual int numSrcs() { return _valueAcList.size(); }
 
  // See comments on the base class
  virtual int size() const { return _pointSet->size(); }
 
  // See comments on the base class
  virtual int valueSize(int srcIndex) const { assert(srcIndex >= 0 && srcIndex < _valueAcList.size()); return _valueAcList.at(srcIndex)->valueSize(); }
 
  // See comments on the base class
  virtual void reset() { _pointSet->reset(); _pointSet->next(_currCoord, &_currElem, &_currIp); }
 
  // See comments on the base class
  virtual bool next() { assert(_currElem); return _pointSet->next(_currCoord, &_currElem, &_currIp); }
 
  // See comments on the base class
  virtual const double* value(int srcIndex) 
  {
    assert(srcIndex >= 0 && srcIndex < _valueAcList.size());
    assert(_currElem);
    if(_valueAcList.at(srcIndex)->info()->canStoreFunctions())
    {
      GmVector ipCoord;
      _pointSet->ipNaturalCoord(_currElem, _currIp, ipCoord);
      return _valueAcList.at(srcIndex)->valueAt(_currElem, _currIp, &ipCoord);
    }
    else
      return _valueAcList.at(srcIndex)->valueAt(_currElem, _currIp, NULL);
  }
 
  // See comments on the base class
  virtual void coordinate(GmCRVector& coord) { coord.setMemory(_currCoord.memptr(), _currCoord.n_rows); };
 
protected:
  GmInterpolatorGaussCoordinateSetBinding* _pointSet;    
  QVector<Ac>                              _valueAcList; 
  const GmElement*                         _currElem;    
  int                                      _currIp;      
  GmCRVector                               _currCoord;   
};
 
typedef GmInterpolatorMGaussDataBinding<GmInterpolatorInputDataBinding, const GmGaussAccessor*> GmInterpolatorMGaussInputDataBinding;
 
class GmInterpolatorMGaussInOutDataBinding : public GmInterpolatorMGaussDataBinding<GmInterpolatorInOutDataBinding, GmGaussAccessor*>
{
public:
  GmInterpolatorMGaussInOutDataBinding(GmInterpolatorGaussCoordinateSetBinding* pointSet, const QVector<GmGaussAccessor*>& gaussAccessors)
    : GmInterpolatorMGaussDataBinding<GmInterpolatorInOutDataBinding, GmGaussAccessor*>(pointSet, gaussAccessors) {}
 
  // See comments on the base class
  virtual void setValue(int srcIndex, const double* value)
  {
    assert(srcIndex >= 0 && srcIndex < _valueAcList.size()); assert(_currElem);
    _valueAcList.at(srcIndex)->setValue(_currElem, _currIp, value);
  }
};
 
 
// --------------------------------------------------
// Values provided by a matrix
// --------------------------------------------------
 
class GmInterpolatorMatrixInputDataBinding : public GmInterpolatorInputDataBinding
{
public:
  GmInterpolatorMatrixInputDataBinding(const GmInterpolatorCoordinateSetBinding* pointSet, GmMatrix& data) : _data(data), _currIndex(-1) { 
    assert(data.n_elem); 
    //Needs filtering
    int dsize = size();
    if (pointSet->size() != dsize) {
    assert(pointSet->originalSize() == dsize);
 
    int op = pointSet->originalSize();
    int ncols = pointSet->size();
    _filteredData = GmMatrix(data.n_rows, ncols);
    int cid = 0;
    for (int i = 0; i < op; ++i) {
        if (pointSet->validIndex(i)) {
        _filteredData.col(cid++) = data.col(i);
        }
    }
    _data = _filteredData;
    }
  }
 
  // See comments on the base class
  virtual int numSrcs() { return 1; }
 
  // See comments on the base class
  virtual int size() const { return _data.n_cols; }
 
  // See comments on the base class
  virtual int valueSize(int srcIndex) const { Q_UNUSED(srcIndex);  assert(srcIndex == 0); return _data.n_rows; }
 
  // See comments on the base class
  virtual void reset() { _currIndex = 0; }
 
  // See comments on the base class
  virtual bool next() { assert(_currIndex >= 0); _currIndex++; return _currIndex < size(); }
 
  // See comments on the base class
  virtual const double* value(int srcIndex) { Q_UNUSED(srcIndex); assert(srcIndex == 0); assert(_currIndex >= 0); return _data.colptr(_currIndex); }
 
  // See comments on the base class
  virtual void coordinate(GmCRVector& coord) { Q_UNUSED(coord); }
 
private:
  GmMatrix& _data;         
  GmMatrix  _filteredData; 
  int       _currIndex;    
};
 
class GmInterpolatorMMatrixInputDataBinding : public GmInterpolatorInputDataBinding
{
public:
  GmInterpolatorMMatrixInputDataBinding(const GmInterpolatorCoordinateSetBinding* pointSet, QVector<GmMatrix>& data) : _data(data), _currIndex(-1) { 
      assert(!data.isEmpty()); 
      //Needs filtering
      int dsize = size();
      if (pointSet->size() != dsize) {
          assert(pointSet->originalSize() == dsize);
 
          int op = pointSet->originalSize();
          int ncols = pointSet->size();
          for (const auto& m : _data) {
              GmMatrix newMat(m.n_rows, ncols);
              int cid = 0;
              for (int i = 0; i < op; ++i) {
                  if (pointSet->validIndex(i)) {
                      newMat.col(cid++) = m.col(i);
                  }
              }
              _filteredData.append(newMat);
          }
          _data = _filteredData;
      }
  }
 
  // See comments on the base class
  virtual int numSrcs() { return _data.size(); }
 
  // See comments on the base class
  virtual int size() const { return _data.first().n_cols; }
 
  // See comments on the base class
  virtual int valueSize(int srcIndex) const { assert(srcIndex >= 0 && srcIndex < _data.size()); return _data.at(srcIndex).n_rows; }
 
  // See comments on the base class
  virtual void reset() { _currIndex = 0; }
 
  // See comments on the base class
  virtual bool next() { assert(_currIndex >= 0); _currIndex++; return _currIndex < size(); }
 
  // See comments on the base class
  virtual const double* value(int srcIndex) { assert(srcIndex >= 0 && srcIndex < _data.size()); assert(_currIndex >= 0); return _data.at(srcIndex).colptr(_currIndex); }
 
  // See comments on the base class
  virtual void coordinate(GmCRVector& coord) { Q_UNUSED(coord); }
 
private:
  QVector<GmMatrix>&     _data;         
  QVector<GmMatrix>      _filteredData; 
  int                    _currIndex;    
};
 
 
#endif