616 lines
21 KiB
C
616 lines
21 KiB
C
|
// 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
|