GeometricAlgorithms.hpp

#pragma once
 
#include "DM/config.hpp"
#include "DM/AutoLink.hpp" //enable autolink
#include "DM/IPoint.hpp"
#include "DM/IPolyline.hpp"
#include "DM/IWindow.hpp"
#include "DM/IBox.hpp"
 
DM_NAMESPACE_BEGIN
 
 
/// \brief interface for analysing distances between polyline objects (see GeometricAlgorithms::analyseDistance)
class DM_API IAnalyseDistance
{
protected:
  virtual ~IAnalyseDistance() {}
 
public:
  /// \brief this function is called if non max. distance threshold is set or the distance is below the given threshold.
  /** 
      Note: if lineIdx1 == lineIdx2 then the closest point is a vertex and not a point on a segment
 
      \param[in]  distance    shortest 3d/2d distance between basePt (=base[idx]) and polyline 'other'
      \param[in]  idx         index of the current vertex (of the base polyline)
      \param[in]  basePt      current vertex (of the base polyline)
      \param[in]  lineIdx1    source point index of closest segment of polyline 'other'
      \param[in]  lineIdx2    target point index of closest segment of polyline 'other'
      \param[in]  minDistPt   point on polyline 'other' with the shortest distance to basePt
  */
  virtual void closest(double distance, unsigned idx, const IPoint &basePt, unsigned lineIdx1, unsigned lineIdx2, const IPoint &minDistPt) = 0;
 
  /// \brief this function is called if the distance between the current base vertex and the 'other' polyline exceeds the given distance threshold
  /// \param[in]  idx  index of the current vertex (of the base polyline)
  virtual void exceeds(unsigned idx) = 0;
};
 
 
 
 
/// \brief provides a set of geometric algorithms (Douglas-Peucker algorithm, densification of lines) 
namespace GeometricAlgorithms
{
  /// \brief Use the Douglas-Peucker algorithm to create a polyline with a subset of vertices of the provided line object.
  /**   Each polyline part is treated as a separate object
    
     \param[in]  line          polyline that should be thinned out
     \param[in]  maxOrthoDist  Discarded vertices feature an orthogonal distance to the returned polyline <= d_maxOrthoDist
     \return resulting object
  */
  DM_API DM::PolylineHandle thinOut(const DM::PolylineHandle &line, double maxOrthoDist);
 
 
  /// \brief densify a polyline by inserting new points along the line segments\n
  /** insert as few points as possible to reach the criterion:\n
      (distances between neighbours) <= d_maxSpacing\n
      distribute the new points equally along each line segment\n
      preserve original points together with their additional infos\n
      
     \param[in]  line        polyline that should be densified
     \param[in]  maxSpacing  maximum spacing between neighboring vertices
     \return resulting object
  */
  DM_API DM::PolylineHandle densify(const DM::PolylineHandle &line, double maxSpacing );
 
 
  /// test if a polyline is self intersecting
  DM_API bool isSelfIntersecting(const DM::PolylineHandle &line);
 
  /// \brief For analysing 2d/3d distances between vertices of the base polyline to the other provided polyline (optional a max distance threshold is considered)
  /** The function computes the shortest 2d/3d distances of all vertices of the base polyline to the 'other' polyline. With the results of each 
      base vertex distance computation the corresponding function of the provided callback object is called. If an maximum distance threshold is provided (maxDist>0),
      the algorithms only considers distances up to the given threshold (see IAnalyseDistance). The implemented algorithm uses the maxDist threshold during spatial 
      search and therfore, is more efficient than only handling the distance threshold within the callback oject.
 
      \param[in]  base      the vertex of the base polyline is used for distance analysis
      \param[in]  other     polyline to which the distances are computed
      \param[in]  callback  callback object for analysing the computed distance results
      \param[in]  maxDist   optional maximum distance threshold (-1: no distance threshold is applied)
      \param[in]  d3        flag if 3d or 2d computation (true: 3d / false: 2d)
  */   
  DM_API void analyseDistance(const PolylineHandle &base, const PolylineHandle &other, IAnalyseDistance &callback, double maxDist = -1, bool d3 = true);
 
 
  /// \brief Get the 2D bounding window of a geometry object
  DM_API DM::WindowHandle getBoundingWindow(const IGeometry &geo);
  /// \brief Get the 3D bounding box of a geometry object
  DM_API DM::BoxHandle    getBoundingBox(const IGeometry &geo);
}
 
DM_NAMESPACE_END