Files
OpenFOAM-12/applications/test/polygonTriangulate/Test-polygonTriangulate.C
Will Bainbridge 02b97a714a polygonTriangulate: Added robust polygon triangulation algorithm
The new algorithm provides robust quality triangulations of non-convex
polygons. It also produces a best attempt for polygons that are badly
warped or self intersecting by minimising the area in which the local
normal is in the opposite direction to the overal polygon normal. It is
memory efficient when applied to multiple polygons as it maintains and
reuses its workspace.

This algorithm replaces implementations in the face and
faceTriangulation classes, which have been removed.

Faces can no longer be decomposed into mixtures of tris and
quadrilaterals. Polygonal faces with more than 4 sides are now
decomposed into triangles in foamToVTK and in paraFoam.
2021-06-24 10:08:38 +01:00

122 lines
3.4 KiB
C++

/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "clock.H"
#include "OBJstream.H"
#include "polygonTriangulate.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
argList::validArgs.append("number of edges");
argList::addOption
(
"error",
"value",
"polygon error - default is 0"
);
argList::addOption
(
"seed",
"value",
"random number generator seed - default is clock time"
);
argList::addBoolOption
(
"simple",
"assume polygon as no self intersections"
);
argList::addBoolOption
(
"nonOptimal",
"do not optimise the triangulation quality"
);
Foam::argList args(argc, argv);
Info<< nl;
// Get the size of the polygon
const label n = args.argRead<label>(1);
// Initialise the random number generator
label seed;
if (args.optionFound("seed"))
{
seed = args.optionRead<label>("seed");
}
else
{
seed = clock::getTime();
Info<< "Seeding random number generator with value " << seed
<< nl << endl;
}
Random rndGen(seed);
// Get controls
const bool simple = args.optionFound("simple");
const bool nonOptimal = args.optionFound("nonOptimal");
// Generate a random polygon
const List<point> polygon =
polygonTriangulate::randomPolygon
(
rndGen,
n,
args.optionLookupOrDefault<scalar>("error", 0)
);
// Write the polygon
{
OBJstream os(args[0] + "_polygon.obj");
os.write(face(identity(polygon.size())), polygon, false);
}
// Triangulate the polygon
const List<triFace> triPoints =
polygonTriangulate().triangulate(polygon, simple, !nonOptimal);
// Write the triangulation
faceList triFacePoints(triPoints.size());
forAll(triPoints, trii)
{
triFacePoints[trii] = triPoints[trii];
}
{
OBJstream os(args[0] + "_triangulation.obj");
os.write(triFacePoints, pointField(polygon), false);
}
Info<< "End" << nl << endl;
return 0;
}
// ************************************************************************* //