Voronoi tessellation class#

struct Angle#

#include <Angle.h>

Public Functions

inline Angle(double a)#

inline bool operator<(const Angle &other) const#

Public Members

double angle#

class BoundingBox#

#include <BoundingBox.h>

Public Functions

BoundingBox(Point p1, Point p2)#

Point getFirst() const#

Point getSecond() const#

double getWidth()#

double getHeight()#

double xMin()#

double yMin()#

double xMax()#

double yMax()#

bool operator==(const BoundingBox &other) const#

bool contains(Point p)#

void getSegments(std::vector<PointSegment> &segments)#

Private Members

Point p1#

Point p2#

class CenterTriangulationGenerator : public voronoi::TriangulationGenerator #

#include <CenterTriangulationGenerator.h>

Public Functions

virtual std::vector<Triangle> triangulate(Polygon p, std::vector<Point> &points)#

class Circle#

#include <Circle.h>

Subclassed by voronoi::CircularHole

Public Functions

Circle(double r, Point c)#

std::vector<Point> discretizeCircle()#

Protected Attributes

double radius#

Point center#

class CircularHole : public voronoi::Hole, public voronoi::Circle #

#include <CircularHole.h>

Public Functions

CircularHole(Point p, double r)#

Private Functions

void computeSegments()#

class Clipper : public virtual ClipperLib::ClipperBase #

#include <clipper.hpp>

Public Functions

Clipper(int initOptions = 0)#

bool Execute(ClipType clipType, Paths &solution, PolyFillType fillType = pftEvenOdd)#

bool Execute(ClipType clipType, Paths &solution, PolyFillType subjFillType, PolyFillType clipFillType)#

bool Execute(ClipType clipType, PolyTree &polytree, PolyFillType fillType = pftEvenOdd)#

bool Execute(ClipType clipType, PolyTree &polytree, PolyFillType subjFillType, PolyFillType clipFillType)#

inline bool ReverseSolution()#

inline void ReverseSolution(bool value)#

inline bool StrictlySimple()#

inline void StrictlySimple(bool value)#

Protected Functions

virtual bool ExecuteInternal()#

Private Types

typedef std::list<cInt> MaximaList#

Private Functions

void SetWindingCount(TEdge &edge)#

bool IsEvenOddFillType(const TEdge &edge) const#

bool IsEvenOddAltFillType(const TEdge &edge) const#

void InsertLocalMinimaIntoAEL(const cInt botY)#

void InsertEdgeIntoAEL(TEdge *edge, TEdge *startEdge)#

void AddEdgeToSEL(TEdge *edge)#

bool PopEdgeFromSEL(TEdge *&edge)#

void CopyAELToSEL()#

void DeleteFromSEL(TEdge *e)#

void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2)#

bool IsContributing(const TEdge &edge) const#

bool IsTopHorz(const cInt XPos)#

void DoMaxima(TEdge *e)#

void ProcessHorizontals()#

void ProcessHorizontal(TEdge *horzEdge)#

void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt)#

OutPt *AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt)#

OutRec *GetOutRec(int idx)#

void AppendPolygon(TEdge *e1, TEdge *e2)#

void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt)#

OutPt *AddOutPt(TEdge *e, const IntPoint &pt)#

OutPt *GetLastOutPt(TEdge *e)#

bool ProcessIntersections(const cInt topY)#

void BuildIntersectList(const cInt topY)#

void ProcessIntersectList()#

void ProcessEdgesAtTopOfScanbeam(const cInt topY)#

void BuildResult(Paths &polys)#

void BuildResult2(PolyTree &polytree)#

void SetHoleState(TEdge *e, OutRec *outrec)#

void DisposeIntersectNodes()#

bool FixupIntersectionOrder()#

void FixupOutPolygon(OutRec &outrec)#

void FixupOutPolyline(OutRec &outrec)#

bool IsHole(TEdge *e)#

bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl)#

void FixHoleLinkage(OutRec &outrec)#

void AddJoin(OutPt *op1, OutPt *op2, const IntPoint offPt)#

void ClearJoins()#

void ClearGhostJoins()#

void AddGhostJoin(OutPt *op, const IntPoint offPt)#

bool JoinPoints(Join *j, OutRec *outRec1, OutRec *outRec2)#

void JoinCommonEdges()#

void DoSimplePolygons()#

void FixupFirstLefts1(OutRec *OldOutRec, OutRec *NewOutRec)#

void FixupFirstLefts2(OutRec *InnerOutRec, OutRec *OuterOutRec)#

void FixupFirstLefts3(OutRec *OldOutRec, OutRec *NewOutRec)#

Private Members

JoinList m_Joins#

JoinList m_GhostJoins#

IntersectList m_IntersectList#

ClipType m_ClipType#

MaximaList m_Maxima#

TEdge *m_SortedEdges#

bool m_ExecuteLocked#

PolyFillType m_ClipFillType#

PolyFillType m_SubjFillType#

bool m_ReverseOutput#

bool m_UsingPolyTree#

bool m_StrictSimple#

class ClipperBase#

#include <clipper.hpp>

Subclassed by ClipperLib::Clipper

Public Functions

ClipperBase()#

virtual ~ClipperBase()#

virtual bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed)#

bool AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed)#

virtual void Clear()#

IntRect GetBounds()#

inline bool PreserveCollinear()#

inline void PreserveCollinear(bool value)#

Protected Types

typedef std::vector<LocalMinimum> MinimaList#

typedef std::priority_queue<cInt> ScanbeamList#

Protected Functions

void DisposeLocalMinimaList()#

TEdge *AddBoundsToLML(TEdge *e, bool IsClosed)#

virtual void Reset()#

TEdge *ProcessBound(TEdge *E, bool IsClockwise)#

void InsertScanbeam(const cInt Y)#

bool PopScanbeam(cInt &Y)#

bool LocalMinimaPending()#

bool PopLocalMinima(cInt Y, const LocalMinimum *&locMin)#

OutRec *CreateOutRec()#

void DisposeAllOutRecs()#

void DisposeOutRec(PolyOutList::size_type index)#

void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2)#

void DeleteFromAEL(TEdge *e)#

void UpdateEdgeIntoAEL(TEdge *&e)#

Protected Attributes

MinimaList::iterator m_CurrentLM#

MinimaList m_MinimaList#

bool m_UseFullRange#

EdgeList m_edges#

bool m_PreserveCollinear#

bool m_HasOpenPaths#

PolyOutList m_PolyOuts#

TEdge *m_ActiveEdges#

ScanbeamList m_Scanbeam#

class clipperException : public std::exception#

#include <clipper.hpp>

Public Functions

inline clipperException(const char *description)#

inline virtual ~clipperException()#

inline virtual const char *what() const#

Private Members

std::string m_descr#

class ClipperOffset#

#include <clipper.hpp>

Public Functions

ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25)#

~ClipperOffset()#

void AddPath(const Path &path, JoinType joinType, EndType endType)#

void AddPaths(const Paths &paths, JoinType joinType, EndType endType)#

void Execute(Paths &solution, double delta)#

void Execute(PolyTree &solution, double delta)#

void Clear()#

Public Members

double MiterLimit#

double ArcTolerance#

Private Functions

void FixOrientations()#

void DoOffset(double delta)#

void OffsetPoint(int j, int &k, JoinType jointype)#

void DoSquare(int j, int k)#

void DoMiter(int j, int k, double r)#

void DoRound(int j, int k)#

Private Members

Paths m_destPolys#

Path m_srcPoly#

Path m_destPoly#

std::vector<DoublePoint> m_normals#

double m_delta#

double m_sinA#

double m_sin#

double m_cos#

double m_miterLim#

double m_StepsPerRad#

IntPoint m_lowest#

PolyNode m_polyNodes#

class ClipperWrapper#

#include <ClipperWrapper.h>

Public Static Functions

static ClipperLib::Paths polyIntersection(std::vector<Point> parent, std::vector<Point> child, int maxScale)#

Private Static Functions

static ClipperLib::IntPoint scalePoint(Point point, int maxScale)#

struct DelaunayInfo#

#include <DelaunayInfo.h>

Public Functions

inline DelaunayInfo(std::vector<Triangle> &t, std::vector<Point> &p, SegmentMap *e, std::vector<PointData> &pD, UniqueList<int> &rP, std::vector<EdgeData> &eD, std::unordered_map<Key, int, KeyHasher> &eM, UniqueList<Point> &c)#

Public Members

std::vector<Triangle> triangles#

std::vector<Point> meshPoints#

SegmentMap *delaunayEdges#

std::vector<PointData> points#

UniqueList<int> realPoints#

std::vector<EdgeData> edges#

std::unordered_map<Key, int, KeyHasher> edgeMap#

UniqueList<Point> circumcenters#

class DelaunayToVoronoi#

#include <DelaunayToVoronoi.h>

Public Functions

explicit DelaunayToVoronoi(DelaunayInfo &del)#

Mesh<Polygon> &getMesh()#

Private Functions

int getCircumcenter(DelaunayInfo &del, int triangle, int edge)#

Private Members

Mesh<Polygon> mesh#

class DelaunayTriangulationGenerator : public voronoi::TriangulationGenerator #

#include <DelaunayTriangulationGenerator.h>

Public Functions

virtual std::vector<Triangle> triangulate(Polygon p, std::vector<Point> &points)#

class DelynoiConfig#

#include <DelynoiConfig.h>

Public Functions

void setDiscretizationGrade(int d)#

void setTolerance(double t)#

void setScale(int s)#

void setPrecision(Precision::precision p)#

void setPrecision(int p)#

int getDiscretizationGrade()#

double getTolerance()#

int getScale()#

int getPrecision()#

Public Static Functions

static DelynoiConfig *instance()#

Private Functions

DelynoiConfig()#

DelynoiConfig(const DelynoiConfig &other) = delete#

DelynoiConfig &operator=(const DelynoiConfig &copy) = delete#

Private Members

int circle_discretization_grade#

double double_comparison_tolerance#

int scale_for_clipper#

int precision#

Private Static Attributes

static DelynoiConfig *s_instance#

struct DoublePoint#

#include <clipper.hpp>

Public Functions

inline DoublePoint(double x = 0, double y = 0)#

inline DoublePoint(IntPoint ip)#

Public Members

double X#

double Y#

class EarTriangulationGenerator : public voronoi::TriangulationGenerator #

#include <EarTriangulationGenerator.h>

Public Functions

virtual std::vector<Triangle> triangulate(Polygon p, std::vector<Point> &points)#

Private Functions

Triangle getEar(std::vector<Point> &points, std::vector<int> &pointList)#

class EdgeData#

#include <EdgeData.h>

Public Functions

EdgeData(int p1, int p2)#

void setTriangle(int t)#

std::string getString()#

bool operator==(const EdgeData &other) const#

Public Members

int p1#

int p2#

int t1#

int t2#

class Functor#

#include <Functor.h>

Subclassed by voronoi::RandomDoubleNoise, voronoi::RandomIntegerNoise, voronoi::Random_Double, voronoi::Random_Integer

Public Functions

virtual double apply(double x) = 0#

struct GetKeys#

#include <maputils.h>

Public Functions

template<typename T> inline T::first_type operator()(T keyValuePair) const#

struct GetValues#

#include <maputils.h>

Public Functions

template<typename T> inline T::first_type operator()(T keyValuePair) const#

class Hole#

#include <Hole.h>

Subclassed by voronoi::CircularHole, voronoi::PolygonalHole

Public Functions

inline Hole()#

inline Hole(std::vector<Point> points, Point center, std::vector<IndexSegment> seg)#

inline Hole(const Hole &other)#

inline virtual Point getCenter()#

inline void getSegments(std::vector<IndexSegment> &s, int offset)#

inline virtual std::vector<Point> getPoints()#

inline bool containsPoint(Point point)#

Protected Attributes

std::vector<Point> HolePoints#

Point center#

std::vector<IndexSegment> segments#

class IndexSegment : public voronoi::Segment<int>#

#include <IndexSegment.h>

Public Functions

IndexSegment()#

IndexSegment(int i1, int i2)#

IndexSegment(const IndexSegment &other)#

bool contains(const std::vector<Point> &p, Point point)#

bool contains(const std::vector<Point> &p, IndexSegment s)#

Point middlePoint(const std::vector<Point> &p)#

double cartesianAngle(const std::vector<Point> &p)#

bool intersection(const std::vector<Point> &points, PointSegment other, Point &inter)#

bool intersection(const std::vector<Point> &points, IndexSegment other, Point &inter)#

bool isContained(PointSegment s, const std::vector<Point> &p)#

void orderCCW(const std::vector<Point> &points, Point center)#

bool isCCW(const std::vector<Point> &points, Point center)#

virtual std::string getString() const override#

bool operator==(const IndexSegment &other) const#

bool operator<(const IndexSegment &other) const#

double length(const std::vector<Point> &points)#

IndexSegment add(int o)#

Public Members

std::size_t hash = 0#

struct IntPoint#

#include <clipper.hpp>

Public Functions

inline IntPoint(cInt x = 0, cInt y = 0)#

Public Members

cInt X#

cInt Y#

Friends

inline friend bool operator==(const IntPoint &a, const IntPoint &b)#

inline friend bool operator!=(const IntPoint &a, const IntPoint &b)#

struct IntRect#

#include <clipper.hpp>

Public Members

cInt left#

cInt top#

cInt right#

cInt bottom#

struct Key#

#include <mapdata.h>

Public Functions

inline Key(int f, int s)#

inline bool operator==(const Key &other) const#

Public Members

int first#

int second#

std::size_t hash#

struct KeyHasher#

#include <mapdata.h>

Public Functions

inline std::size_t operator()(const Key &k) const#

template<typename T> class Mesh#

#include <Mesh.h>

Public Functions

Mesh()#

Mesh(std::vector<Point> &p, std::vector<T> &e, SegmentMap *s, PointMap *pM)#

Mesh(UniqueList<Point> &p, std::vector<T> &e, SegmentMap *s, PointMap *pM)#

Mesh(const Mesh &m)#

void printInStream(std::ofstream &file)#

void printInFile(std::string fileName)#

void createFromFile(std::string fileName, int startIndex)#

void createFromStream(std::ifstream &ofstream, int startIndex)#

std::vector<T> &getPolygons()#

std::vector<T> getPolygons() const#

T &getPolygon(int index)#

SegmentMap *getSegments() const#

PointMap *getPointMap() const#

UniqueList<Point> &getPoints()#

UniqueList<Point> getPoints() const#

Point getPoint(int i)#

NeighboursBySegment getNeighbours(IndexSegment s)#

Protected Attributes

SegmentMap *edges#

PointMap *pointMap#

UniqueList<Point> points#

std::vector<T> polygons#

class NeighboursByPoint#

#include <NeighboursByPoint.h>

Public Functions

NeighboursByPoint()#

NeighboursByPoint(int n)#

NeighboursByPoint(std::vector<int> n)#

void add(int n)#

void insert(std::vector<int> n)#

std::vector<int> getNeighbours() const#

std::vector<int> &getNeighbours()#

Private Members

std::vector<int> neighbours#

class NeighboursBySegment#

#include <NeighboursBySegment.h>

Public Functions

NeighboursBySegment()#

NeighboursBySegment(int i1)#

NeighboursBySegment(int i1, int i2)#

NeighboursBySegment(Pair<int> p)#

void setNeighbour(int i)#

int getFirst() const#

int getSecond() const#

void setFirst(int value)#

void setSecond(int value)#

std::string getString() const#

bool operator==(const NeighboursBySegment &other) const#

Private Members

int n1#

int n2 = -1#

struct NeighboursHasher#

#include <SegmentMap.h>

Public Functions

inline std::size_t operator()(const NeighboursBySegment &k) const#

template<typename T> class Pair#

#include <Pair.h>

Public Functions

Pair(T first, T second)#

Pair(const Pair &other)#

Pair()#

bool operator==(const Pair &other) const#

bool operator<(const Pair &other) const#

T dot(Pair other)#

Pair<T> operator*(const double other)#

Pair<T> operator+(const Pair &other) const#

Public Members

T first#

T second#

class Point#

#include <Point.h>

Public Functions

Point(double x, double y)#

Point()#

bool isValid()#

double getX() const#

double getY() const#

double squareNorm()#

std::string getString() const#

bool operator==(const Point &other) const#

bool operator<(const Point &other) const#

Point operator-(const Point &other)#

bool isInBoundary()#

void setBoundary()#

void setX(double newX)#

void setY(double newY)#

Private Members

double x#

double y#

bool isBoundaryPoint = false#

bool isEmpty = false#

class PointData#

#include <PointData.h>

Public Functions

inline PointData(int p)#

inline void setEdge(int edge, int marker)#

Public Members

int point#

int edge#

class PointGenerator#

#include <PointGenerator.h>

Public Functions

PointGenerator()#

PointGenerator(Functor *lX, Functor *lY)#

PointGenerator(Functor *l, functions::independent_variable variable)#

virtual void generate(std::vector<Point> &vector, BoundingBox box, int nX, int nY)#

Private Functions

Point result(double x, double y)#

Private Members

Functor *lX#

Functor *lY#

functions::independent_variable variable#

class PointMap#

#include <PointMap.h>

Public Functions

PointMap()#

void insert(Point p, int neighbour)#

void insert(Point &p, std::vector<int> &neighbours)#

NeighboursByPoint &get(Point p)#

std::map<Point, NeighboursByPoint> &getMap()#

int size()#

void printInFile(std::string fileName)#

Protected Attributes

std::map<Point, NeighboursByPoint> map#

class PointSegment : public voronoi::Segment<Point>#

#include <PointSegment.h>

Public Functions

PointSegment(Point p1, Point p2)#

PointSegment()#

double length()#

bool contains(Point point)#

virtual std::string getString() const override#

double cartesianAngle()#

bool operator==(const PointSegment &other) const#

class Polygon#

#include <Polygon.h>

Subclassed by voronoi::PolygonalHole, voronoi::Region, voronoi::Triangle

Public Functions

Polygon(std::vector<int> &points, std::vector<Point> &p)#

Polygon(std::vector<Point> &p)#

Polygon(const Polygon &obj)#

Polygon()#

double getDiameter(std::vector<Point> &points)#

double getArea(std::vector<Point> &points)#

Point getCentroid(std::vector<Point> &points)#

void getSegments(std::vector<IndexSegment> &segments)#

std::vector<int> getPoints() const#

std::vector<int> &getPoints()#

std::vector<Point> getPoints(std::vector<Point> &p)#

int numberOfSides() const#

bool operator==(const Polygon &other) const#

bool operator<(const Polygon &other) const#

std::string getString()#

void mutate(std::vector<Point> &p)#

bool containsPoint(std::vector<Point> &p, Point point)#

bool inEdges(std::vector<Point> &p, Point point)#

double signedArea(std::vector<Point> &p)#

bool containsEdge(IndexSegment &s)#

bool isConvex(std::vector<Point> &p)#

bool isClockwise(std::vector<Point> &p)#

bool isVertex(int index)#

bool isSelfIntersecting(std::vector<Point> &points)#

void fixCCW(std::vector<Point> &p)#

IndexSegment containerEdge(std::vector<Point> &p, Point point)#

Point getAverage(std::vector<Point> &p)#

double getMaxDistance(std::vector<Point> &points)#

Public Members

std::size_t hash = 0#

Protected Functions

double calculateDiameter(std::vector<Point> &p)#

double calculateArea(std::vector<Point> &p)#

Point calculateCentroid(std::vector<Point> &p)#

void calculateHash()#

Protected Attributes

std::vector<int> points#

double diameter#

double area#

Point centroid#

class PolygonalHole : public voronoi::Hole, public voronoi::Polygon #

#include <PolygonalHole.h>

Public Functions

PolygonalHole(std::vector<Point> &p)#

class PolyNode#

#include <clipper.hpp>

Subclassed by ClipperLib::PolyTree

Public Functions

PolyNode()#

inline virtual ~PolyNode()#

PolyNode *GetNext() const#

bool IsHole() const#

bool IsOpen() const#

int ChildCount() const#

Public Members

Path Contour#

PolyNodes Childs#

PolyNode *Parent#

Private Functions

PolyNode *GetNextSiblingUp() const#

void AddChild(PolyNode &child)#

Private Members

unsigned Index#

bool m_IsOpen#

JoinType m_jointype#

EndType m_endtype#

Friends

friend class Clipper

friend class ClipperOffset

class PolyTree : public ClipperLib::PolyNode #

#include <clipper.hpp>

Public Functions

inline ~PolyTree()#

PolyNode *GetFirst() const#

void Clear()#

int Total() const#

Private Members

PolyNodes AllNodes#

Friends

friend class Clipper

class Random_Double : public voronoi::Functor #

#include <RandomDouble.h>

Public Functions

Random_Double(double min, double max)#

virtual double apply(double x)#

Public Members

double min#

double max#

std::uniform_real_distribution<double> uni#

Public Static Attributes

static std::default_random_engine rd#

static std::mt19937 rng#

class Random_Integer : public voronoi::Functor #

#include <RandomInteger.h>

Public Functions

Random_Integer(double min, double max)#

virtual double apply(double x)#

Private Members

double min#

double max#

std::uniform_int_distribution<int> uni#

Private Static Attributes

static std::default_random_engine rd#

static std::mt19937 rng#

class RandomDoubleNoise : public voronoi::Functor #

#include <RandomDoubleNoise.h>

Public Functions

RandomDoubleNoise(Functor *f, double min, double max)#

virtual double apply(double x)#

Private Members

double min#

double max#

Functor *f#

std::uniform_real_distribution<double> uni#

std::uniform_int_distribution<int> uni_int#

Private Static Attributes

static std::default_random_engine rd#

static std::mt19937 rng#

class RandomIntegerNoise : public voronoi::Functor #

#include <RandomIntegerNoise.h>

Public Functions

RandomIntegerNoise(Functor *f, double min, double max)#

virtual double apply(double x)#

Private Members

double min#

double max#

Functor *f#

std::uniform_int_distribution<int> uni#

Private Static Attributes

static std::default_random_engine rd#

static std::mt19937 rng#

class Region : public voronoi::Polygon #

#include <Region.h>

Public Functions

Region(std::vector<Point> &points)#

Region()#

Region(const Polygon &other, std::vector<Point> &points)#

Region(const Region &other)#

void mutate(std::vector<Point> &points)#

std::vector<Point> getSeedPoints()#

std::vector<Point> getRegionPoints()#

std::vector<Hole> &getHoles()#

void addHole(Hole h)#

void cleanInternalHoles()#

void generateSeedPoints(PointGenerator p, int nX, int nY)#

void addSeedPoints(std::vector<Point> &seeds)#

void addSeedsFromFile(std::string fileName)#

BoundingBox getBox()#

void getSegments(std::vector<IndexSegment> &s)#

bool containsPoint(Point p)#

bool inEdges(Point p)#

void cleanSeedPoints()#

void printInFile(std::string fileName)#

Private Functions

void clean()#

Private Members

std::vector<Hole> holes#

std::vector<Point> p#

std::vector<Point> seedPoints#

template<class T> class Segment#

#include <Segment.h>

Public Functions

Segment()#

Segment(T p1, T p2)#

T getFirst() const#

T getSecond() const#

virtual std::string getString() const = 0#

bool isVertex(T p)#

Protected Functions

double length(Point p1, Point p2)#

bool intersects(Point p1, Point p2, Point o1, Point o2, Point &inter)#

double cartesianAngle(Point p1, Point p2)#

virtual bool intersectionInfinite(Point p1, Point p2, Point o1, Point o2, Point &inter)#

bool contains(Point point, Point p1, Point p2)#

Protected Attributes

T p1#

T p2#

struct SegmentHasher#

#include <mapdata.h>

Public Functions

inline std::size_t operator()(const IndexSegment &k) const#

class SegmentMap#

#include <SegmentMap.h>

Public Functions

SegmentMap()#

void insert(IndexSegment s, int polygonIndex)#

void insert(IndexSegment s, NeighboursBySegment n)#

NeighboursBySegment &get(IndexSegment s)#

std::unordered_map<IndexSegment, NeighboursBySegment, SegmentHasher> &getMap()#

std::unordered_map<IndexSegment, NeighboursBySegment, SegmentHasher> getMap() const#

int size()#

void printInFile(std::string fileName)#

bool containsSegment(IndexSegment s)#

Protected Attributes

std::unordered_map<IndexSegment, NeighboursBySegment, SegmentHasher> map#

class Triangle : public voronoi::Polygon #

#include <Triangle.h>

Public Functions

Triangle()#

Triangle(std::vector<int> points, std::vector<Point> &p)#

Triangle(std::vector<int> points, std::vector<Point> &p, UniqueList<Point> &circumcenters)#

Triangle(std::vector<int> points, std::vector<Point> &p, std::vector<Point> &circumcenters)#

Point getCircumcenter()#

int getCircumcenterIndex()#

int nextEdge(int center, EdgeData edge, std::unordered_map<Key, int, KeyHasher> &edgeMap)#

int thirdPoint(EdgeData edge)#

bool isNull()#

Private Functions

Point calculateCircumcenter(std::vector<Point> &p)#

Private Members

Point circumcenter#

int circumcenterIndex#

class TriangleDelaunayGenerator#

#include <TriangleDelaunayGenerator.h>

Public Functions

TriangleDelaunayGenerator(const std::vector<Point> &points, Region region)#

Mesh<Triangle> &getConformingDelaunayTriangulation()#

Mesh<Triangle> getConstrainedDelaunayTriangulation()#

Mesh<Triangle> getConstrainedDelaunayTriangulation(std::vector<PointSegment> restrictedSegments)#

DelaunayInfo getConformingDelaunay()#

void writeTriangleInputFile(UniqueList<Point> &point_list, Region region, std::vector<int> regionIndex)#

template<typename T> inline Mesh<T> initializeMesh()#

Private Functions

void callTrianglea(std::vector<Point> &point_list, char switches[])#

void callTriangle(std::vector<Point> &point_list, char switches[], std::vector<PointSegment> restrictedSegments)#

Private Members

Region region#

std::vector<Point> seedPoints#

std::vector<Triangle> triangles#

std::vector<Point> meshPoints#

SegmentMap *delaunayEdges#

std::vector<PointData> points#

UniqueList<int> realPoints#

std::vector<EdgeData> edges#

UniqueList<Point> circumcenters#

std::unordered_map<Key, int, KeyHasher> edgeMap#

bool empty = false#

class TriangleVoronoiGenerator#

#include <TriangleVoronoiGenerator.h>

Public Functions

TriangleVoronoiGenerator(std::vector<Point> &point_list, Region region)#

Mesh<Polygon> &getMesh()#

Mesh<Polygon> &getTriangulation()#

Private Members

Mesh<Polygon> voronoi#

Mesh<Polygon> delaunay#

struct triangulateio#

#include <triangle.h>

Public Members

REAL *pointlist#

REAL *pointattributelist#

int *pointmarkerlist#

int numberofpoints#

int numberofpointattributes#

int *trianglelist#

REAL *triangleattributelist#

REAL *trianglearealist#

int *neighborlist#

int numberoftriangles#

int numberofcorners#

int numberoftriangleattributes#

int *segmentlist#

int *segmentmarkerlist#

int numberofsegments#

REAL *holelist#

int numberofholes#

REAL *regionlist#

int numberofregions#

int *edgelist#

int *edgemarkerlist#

REAL *normlist#

int numberofedges#

class TriangulationGenerator#

#include <TriangulationGenerator.h>

Subclassed by voronoi::CenterTriangulationGenerator, voronoi::DelaunayTriangulationGenerator, voronoi::EarTriangulationGenerator

Public Functions

virtual std::vector<Triangle> triangulate(Polygon p, std::vector<Point> &points) = 0#

inline std::vector<Triangle> triangulate(Triangle p, std::vector<Point> &points)#

template<class T> class UniqueList#

#include <UniqueList.h>

Public Functions

UniqueList()#

UniqueList(const UniqueList<T> &other)#

int push_back(T &item)#

int force_push_back(T &item)#

int size()#

std::vector<int> push_list(std::vector<T> &list)#

std::vector<int> push_list(UniqueList<T> &list)#

void pop_front()#

std::vector<T> getList() const#

std::vector<T> &getList()#

int indexOf(T elem)#

T &operator[](int i)#

bool operator==(const UniqueList<T> &other)#

bool contains(T elem)#

bool hasCommonElement(UniqueList<T> &other)#

void clear()#

void delete_element(T item)#

Private Members

std::vector<T> list#

std::map<T, int> map#

class Voronoi#

#include <openfdem_Voronoi_module.h>

Public Functions

inline Voronoi()#

inline ~Voronoi()#

Public Static Functions

static Region createVoronoiPolygon(General general)#

static void addVoronoiHole(Region &region, General general)#

static Mesh<Polygon> generateVoronoiSeeds(Region &region, General general)#

static void VoronoitoOpenfdem(Mesh<Polygon> &mesh, Nodal nodal, Element element)#

static void VoronoiClear(Region &region)#

namespace ClipperLib#

Typedefs

typedef signed long long cInt#

typedef signed long long long64#

typedef unsigned long long ulong64#

typedef std::vector<IntPoint> Path#

typedef std::vector<Path> Paths#

typedef std::vector<PolyNode*> PolyNodes#

typedef std::vector<OutRec*> PolyOutList#

typedef std::vector<TEdge*> EdgeList#

typedef std::vector<Join*> JoinList#

typedef std::vector<IntersectNode*> IntersectList#

Enums

enum ClipType#

Values:

enumerator ctIntersection#

enumerator ctUnion#

enumerator ctDifference#

enumerator ctXor#

enum PolyType#

Values:

enumerator ptSubject#

enumerator ptClip#

enum PolyFillType#

Values:

enumerator pftEvenOdd#

enumerator pftNonZero#

enumerator pftPositive#

enumerator pftNegative#

enum InitOptions#

Values:

enumerator ioReverseSolution#

enumerator ioStrictlySimple#

enumerator ioPreserveCollinear#

enum JoinType#

Values:

enumerator jtSquare#

enumerator jtRound#

enumerator jtMiter#

enum EndType#

Values:

enumerator etClosedPolygon#

enumerator etClosedLine#

enumerator etOpenButt#

enumerator etOpenSquare#

enumerator etOpenRound#

enum EdgeSide#

Values:

enumerator esLeft#

enumerator esRight#

Functions

inline Path &operator<<(Path &poly, const IntPoint &p)#

inline Paths &operator<<(Paths &polys, const Path &p)#

std::ostream &operator<<(std::ostream &s, const IntPoint &p)#

std::ostream &operator<<(std::ostream &s, const Path &p)#

std::ostream &operator<<(std::ostream &s, const Paths &p)#

bool Orientation(const Path &poly)#

double Area(const Path &poly)#

int PointInPolygon(const IntPoint &pt, const Path &path)#

void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = pftEvenOdd)#

void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = pftEvenOdd)#

void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd)#

void CleanPolygon(const Path &in_poly, Path &out_poly, double distance = 1.415)#

void CleanPolygon(Path &poly, double distance = 1.415)#

void CleanPolygons(const Paths &in_polys, Paths &out_polys, double distance = 1.415)#

void CleanPolygons(Paths &polys, double distance = 1.415)#

void MinkowskiSum(const Path &pattern, const Path &path, Paths &solution, bool pathIsClosed)#

void MinkowskiSum(const Path &pattern, const Paths &paths, Paths &solution, bool pathIsClosed)#

void MinkowskiDiff(const Path &poly1, const Path &poly2, Paths &solution)#

void PolyTreeToPaths(const PolyTree &polytree, Paths &paths)#

void ClosedPathsFromPolyTree(const PolyTree &polytree, Paths &paths)#

void OpenPathsFromPolyTree(PolyTree &polytree, Paths &paths)#

void ReversePath(Path &p)#

void ReversePaths(Paths &p)#

Variables

static cInt const loRange = 0x3FFFFFFF#

static cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL#

namespace map_utils#

namespace Precision#

Enums

enum precision#

Values:

enumerator small#

enumerator mid#

enumerator large#

namespace std

namespace voronoi#

namespace convex#

Functions

void convexHull(std::vector<Point> &points, std::vector<Point> &u, std::vector<Point> &l)#

std::vector<std::pair<Point, Point>> rotatingCalipers(std::vector<Point> &points)#

namespace delynoi_utilities#

Functions

void TrivialIndexVector(std::vector<int> &index_vector, int n)#

double crossProduct(Point a, Point b)#

double norm(Point p)#

double squareNorm(Point p)#

double orientation(Point p, Point q, Point r)#

std::vector<Point> generateArcPoints(Point center, double radius, double initAngle, double endAngle)#

void checkTriangleIntegrity(std::vector<int> &trianglePoints)#

namespace functions#

Enums

enum independent_variable#

Values:

enumerator x#

enumerator y#

enumerator both#

Functions

Functor *constant()#

Functor *displace_points(double delta)#

Functor *constantAlternating()#

Functor *uniform(double delta)#

Functor *random_integer(double min, double max)#

Functor *random_double(double min, double max)#

Functor *sine(double amplitude, double frecuency, double phase)#

Functor *cosine(double amplitude, double frecuency, double phase)#

namespace geometry_functions#

Functions

double area2(Point p1, Point p2, Point p3)#

bool collinear(Point p1, Point p2, Point p3)#

bool collinear(PointSegment &seg1, PointSegment &seg2)#

double triangleArea(Point p1, Point p2, Point origin)#

double area(std::vector<Point> &points, std::vector<int> index)#

double area(std::vector<Point> &points)#

namespace noise#

Functions

Functor *random_double_noise(Functor *f, double min, double max)#

Functor *random_integer_noise(Functor *f, double min, double max)#

namespace utilities#

Functions

template<typename T> std::string toString(T a)#

template<typename T> int indexOf(const std::vector<T> &vector, T element)#

template<typename T> int sign(T x)#

std::string toStringWithPrecision(double d, int precision)#

int hash32(int key)#

int random_integer(int min, int max)#

std::string getPath()#

Pair<double> normalize(Pair<double> vector)#

double radian(double angle)#

double degrees(double angle)#

std::vector<std::string> split(std::string s, const std::regex regex)#

std::vector<std::string> splitBySpaces(std::string s)#

std::ifstream openFile(std::string fileName)#

file openfdem_Voronoi_module.h: #include <voronoi/voro/models/Region.h>

#include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/hole/CircularHole.h>

#include <voronoi/voro/models/generator/functions/functions.h>

#include <voronoi/voro/voronoi/TriangleVoronoiGenerator.h>

#include <voronoi/voro/models/generator/noise/noise.h>

#include “solver/openfdem.h”

file maputils.h

file Pair.h

file Precision.h

file UniqueList.h: #include <vector>

#include <algorithm>

#include <map>

file utilities.h: #include <iostream>

#include <sstream>

#include <vector>

#include <algorithm>

#include “Pair.h”

#include <iomanip>

#include <regex>

file DelynoiConfig.h: #include <utilities/Precision.h>

file Angle.h: #include <cmath>

#include <voronoi/voro/config/DelynoiConfig.h>

file IndexSegment.h: #include <voronoi/voro/models/basic/Segment.h>

#include <voronoi/voro/models/basic/PointSegment.h>

file Point.h: #include <string>

#include <math.h>

#include <cmath>

#include <sstream>

#include <utilities/utilities.h>

file PointSegment.h: #include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/basic/Segment.h>

file Segment.h: #include <vector>

#include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/utilities/delynoi_utilities.h>

#include <voronoi/voro/config/DelynoiConfig.h>

file functions.h: #include “voronoi/voro/models/generator/Functor.h”

file RandomDouble.h: #include <random>

#include “voronoi/voro/models/generator/Functor.h”

file RandomInteger.h: #include <random>

#include “voronoi/voro/models/generator/Functor.h”

file Functor.h

file noise.h: #include <voronoi/voro/models/generator/Functor.h>

file RandomDoubleNoise.h: #include <random>

#include <climits>

#include <voronoi/voro/models/generator/Functor.h>

file RandomIntegerNoise.h: #include <random>

#include <voronoi/voro/models/generator/Functor.h>

file PointGenerator.h: #include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/polygon/BoundingBox.h>

#include “Functor.h”

#include “voronoi/voro/models/generator/functions/functions.h”

#include <vector>

file CircularHole.h: #include <vector>

#include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/basic/Segment.h>

#include <voronoi/voro/models/polygon/Circle.h>

#include <voronoi/voro/models/hole/Hole.h>

#include <voronoi/voro/models/polygon/Polygon.h>

file ClipperWrapper.h: #include <voronoi/voro/models/hole/clipper/lib/clipper.hpp>

#include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/polygon/Polygon.h>

file clipper.hpp

#include <vector>

#include <list>

#include <set>

#include <stdexcept>

#include <cstring>

#include <cstdlib>

#include <ostream>

#include <functional>

#include <queue>

Defines

CLIPPER_VERSION#

use_lines#

file Hole.h: #include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/basic/Segment.h>

#include <vector>

#include <voronoi/voro/models/basic/IndexSegment.h>

file PolygonalHole.h: #include <vector>

#include <voronoi/voro/models/polygon/Polygon.h>

#include <voronoi/voro/models/hole/Hole.h>

file Mesh.h: #include <voronoi/voro/models/neighbourhood/SegmentMap.h>

#include <utilities/UniqueList.h>

#include <fstream>

#include <voronoi/voro/models/polygon/Polygon.h>

#include <voronoi/voro/models/neighbourhood/PointMap.h>

#include <voronoi/voro/models/polygon/Triangle.h>

file EdgeData.h: #include <iostream>

#include <utilities/utilities.h>

file NeighboursByPoint.h: #include <vector>

file NeighboursBySegment.h: #include <iostream>

#include <utilities/utilities.h>

file PointMap.h: #include <map>

#include <vector>

#include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/neighbourhood/NeighboursByPoint.h>

#include <fstream>

file SegmentMap.h: #include <voronoi/voro/voronoi/structures/mapdata.h>

#include <utilities/Pair.h>

#include <unordered_map>

#include “NeighboursBySegment.h”

#include <fstream>

#include <voronoi/voro/models/basic/IndexSegment.h>

file BoundingBox.h: #include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/basic/PointSegment.h>

file Circle.h: #include <vector>

#include <voronoi/voro/models/basic/Point.h>

#include <cstdlib>

#include <cmath>

#include <voronoi/voro/utilities/geometryFunctions.h>

#include <voronoi/voro/utilities/delynoi_utilities.h>

file Polygon.h: #include <vector>

#include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/basic/Segment.h>

#include <voronoi/voro/utilities/geometryFunctions.h>

#include <voronoi/voro/utilities/convexHull.h>

#include <voronoi/voro/models/basic/IndexSegment.h>

#include <utilities/Pair.h>

#include <map>

#include <utilities/UniqueList.h>

#include <algorithm>

#include <voronoi/voro/models/neighbourhood/SegmentMap.h>

#include <climits>

file models/polygon/Triangle.h: #include <voronoi/voro/models/polygon/Polygon.h>

#include <voronoi/voro/models/neighbourhood/EdgeData.h>

#include <voronoi/voro/voronoi/structures/mapdata.h>

#include <unordered_map>

file voronoi/lib/Triangle.h

Defines

REAL#

VOID#

Functions

void triangulate(char*, struct triangulateio*, struct triangulateio*, struct triangulateio*)#

void trifree(VOID *memptr)#

file Region.h: #include <vector>

#include <voronoi/voro/models/basic/Segment.h>

#include <voronoi/voro/models/hole/Hole.h>

#include <voronoi/voro/models/polygon/Polygon.h>

#include <algorithm>

#include <voronoi/voro/utilities/delynoi_utilities.h>

#include <voronoi/voro/models/generator/PointGenerator.h>

#include <climits>

#include <voronoi/voro/models/hole/PolygonalHole.h>

#include <voronoi/voro/models/hole/clipper/lib/clipper.hpp>

#include <voronoi/voro/models/hole/clipper/ClipperWrapper.h>

#include <voronoi/voro/config/DelynoiConfig.h>

file CenterTriangulationGenerator.h: #include “TriangulationGenerator.h”

file DelaunayTriangulationGenerator.h: #include “TriangulationGenerator.h”

#include <voronoi/voro/models/Region.h>

#include <voronoi/voro/voronoi/TriangleDelaunayGenerator.h>

file EarTriangulationGenerator.h: #include “TriangulationGenerator.h”

file TriangulationGenerator.h: #include <voronoi/voro/models/polygon/Triangle.h>

file convexHull.h: #include <voronoi/voro/models/basic/Point.h>

file delynoi_utilities.h: #include <vector>

#include <iostream>

#include <voronoi/voro/models/basic/Point.h>

#include <utilities/Pair.h>

file geometryFunctions.h: #include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/basic/PointSegment.h>

#include <vector>

file DelaunayToVoronoi.h: #include <voronoi/voro/models/basic/Point.h>

#include <voronoi/voro/models/polygon/Triangle.h>

#include <voronoi/voro/voronoi/structures/DelaunayInfo.h>

#include <voronoi/voro/models/Mesh.h>

#include <chrono>

file DelaunayInfo.h: #include <voronoi/voro/models/polygon/Triangle.h>

#include “PointData.h”

file mapdata.h: #include <functional>

#include <voronoi/voro/models/basic/IndexSegment.h>

file PointData.h

file TriangleDelaunayGenerator.h: #include <voronoi/voro/models/Region.h>

#include <voronoi/voro/voronoi/structures/PointData.h>

#include <voronoi/voro/voronoi/structures/DelaunayInfo.h>

#include <voronoi/voro/models/Mesh.h>

#include <voronoi/voro/utilities/delynoi_utilities.h>

#include <chrono>

#include <voronoi/voro/voronoi/lib/triangle.h>

file TriangleVoronoiGenerator.h: #include <voronoi/voro/voronoi/TriangleDelaunayGenerator.h>

#include <voronoi/voro/voronoi/structures/DelaunayInfo.h>

#include <voronoi/voro/models/Mesh.h>

dir basic

dir clipper

dir config

dir functions

dir generator

dir hole

dir lib

dir lib

dir models

dir neighbourhood

dir noise

dir polygon

dir src

dir structures

dir triangulation

dir utilities

dir utilities

dir voro

dir voronoi

dir voronoi