MeVisLab/Standard/Sources/ML/MLCSO/CSOTools/CSOInterpolate3DFunction.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __CSOInterpolate3DFunction_H
#define __CSOInterpolate3DFunction_H

#include "MLCSOIncludes.h"
#include "CSOFunction.h"
#include <CSOBase/CSOList.h>
#include <CSOTools/CSOMath.h>
#include <CSOTools/CSOPointInPolygonChecker.h>


ML_START_NAMESPACE


class MLCSO_EXPORT CSOInterpolate3DFunctionSettings
{
public:

  enum AdditionalPointLocation {
    ADDITIONAL_POINT_INNER = 0,
    ADDITIONAL_POINT_OUTER = 1,
    ADDITIONAL_POINT_AUTO  = 2,
    ADDITIONAL_POINT_NUM_OPTIONS = 3
  };

  CSOInterpolate3DFunctionSettings()
    : maxNumPoints(3000)
    , quality(0.9)
    , useOnlySeedPoints(false)
    , useSplineApproximationSmoothing(false)
    , resolveIntersections(true)
    , additionalPointLocation(ADDITIONAL_POINT_AUTO)
    , innerPointScale(0.25)
    , regularizationStrength(0.0)
    , regularizationStrength2(0.0)
    , resolveEmbeddedCSOs(false)
  {}

  unsigned int maxNumPoints;
  double       quality;

  bool useOnlySeedPoints;
  bool useSplineApproximationSmoothing;

  bool resolveIntersections;
  AdditionalPointLocation additionalPointLocation;
  double innerPointScale;

  double regularizationStrength;
  double regularizationStrength2;
  bool resolveEmbeddedCSOs;
};


class MLCSO_EXPORT CSOInterpolate3DFunction : public CSOFunction 
{

public:

  typedef std::vector<Vector3>                         StartingPositions;
  typedef std::map<unsigned int, StartingPositions> StartingPositionsMap;

  CSOInterpolate3DFunction();    

  CSOInterpolate3DFunction(const CSOList* csoList, const Matrix4& worldToVoxelMatrix, const Matrix4& voxelToWorldMatrix, 
                           const CSOInterpolate3DFunctionSettings& settings);

  virtual ~CSOInterpolate3DFunction();

  virtual float evaluateAtPos(const Vector3& pos) const;

  virtual bool shouldParallelize() const { return true; }

  StartingPositionsMap& getStartingPositions() { return _startingPositions; }

  const CSOInterpolate3DFunctionSettings& getSettings() const { return _settings; }

private:


  /* STATE VARIABLES */

  CSOListPtr _csoList;

  CSOInterpolate3DFunctionSettings _settings;

  double* _coefficients;
  long int _numElements;
  Vector3* _positions;
  Matrix4 _worldToVoxelMatrix;
  Matrix4 _voxelToWorldMatrix;
  StartingPositionsMap _startingPositions;

 /* METHODS */

  void _computeCoefficientVector();
  Vector3 _computeInnerPosition(const std::vector<Vector3>&allPathPointPositions, const Vector3& planeNormal, unsigned int j, bool resolveIntersections, double& functionValue, size_t levelOfEmbedding, CSOPointInPolygonChecker* pointInPolygonChecker=NULL);
  bool _needsHelperCSO() const;

  bool _checkSelfIntersection(const std::vector<Vector3>& allPathPointPositions, unsigned int predIndex, unsigned int currIndex) const;

  inline double _phi(const Vector3& vecarg) const
  {
    const double sLen = vecarg.lengthSquared();

    if (sLen < 10e-10) { // clamp towards 0
      return 0.0;
    } else {
      return (sLen) * sqrt(sLen);
    }
  }

};



ML_END_NAMESPACE

#endif // __CSOInterpolate3DFunction_H