zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

cvMesh: Relocated the conformalVoronoiMesh library and localised all uses of CGAL

Browse Source 
Removed unused dependencies on CGAL
This commit is contained in:
Henry
2011-07-22 14:12:08 +01:00
parent 8417b828d6
commit 5f9e3a04f0
71 changed files with 32 additions and 594 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
applications/utilities/surface/surfaceFeatureExtract/CGALPolyhedron/CGALPolyhedronRings.H
View File

@ -1,203 +0,0 @@
#ifndef CGAL_PSURF_RINGS_H_
#define CGAL_PSURF_RINGS_H_
// This file adapted from
// CGAL-3.7/examples/Jet_fitting_3//PolyhedralSurf_rings.h
// Licensed under CGAL-3.7/LICENSE.FREE_USE
// Copyright (c) 1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007
// Utrecht University (The Netherlands), ETH Zurich (Switzerland), Freie
// Universitaet Berlin (Germany), INRIA Sophia-Antipolis (France),
// Martin-Luther-University Halle-Wittenberg (Germany), Max-Planck-Institute
// Saarbruecken (Germany), RISC Linz (Austria), and Tel-Aviv University
// (Israel). All rights reserved.
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include <cassert>
using namespace std;
template
<
class TPoly,
class VertexPropertyMap
>
class T_PolyhedralSurf_rings
{
protected:
//Polyhedron
typedef typename TPoly::Vertex Vertex;
typedef typename TPoly::Halfedge Halfedge;
typedef typename TPoly::Facet Facet;
typedef typename TPoly::Halfedge_around_vertex_circulator
Halfedge_around_vertex_circulator;
typedef typename TPoly::Vertex_iterator Vertex_iterator;
//vertex indices are initialised to -1
static void reset_ring_indices(std::vector < Vertex * >&vces,
VertexPropertyMap& vpm);
// i >= 1; from a start vertex on the current i-1 ring, push non-visited
// neighbors of start in the nextRing and set indices to i. Also add these
// vertices in all.
static void push_neighbours_of(Vertex * start, int ith,
std::vector < Vertex * >&nextRing,
std::vector < Vertex * >&all,
VertexPropertyMap& vpm);
// i >= 1, from a currentRing i-1, collect all neighbors, set indices
// to i and store them in nextRing and all.
static void collect_ith_ring(int ith,
std::vector < Vertex * >&currentRing,
std::vector < Vertex * >&nextRing,
std::vector < Vertex * >&all,
VertexPropertyMap& vpm);
public:
// collect i>=1 rings : all neighbours up to the ith ring,
static void
collect_i_rings(Vertex* v,
int ring_i,
std::vector < Vertex * >& all,
VertexPropertyMap& vpm);
//collect enough rings (at least 1), to get at least min_nb of neighbors
static void
collect_enough_rings(Vertex* v,
unsigned int min_nb,
std::vector < Vertex * >& all,
VertexPropertyMap& vpm);
};
////IMPLEMENTATION////////////////////////////////////////////////////
template < class TPoly , class VertexPropertyMap>
void T_PolyhedralSurf_rings <TPoly, VertexPropertyMap>::
push_neighbours_of(Vertex * start, int ith,
std::vector < Vertex * >&nextRing,
std::vector < Vertex * >&all,
VertexPropertyMap& vpm)
{
Vertex *v;
Halfedge_around_vertex_circulator
hedgeb = start->vertex_begin(), hedgee = hedgeb;
CGAL_For_all(hedgeb, hedgee)
{
v = &*(hedgeb->opposite()->vertex());
if(get(vpm, v) != -1) continue;//if visited: next
put(vpm, v, ith);
nextRing.push_back(v);
all.push_back(v);
}
}
template <class TPoly, class VertexPropertyMap>
void T_PolyhedralSurf_rings <TPoly, VertexPropertyMap>::
collect_ith_ring(int ith, std::vector < Vertex * >&currentRing,
std::vector < Vertex * >&nextRing,
std::vector < Vertex * >&all,
VertexPropertyMap& vpm)
{
typename std::vector < Vertex * >::iterator
itb = currentRing.begin(), ite = currentRing.end();
CGAL_For_all(itb, ite) push_neighbours_of(*itb, ith, nextRing, all, vpm);
}
template <class TPoly, class VertexPropertyMap>
void T_PolyhedralSurf_rings <TPoly, VertexPropertyMap>::
reset_ring_indices(std::vector < Vertex * >&vces,
VertexPropertyMap& vpm)
{
typename std::vector < Vertex * >::iterator
itb = vces.begin(), ite = vces.end();
CGAL_For_all(itb, ite) put(vpm, *itb, -1);
}
template <class TPoly, class VertexPropertyMap>
void T_PolyhedralSurf_rings <TPoly, VertexPropertyMap>::
collect_i_rings(Vertex* v,
int ring_i,
std::vector < Vertex * >& all,
VertexPropertyMap& vpm)
{
std::vector<Vertex*> current_ring, next_ring;
std::vector<Vertex*> *p_current_ring, *p_next_ring;
assert(ring_i >= 1);
//initialize
p_current_ring = &current_ring;
p_next_ring = &next_ring;
put(vpm, v, 0);
current_ring.push_back(v);
all.push_back(v);
for (int i=1; i<=ring_i; i++)
{
collect_ith_ring(i, *p_current_ring, *p_next_ring, all, vpm);
//next round must be launched from p_nextRing...
p_current_ring->clear();
std::swap(p_current_ring, p_next_ring);
}
//clean up
reset_ring_indices(all, vpm);
}
template <class TPoly, class VertexPropertyMap>
void T_PolyhedralSurf_rings <TPoly, VertexPropertyMap>::
collect_enough_rings(Vertex* v,
unsigned int min_nb,
std::vector < Vertex * >& all,
VertexPropertyMap& vpm)
{
std::vector<Vertex*> current_ring, next_ring;
std::vector<Vertex*> *p_current_ring, *p_next_ring;
//initialize
p_current_ring = &current_ring;
p_next_ring = &next_ring;
put(vpm, v, 0);
current_ring.push_back(v);
all.push_back(v);
int i = 1;
while ( (all.size() < min_nb) && (p_current_ring->size() != 0) )
{
collect_ith_ring(i, *p_current_ring, *p_next_ring, all, vpm);
//next round must be launched from p_nextRing...
p_current_ring->clear();
std::swap(p_current_ring, p_next_ring);
i++;
}
//clean up
reset_ring_indices(all, vpm);
}
#endif

89
applications/utilities/surface/surfaceFeatureExtract/CGALPolyhedron/buildCGALPolyhedron.C
View File

@ -1,89 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2011 OpenCFD Ltd.
\\/ 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 "buildCGALPolyhedron.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::buildCGALPolyhedron::buildCGALPolyhedron
(
const Foam::triSurface& surf
)
:
CGAL::Modifier_base<HalfedgeDS>(),
surf_(surf)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::buildCGALPolyhedron::~buildCGALPolyhedron()
{}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
void Foam::buildCGALPolyhedron::operator()
(
HalfedgeDS& hds
)
{
typedef HalfedgeDS::Traits Traits;
typedef Traits::Point_3 Point;
// Postcondition: `hds' is a valid polyhedral surface.
CGAL::Polyhedron_incremental_builder_3<HalfedgeDS> B(hds, false);
B.begin_surface
(
surf_.points().size(), // n points
surf_.size(), // n facets
2*surf_.edges().size() // n halfedges
);
forAll(surf_.points(), pI)
{
const Foam::point& p = surf_.points()[pI];
B.add_vertex(Point(p.x(), p.y(), p.z()));
}
forAll(surf_, fI)
{
B.begin_facet();
B.add_vertex_to_facet(surf_[fI][0]);
B.add_vertex_to_facet(surf_[fI][1]);
B.add_vertex_to_facet(surf_[fI][2]);
B.end_facet();
}
B.end_surface();
}
// ************************************************************************* //

106
applications/utilities/surface/surfaceFeatureExtract/CGALPolyhedron/buildCGALPolyhedron.H
View File

@ -1,106 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2011 OpenCFD Ltd.
\\/ 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/>.
Class
Foam::buildCGALPolyhedron
Description
Convert a triSurface into a CGAL Polyhedron
SourceFiles
buildCGALPolyhedron.C
\*---------------------------------------------------------------------------*/
#ifndef buildCGALPolyhedron_H
#define buildCGALPolyhedron_H
#include "triSurface.H"
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Polyhedron_incremental_builder_3.h>
#include <CGAL/Polyhedron_3.h>
typedef CGAL::Simple_cartesian<double> Kernel;
typedef CGAL::Polyhedron_3<Kernel> Polyhedron;
typedef Polyhedron::HalfedgeDS HalfedgeDS;
typedef Polyhedron::Vertex Vertex;
typedef Polyhedron::Vertex_iterator Vertex_iterator;
typedef Kernel::Point_3 Point_3;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class buildCGALPolyhedron Declaration
\*---------------------------------------------------------------------------*/
class buildCGALPolyhedron
:
public CGAL::Modifier_base<HalfedgeDS>
{
// Private data
//- Reference to triSurface to convert
const Foam::triSurface& surf_;
// Private Member Functions
//- Disallow default bitwise copy construct
buildCGALPolyhedron(const buildCGALPolyhedron&);
//- Disallow default bitwise assignment
void operator=(const buildCGALPolyhedron&);
public:
// Constructors
//- Construct with reference to triSurface
buildCGALPolyhedron(const triSurface& surf);
//- Destructor
~buildCGALPolyhedron();
// Member Operators
//- operator() of this `modifier' called by delegate function of
// Polyhedron
void operator()(HalfedgeDS& hds);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

1
applications/utilities/surface/surfaceFeatureExtract/Make/files
View File

@ -1,4 +1,3 @@
surfaceFeatureExtract.C
/* CGALPolyhedron/buildCGALPolyhedron.C */
EXE = $(FOAM_APPBIN)/surfaceFeatureExtract

36
applications/utilities/surface/surfaceFeatureExtract/Make/options
View File

@ -1,37 +1,3 @@
#if false
EXE_FROUNDING_MATH = -frounding-math
EXE_NDEBUG = -DNDEBUG
USE_F2C = -DCGAL_USE_F2C
include $(GENERAL_RULES)/CGAL
EXE_INC = \
-DENABLE_CURVATURE \
${EXE_FROUNDING_MATH} \
${EXE_NDEBUG} \
${USE_F2C} \
${CGAL_INC} \
-ICGALPolyhedron \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/surfMesh/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude
EXE_LIBS = \
$(CGAL_LIBS) \
-L$(CGAL_ARCH_PATH)/lib \
-llapack \
-lblas \
-lCGAL \
-lmeshTools \
-ledgeMesh \
-ltriSurface \
-lsampling
#else
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
@ -45,5 +11,3 @@ EXE_LIBS = \
-ledgeMesh \
-ltriSurface \
-lsampling
#endif

157
applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
View File

@ -45,14 +45,6 @@ Description
#include "treeDataEdge.H"
#include "unitConversion.H"
#ifdef ENABLE_CURVATURE
#include "buildCGALPolyhedron.H"
#include "CGALPolyhedronRings.H"
#include <CGAL/Monge_via_jet_fitting.h>
#include <CGAL/Lapack/Linear_algebra_lapack.h>
#include <CGAL/property_map.h>
#endif
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -149,155 +141,6 @@ void drawHitProblem
}
#ifdef ENABLE_CURVATURE
scalarField calcCurvature(const triSurface& surf)
{
scalarField k(surf.points().size(), 0);
Polyhedron P;
buildCGALPolyhedron convert(surf);
P.delegate(convert);
// Info<< "Created CGAL Polyhedron with " << label(P.size_of_vertices())
// << " vertices and " << label(P.size_of_facets())
// << " facets. " << endl;
// The rest of this function adapted from
// CGAL-3.7/examples/Jet_fitting_3/Mesh_estimation.cpp
// Licensed under CGAL-3.7/LICENSE.FREE_USE
// Copyright (c) 1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007
// Utrecht University (The Netherlands), ETH Zurich (Switzerland), Freie
// Universitaet Berlin (Germany), INRIA Sophia-Antipolis (France),
// Martin-Luther-University Halle-Wittenberg (Germany), Max-Planck-Institute
// Saarbruecken (Germany), RISC Linz (Austria), and Tel-Aviv University
// (Israel). All rights reserved.
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
// OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
// THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//Vertex property map, with std::map
typedef std::map<Vertex*, int> Vertex2int_map_type;
typedef boost::associative_property_map< Vertex2int_map_type >
Vertex_PM_type;
typedef T_PolyhedralSurf_rings<Polyhedron, Vertex_PM_type > Poly_rings;
typedef CGAL::Monge_via_jet_fitting<Kernel> Monge_via_jet_fitting;
typedef Monge_via_jet_fitting::Monge_form Monge_form;
std::vector<Point_3> in_points; //container for data points
// default parameter values and global variables
unsigned int d_fitting = 2;
unsigned int d_monge = 2;
unsigned int min_nb_points = (d_fitting + 1)*(d_fitting + 2)/2;
//initialize the tag of all vertices to -1
Vertex_iterator vitb = P.vertices_begin();
Vertex_iterator vite = P.vertices_end();
Vertex2int_map_type vertex2props;
Vertex_PM_type vpm(vertex2props);
CGAL_For_all(vitb, vite)
{
put(vpm, &(*vitb), -1);
}
vite = P.vertices_end();
label vertI = 0;
for (vitb = P.vertices_begin(); vitb != vite; vitb++)
{
//initialize
Vertex* v = &(*vitb);
//gather points around the vertex using rings
// From: gather_fitting_points(v, in_points, vpm);
{
std::vector<Vertex*> gathered;
in_points.clear();
Poly_rings::collect_enough_rings(v, min_nb_points, gathered, vpm);
//store the gathered points
std::vector<Vertex*>::iterator itb = gathered.begin();
std::vector<Vertex*>::iterator ite = gathered.end();
CGAL_For_all(itb, ite)
{
in_points.push_back((*itb)->point());
}
}
//skip if the nb of points is to small
if ( in_points.size() < min_nb_points )
{
std::cerr
<< "not enough pts for fitting this vertex"
<< in_points.size()
<< std::endl;
continue;
}
// perform the fitting
Monge_via_jet_fitting monge_fit;
Monge_form monge_form = monge_fit
(
in_points.begin(),
in_points.end(),
d_fitting,
d_monge
);
// std::cout<< monge_form << std::endl;
// std::cout<< "k1 " << monge_form.principal_curvatures(0) << std::endl;
// std::cout<< "k2 " << monge_form.principal_curvatures(1) << std::endl;
// std::vector<Point_3>::iterator itbp = in_points.begin();
// std::vector<Point_3>::iterator itep = in_points.end();
// std::cout << "in_points list : " << std::endl;
// for (; itbp != itep; itbp++)
// {
// std::cout << *itbp << std::endl;
// }
// std::cout << "--- vertex " << vertI
// << " : " << v->point() << std::endl
// << "number of points used : " << in_points.size()
// << std::endl;
k[vertI++] = Foam::sqrt
(
sqr(monge_form.principal_curvatures(0))
+ sqr(monge_form.principal_curvatures(1))
);
}
return k;
}
#endif
// Unmark non-manifold edges if individual triangles are not features
void unmarkBaffles
(