CSOInterpolate3DFunction.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2009, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
 
 
#pragma once
 
 
#include "MLCSOIncludes.h"
#include "CSOFunction.h"
#include <CSOBase/CSOList.h>
#include <CSOTools/CSOMath.h>
#include <CSOTools/CSOPointInPolygonChecker.h>
 
#include <ThirdPartyWarningsDisable.h>
#include <Eigen/Core>
#include <ThirdPartyWarningsRestore.h>
 
#include <Eigen/Dense>
 
ML_START_NAMESPACE
 
 
class MLCSO_EXPORT CSOInterpolate3DFunctionSettings
{
public:
 
  enum CodePath
  {
    FPU = 0,
    SSE3,
    //AVX,
    CODEPATH_NUM_OPTIONS
  };
 
  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)
    , supportOpenCSOs(false)
    , numThreads(1)
    , codePath(FPU)
    , logging(false)
  {}
 
  unsigned int maxNumPoints;
  double       quality;
 
  bool useOnlySeedPoints;
  bool useSplineApproximationSmoothing;
 
  bool resolveIntersections;
  AdditionalPointLocation additionalPointLocation;
  double innerPointScale;
 
  double regularizationStrength;
  double regularizationStrength2;
  bool resolveEmbeddedCSOs;
 
  bool supportOpenCSOs;
 
  unsigned int numThreads;
 
  CodePath codePath;
 
  bool logging;
 
};
 
 
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);
 
  ~CSOInterpolate3DFunction() override;
 
  float evaluateAtPos(const Vector3& pos) const override;
 
  bool shouldParallelize() const override { return _settings.numThreads > 1; }
 
 
  StartingPositionsMap& getStartingPositions() { return _startingPositions; }
 
  const CSOInterpolate3DFunctionSettings& getSettings() const { return _settings; }
 
  // fulfill Eigen alignment requirements
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
private:
 
 
  /* STATE VARIABLES */
 
  CSOListPtr _csoList;
 
  CSOInterpolate3DFunctionSettings _settings;
 
  Eigen::ArrayXd  _coefficientsHead;
  Eigen::Array4d  _coefficientsTail;
  unsigned int _numElements;
  Eigen::Matrix4Xd _positions;
  Eigen::Matrix4d _worldToVoxelMatrix;
  Eigen::Matrix4d _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 csoLevelOfEmbedding, CSOPointInPolygonChecker* pointInPolygonChecker=nullptr);
  bool _needsHelperCSO() const;
 
  bool _checkSelfIntersection(const std::vector<Vector3>& allPathPointPositions, unsigned int predIndex, unsigned int currIndex) const;
 
  inline double _phi(const Eigen::Vector4d& vecarg) const
  {
    const double sLen = vecarg.dot(vecarg);
    {
      return sLen * sqrt(sLen);
    }
  }
 
};
 
 
ML_END_NAMESPACE