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

391 lines
13 KiB
C++
Executable File
Raw Blame History

// Copyright (c) 2017 GeometryFactory (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) : Mael Rouxel-Labbé
// The purpose of this file is to implement a function 'canonicalize_point()'
// which transforms a point into its canonical representative (the representative
// that belongs to the domain). To improve robustness, the function is allowed
// to modify slightly the position of the point, snapping it to the domain if
// it is epsilon-close (and outside).
//
// Although 'canoncalize_point()' is used by Periodic_3_mesh_3, this file is here
// (in Periodic_3_triangulation_3) because of 'construct_periodic_point()',
// which is a function used in P3T3.h and also needed by 'canonicalize_point()'.
// However, P3M3 needs 'canoncalize_point()' without having access to a triangulation
// and to avoid duplicating it, the function is here.
// Geom_traits must be a model of the concept 'P3T3Traits' for 'construct_periodic_point()'.
// Geom_traits must be a model of the concept 'P3T3RegularTraits' for everything else.
#ifndef CGAL_PERIODIC_3_TRIANGULATION_3_CANONICALIZE_HELPER_H
#define CGAL_PERIODIC_3_TRIANGULATION_3_CANONICALIZE_HELPER_H
#include <CGAL/license/Periodic_3_triangulation_3.h>
#include <CGAL/Periodic_3_triangulation_traits_3.h>
#include <CGAL/Exact_kernel_selector.h>
#include <utility>
namespace CGAL {
namespace P3T3 { // can't name it Periodic_3_triangulation_3 because it's already a class...
namespace internal {
template <typename Gt_>
std::pair<typename Gt_::Point_3, typename Gt_::Periodic_3_offset_3>
construct_periodic_point_exact(const typename Gt_::Point_3& p,
const Gt_& gt)
{
typedef Gt_ Geom_traits;
typedef typename Geom_traits::Periodic_3_offset_3 Offset;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid;
const Iso_cuboid& domain = gt.get_domain();
typedef typename Geom_traits::Kernel K;
typedef typename Exact_kernel_selector<K>::Exact_kernel EK;
typedef typename Exact_kernel_selector<K>::C2E C2E;
C2E to_exact;
typedef Periodic_3_triangulation_traits_3<EK> Exact_traits;
Exact_traits etraits(to_exact(domain));
Offset transl(0, 0, 0);
typename EK::Point_3 ep = to_exact(p);
typename EK::Point_3 dp;
const typename EK::Iso_cuboid_3& exact_domain = etraits.get_domain();
while(true) /* while not in */
{
dp = etraits.construct_point_3_object()(ep, transl);
if(dp.x() < exact_domain.xmin())
transl.x() += 1;
else if(dp.y() < exact_domain.ymin())
transl.y() += 1;
else if(dp.z() < exact_domain.zmin())
transl.z() += 1;
else if(!(dp.x() < exact_domain.xmax()))
transl.x() -= 1;
else if(!(dp.y() < exact_domain.ymax()))
transl.y() -= 1;
else if(!(dp.z() < exact_domain.zmax()))
transl.z() -= 1;
else
break;
}
return std::make_pair(p, transl);
}
// Given a point `p` in space, compute its offset `o` with respect
// to the canonical instance and returns (p, o)
template <typename Gt_>
std::pair<typename Gt_::Point_3, typename Gt_::Periodic_3_offset_3>
construct_periodic_point(const typename Gt_::Point_3& p, bool& encountered_issue, const Gt_& gt)
{
typedef Gt_ Geom_traits;
typedef typename Geom_traits::Point_3 Point;
typedef typename Geom_traits::Periodic_3_offset_3 Offset;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid;
const Iso_cuboid& domain = gt.get_domain();
// Check if p lies within the domain. If not, translate.
if(!(p.x() < domain.xmin()) && p.x() < domain.xmax() &&
!(p.y() < domain.ymin()) && p.y() < domain.ymax() &&
!(p.z() < domain.zmin()) && p.z() < domain.zmax())
return std::make_pair(p, Offset());
typename Geom_traits::Construct_point_3 cp = gt.construct_point_3_object();
// Numerical approximations might create inconsistencies between the constructions
// and the comparisons. For example in a cubic domain of size 2:
// 1. initial point: P(2+1e-17, 0, 0)
// 2. the function computes an offset(1, 0, 0),
// 3. P + (-1, 0, 0) * domain_size constructs Q(-1e-17, 0, 0) // numerical approximation
// 4. the function computes an offset of (-1, 0, 0)
// 5. Q + (1, 0, 0) * domain_size constructs (2+1e-17, 0, 0) (that is P)
// And the function is looping...
//
// If this is happening the 'Last_change' enum will break this infinite
// loop and return the wrong point and the 'encountered_issue' bool will be
// set to 'true'. An exact version of this function should then be called.
enum Last_change {
NO_LAST_CHANGE,
INCREASED_X, DECREASED_X, INCREASED_Y, DECREASED_Y, INCREASED_Z, DECREASED_Z
};
Last_change lc = NO_LAST_CHANGE;
bool in = false;
Offset transl(0, 0, 0);
Point dp;
while(!in)
{
dp = cp(p, transl);
if(dp.x() < domain.xmin())
{
if(lc == DECREASED_X) // stuck in a loop
break;
lc = INCREASED_X;
transl.x() += 1;
}
else if(dp.y() < domain.ymin())
{
if(lc == DECREASED_Y) // stuck in a loop
break;
lc = INCREASED_Y;
transl.y() += 1;
}
else if(dp.z() < domain.zmin())
{
if(lc == DECREASED_Z) // stuck in a loop
break;
lc = INCREASED_Z;
transl.z() += 1;
}
else if(!(dp.x() < domain.xmax()))
{
if(lc == INCREASED_X) // stuck in a loop
break;
lc = DECREASED_X;
transl.x() -= 1;
}
else if(!(dp.y() < domain.ymax()))
{
if(lc == INCREASED_Y) // stuck in a loop
break;
lc = DECREASED_Y;
transl.y() -= 1;
}
else if(!(dp.z() < domain.zmax()))
{
if(lc == INCREASED_Z) // stuck in a loop
break;
lc = DECREASED_Z;
transl.z() -= 1;
}
else
{
in = true;
}
}
std::pair<Point, Offset> pp(p, transl);
if(dp.x() < domain.xmin() || !(dp.x() < domain.xmax()) ||
dp.y() < domain.ymin() || !(dp.y() < domain.ymax()) ||
dp.z() < domain.zmin() || !(dp.z() < domain.zmax()))
{
encountered_issue = true;
pp = construct_periodic_point_exact(p, gt);
}
return pp;
}
template <typename Gt_>
bool
is_point_too_close_to_border(const std::pair<typename Gt_::Point_3,
typename Gt_::Periodic_3_offset_3>& pbp,
const Gt_& gt)
{
typedef Gt_ Geom_traits;
typedef typename Geom_traits::FT FT;
typedef typename Geom_traits::Point_3 Bare_point;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid;
typename Geom_traits::Construct_point_3 cp = gt.construct_point_3_object();
const Bare_point p = cp(pbp.first /*point*/, pbp.second /*offset*/);
const FT px = p.x();
const FT py = p.y();
const FT pz = p.z();
const Iso_cuboid& domain = gt.get_domain();
const FT dxm = domain.xmin();
const FT dym = domain.ymin();
const FT dzm = domain.zmin();
const FT dxM = domain.xmax();
const FT dyM = domain.ymax();
const FT dzM = domain.zmax();
// simply comparing to FT::epsilon() is probably not completely satisfactory
const FT eps = std::numeric_limits<FT>::epsilon();
FT diff = CGAL::abs(px - dxm);
if(diff < eps && diff > 0) return true;
diff = CGAL::abs(px - dxM);
if(diff < eps && diff > 0) return true;
diff = CGAL::abs(py - dym);
if(diff < eps && diff > 0) return true;
diff = CGAL::abs(py - dyM);
if(diff < eps && diff > 0) return true;
diff = CGAL::abs(pz - dzm);
if(diff < eps && diff > 0) return true;
diff = CGAL::abs(pz - dzM);
if(diff < eps && diff > 0) return true;
return false;
}
template <typename Gt_>
typename Gt_::Point_3
snap_to_domain_border(const typename Gt_::Point_3& p, const Gt_& gt)
{
typedef Gt_ Geom_traits;
typedef typename Geom_traits::FT FT;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid;
const FT px = p.x();
const FT py = p.y();
const FT pz = p.z();
FT sx = px, sy = py, sz = pz;
const Iso_cuboid& domain = gt.get_domain();
const FT dxm = domain.xmin();
const FT dym = domain.ymin();
const FT dzm = domain.zmin();
const FT dxM = domain.xmax();
const FT dyM = domain.ymax();
const FT dzM = domain.zmax();
// simply comparing to FT::epsilon() is probably not completely satisfactory
const FT eps = std::numeric_limits<FT>::epsilon();
if(CGAL::abs(px - dxm) < eps) sx = dxm;
if(CGAL::abs(px - dxM) < eps) sx = dxM;
if(CGAL::abs(py - dym) < eps) sy = dym;
if(CGAL::abs(py - dyM) < eps) sy = dyM;
if(CGAL::abs(pz - dzm) < eps) sz = dzm;
if(CGAL::abs(pz - dzM) < eps) sz = dzM;
return gt.construct_point_3_object()(sx, sy, sz);
}
template <typename Gt_>
typename Gt_::Weighted_point_3
snap_to_domain_border(const typename Gt_::Weighted_point_3& p,
const Gt_& gt)
{
typedef Gt_ Geom_traits;
typedef typename Geom_traits::Point_3 Bare_point;
typename Geom_traits::Compute_weight_3 cw = gt.compute_weight_3_object();
const Bare_point snapped_p = snap_to_domain_border(gt.construct_point_3_object()(p), gt);
return gt.construct_weighted_point_3_object()(snapped_p, cw(p));
}
/// transform a bare point (living anywhere in space) into the canonical
/// instance of the same bare point that lives inside the base domain
template <typename Gt_>
typename Gt_::Point_3
robust_canonicalize_point(const typename Gt_::Point_3& p, const Gt_& gt)
{
typedef Gt_ Geom_traits;
typedef typename Geom_traits::Point_3 Bare_point;
typedef typename Geom_traits::Periodic_3_offset_3 Offset;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid;
const Iso_cuboid& domain = gt.get_domain();
if(p.x() >= domain.xmin() && p.x() < domain.xmax() &&
p.y() >= domain.ymin() && p.y() < domain.ymax() &&
p.z() >= domain.zmin() && p.z() < domain.zmax())
return p;
bool should_snap = false;
std::pair<Bare_point, Offset> pbp = construct_periodic_point(p, should_snap, gt);
if(!should_snap)
{
// Even if there is no issue while constructing the canonical point,
// snap the point if it's too close to a border of the domain
should_snap = is_point_too_close_to_border(pbp, gt);
}
if(should_snap)
{
Bare_point sp = snap_to_domain_border(p, gt);
// might have snapped to a 'max' of the domain, which is not in the domain
// note: we could snap to 'min' all the time in 'snap_to_domain_border'
// but this is clearer like that (and costs very little since we should
// not have to use exact computations too often)
return robust_canonicalize_point(sp, gt);
}
typename Geom_traits::Construct_point_3 cp = gt.construct_point_3_object();
Bare_point canonical_p = cp(pbp.first /*point*/, pbp.second /*offset*/);
CGAL_postcondition( !(canonical_p.x() < domain.xmin()) &&
(canonical_p.x() < domain.xmax()) );
CGAL_postcondition( !(canonical_p.y() < domain.ymin()) &&
(canonical_p.y() < domain.ymax()) );
CGAL_postcondition( !(canonical_p.z() < domain.zmin()) &&
(canonical_p.z() < domain.zmax()) );
return canonical_p;
}
/// transform a weighted point (living anywhere in space) into the canonical
/// instance of the same weighted point that lives inside the base domain
template <typename Gt_>
typename Gt_::Weighted_point_3
robust_canonicalize_point(const typename Gt_::Weighted_point_3& wp, const Gt_& gt)
{
typedef Gt_ Geom_traits;
typedef typename Geom_traits::Point_3 Bare_point;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid;
const Iso_cuboid& domain = gt.get_domain();
if(wp.x() >= domain.xmin() && wp.x() < domain.xmax() &&
wp.y() >= domain.ymin() && wp.y() < domain.ymax() &&
wp.z() >= domain.zmin() && wp.z() < domain.zmax())
return wp;
typename Geom_traits::Construct_point_3 cp = gt.construct_point_3_object();
typename Geom_traits::Compute_weight_3 cw = gt.compute_weight_3_object();
typename Geom_traits::Construct_weighted_point_3 cwp = gt.construct_weighted_point_3_object();
const Bare_point& bp = cp(wp);
Bare_point canonical_point = robust_canonicalize_point(bp, gt);
return cwp(canonical_point, cw(wp));
}
} // end namespace internal
} // end namespace Periodic_3_triangulation_3
} // end namespace CGAL
#endif // CGAL_PERIODIC_3_TRIANGULATION_3_CANONICALIZE_HELPER_H
Reference in New Issue View Git Blame Copy Permalink