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);
 
Polygon rotatePolygonToXY(Polygon const& polygon_in,
                                  Eigen::Vector3d& plane_normal);
 
void sortSegments(MathLib::Point3d const& seg_beg_pnt,
    std::vector<LineSegment>& sub_segments);
 
} // end namespace GeoLib
 
#include "AnalyticalGeometry-impl.h"