songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

removing AABB_filtered_traits_2.h and AABB_statically_filtered_traits_2.h

This commit is contained in:
Sven Oesau 2025-11-06 15:55:34 +01:00
parent c68c64e727
commit 910ef27657
4 changed files with 289 additions and 408 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

431
AABB_tree/include/CGAL/AABB_traits_2.h
View File

@ -26,6 +26,9 @@
#include <CGAL/AABB_tree/internal/Is_ray_intersection_geomtraits.h> #include <CGAL/AABB_tree/internal/Is_ray_intersection_geomtraits.h>
#include <CGAL/AABB_tree/internal/Primitive_helper.h> #include <CGAL/AABB_tree/internal/Primitive_helper.h>
#include <CGAL/AABB_tree/internal/Remove_optional.h> #include <CGAL/AABB_tree/internal/Remove_optional.h>
#include <CGAL/Filtered_predicate.h>
#include <CGAL/Filtered_kernel/internal/Static_filters/Static_filter_error.h>
#include <CGAL/Filtered_kernel/internal/Static_filters/tools.h>
#include <CGAL/Kernel_23/internal/Has_boolean_tags.h> #include <CGAL/Kernel_23/internal/Has_boolean_tags.h>
#include <CGAL/Search_traits_2.h> #include <CGAL/Search_traits_2.h>
#include <optional> #include <optional>
@ -120,6 +123,256 @@ public:
Intersection_distance intersection_distance_object() const { return Intersection_distance(); } Intersection_distance intersection_distance_object() const { return Intersection_distance(); }
}; };
template<typename GeomTraits>
class Compare_distance {
typedef typename GeomTraits::Point_2 Point;
typedef typename GeomTraits::FT FT;
/// Bounding box type.
typedef typename CGAL::Bbox_2 Bounding_box;
public:
CGAL::Comparison_result operator()(const Point& p, const Bounding_box& bb, const Point& bound) const
{
return do_intersect_circle_iso_rectangle_2
(GeomTraits().construct_circle_2_object()
(p, GeomTraits().compute_squared_distance_2_object()(p, bound)), bb) ?
CGAL::SMALLER : CGAL::LARGER;
}
template <class Solid>
CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const Point& bound) const
{
return GeomTraits().do_intersect_2_object()
(GeomTraits().construct_circle_2_object()
(p, GeomTraits().compute_squared_distance_2_object()(p, bound)), pr) ?
CGAL::SMALLER : CGAL::LARGER;
}
template <class Solid>
CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const FT& sq_distance) const
{
return GeomTraits().do_intersect_2_object()
(GeomTraits().construct_circle_2_object()(p, sq_distance),
pr) ?
CGAL::SMALLER :
CGAL::LARGER;
}
typename GeomTraits::Boolean do_intersect_circle_iso_rectangle_2(const typename GeomTraits::Circle_2& circle,
const typename GeomTraits::Iso_rectangle_2& rec) const
{
typedef typename GeomTraits::FT FT;
typedef typename GeomTraits::Point_2 Point;
Point center = circle.center();
// Check that the minimum distance to the box is smaller than the radius, otherwise there is
// no intersection. `distance` stays at 0 if the center is inside or on `rec`.
FT distance = FT(0);
if (center.x() < rec.xmin())
{
FT d = rec.xmin() - center.x();
distance += d * d;
}
else if (center.x() > rec.xmax())
{
FT d = center.x() - rec.xmax();
distance += d * d;
}
if (center.y() < rec.ymin())
{
FT d = rec.ymin() - center.y();
distance += d * d;
}
else if (center.y() > rec.ymax())
{
FT d = center.y() - rec.ymax();
distance += d * d;
}
if (distance <= circle.squared_radius())
return true;
return false;
}
};
template <typename GeomTraits, bool Has_filtered_predicates = internal::Has_filtered_predicates<GeomTraits>::value, bool Has_static_filters = internal::Has_static_filters<GeomTraits>::value>
class Compare_distance_getter_2 {};
template <typename GeomTraits>
class Compare_distance_getter_2<GeomTraits, false, false> {
// this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.)
// depending on that it defines
public:
typedef Compare_distance<GeomTraits> type;
static Compare_distance<GeomTraits> compare_distance_object() {
return Compare_distance<GeomTraits>();
}
};
template <typename GeomTraits>
class Compare_distance_getter_2<GeomTraits, true, false> {
// this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.)
// depending on that it defines
typedef GeomTraits Kernel;
typedef typename Kernel::Exact_kernel EKernel;
typedef typename Kernel::Approximate_kernel AKernel;
typedef typename Kernel::C2E C2E;
typedef typename Kernel::C2F C2F;
typedef Compare_distance<EKernel> Exact_functor;
typedef Compare_distance<AKernel> Filtered_functor;
public:
typedef Filtered_predicate<Exact_functor, Filtered_functor,
C2E, C2F> Compare_distance_pred;
typedef Compare_distance_pred type;
static Compare_distance_pred compare_distance_object() {
return Compare_distance_pred(Exact_functor(), Filtered_functor());
}
};
template <typename GeomTraits>
class Compare_distance_getter_2<GeomTraits, true, true> {
// this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.)
// depending on that it defines
class Statically_filtered_compare_distance {
public:
typedef typename GeomTraits::Point_2 Point;
typedef typename GeomTraits::FT FT;
typedef typename GeomTraits::Circle_2 Circle_2;
/// Bounding box type.
typedef CGAL::Bbox_2 Bounding_box;
template <class Solid>
CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const Point& bound) const {
return Compare_distance_getter_2<GeomTraits, true, false>::compare_distance_object()(p, pr, bound);
}
template <class Solid>
CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const FT& sq_distance) const {
return Compare_distance_getter_2<GeomTraits, true, false>::compare_distance_object()(p, pr, sq_distance);
}
Comparison_result operator()(const Point& p, const Bounding_box& b, const Point& bound) const {
Circle_2 s = GeomTraits().construct_circle_2_object()(p, GeomTraits().compute_squared_distance_2_object()(p, bound));
CGAL_BRANCH_PROFILER_3(std::string("semi-static failures/attempts/calls to : ") +
std::string(CGAL_PRETTY_FUNCTION), tmp);
internal::Static_filters_predicates::Get_approx<Point> get_approx; // Identity functor for all points
const Point& c = s.center();
double scx, scy, ssr;
double bxmin = b.xmin(), bymin = b.ymin(),
bxmax = b.xmax(), bymax = b.ymax();
if (internal::fit_in_double(get_approx(c).x(), scx) &&
internal::fit_in_double(get_approx(c).y(), scy) &&
internal::fit_in_double(s.squared_radius(), ssr))
{
CGAL_BRANCH_PROFILER_BRANCH_1(tmp);
if ((ssr < 1.11261183279326254436e-293) || (ssr > 2.80889552322236673473e+306)) {
CGAL_BRANCH_PROFILER_BRANCH_2(tmp);
return Compare_distance_getter_2<GeomTraits, true, false>::compare_distance_object()(p, b, bound);
}
double distance = 0;
double max1 = 0;
double double_tmp_result = 0;
double eps = 0;
if (scx < bxmin)
{
double bxmin_scx = bxmin - scx;
max1 = bxmin_scx;
distance = square(bxmin_scx);
double_tmp_result = (distance - ssr);
if ((max1 < 3.33558365626356687717e-147) || (max1 > 1.67597599124282407923e+153))
return CGAL::SMALLER;
eps = 1.99986535548615598560e-15 * (std::max)(ssr, square(max1));
if (double_tmp_result > eps)
return CGAL::LARGER;
}
else if (scx > bxmax)
{
double scx_bxmax = scx - bxmax;
max1 = scx_bxmax;
distance = square(scx_bxmax);
double_tmp_result = (distance - ssr);
if ((max1 < 3.33558365626356687717e-147) || (max1 > 1.67597599124282407923e+153))
return CGAL::SMALLER;
eps = 1.99986535548615598560e-15 * (std::max)(ssr, square(max1));
if (double_tmp_result > eps)
return CGAL::LARGER;
}
if (scy < bymin)
{
double bymin_scy = bymin - scy;
if (max1 < bymin_scy) {
max1 = bymin_scy;
}
distance += square(bymin_scy);
double_tmp_result = (distance - ssr);
if ((max1 < 3.33558365626356687717e-147) || ((max1 > 1.67597599124282407923e+153)))
return CGAL::SMALLER;
eps = 1.99986535548615598560e-15 * (std::max)(ssr, square(max1));
if (double_tmp_result > eps) {
return CGAL::LARGER;
}
}
else if (scy > bymax)
{
double scy_bymax = scy - bymax;
if (max1 < scy_bymax) {
max1 = scy_bymax;
}
distance += square(scy_bymax);
double_tmp_result = (distance - ssr);
if (((max1 < 3.33558365626356687717e-147)) || ((max1 > 1.67597599124282407923e+153)))
return CGAL::SMALLER;
eps = 1.99986535548615598560e-15 * (std::max)(ssr, square(max1));
if (double_tmp_result > eps)
return CGAL::LARGER;
}
// double_tmp_result and eps were growing all the time
// no need to test for > eps as done earlier in at least one case
return CGAL::SMALLER;
}
return Compare_distance_getter_2<GeomTraits, true, false>::compare_distance_object()(p, b, bound);
}
};
public:
typedef Statically_filtered_compare_distance type;
static Statically_filtered_compare_distance compare_distance_object() {
return Statically_filtered_compare_distance();
}
};
} } //end of namespace internal::AABB_tree } } //end of namespace internal::AABB_tree
/// \addtogroup PkgAABBTreeRef /// \addtogroup PkgAABBTreeRef
@ -130,7 +383,7 @@ template< typename AABBTraits>
class AABB_tree; class AABB_tree;
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap = Default> template<typename GeomTraits, typename AABBPrimitive, typename BboxMap = Default>
class AABB_traits_base_2 class AABB_traits_2
#ifndef DOXYGEN_RUNNING #ifndef DOXYGEN_RUNNING
: public internal::AABB_tree::AABB_traits_base<AABBPrimitive>, : public internal::AABB_tree::AABB_traits_base<AABBPrimitive>,
public internal::AABB_tree::AABB_traits_intersection_base_2<GeomTraits>, public internal::AABB_tree::AABB_traits_intersection_base_2<GeomTraits>,
@ -141,7 +394,7 @@ class AABB_traits_base_2
typedef GeomTraits Geom_traits; typedef GeomTraits Geom_traits;
public: public:
typedef AABB_traits_base_2<GeomTraits, AABBPrimitive, BboxMap> AT; typedef AABB_traits_2<GeomTraits, AABBPrimitive, BboxMap> AT;
// AABBTraits concept types // AABBTraits concept types
typedef typename GeomTraits::FT FT; typedef typename GeomTraits::FT FT;
typedef AABBPrimitive Primitive; typedef AABBPrimitive Primitive;
@ -195,9 +448,9 @@ public:
BboxMap bbm; BboxMap bbm;
/// Default constructor. /// Default constructor.
AABB_traits_base_2() { } AABB_traits_2() { }
AABB_traits_base_2(BboxMap bbm) AABB_traits_2(BboxMap bbm)
: bbm(bbm) : bbm(bbm)
{} {}
@ -220,10 +473,10 @@ public:
*/ */
class Split_primitives class Split_primitives
{ {
typedef AABB_traits_base_2<GeomTraits,AABBPrimitive,BboxMap> Traits; typedef AABB_traits_2<GeomTraits,AABBPrimitive,BboxMap> Traits;
const Traits& m_traits; const Traits& m_traits;
public: public:
Split_primitives(const AABB_traits_base_2<GeomTraits,AABBPrimitive,BboxMap>& traits) Split_primitives(const AABB_traits_2<GeomTraits,AABBPrimitive,BboxMap>& traits)
: m_traits(traits) {} : m_traits(traits) {}
typedef void result_type; typedef void result_type;
@ -257,9 +510,9 @@ public:
* @return the bounding box of the primitives of the iterator range * @return the bounding box of the primitives of the iterator range
*/ */
class Compute_bbox { class Compute_bbox {
const AABB_traits_base_2<GeomTraits,AABBPrimitive, BboxMap>& m_traits; const AABB_traits_2<GeomTraits,AABBPrimitive, BboxMap>& m_traits;
public: public:
Compute_bbox(const AABB_traits_base_2<GeomTraits,AABBPrimitive, BboxMap>& traits) Compute_bbox(const AABB_traits_2<GeomTraits,AABBPrimitive, BboxMap>& traits)
:m_traits (traits) {} :m_traits (traits) {}
template<typename ConstPrimitiveIterator> template<typename ConstPrimitiveIterator>
@ -282,9 +535,9 @@ public:
/// In the case the query is a `CGAL::AABB_tree`, the `do_intersect()` /// In the case the query is a `CGAL::AABB_tree`, the `do_intersect()`
/// function of this tree is used. /// function of this tree is used.
class Do_intersect { class Do_intersect {
const AABB_traits_base_2<GeomTraits,AABBPrimitive, BboxMap>& m_traits; const AABB_traits_2<GeomTraits,AABBPrimitive, BboxMap>& m_traits;
public: public:
Do_intersect(const AABB_traits_base_2<GeomTraits,AABBPrimitive, BboxMap>& traits) Do_intersect(const AABB_traits_2<GeomTraits,AABBPrimitive, BboxMap>& traits)
:m_traits(traits) {} :m_traits(traits) {}
template<typename Query> template<typename Query>
@ -317,9 +570,9 @@ public:
class Intersection { class Intersection {
const AABB_traits_base_2<GeomTraits,AABBPrimitive,BboxMap>& m_traits; const AABB_traits_2<GeomTraits,AABBPrimitive,BboxMap>& m_traits;
public: public:
Intersection(const AABB_traits_base_2<GeomTraits,AABBPrimitive,BboxMap>& traits) Intersection(const AABB_traits_2<GeomTraits,AABBPrimitive,BboxMap>& traits)
:m_traits(traits) {} :m_traits(traits) {}
template<typename Query> template<typename Query>
std::optional< typename Intersection_and_primitive_id<Query>::Type > std::optional< typename Intersection_and_primitive_id<Query>::Type >
@ -338,9 +591,9 @@ public:
class Closest_point { class Closest_point {
typedef typename AT::Point Point; typedef typename AT::Point Point;
typedef typename AT::Primitive Primitive; typedef typename AT::Primitive Primitive;
const AABB_traits_base_2<GeomTraits,AABBPrimitive, BboxMap>& m_traits; const AABB_traits_2<GeomTraits,AABBPrimitive, BboxMap>& m_traits;
public: public:
Closest_point(const AABB_traits_base_2<GeomTraits,AABBPrimitive, BboxMap>& traits) Closest_point(const AABB_traits_2<GeomTraits,AABBPrimitive, BboxMap>& traits)
: m_traits(traits) {} : m_traits(traits) {}
@ -355,85 +608,10 @@ public:
} }
}; };
// This should go down to the GeomTraits, i.e. the kernel typedef typename internal::AABB_tree::Compare_distance_getter_2<GeomTraits>::type Compare_distance;
// and the internal implementation should change its name from
// do_intersect to something like does_contain (this is what we compute,
// this is not the same do_intersect as the spherical kernel)
class Compare_distance {
typedef typename AT::Point Point;
typedef typename AT::FT FT;
typedef typename AT::Primitive Primitive;
public:
CGAL::Comparison_result operator()(const Point& p, const Bounding_box& bb, const Point& bound) const
{
return do_intersect_circle_iso_rectangle_2
(GeomTraits().construct_circle_2_object()
(p, GeomTraits().compute_squared_distance_2_object()(p, bound)), bb) ?
CGAL::SMALLER : CGAL::LARGER;
}
// The following functions seem unused...? Closest_point closest_point_object() const { return Closest_point(*this); }
template <class Solid> Compare_distance compare_distance_object() const { return internal::AABB_tree::Compare_distance_getter_2<GeomTraits>::compare_distance_object(); }
CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const Point& bound) const
{
return GeomTraits().do_intersect_2_object()
(GeomTraits().construct_circle_2_object()
(p, GeomTraits().compute_squared_distance_2_object()(p, bound)), pr)?
CGAL::SMALLER : CGAL::LARGER;
}
template <class Solid>
CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const FT& sq_distance) const
{
return GeomTraits().do_intersect_2_object()
(GeomTraits().construct_circle_2_object()(p, sq_distance),
pr) ?
CGAL::SMALLER :
CGAL::LARGER;
}
typename GeomTraits::Boolean do_intersect_circle_iso_rectangle_2(const typename GeomTraits::Circle_2& circle,
const typename GeomTraits::Iso_rectangle_2& rec) const
{
typedef typename GeomTraits::FT FT;
typedef typename GeomTraits::Point_2 Point;
Point center = circle.center();
// Check that the minimum distance to the box is smaller than the radius, otherwise there is
// no intersection. `distance` stays at 0 if the center is inside or on `rec`.
FT distance = FT(0);
if (center.x() < rec.xmin())
{
FT d = rec.xmin() - center.x();
distance += d * d;
}
else if (center.x() > rec.xmax())
{
FT d = center.x() - rec.xmax();
distance += d * d;
}
if (center.y() < rec.ymin())
{
FT d = rec.ymin() - center.y();
distance += d * d;
}
else if (center.y() > rec.ymax())
{
FT d = center.y() - rec.ymax();
distance += d * d;
}
if (distance <= circle.squared_radius())
return true;
return false;
}
};
Closest_point closest_point_object() const {return Closest_point(*this);}
Compare_distance compare_distance_object() const {return Compare_distance();}
typedef enum { CGAL_AXIS_X = 0, typedef enum { CGAL_AXIS_X = 0,
CGAL_AXIS_Y = 1} Axis; CGAL_AXIS_Y = 1} Axis;
@ -458,26 +636,26 @@ private:
} }
/// Comparison functions /// Comparison functions
static bool less_x(const Primitive& pr1, const Primitive& pr2,const AABB_traits_base_2<GeomTraits,AABBPrimitive, BboxMap>& traits) static bool less_x(const Primitive& pr1, const Primitive& pr2,const AABB_traits_2<GeomTraits,AABBPrimitive, BboxMap>& traits)
{ {
return GeomTraits().less_x_2_object()( internal::Primitive_helper<AT>::get_reference_point(pr1,traits), return GeomTraits().less_x_2_object()( internal::Primitive_helper<AT>::get_reference_point(pr1,traits),
internal::Primitive_helper<AT>::get_reference_point(pr2,traits) ); internal::Primitive_helper<AT>::get_reference_point(pr2,traits) );
} }
static bool less_y(const Primitive& pr1, const Primitive& pr2,const AABB_traits_base_2<GeomTraits,AABBPrimitive, BboxMap>& traits) static bool less_y(const Primitive& pr1, const Primitive& pr2,const AABB_traits_2<GeomTraits,AABBPrimitive, BboxMap>& traits)
{ {
return GeomTraits().less_y_2_object()( internal::Primitive_helper<AT>::get_reference_point(pr1,traits), return GeomTraits().less_y_2_object()( internal::Primitive_helper<AT>::get_reference_point(pr1,traits),
internal::Primitive_helper<AT>::get_reference_point(pr2,traits) ); internal::Primitive_helper<AT>::get_reference_point(pr2,traits) );
} }
}; // end class AABB_traits_base_2 }; // end class AABB_traits_2
//------------------------------------------------------- //-------------------------------------------------------
// Private methods // Private methods
//------------------------------------------------------- //-------------------------------------------------------
template<typename GT, typename P, typename B> template<typename GT, typename P, typename B>
typename AABB_traits_base_2<GT,P,B>::Axis typename AABB_traits_2<GT,P,B>::Axis
AABB_traits_base_2<GT,P,B>::longest_axis(const Bounding_box& bbox) AABB_traits_2<GT,P,B>::longest_axis(const Bounding_box& bbox)
{ {
const double dx = bbox.xmax() - bbox.xmin(); const double dx = bbox.xmax() - bbox.xmin();
const double dy = bbox.ymax() - bbox.ymin(); const double dy = bbox.ymax() - bbox.ymin();
@ -491,65 +669,6 @@ private:
return CGAL_AXIS_Y; return CGAL_AXIS_Y;
} }
} }
}
//-------------------------------------------------------
// Filtered traits
//-------------------------------------------------------
#include <CGAL/AABB_tree/internal/AABB_filtered_traits_2.h>
namespace CGAL {
/// This traits class handles any type of 2D geometric
/// primitives provided that the proper intersection tests and
/// constructions are implemented. It handles points, rays, lines and
/// segments as query types for intersection detection and
/// computations, and it handles points as query type for distance
/// queries.
///
/// \cgalModels{AABBTraits,AABBRayIntersectionTraits}
///
/// \tparam GeomTraits must be a model of the concept \ref AABBGeomTraits_2,
/// and provide the geometric types as well as the intersection tests and computations.
/// \tparam Primitive provide the type of primitives stored in the AABB_tree.
/// It is a model of the concept `AABBPrimitive` or `AABBPrimitiveWithSharedData`.
///
/// \tparam BboxMap must be a model of `ReadablePropertyMap` that has as key type a primitive id,
/// and as value type a `Bounding_box`.
/// If the type is `Default` the `Datum` must have the
/// member function `bbox()` that returns the bounding box of the primitive.
///
/// If the argument `GeomTraits` is a model of the concept \ref
/// AABBRayIntersectionGeomTraits_2, this class is also a model of \ref
/// AABBRayIntersectionTraits.
///
/// \sa `AABBTraits`
/// \sa `AABB_tree`
/// \sa `AABBPrimitive`
/// \sa `AABBPrimitiveWithSharedData`
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap = Default, bool Has_filtered_predicates_ = internal::Has_filtered_predicates<GeomTraits>::value>
class AABB_traits_2;
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap>
class AABB_traits_2<GeomTraits, AABBPrimitive, BboxMap, false> : public AABB_traits_base_2<GeomTraits, AABBPrimitive, BboxMap> {
using Base = AABB_traits_base_2<GeomTraits, AABBPrimitive, BboxMap>;
public:
AABB_traits_2() : Base() {}
AABB_traits_2(BboxMap bbm) : Base(bbm) {}
};
template<class GeomTraits, typename AABBPrimitive, typename BboxMap>
class AABB_traits_2<GeomTraits, AABBPrimitive, BboxMap, true> : public AABB_filtered_traits_2<GeomTraits, AABBPrimitive, BboxMap> {
using Base = AABB_filtered_traits_2<GeomTraits, AABBPrimitive, BboxMap>;
public:
AABB_traits_2() : Base() {}
AABB_traits_2(BboxMap bbm) : Base(bbm) {}
};
/// @}
} // end namespace CGAL } // end namespace CGAL

29
AABB_tree/include/CGAL/AABB_traits_3.h
View File

@ -251,10 +251,10 @@ public:
}; };
template <typename GeomTraits, bool Has_filtered_predicates = internal::Has_filtered_predicates<GeomTraits>::value, bool Has_static_filters = internal::Has_static_filters<GeomTraits>::value> template <typename GeomTraits, bool Has_filtered_predicates = internal::Has_filtered_predicates<GeomTraits>::value, bool Has_static_filters = internal::Has_static_filters<GeomTraits>::value>
class Compare_distance_getter {}; class Compare_distance_getter_3 {};
template <typename GeomTraits> template <typename GeomTraits>
class Compare_distance_getter<GeomTraits, false, false> { class Compare_distance_getter_3<GeomTraits, false, false> {
// this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.) // this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.)
// depending on that it defines // depending on that it defines
public: public:
@ -265,7 +265,7 @@ public:
}; };
template <typename GeomTraits> template <typename GeomTraits>
class Compare_distance_getter<GeomTraits, true, false> { class Compare_distance_getter_3<GeomTraits, true, false> {
// this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.) // this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.)
// depending on that it defines // depending on that it defines
@ -290,27 +290,26 @@ public:
}; };
template <typename GeomTraits> template <typename GeomTraits>
class Compare_distance_getter<GeomTraits, true, true> { class Compare_distance_getter_3<GeomTraits, true, true> {
// this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.) // this class is in charge of checking what K provides (i.e., can we use filtered predicates, can we use statically filtered predicates, etc.)
// depending on that it defines // depending on that it defines
class Statically_filtered_compare_distance { class Statically_filtered_compare_distance {
public:
typedef typename GeomTraits::Point_3 Point; typedef typename GeomTraits::Point_3 Point;
typedef typename GeomTraits::FT FT; typedef typename GeomTraits::FT FT;
typedef typename GeomTraits::Boolean Boolean; typedef typename GeomTraits::Boolean Boolean;
/// Bounding box type. /// Bounding box type.
typedef typename CGAL::Bbox_3 Bounding_box; typedef CGAL::Bbox_3 Bounding_box;
public:
template <class Solid> template <class Solid>
CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const Point& bound) const { CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const Point& bound) const {
return Compare_distance_getter<GeomTraits, true, false>::compare_distance_object()(p, pr, bound); return Compare_distance_getter_3<GeomTraits, true, false>::compare_distance_object()(p, pr, bound);
} }
template <class Solid> template <class Solid>
CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const FT& sq_distance) const { CGAL::Comparison_result operator()(const Point& p, const Solid& pr, const FT& sq_distance) const {
return Compare_distance_getter<GeomTraits, true, false>::compare_distance_object()(p, pr, sq_distance); return Compare_distance_getter_3<GeomTraits, true, false>::compare_distance_object()(p, pr, sq_distance);
} }
Comparison_result operator()(const Point& p, const Bounding_box& b, const Point& bound) const { Comparison_result operator()(const Point& p, const Bounding_box& b, const Point& bound) const {
@ -334,7 +333,7 @@ class Compare_distance_getter<GeomTraits, true, true> {
if ((ssr < 1.11261183279326254436e-293) || (ssr > 2.80889552322236673473e+306)) { if ((ssr < 1.11261183279326254436e-293) || (ssr > 2.80889552322236673473e+306)) {
CGAL_BRANCH_PROFILER_BRANCH_2(tmp); CGAL_BRANCH_PROFILER_BRANCH_2(tmp);
return Compare_distance_getter<GeomTraits, true, false>::compare_distance_object()(p, b, bound); return Compare_distance_getter_3<GeomTraits, true, false>::compare_distance_object()(p, b, bound);
} }
double distance = 0; double distance = 0;
double max1 = 0; double max1 = 0;
@ -453,7 +452,7 @@ class Compare_distance_getter<GeomTraits, true, true> {
CGAL_BRANCH_PROFILER_BRANCH_2(tmp); CGAL_BRANCH_PROFILER_BRANCH_2(tmp);
} }
return Compare_distance_getter<GeomTraits, true, false>::compare_distance_object()(p, b, bound); return Compare_distance_getter_3<GeomTraits, true, false>::compare_distance_object()(p, b, bound);
} }
}; };
public: public:
@ -730,10 +729,10 @@ public:
} }
}; };
typedef typename internal::AABB_tree::Compare_distance_getter<GeomTraits>::type Compare_distance; typedef typename internal::AABB_tree::Compare_distance_getter_3<GeomTraits>::type Compare_distance;
Closest_point closest_point_object() const {return Closest_point(*this);} Closest_point closest_point_object() const {return Closest_point(*this);}
Compare_distance compare_distance_object() const {return internal::AABB_tree::Compare_distance_getter<GeomTraits>::compare_distance_object();} Compare_distance compare_distance_object() const {return internal::AABB_tree::Compare_distance_getter_3<GeomTraits>::compare_distance_object();}
typedef enum { CGAL_AXIS_X = 0, typedef enum { CGAL_AXIS_X = 0,
CGAL_AXIS_Y = 1, CGAL_AXIS_Y = 1,
@ -775,7 +774,7 @@ private:
internal::Primitive_helper<AT>::get_reference_point(pr2,traits) ); internal::Primitive_helper<AT>::get_reference_point(pr2,traits) );
} }
}; // end class AABB_traits_base_3 }; // end class AABB_traits_3
//------------------------------------------------------- //-------------------------------------------------------
@ -813,8 +812,6 @@ private:
} }
} }
/// @}
} // end namespace CGAL } // end namespace CGAL
#include <CGAL/enable_warnings.h> #include <CGAL/enable_warnings.h>

85
AABB_tree/include/CGAL/AABB_tree/internal/AABB_filtered_traits_2.h
View File

@ -1,85 +0,0 @@
// Copyright (c) 2024 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : Stéphane Tayeb, Pierre Alliez, Camille Wormser
//
#ifndef CGAL_AABB_FILTERED_TRAITS_2_H
#define CGAL_AABB_FILTERED_TRAITS_2_H
#include <CGAL/license/AABB_tree.h>
#include <CGAL/AABB_traits_2.h>
#include <CGAL/Filtered_predicate.h>
namespace CGAL {
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap = Default>
class AABB_filtered_traits_base_2 : public AABB_traits_base_2<GeomTraits, AABBPrimitive, BboxMap> {
using Base = AABB_traits_base_2<GeomTraits, AABBPrimitive, BboxMap>;
public:
typedef GeomTraits Kernel;
typedef typename Kernel::Exact_kernel EKernel;
typedef typename Kernel::Approximate_kernel AKernel;
typedef typename Kernel::C2E C2E;
typedef typename Kernel::C2F C2F;
// Exact traits is based on the exact kernel.
typedef AABB_traits_base_2<EKernel, AABBPrimitive, BboxMap> Exact_traits;
// Filtering traits is based on the filtering kernel.
typedef AABB_traits_base_2<AKernel, AABBPrimitive, BboxMap> Filtering_traits;
typedef Filtered_predicate<
typename Exact_traits::Compare_distance,
typename Filtering_traits::Compare_distance,
C2E, C2F> Compare_distance;
AABB_filtered_traits_base_2() : Base() {}
AABB_filtered_traits_base_2(BboxMap bbm) : Base(bbm) {}
Compare_distance compare_distance_object() const
{
typename Exact_traits::Compare_distance pe = Exact_traits().compare_distance_object();
typename Filtering_traits::Compare_distance pf = Filtering_traits().compare_distance_object();
return Compare_distance(pe, pf);
}
};
}
#include <CGAL/AABB_tree/internal/AABB_statically_filtered_traits_2.h>
namespace CGAL {
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap = Default, bool Has_static_filters = internal::Has_static_filters<GeomTraits>::value>
class AABB_filtered_traits_2;
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap>
class AABB_filtered_traits_2<GeomTraits, AABBPrimitive, BboxMap, false> : public AABB_filtered_traits_base_2<GeomTraits, AABBPrimitive, BboxMap> {
using Base = AABB_filtered_traits_base_2<GeomTraits, AABBPrimitive, BboxMap>;
public:
AABB_filtered_traits_2() : Base() {}
AABB_filtered_traits_2(BboxMap bbm) : Base(bbm) {}
};
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap>
class AABB_filtered_traits_2<GeomTraits, AABBPrimitive, BboxMap, true> : public AABB_statically_filtered_traits_2<GeomTraits, AABBPrimitive, BboxMap> {
using Base = AABB_statically_filtered_traits_2<GeomTraits, AABBPrimitive, BboxMap>;
public:
AABB_filtered_traits_2() : Base() {}
AABB_filtered_traits_2(BboxMap bbm) : Base(bbm) {}
};
} //namespace CGAL
#endif

150
AABB_tree/include/CGAL/AABB_tree/internal/AABB_statically_filtered_traits_2.h
View File

@ -1,150 +0,0 @@
// Copyright (c) 2024 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : Stéphane Tayeb, Pierre Alliez, Camille Wormser
//
#ifndef CGAL_AABB_STATICALLY_FILTERED_TRAITS_2_H
#define CGAL_AABB_STATICALLY_FILTERED_TRAITS_2_H
#include <CGAL/license/AABB_tree.h>
#include <CGAL/Filtered_kernel/internal/Static_filters/Static_filter_error.h>
#include <CGAL/Filtered_kernel/internal/Static_filters/tools.h>
#include <CGAL/AABB_tree/internal/AABB_filtered_traits_2.h>
namespace CGAL {
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap = Default>
class AABB_statically_filtered_traits_2 : public AABB_filtered_traits_base_2<GeomTraits, AABBPrimitive, BboxMap> {
using Base = AABB_filtered_traits_base_2<GeomTraits, AABBPrimitive, BboxMap>;
public:
class Compare_distance : public Base::Compare_distance {
public:
using Point = typename GeomTraits::Point_2;
using Bounding_box = Bbox_2;
using Circle_2 = typename GeomTraits::Circle_2;
Comparison_result operator()(const Point& p, const Bounding_box& b, const Point& bound) const {
Circle_2 s = GeomTraits().construct_circle_2_object()(p, GeomTraits().compute_squared_distance_2_object()(p, bound));
CGAL_BRANCH_PROFILER_3(std::string("semi-static failures/attempts/calls to : ") +
std::string(CGAL_PRETTY_FUNCTION), tmp);
internal::Static_filters_predicates::Get_approx<Point> get_approx; // Identity functor for all points
const Point& c = s.center();
double scx, scy, ssr;
double bxmin = b.xmin(), bymin = b.ymin(),
bxmax = b.xmax(), bymax = b.ymax();
if (internal::fit_in_double(get_approx(c).x(), scx) &&
internal::fit_in_double(get_approx(c).y(), scy) &&
internal::fit_in_double(s.squared_radius(), ssr))
{
CGAL_BRANCH_PROFILER_BRANCH_1(tmp);
if ((ssr < 1.11261183279326254436e-293) || (ssr > 2.80889552322236673473e+306)) {
CGAL_BRANCH_PROFILER_BRANCH_2(tmp);
return Base::Compare_distance::operator()(p, b, bound);
}
double distance = 0;
double max1 = 0;
double double_tmp_result = 0;
double eps = 0;
if (scx < bxmin)
{
double bxmin_scx = bxmin - scx;
max1 = bxmin_scx;
distance = square(bxmin_scx);
double_tmp_result = (distance - ssr);
if ((max1 < 3.33558365626356687717e-147) || (max1 > 1.67597599124282407923e+153))
return CGAL::SMALLER;
eps = 1.99986535548615598560e-15 * (std::max)(ssr, square(max1));
if (double_tmp_result > eps)
return CGAL::LARGER;
}
else if (scx > bxmax)
{
double scx_bxmax = scx - bxmax;
max1 = scx_bxmax;
distance = square(scx_bxmax);
double_tmp_result = (distance - ssr);
if ((max1 < 3.33558365626356687717e-147) || (max1 > 1.67597599124282407923e+153))
return CGAL::SMALLER;
eps = 1.99986535548615598560e-15 * (std::max)(ssr, square(max1));
if (double_tmp_result > eps)
return CGAL::LARGER;
}
if (scy < bymin)
{
double bymin_scy = bymin - scy;
if (max1 < bymin_scy) {
max1 = bymin_scy;
}
distance += square(bymin_scy);
double_tmp_result = (distance - ssr);
if ((max1 < 3.33558365626356687717e-147) || ((max1 > 1.67597599124282407923e+153)))
return CGAL::SMALLER;
eps = 1.99986535548615598560e-15 * (std::max)(ssr, square(max1));
if (double_tmp_result > eps) {
return CGAL::LARGER;
}
}
else if (scy > bymax)
{
double scy_bymax = scy - bymax;
if (max1 < scy_bymax) {
max1 = scy_bymax;
}
distance += square(scy_bymax);
double_tmp_result = (distance - ssr);
if (((max1 < 3.33558365626356687717e-147)) || ((max1 > 1.67597599124282407923e+153)))
return CGAL::SMALLER;
eps = 1.99986535548615598560e-15 * (std::max)(ssr, square(max1));
if (double_tmp_result > eps)
return CGAL::LARGER;
}
// double_tmp_result and eps were growing all the time
// no need to test for > eps as done earlier in at least one case
return CGAL::SMALLER;
}
return Base::Compare_distance::operator()(p, b, bound);
}
};
AABB_statically_filtered_traits_2() : Base() {}
AABB_statically_filtered_traits_2(BboxMap bbm) : Base(bbm) {}
Compare_distance compare_distance_object() const { return Compare_distance(); }
};
} //namespace CGAL
#endif