zcy
/
dust3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dust3d/thirdparty/cgal/CGAL-4.13/include/CGAL/Mesh_3/Lloyd_move.h

616 lines
21 KiB
C++
Executable File
Raw Blame History

// Copyright (c) 2009 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
// 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.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0+
//
//
// Author(s) : Stephane Tayeb
//
//******************************************************************************
// File Description : Lloyd move function
//******************************************************************************
#ifndef CGAL_MESH_3_LLOYD_MOVE_H
#define CGAL_MESH_3_LLOYD_MOVE_H
#include <CGAL/license/Mesh_3.h>
#include <CGAL/disable_warnings.h>
#include <CGAL/Mesh_3/config.h>
#include <CGAL/Mesh_3/Uniform_sizing_field.h>
#include <CGAL/Hash_handles_with_or_without_timestamps.h>
#include <CGAL/convex_hull_2.h>
#include <CGAL/ch_graham_andrew.h>
#include <boost/unordered_set.hpp>
#include <iostream>
#include <iterator>
#include <string>
#include <utility>
#include <vector>
namespace CGAL {
namespace Mesh_3 {
template <typename C3T3,
typename SizingField = Uniform_sizing_field<typename C3T3::Triangulation> >
class Lloyd_move
{
typedef typename C3T3::Triangulation Tr;
typedef typename Tr::Geom_traits Gt;
typedef typename Tr::Vertex_handle Vertex_handle;
typedef typename Tr::Edge Edge;
typedef typename Tr::Facet Facet;
typedef typename Tr::Cell_handle Cell_handle;
typedef typename Tr::Bare_point Bare_point;
typedef typename Tr::Weighted_point Weighted_point;
typedef typename std::vector<Facet> Facet_vector;
typedef typename std::vector<Cell_handle> Cell_vector;
typedef typename Gt::FT FT;
typedef typename Gt::Point_2 Point_2;
typedef typename Gt::Vector_3 Vector_3;
typedef typename Gt::Tetrahedron_3 Tetrahedron_3;
typedef typename Gt::Plane_3 Plane_3;
typedef typename Gt::Aff_transformation_3 Aff_transformation_3;
public:
typedef SizingField Sizing_field;
/**
* @brief Return the move to apply on \c v according to Lloyd optimization
* function.
*/
Vector_3 operator()(const Vertex_handle& v,
const Cell_vector& incident_cells,
const C3T3& c3t3,
const Sizing_field& sizing_field = Sizing_field() ) const
{
#ifdef CGAL_MESH_3_OPTIMIZER_DEBUG_VERBOSE
std::cout << "computing move of: " << &*v
<< " pos: " << c3t3.triangulation().point(v)
<< " dim: " << c3t3.in_dimension(v) << std::endl;
#endif
switch ( c3t3.in_dimension(v) )
{
case 3:
return lloyd_move_inside_domain(v,incident_cells,c3t3,sizing_field);
break;
case 2:
return lloyd_move_on_boundary(v,c3t3,sizing_field);
break;
case 1:
case 0:
case -1:
// Don't move edge or corner vertices
// N.B.: dimension = -1 is possible if we added points on a far sphere
// during initialization
return CGAL::NULL_VECTOR;
break;
default:
// Should not happen
CGAL_assertion(false);
return CGAL::NULL_VECTOR;
break;
}
return CGAL::NULL_VECTOR;
}
#if defined(CGAL_MESH_3_OPTIMIZER_VERBOSE) \
|| defined (CGAL_MESH_3_EXPORT_PERFORMANCE_DATA)
static std::string name() { return std::string("Lloyd"); }
#endif
private:
/**
* Project_on_plane defines `operator()` to project a point object on the plane `plane`.
*/
struct Project_on_plane
{
Project_on_plane(const Plane_3& plane, const C3T3& c3t3)
: plane_(plane), c3t3_(c3t3)
{ }
Bare_point operator()(const Bare_point& p) const
{ return c3t3_.triangulation().geom_traits().
construct_projected_point_3_object()(plane_, p); }
private:
const Plane_3& plane_;
const C3T3& c3t3_;
};
/**
* `To_2d` defines `operator()` to transform from `Bare_point` to `Point_2`.
*/
struct To_2d
{
To_2d(const Aff_transformation_3& to_2d) : to_2d_(to_2d) {}
Point_2 operator()(const Bare_point& p) const
{ return Point_2(to_2d_.transform(p).x(), to_2d_.transform(p).y()); }
private:
const Aff_transformation_3& to_2d_;
};
/**
* `To_3d` defines `operator()` to transform from `Point_2` to `Bare_point`.
*/
struct To_3d
{
To_3d(const Aff_transformation_3& to_3d) : to_3d_(to_3d) {}
Bare_point operator()(const Point_2& p) const
{ return to_3d_.transform((Bare_point(p.x(),p.y(),0))); }
private:
const Aff_transformation_3& to_3d_;
};
/**
* Return the move for the inside vertex \c v.
*/
Vector_3 lloyd_move_inside_domain(const Vertex_handle& v,
const Cell_vector& incident_cells,
const C3T3& c3t3,
const Sizing_field& sizing_field) const
{
// Move data
Vector_3 move = CGAL::NULL_VECTOR;
FT sum_masses(0);
// -----------------------------------
// Tessellate Voronoi cell
// -----------------------------------
// Stores vertex that have already been used
typedef CGAL::Hash_handles_with_or_without_timestamps Hash_fct;
typedef boost::unordered_set<Vertex_handle, Hash_fct> Vertex_container;
typedef typename Vertex_container::iterator VC_it;
Vertex_container treated_vertices;
for (typename Cell_vector::const_iterator cit = incident_cells.begin();
cit != incident_cells.end();
++cit)
{
const int& k = (*cit)->index(v);
// For each vertex of the cell
for ( int i=1 ; i<4 ; ++i )
{
const Vertex_handle& v1 = (*cit)->vertex((k+i)&3);
std::pair<VC_it, bool> is_insert_succesful = treated_vertices.insert(v1);
if ( ! is_insert_succesful.second ) // vertex has already been treated
continue;
// Vertex has not been treated: turn around edge(v,v1)
turn_around_edge(v, Edge(*cit,k,(k+i)&3), c3t3,
move, sum_masses, sizing_field);
}
}
CGAL_assertion(sum_masses != 0.0);
return move / sum_masses;
}
/**
* Return the move for the on-boundary vertex \c v.
*/
Vector_3 lloyd_move_on_boundary(const Vertex_handle& v,
const C3T3& c3t3,
const Sizing_field& sizing_field) const
{
CGAL_precondition(c3t3.in_dimension(v) == 2);
// get all surface delaunay ball point
std::vector<Bare_point> points = extract_lloyd_boundary_points(v,c3t3);
switch(points.size())
{
case 0: // could happen if there is an isolated surface point into mesh
case 1: // don't do anything, as the point is already on the surface
{
return CGAL::NULL_VECTOR;
break;
}
case 2: // segment centroid
{
const Bare_point& a = points.front();
const Bare_point& b = points.back();
return centroid_segment_move(v, a, b, c3t3, sizing_field);
break;
}
case 3: // triangle centroid
{
const Bare_point& a = points.at(0);
const Bare_point& b = points.at(1);
const Bare_point& c = points.at(2);
return centroid_triangle_move(v, a, b, c, c3t3, sizing_field);
break;
}
default: // >= 4 points, centroid + projection
return centroid_general_move(v, points.begin(), points.end(), c3t3, sizing_field);
break;
}
return CGAL::NULL_VECTOR;
}
/**
* Returns a vector containing the surface delaunay ball centers of the surface
* facets that are incident to vertex \c v.
*/
std::vector<Bare_point> extract_lloyd_boundary_points(const Vertex_handle& v,
const C3T3& c3t3) const
{
const Tr& tr = c3t3.triangulation();
typename Gt::Construct_point_3 cp = tr.geom_traits().construct_point_3_object();
Facet_vector incident_facets;
incident_facets.reserve(64);
tr.finite_incident_facets(v, std::back_inserter(incident_facets));
std::vector<Bare_point> points;
points.reserve(64);
const Weighted_point& position = tr.point(v);
// Get c3t3's facets incident to v, and add their surface delaunay ball
// center to output
for ( typename Facet_vector::iterator fit = incident_facets.begin() ;
fit != incident_facets.end() ;
++fit )
{
if ( ! c3t3.is_in_complex(*fit) )
continue;
const Cell_handle cell = fit->first;
const int i = fit->second;
// In the case of a periodic triangulation, the incident facets of a point
// do not necessarily have the same offsets. Worse, the surface centers
// might not have the same offset as their facet. Thus, no solution except
// calling a function 'get_closest_point(p, q)' that simply returns q
// for a non-periodic triangulation, and checks all possible offsets for
// periodic triangulations
points.push_back(tr.get_closest_point(cp(position),
cell->get_facet_surface_center(i)));
}
return points;
}
/**
* Return the move from \c v to the centroid of the segment [a,b].
*/
Vector_3 centroid_segment_move(const Vertex_handle& v,
const Bare_point& a,
const Bare_point& b,
const C3T3& c3t3,
const Sizing_field& sizing_field) const
{
typename Gt::Construct_point_3 cp = c3t3.triangulation().geom_traits().construct_point_3_object();
typename Gt::Construct_vector_3 vector = c3t3.triangulation().geom_traits().construct_vector_3_object();
const Weighted_point position = c3t3.triangulation().point(v);
const Bare_point& p = cp(position);
FT da = density_1d(a, v, sizing_field);
FT db = density_1d(b, v, sizing_field);
CGAL_assertion( !is_zero(da + db) );
return ( (vector(p,a)*da + vector(p,b)*db) / (da + db) );
}
/**
* Return the move from \c v to the centroid of triangle [a,b,c].
*/
Vector_3 centroid_triangle_move(const Vertex_handle& v,
const Bare_point& a,
const Bare_point& b,
const Bare_point& c,
const C3T3& c3t3,
const Sizing_field& sizing_field) const
{
typename Gt::Construct_point_3 cp = c3t3.triangulation().geom_traits().construct_point_3_object();
typename Gt::Construct_vector_3 vector = c3t3.triangulation().geom_traits().construct_vector_3_object();
const Weighted_point& position = c3t3.triangulation().point(v);
const Bare_point& p = cp(position);
FT da = density_2d<true>(a,v,sizing_field);
FT db = density_2d<false>(b,v,sizing_field);
FT dc = density_2d<false>(c,v,sizing_field);
CGAL_assertion( !is_zero(da+db+dc) );
return ( (da*vector(p,a) + db*vector(p,b) + dc*vector(p,c)) / (da+db+dc) );
}
/**
* Compute the approximate centroid of the intersection between the 3D voronoi
* cell and the boundary. The input is the set of intersection points between
* Voronoi edges and the boundary.
*/
template <typename ForwardIterator>
Vector_3 centroid_general_move(const Vertex_handle& v,
ForwardIterator first,
ForwardIterator last,
const C3T3& c3t3,
const Sizing_field& sizing_field) const
{
CGAL_assertion(std::distance(first,last) > 3);
// Fit plane using point-based PCA: compute least square fitting plane
Plane_3 plane;
Bare_point point;
CGAL::linear_least_squares_fitting_3(first, last, plane, point, Dimension_tag<0>(),
c3t3.triangulation().geom_traits(),
Default_diagonalize_traits<FT, 3>());
// Project all points to the plane
std::transform(first, last, first, Project_on_plane(plane, c3t3));
CGAL_assertion(std::distance(first, last) > 3);
// Get 2D-3D transformations
Aff_transformation_3 to_3d = compute_to_3d_transform(plane, *first, c3t3);
Aff_transformation_3 to_2d = to_3d.inverse();
// Transform to 2D
std::vector<Point_2> points_2d;
points_2d.reserve(std::distance(first,last));
std::transform(first, last, std::back_inserter(points_2d), To_2d(to_2d));
// Compute 2D convex hull
CGAL_assertion(points_2d.size() > 3);
std::vector<Point_2> ch_2d;
// AF: We have to debug CGAL::convex_hull_2 = ch_akl_toussaint
// as it triggers filter failures unnecessarily
CGAL::ch_graham_andrew(points_2d.begin(),points_2d.end(),
std::back_inserter(ch_2d));
// Lift back convex hull to 3D
std::vector<Bare_point> polygon_3d;
polygon_3d.reserve(ch_2d.size());
std::transform(ch_2d.begin(), ch_2d.end(),
std::back_inserter(polygon_3d), To_3d(to_3d));
// Compute centroid using quadrature sizing
return centroid_3d_polygon_move(v, polygon_3d.begin(), polygon_3d.end(),
c3t3, sizing_field);
}
/**
* Return the move from \c v to the centroid of polygon[first,last].
* The polygon has to be convex.
*/
template <typename ForwardIterator>
Vector_3 centroid_3d_polygon_move(const Vertex_handle& v,
ForwardIterator first,
ForwardIterator last,
const C3T3& c3t3,
const Sizing_field& sizing_field) const
{
CGAL_precondition(std::distance(first,last) >= 3);
typename Gt::Compute_area_3 area = c3t3.triangulation().geom_traits().compute_area_3_object();
typename Gt::Construct_centroid_3 centroid = c3t3.triangulation().geom_traits().construct_centroid_3_object();
typename Gt::Construct_point_3 cp = c3t3.triangulation().geom_traits().construct_point_3_object();
typename Gt::Construct_vector_3 vector = c3t3.triangulation().geom_traits().construct_vector_3_object();
// Vertex current position
const Weighted_point& vertex_weighted_position = c3t3.triangulation().point(v);
const Bare_point& vertex_position = cp(vertex_weighted_position);
// Use as reference point to triangulate
const Bare_point& a = *first++;
const Bare_point* b = &(*first++);
// Treat first point (optimize density_2d call)
const Bare_point& c = *first++;
const Bare_point& triangle_centroid = centroid(a,*b,c);
FT density = density_2d<true>(triangle_centroid, v, sizing_field);
FT sum_masses = density * area(a,*b,c);
Vector_3 move = sum_masses * vector(vertex_position, triangle_centroid);
b = &c;
// Next points
while ( first != last )
{
const Bare_point& c = *first++;
const Bare_point& triangle_centroid = centroid(a,*b,c);
FT density = density_2d<false>(triangle_centroid, v, sizing_field);
FT mass = density * area(a,*b,c);
move = move + mass * vector(vertex_position, triangle_centroid);
sum_masses += mass;
// Go one step forward
b = &c;
}
CGAL_assertion(sum_masses != 0);
return move / sum_masses;
}
/**
* Return the transformation from `reference_point` to `plane`.
*/
Aff_transformation_3 compute_to_3d_transform(const Plane_3& plane,
const Bare_point& reference_point,
const C3T3& c3t3) const
{
typename Gt::Construct_base_vector_3 base = c3t3.triangulation().geom_traits().construct_base_vector_3_object();
typename Gt::Construct_orthogonal_vector_3 orthogonal_vector = c3t3.triangulation().geom_traits().construct_orthogonal_vector_3_object();
Vector_3 u = base(plane, 1);
u = u / CGAL::sqrt(u*u);
Vector_3 v = base(plane, 2);
v = v / CGAL::sqrt(v*v);
Vector_3 w = orthogonal_vector(plane);
w = w / CGAL::sqrt(w*w);
return Aff_transformation_3(u.x(),v.x(),w.x(),reference_point.x(),
u.y(),v.y(),w.y(),reference_point.y(),
u.z(),v.z(),w.z(),reference_point.z());
}
/**
* Return density_1d
*/
template <typename Sizing_field>
FT density_1d(const Bare_point& p,
const Vertex_handle& v,
const Sizing_field& sizing_field) const
{
FT s = sizing_field(p,v);
CGAL_assertion(!is_zero(s));
// s^(d+2)
return ( 1/(s*s*s) );
}
/**
* Return density_2d
*/
template <bool use_v, typename Sizing_field>
FT density_2d(const Bare_point& p,
const Vertex_handle& v,
const Sizing_field& sizing_field) const
{
FT s = use_v ? sizing_field(p,v) : sizing_field(p);
CGAL_assertion(!is_zero(s));
// s^(d+2)
return ( 1/(s*s*s*s) );
}
/**
* Return density_3d
*/
template <typename Sizing_field>
FT density_3d(const Bare_point& p,
const Cell_handle& cell,
const Sizing_field& sizing_field) const
{
FT s = sizing_field(p,cell);
CGAL_assertion(!is_zero(s));
// s^(d+2)
return ( 1/(s*s*s*s*s) );
}
/**
* Turn around the edge \c edge and add the values computed from tets made by
* `v` and the circumcenters of cells incident to \c edge.
*
* Note that this function abundantly uses dual() calls and using a cell base
* which stores the circumcenter thus improves its efficiency.
*/
void turn_around_edge(const Vertex_handle& v,
const Edge& edge,
const C3T3& c3t3,
Vector_3& move,
FT& sum_masses,
const Sizing_field& sizing_field) const
{
CGAL_precondition(c3t3.in_dimension(v) == 3);
typedef typename Tr::Cell_circulator Cell_circulator;
const Tr& tr = c3t3.triangulation();
typename Gt::Construct_centroid_3 centroid = tr.geom_traits().construct_centroid_3_object();
typename Gt::Construct_point_3 cp = tr.geom_traits().construct_point_3_object();
typename Gt::Construct_tetrahedron_3 tetrahedron = tr.geom_traits().construct_tetrahedron_3_object();
typename Gt::Construct_translated_point_3 translate = tr.geom_traits().construct_translated_point_3_object();
typename Gt::Construct_vector_3 vector = tr.geom_traits().construct_vector_3_object();
typename Gt::Compute_volume_3 volume = tr.geom_traits().compute_volume_3_object();
Cell_circulator current_cell = tr.incident_cells(edge);
Cell_circulator done = current_cell;
CGAL_assertion(c3t3.is_in_complex(current_cell));
// a & b are fixed points
const Weighted_point& wa = tr.point(v);
const Bare_point& a = cp(wa);
Bare_point b = tr.dual(current_cell);
const Weighted_point& a_b = tr.point(current_cell, current_cell->index(v));
Vector_3 ba = Vector_3(cp(a_b), b);
++current_cell;
CGAL_assertion(c3t3.is_in_complex(current_cell));
CGAL_assertion(current_cell != done);
// c & d are moving points
Bare_point c = tr.dual(current_cell);
const Weighted_point& a_c = tr.point(current_cell, current_cell->index(v));
Vector_3 ca = Vector_3(cp(a_c), c);
++current_cell;
CGAL_assertion(current_cell != done);
while ( current_cell != done )
{
CGAL_assertion(c3t3.is_in_complex(current_cell));
Bare_point d = tr.dual(current_cell);
const Weighted_point& a_d = tr.point(current_cell, current_cell->index(v));
Vector_3 da = Vector_3(cp(a_d), d);
Tetrahedron_3 tet = tetrahedron(a, translate(a, ba), translate(a, ca), translate(a, da));
Bare_point tet_centroid = centroid(tet);
// Compute mass
FT density = density_3d(tet_centroid, current_cell, sizing_field);
FT abs_volume = CGAL::abs(volume(tet));
FT mass = abs_volume * density;
move = move + mass * vector(a, tet_centroid);
sum_masses += mass;
++current_cell;
c = d;
ca = da;
}
}
};
} // end namespace Mesh_3
} //namespace CGAL
#include <CGAL/enable_warnings.h>
#endif // CGAL_MESH_3_LLOYD_MOVE_H
Reference in New Issue View Git Blame Copy Permalink