AnalyticalGeometry.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#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"