CSOGeometry.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, 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 "CSOTools/CSOHeapObject.h"
#include "CSOTools/CSOObjectHeap.h"
#include "CSOTools/CSOPathPointIterator.h"
 
 
#include <mlRotation.h>
 
ML_START_NAMESPACE
 
 
 
class CSO;
class CSOList;
ML_REFCOUNTED_PTR(CSOList)
 
 
 
 
namespace CSOGeometry
{
  const double maxPointDiff = 10e-6;
 
  enum ReductionMode
  {
    REDUCTION_MODE_ANGLE = 0,
    REDUCTION_MODE_LENGTH,
    REDUCTION_MODE_ANGLE_AND_LENGTH
  };
 
  MLCSO_EXPORT bool computeIsInPlane(const CSO* cso, Vector3& planeNormal, double angleEpsilon=1e-3, double collinearEpsilon=1e-3);
  MLCSO_EXPORT bool computeIsInPlane(const std::vector< Vector3 >& points, Vector3& planeNormal, double angleEpsilon = 1e-3, double collinearEpsilon = 1e-3);
  MLCSO_EXPORT Vector3 computeNewellsNormal(const std::vector< Vector3 >& points);
  MLCSO_EXPORT bool arePointsCollinear(const std::vector<Vector3>& points, double epsilon);
 
  MLCSO_EXPORT bool isSelfIntersecting(const std::vector<Vector3>& positions, std::vector<Vector3>& intersectPoints, bool isClosed);
  MLCSO_EXPORT bool isSelfIntersecting(const std::vector<Vector3>& positions, bool isClosed);
 
  MLCSO_EXPORT bool isSelfIntersecting(const CSO* cso);
  MLCSO_EXPORT bool isSelfIntersecting(const CSO* cso, std::vector<Vector3>& intersectPositions);
 
  MLCSO_EXPORT double computeSegmentSegmentDistance(const Vector3& start0, const Vector3& end0, const Vector3& start1, const Vector3& end1, Vector3& intersectionPoint, bool& isParallel);
  MLCSO_EXPORT double computeSegmentSegmentDistance(const Vector3& start0, const Vector3& end0, const Vector3& start1, const Vector3& end1, Vector3& intersectionPoint);
 
  MLCSO_EXPORT int intersect2DSegments(const Vector2& start0, const Vector2& end0, const Vector2& start1, const Vector2& end1, Vector2& intersection0, Vector2& intersection1);
  bool  isInSegment(const Vector2& point, const Vector2& segmentStart, const Vector2& segmentEnd);
  MLdouble perp(const Vector2& v0, const Vector2& v1);
 
  MLCSO_EXPORT bool areInSamePlane(const CSO* cso0, const CSO* cso1, MLdouble angleEpsilon = 10e-5, MLdouble minPlaneDistanceInMM = 10e-5);
 
  MLCSO_EXPORT bool areOverlapping(const CSO* cso0, const CSO* cso1, MLdouble epsilon = 10e-5, MLdouble minPlaneDistanceInMM = 10e-5);
 
  MLCSO_EXPORT void rotateAndProject(Rotation& rot, Vector3& voxelPos, bool shouldProject=true);
 
  MLCSO_EXPORT void level(CSO* cso);
 
  MLCSO_EXPORT void level(std::vector<Vector3>& positions);
 
  MLCSO_EXPORT void levelToPlane(CSO& cso, const Vector3& normal, const Vector3& planeAnchorPoint);
 
  MLCSO_EXPORT std::vector<Vector2> projectTo2D(const std::vector<Vector3>& points, const Vector3& normal, const Vector3& planeAnchorPoint);
 
  MLCSO_EXPORT std::vector<Vector3> backprojectTo3D(const std::vector<Vector2>& points, const Vector3& normal, const Vector3& planeAnchorPoint);
 
  MLCSO_EXPORT double getLargestDistanceBetweenAllPathPoints(CSO& cso, Vector3& point0, Vector3& point1);
 
  MLCSO_EXPORT void translate(CSO* cso, const Vector3& translation);
 
  MLCSO_EXPORT bool isPointInsidePolygon(const std::vector<Vector3>& polygonPoints, const Vector3& point);
 
  MLCSO_EXPORT void appendUniquePosition(std::vector<Vector3>&positions, Vector3 pos);
 
  MLCSO_EXPORT Vector3 getCenterOfGravity(CSO* cso, bool considerSeedPointsExtra=false);
  MLCSO_EXPORT Vector3 getCenterOfGravity(const std::vector<Vector3>& positions);
 
  MLCSO_EXPORT double distanceToLine (const Vector3& point, const Vector3& linePoint1, const Vector3& linePoint2);
 
  MLCSO_EXPORT double squaredDistanceToLineSegment(const Vector3& point, const Vector3& linePoint1, const Vector3& linePoint2);
  MLCSO_EXPORT double squaredDistanceToLineSegment(const Vector3& point, const Vector3& linePoint1, const Vector3& linePoint2, Vector3& resultPoint);
 
  MLCSO_EXPORT double squaredDistanceToLineSegment(const Vector2& point, const Vector2& linePoint1, const Vector2& linePoint2);
 
  MLCSO_EXPORT void computeClosestSeedPoint(CSO* cso, const Vector3& referencePoint, unsigned int &resultSeedPointIndex);
  // \param resultPathPointIndex returns the index of the closest path point of the cso.
  MLCSO_EXPORT void computeClosestPathPoint(CSO* cso, const Vector3& referencePoint, unsigned int &resultPathPointListIndex, unsigned int &resultPathPointIndex, Vector3 &resultPosition);
  // \param resultPathPointIndex returns the index of the start point of the closest line segment.
  MLCSO_EXPORT void computeClosestPoint(CSO* cso, const Vector3& referencePoint, unsigned int &resultPathPointListIndex, unsigned int &resultPathPointIndex, Vector3 &resultPosition);
  MLCSO_EXPORT void computeClosestPoint(const std::vector<Vector3>& pointList, const Vector3& referencePoint, unsigned int& resultPointIndex, Vector3& resultPosition);
  MLCSO_EXPORT double computeDistance(CSO* cso, const Vector3& referencePoint);
  MLCSO_EXPORT double computeLength(const CSOPathPointIterator& startIter, const CSOPathPointIterator& endIter);
 
  MLCSO_EXPORT double computeDiameter(const CSO* cso);
  MLCSO_EXPORT double computeDiameter(const std::vector<Vector3>& positions);
 
  MLCSO_EXPORT void thinOutCSO(CSO* cso, float quality=0.5f, ReductionMode reductionMode=REDUCTION_MODE_ANGLE_AND_LENGTH, unsigned int minPoints=5, float maxAngleLimit=1.0);
  MLCSO_EXPORT void thinOutPointList(std::vector<Vector3>& positionList, float quality=0.5f, ReductionMode reductionMode=REDUCTION_MODE_ANGLE_AND_LENGTH, unsigned int minPoints=5, float maxAngleLimit=1.0);
 
  MLCSO_EXPORT bool csoIsEnclosedByCSO(CSO* toTestInnerCSO, CSO* toTestOuterCSO);
  MLCSO_EXPORT size_t getLevelOfEmbedding(const CSOListPtr& csoList, std::vector<size_t>& result);
  MLCSO_EXPORT size_t getLevelOfEmbedding(const std::vector<CSO*>& csos, std::vector<size_t>& result, std::vector<std::vector<size_t> >& enclosedCSOIndices);
  MLCSO_EXPORT void groupByLevelOfEmbedding(const std::vector<CSO*>& csos, std::vector<std::vector<CSO*> >& groupedCSOs);
 
  MLCSO_EXPORT double computeSumOfAreas(const CSOListPtr& csoList);
  MLCSO_EXPORT double computeVolume(const CSOListPtr& csoList, double sliceThickness);
 
  MLCSO_EXPORT bool isApproximatelyParallel(const CSO* cso, const Vector3& normal, double epsilon=0.1);
 
  template<class T>
  inline bool isSamePosition(const T& pos1, const T& pos2)
  {
    static_assert(std::is_same_v<T, Vector3> || std::is_same_v<T, Vector4>, "Need Vector3 or Vector4 type");
    return ((fabs(pos1[0] - pos2[0]) < maxPointDiff) &&
            (fabs(pos1[1] - pos2[1]) < maxPointDiff) &&
            (fabs(pos1[2] - pos2[2]) < maxPointDiff));
  }
 
 
  const unsigned int INVALID_INDEX = static_cast<unsigned int>(-1);
 
 
  class PositionObj : public CSOHeapObject
  {
  public:
    double angle;
    Vector3 position;
    PositionObj* predPos;
    PositionObj* succPos;
  };
 
 
  class CSOPlaneGuard
  {
 
  public:
    MLCSO_EXPORT CSOPlaneGuard(CSO& cso);
    MLCSO_EXPORT void disable();
    MLCSO_EXPORT ~CSOPlaneGuard();
 
  private:
    CSOPlaneGuard& operator=(const CSOPlaneGuard&) { return *this; }
    CSO& _cso;
    bool _shouldPreservePlane;
    Vector3 _planeNormal;
    Vector3 _planeAnchorPoint;
  };
}
 
 
ML_END_NAMESPACE