### Features:

Free and open source C++ library for the generation of polygonal meshes on arbitrary domains, based on the constrained Voronoi diagram. It is the built-in polygonal mesh generator of the Veamy library.

- The meshes are generated on arbitrary domains, created from user defined points. Domains have no restrictions on convexity.
- It allows the inclusion of completely contained or intersecting holes, which are processed if required.
- The meshes are generated from seed points, which can be read either directly from a text file, included one by one,

or created from a number of generation rules included in the library. New generation rules can be easily included. - Meshes can be stored in OFF-style text files, or used directly in another program.
- To generate the meshes, the library first computes the conforming Delaunay triangulation using Triangle; the triangulation

is considered as a mesh that is left available for use if needed. Then, it computes the constrained Voronoi diagram.

## Author

Catalina Alvarez – B.Sc., M.Sc., Universidad de Chile.

## Supervisors

Nancy Hitschfeld-Kahler – Associate Professor, Department of Computer Science, Universidad de Chile.

Alejandro Ortiz-Bernardin – Associate Professor, Department of Mechanical Engineering, Universidad de Chile.

## Usage instructions

Delynoi is currently for Unix systems only.

- Download the source code and unpack it.
- In the root directory of Veamy, create a
**build/**folder. - Go to test/ folder located in the root directory of Delynoi and: (a) add the main C++ file

(say,**mytest.cpp**) containing your test example problem, (b) modify the**CMakeLists.txt**

by changing the file name**example.cpp**in`set(SOURCE_FILES example.cpp)`

by the name

of your main C++ file (in this case,**mytest.cpp**) - Inside the
**build**folder and in the command line type:`cmake ..`

to create the makefiles. And to compile the program type:

`make`

- To run your example, go to the
**build/test/**folder and in the command line type:`./Test`

## Usage example

To generate a polygonal mesh, one needs to:

- List, in counterclockwise order, the points that define the domain and

create the domain as a Region instance:`std::vector square_points = {Point(0,0), Point(10,0), Point(10,10), Point(0,10)}; Region square(square_points);`

- Include the required seed points on the domain, for which there are three alternatives:
- Create the points as a list of Point instances, and call:
`std::vector seeds = {Point(5,5)}; square.addSeedPoints(seeds);`

- With the points coordinates listed on a text file, say
**seeds.txt**(an example is found in the

test folder), call:`square.addSeedsFromFile("seeds.txt");`

- Decide on two generation rules (one for each axis) from the predifined list of functions (or create a new one inheriting

following the instructions given in the manual), and create a PointGenerator instance. If required, include a noise function

from the noise list provided. Then, call including the PointGenerator and the number of

points on each axis:`PointGenerator rules(functions::random_double(0,10), functions::random_double(0,10)); int nX = 5, nY = 5; square.generateSeedPoints(rules, nX, nY);`

- Create the points as a list of Point instances, and call:
- Create a TriangleVoronoiGenerator instances with the points inside the domain, and the domain

itself:`std::vector seeds = square.getSeedPoints(); TriangleVoronoiGenerator generator (seeds, square);`

- To obtain the Voronoi diagram, call:
`Mesh voronoi = generator.getMesh();`

- To use the Delaunay triangulation instead of the Voronoi diagram, a different class is used, TriangleDelaunayGenerator,

which can return the constrained Delaunay triangulation or the conforming Delaunay triangulation:`TriangleDelaunayGenerator generator (seeds, square); Mesh constrained_delaunay = generator.getConstrainedDelaunayTriangulation(); Mesh conforming_delaunay = generator.getConformingDelaunayTriangulation();`

It is also possible to define a number of constrained segments inside the domain, that will not be flipped

when the Delaunay triangulation is computed:`Mesh constrained_delaunay = generator.getConstrainedDelaunayTriangulation(restrictedSegments);`

- To print the mesh to a text file use:
`mesh.printInFile("mesh.txt");`

## Acknowledgements

Delynoi depends on two external open source libraries, whose source codes are included in the repository.

- Triangle – A Two-Dimensional Quality Mesh Generator and Delaunay Triangulator.
- Clipper – an open source freeware library for clipping and offsetting lines and polygons.

## License

This project is licensed under the GPL License. This program is free software; it can be redistributed or modified under the terms of the GNU General Public License as published by the Free Software Foundation.

## Download

>> Latest stable version of Delynoi (7-April-2019): **Delynoi v2.0 **

Download: Source code (zip) | Source code (tar.gz) | Delynoi Primer (PDF manual)

GitHub: Browse the source code on GitHub

—

Public stats for Delinoy’s page since 16 FEB 2018