freeFunctions.h

Go to the documentation of this file.

// Copyright (C) Geom Software e.U, Bernhard Kornberger, Graz/Austria
//
// This file is part of the Fade2D library. The student license is free
// of charge and covers personal non-commercial research. Licensees
// holding a commercial license may use this file in accordance with
// the Commercial License Agreement.
//
// This software is provided AS IS with NO WARRANTY OF ANY KIND,
// INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE.
//
// Please contact the author if any conditions of this licensing are
// not clear to you.
//
// Author: Bernhard Kornberger, bkorn (at) geom.at
// http://www.geom.at
 
 
#pragma once
#include "Point2.h"
#include "Segment2.h"
#include "Edge2.h"
#include <vector>
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    namespace GEOM_FADE25D {
#elif GEOM_PSEUDO3D==GEOM_FALSE
    namespace GEOM_FADE2D {
#else
    #error GEOM_PSEUDO3D is not defined
#endif
 
class Mesh3; // FWD
class Zone2; // FWD
 
CLASS_DECLSPEC
void simplifyPolygon(const std::vector<Point2>& vIn,double errBound,std::vector<Point2>& vOut);
 
 
 
// *
// * <div class="row">
// * \image html offset_polygon_without_angle_correction.jpg "Offset polygon without angle correction"
// * \image html offset_polygon_90_degrees.jpg "Offset polygon with maximum angle correction factor 1.414 (down to 90 degrees)"
// * \image html offset_polygon_18.4_degrees.jpg "Offset polygon with angle correction limited to factor 6.25 (for angles as low as 18.4 degrees)"
// * </div>
// * \image latex offset_polygon_without_angle_correction.eps "Offset polygon without angle correction" width=4cm
// * \image latex offset_polygon_90_degrees.eps "Offset polygon with angle correction factor 1.414 (down to 90 degrees)" width=4cm
// * \image latex offset_polygon_18.4_degrees.eps "Offset polygon with angle correction factor 6.25 (for angles as low as 18.4 degrees)" width=4cm
// *
// *
// * @param offset specifies the offset distance (positive or negative)
// * @param [in] vOrgPoints are ordered points of a <em>counterclockwise</em>
// * polygon (no point repeated)
// * @param [out] vOffsetPoints returns points moved outside/inside by a
// * positive/negative offset distance (times the angle correction factor)
// * @param [in] maxCorrectionFactor is the maximum angle correction
// * factor that may be applied to the \p offset value. It's default
// * value is 1.0 (no angle correction), lower values are ignored.
// * The angle that can be corrected with a certain maxCorrectionFactor
// * is computed according to \f$ 2*asin(1.0/maxCorrectionFactor) \f$. This means,
// * a maxCorrectionFactor=1.4143 can account for angles down to 90 degrees
// * while 2.6132 is required to correct angles as low as 45 degrees.
// *
// * @note You may want to simplify and smooth the input polygon using
// * `simplifyPolygon()` before using this function.
// *
// * @warning The resuling offset polygon may self-intersect!
// */
 
// Deprecated, but kept for backwards compatibility, September 12, 2024: Use the new
// method Zone2::getOffsetBoundary() instead, because it removes self-intersections.
CLASS_DECLSPEC
void offsetPolygonPoints(
    double offset,
    const std::vector<Point2>& vOrgPoints,
    std::vector<Point2>& vOffsetPoints,
    double maxCorrectionFactor=1.0
    );
 
CLASS_DECLSPEC
void untwistPolygon(std::vector<Segment2>& vPolygon,std::vector<std::vector<Segment2> >& vvPolygon);
 
 
CLASS_DECLSPEC
int setGlobalNumCPU(int numCPU);
 
CLASS_DECLSPEC
int getGlobalNumCPU();
 
 
// Expects _one_ edge-connected component. No problem if the component
// forms a ring around a void that touches only at one vertex. But keep
// in mind that two completely disjoint borders may exist. This is why
// we use sIgnorePairs.
CLASS_DECLSPEC
void getSortedBoundaryPolygons( std::vector<Triangle2*>& vConnectedComponent,
                                std::vector<Edge2>& vOutsidePolygon,
                                std::vector<std::vector<Edge2> >& vHolePolygons
                                );
 
 
CLASS_DECLSPEC
void pointsToPolyline(std::vector<Point2>& vInPoints,bool bClose,std::vector<Segment2>& vOutSegments);
 
 
 
CLASS_DECLSPEC
bool isSimplePolygon(std::vector<Segment2>& vSegments);
 
#if GEOM_PSEUDO3D==GEOM_TRUE
CLASS_DECLSPEC
Vector2 getNormalVector(    const Point2& p0,
                            const Point2& p1,
                            const Point2& p2,
                            bool& bOK);
#endif
 
 
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
CLASS_DECLSPEC
double getArea25D(const Point2* p0,const Point2* p1,const Point2* p2);
#endif
 
 
CLASS_DECLSPEC
double getArea2D(const Point2* p0,const Point2* p1,const Point2* p2);
 
 
CLASS_DECLSPEC
void getDirectedEdges(const std::vector<Triangle2*>& vT,std::vector<Edge2>& vDirectedEdgesOut);
 
CLASS_DECLSPEC
void getUndirectedEdges(const std::vector<Triangle2*>& vT,std::vector<Edge2>& vUndirectedEdgesOut);
 
CLASS_DECLSPEC
void getConnectedComponents(    const std::vector<Triangle2*>& vT,
                                std::vector<std::vector<Triangle2*> >& vvT
                                );
 
 
CLASS_DECLSPEC
bool fillHole(  const std::vector<std::pair<Segment2,Vector2> >& vPolygonSegments,
                bool bWithRefine,
                bool bVerbose,
                std::vector<Point2>& vCornersOut
                );
 
 
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
CLASS_DECLSPEC
bool fillHole(  const std::vector<Point2>& vMeshCorners,
                const std::vector<Segment2>& vPolygonSegments,
                bool bWithRefine,
                bool bVerbose,
                std::vector<Point2>& vCornersOut
                );
 
CLASS_DECLSPEC
bool fillHole(  Mesh3* pMesh,
                const std::vector<Edge2>& vPolygonEdges,
                bool bWithRefine,
                bool bVerbose,
                std::vector<Point2>& vCornersOut
                );
#endif
 
 
CLASS_DECLSPEC
void edgesToPolygons(
    const std::vector<Edge2>& vEdgesIn,
    std::vector<std::vector<Edge2> >& vvPolygonsOut,
    std::vector<Edge2>& vRemainingOut
    );
 
CLASS_DECLSPEC
void getBorders(const std::vector<Triangle2*>& vT,std::vector<Segment2>& vBorderSegmentsOut);
CLASS_DECLSPEC
bool sortRing(std::vector<Segment2>& vRing);
 
//CLASS_DECLSPEC
//bool temporaryDebug(std::vector<Segment2>& vRing);
 
CLASS_DECLSPEC
bool sortRingCCW(std::vector<Segment2>& vRing);
 
 
CLASS_DECLSPEC
Orientation2 getOrientation2(const Point2* p0,const Point2* p1,const Point2* p2);
CLASS_DECLSPEC
Orientation2 getOrientation2_mt(const Point2* p0,const Point2* p1,const Point2* p2);
 
CLASS_DECLSPEC
const char* getString(const Orientation2 ori);
 
CLASS_DECLSPEC
const char* getFade2DVersion();
CLASS_DECLSPEC
int getMajorVersionNumber();
CLASS_DECLSPEC
int getMinorVersionNumber();
CLASS_DECLSPEC
int getRevisionNumber();
CLASS_DECLSPEC
bool isRelease();
 
CLASS_DECLSPEC
void setLic(
    const char* l1,
    const char* l2,
    const char* dt,
    const char* s1,
    const char* s2_
    );
class Lic;
Lic* getLic();
 
// READ AND WRITE, ASCII
 
CLASS_DECLSPEC
bool writePointsASCII(const char* filename,const std::vector<Point2*>& vPointsIn);
 
CLASS_DECLSPEC
bool writePointsASCII(const char* filename,const std::vector<Point2>& vPointsIn);
 
 
 
 
 
CLASS_DECLSPEC
bool readXY(const char* filename,std::vector<Point2>& vPointsOut);
 
#if GEOM_PSEUDO3D==GEOM_TRUE
// ONLY 2.5D
CLASS_DECLSPEC
bool readXYZ(const char* filename,std::vector<Point2>& vPointsOut);
#endif
 
 
 
// READ AND WRITE, PLY
#ifndef SKIPTHREADS
CLASS_DECLSPEC
bool readPointsPLY(const char* filename,bool bUniquePoints,std::vector<Point2>& vPoints,std::vector<VtxColor>* pVertexColors=NULL);
 
 
CLASS_DECLSPEC
bool readPointsPLY(std::istream& is,bool bUniquePoints,std::vector<Point2>& vPoints,std::vector<VtxColor>* pVertexColors=NULL);
 
 
CLASS_DECLSPEC
bool writePointsPLY(std::ostream& os,std::vector<Point2*>& vPoints,bool bASCII);
 
 
CLASS_DECLSPEC
bool writePointsPLY(const char* filename,std::vector<Point2*>& vPoints,bool bASCII);
 
#endif
 
 
 
// READ AND WRITE, BINARY
 
 
 
CLASS_DECLSPEC
bool writePointsBIN(const char* filename,std::vector<Point2>& vPoints);
 
CLASS_DECLSPEC
bool writePointsBIN(const char* filename,std::vector<Point2*>& vPoints);
 
CLASS_DECLSPEC
bool readPointsBIN(const char* filename, std::vector<Point2>& vPointsIn,bool bWithHeader=true);
 
CLASS_DECLSPEC
bool writeSegmentsBIN(const char* filename,std::vector<Segment2>& vSegmentsIn);
 
CLASS_DECLSPEC
bool readSegmentsBIN(const char* filename,std::vector<Segment2>& vSegmentsOut);
 
 
 
 
 
 
} // NAMESPACE