AnalyticalGeometry.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
 
#include "Polygon.h"
 
namespace GeoLib
{
 
enum Orientation
{
    CW = -1,
    COLLINEAR = 0,
    CCW = 1
};
 
Orientation getOrientation(MathLib::Point3d const& p0,
                           MathLib::Point3d const& p1,
                           MathLib::Point3d const& p2);
Orientation getOrientationFast(MathLib::Point3d const& p0,
                               MathLib::Point3d const& p1,
                               MathLib::Point3d const& p2);
template <typename InputIterator>
std::pair<Eigen::Vector3d, double> getNewellPlane(InputIterator pnts_begin,
                                                  InputIterator pnts_end);
 
template <class T_POINT>
std::pair<Eigen::Vector3d, double> getNewellPlane(
    const std::vector<T_POINT*>& pnts);
 
template <class T_POINT>
std::pair<Eigen::Vector3d, double> getNewellPlane(
    const std::vector<T_POINT>& pnts);
 
Eigen::Matrix3d compute2DRotationMatrixToX(Eigen::Vector3d const& v);
 
Eigen::Matrix3d compute3DRotationMatrixToX(Eigen::Vector3d const& v);
 
Eigen::Matrix3d computeRotationMatrixToXY(Eigen::Vector3d const& n);
 
template <typename InputIterator>
void rotatePoints(Eigen::Matrix3d const& rot_mat, InputIterator pnts_begin,
                  InputIterator pnts_end);
 
template <typename P>
void rotatePoints(Eigen::Matrix3d const& rot_mat, std::vector<P*> const& pnts);
 
Eigen::Matrix3d rotatePointsToXY(std::vector<Point*>& pnts);
 
template <typename InputIterator1, typename InputIterator2>
Eigen::Matrix3d rotatePointsToXY(InputIterator1 p_pnts_begin,
                                 InputIterator1 p_pnts_end,
                                 InputIterator2 r_pnts_begin,
                                 InputIterator2 r_pnts_end);
 
bool lineSegmentsIntersect(const Polyline* ply,
                           Polyline::SegmentIterator& seg_it0,
                           Polyline::SegmentIterator& seg_it1,
                           Point& intersection_pnt);
 
bool parallel(Eigen::Vector3d v, Eigen::Vector3d w);
 
bool lineSegmentIntersect(LineSegment const& s0, LineSegment const& s1,
                          Point& s);
 
std::vector<MathLib::Point3d> lineSegmentIntersect2d(LineSegment const& ab,
                                                     LineSegment const& cd);
 
std::unique_ptr<Point> triangleLineIntersection(MathLib::Point3d const& a,
                                                MathLib::Point3d const& b,
                                                MathLib::Point3d const& c,
                                                MathLib::Point3d const& p,
                                                MathLib::Point3d const& q);
 
void computeAndInsertAllIntersectionPoints(PointVec& pnt_vec,
                                           std::vector<Polyline*>& plys);
 
std::tuple<std::vector<GeoLib::Point*>, Eigen::Vector3d>
rotatePolygonPointsToXY(GeoLib::Polygon const& polygon_in);
 
void sortSegments(MathLib::Point3d const& seg_beg_pnt,
                  std::vector<LineSegment>& sub_segments);
 
}  // end namespace GeoLib
 
#include "AnalyticalGeometry-impl.h"