513 lines
18 KiB
C++
513 lines
18 KiB
C++
// Copyright (c) 2001-2004
|
|
// Utrecht University (The Netherlands),
|
|
// ETH Zurich (Switzerland),
|
|
// INRIA Sophia-Antipolis (France),
|
|
// Max-Planck-Institute Saarbruecken (Germany),
|
|
// and Tel-Aviv University (Israel). All rights reserved.
|
|
//
|
|
// This file is part of CGAL (www.cgal.org)
|
|
//
|
|
// $URL$
|
|
// $Id$
|
|
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
|
|
//
|
|
//
|
|
// Author(s) : Sylvain Pion
|
|
// Menelaos Karavelas <mkaravel@cse.nd.edu>
|
|
|
|
#ifndef CGAL_CARTESIAN_CONVERTER_H
|
|
#define CGAL_CARTESIAN_CONVERTER_H
|
|
|
|
// This file contains the definition of a kernel converter, based on Cartesian
|
|
// representation. It should work between *Cartesian<A> and *Cartesian<B>,
|
|
// provided you give a NT converter from A to B.
|
|
// There's a Homogeneous counterpart.
|
|
|
|
#include <CGAL/Cartesian_converter_fwd.h>
|
|
#include <CGAL/basic.h>
|
|
#include <CGAL/NT_converter.h>
|
|
#include <CGAL/Enum_converter.h>
|
|
#include <CGAL/Bbox_2.h>
|
|
#include <CGAL/Bbox_3.h>
|
|
#include <CGAL/Origin.h>
|
|
#include <CGAL/Kernel/Return_base_tag.h>
|
|
#include <CGAL/Kernel/Type_mapper.h>
|
|
#include <vector>
|
|
#include <boost/mpl/lambda.hpp>
|
|
#include <boost/mpl/transform.hpp>
|
|
#include <boost/mpl/vector.hpp>
|
|
#include <boost/mpl/not.hpp>
|
|
#include <boost/mpl/logical.hpp>
|
|
#include <boost/mpl/remove.hpp>
|
|
|
|
#include <type_traits>
|
|
|
|
namespace CGAL {
|
|
|
|
// Guess which compiler needs this work around ?
|
|
// ... VC++, again!
|
|
namespace internal {
|
|
template < typename K1, typename K2 >
|
|
struct Default_converter {
|
|
typedef typename K1::FT FT1;
|
|
typedef typename K2::FT FT2;
|
|
typedef ::CGAL::NT_converter<FT1, FT2> Type;
|
|
};
|
|
|
|
// Out will be a variant, source kernel and target kernel
|
|
template<typename Converter, typename Output>
|
|
struct Converting_visitor{
|
|
Converting_visitor(const Converter& conv, Output& out) : conv(&conv), out(&out) {}
|
|
const Converter* conv;
|
|
Output* out;
|
|
|
|
template<typename T>
|
|
void operator()(const T& t) { *out = conv->operator()(t); }
|
|
|
|
template<typename T>
|
|
void operator()(const std::vector<T>& t) {
|
|
typedef typename
|
|
Type_mapper< T, typename Converter::Source_kernel,
|
|
typename Converter::Target_kernel >::type
|
|
value_type;
|
|
|
|
std::vector< value_type > tmp;
|
|
tmp.reserve(t.size());
|
|
for(typename std::vector< T >::const_iterator it = t.begin();
|
|
it != t.end(); ++it) {
|
|
tmp.push_back(conv->operator()(*it));
|
|
}
|
|
|
|
*out = tmp;
|
|
}
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
template < class K1, class K2,
|
|
class Converter /*= typename internal::Default_converter<K1, K2>::Type*/>
|
|
class Cartesian_converter : public Enum_converter
|
|
{
|
|
typedef Enum_converter Base;
|
|
typedef Cartesian_converter Self;
|
|
public:
|
|
typedef K1 Source_kernel;
|
|
typedef K2 Target_kernel;
|
|
typedef Converter Number_type_converter;
|
|
|
|
using Base::operator();
|
|
|
|
Origin
|
|
operator()(Origin o) const
|
|
{
|
|
return o;
|
|
}
|
|
|
|
Null_vector
|
|
operator()(Null_vector n) const
|
|
{
|
|
return n;
|
|
}
|
|
|
|
Return_base_tag
|
|
operator()(Return_base_tag o) const
|
|
{
|
|
return o;
|
|
}
|
|
|
|
const Bbox_2&
|
|
operator()(const Bbox_2& b) const
|
|
{
|
|
return b;
|
|
}
|
|
|
|
const Bbox_3&
|
|
operator()(const Bbox_3& b) const
|
|
{
|
|
return b;
|
|
}
|
|
|
|
typename K2::FT
|
|
operator()(const typename K1::FT& a) const
|
|
{
|
|
return conv(a);
|
|
}
|
|
|
|
template <typename T>
|
|
T
|
|
operator()(const T t,
|
|
std::enable_if_t<std::is_fundamental<T>::value>* = nullptr) const
|
|
{
|
|
return t;
|
|
}
|
|
|
|
// drop the boost::detail::variant::void_ generated by the macros
|
|
// from the sequence, transform with the type mapper and throw the
|
|
// new list into a variant
|
|
// visit to get the type, and copy construct inside the return type
|
|
template<typename ... U>
|
|
typename
|
|
Type_mapper< std::optional< std::variant< U ... > >,
|
|
K1, K2 >::type
|
|
operator()(const std::optional< std::variant< U ... > >& o) const {
|
|
typedef typename
|
|
Type_mapper< std::optional< std::variant< U ... > >,
|
|
K1, K2 >::type result_type;
|
|
result_type res;
|
|
if(!o) {
|
|
// empty converts to empty
|
|
return res;
|
|
}
|
|
|
|
internal::Converting_visitor<Self, result_type>
|
|
conv_visitor = internal::Converting_visitor<Self, result_type>(*this, res);
|
|
std::visit(conv_visitor, *o);
|
|
return res;
|
|
}
|
|
|
|
template<typename ... U>
|
|
typename
|
|
Type_mapper< std::variant< U ... >,
|
|
K1, K2 >::type
|
|
operator()(const std::variant< U ... > & o) const {
|
|
typedef typename
|
|
Type_mapper< std::variant< U ... >,
|
|
K1, K2 >::type result_type;
|
|
result_type res;
|
|
internal::Converting_visitor<Self, result_type>
|
|
conv_visitor = internal::Converting_visitor<Self, result_type>(*this, res);
|
|
std::visit(conv_visitor, o);
|
|
return res;
|
|
}
|
|
|
|
BOOST_MPL_HAS_XXX_TRAIT_DEF(Object_2);
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Object_2<U1>::value && has_Object_2<U2>::value, int> = 0>
|
|
typename U2::Object_2
|
|
operator()(const typename U1::Object_2 &obj) const
|
|
{
|
|
#define CGAL_Kernel_obj(X) \
|
|
if (const typename K1::X * ptr = object_cast<typename K1::X>(&obj)) \
|
|
return make_object(operator()(*ptr));
|
|
|
|
#include <CGAL/Kernel/interface_macros.h>
|
|
|
|
#define CGAL_Kernel_obj(X) \
|
|
if (const std::vector<typename K1::X> * ptr = object_cast<std::vector<typename K1::X> >(&obj)) { \
|
|
std::vector<typename K2::X> res; \
|
|
res.reserve((*ptr).size()); \
|
|
for(unsigned int i=0; i < (*ptr).size(); i++){ \
|
|
res.push_back(operator()((*ptr)[i])); \
|
|
} \
|
|
return make_object(res); \
|
|
}
|
|
|
|
CGAL_Kernel_obj(Point_2)
|
|
CGAL_Kernel_obj(Point_3)
|
|
#undef CGAL_Kernel_obj
|
|
|
|
CGAL_error_msg("Cartesian_converter is unable to determine what is wrapped in the Object");
|
|
return Object();
|
|
}
|
|
|
|
std::vector<Object>
|
|
operator()(const std::vector<Object>& v) const
|
|
{
|
|
std::vector<Object> res;
|
|
res.reserve(v.size());
|
|
for(unsigned int i = 0; i < v.size(); i++) {
|
|
res.push_back(operator()(v[i]));
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// For SFINAE
|
|
#define CGAL_Kernel_obj(X) \
|
|
BOOST_MPL_HAS_XXX_TRAIT_DEF(X);
|
|
|
|
#include <CGAL/Kernel/interface_macros.h>
|
|
|
|
#undef CGAL_Kernel_obj
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Point_2<U1>::value && has_Point_2<U2>::value, int> = 0>
|
|
typename U2::Point_2
|
|
operator()(const typename U1::Point_2& p) const
|
|
{
|
|
return k2.construct_point_2_object()(conv(k1.compute_x_2_object()(p)),
|
|
conv(k1.compute_y_2_object()(p)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Weighted_point_2<U1>::value && has_Weighted_point_2<U2>::value, int> = 0>
|
|
typename U2::Weighted_point_2
|
|
operator()(const typename U1::Weighted_point_2& wp) const
|
|
{
|
|
return k2.construct_weighted_point_2_object()(operator()(k1.construct_point_2_object()(wp)),
|
|
conv(k1.compute_weight_2_object()(wp)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Vector_2<U1>::value && has_Vector_2<U2>::value, int> = 0>
|
|
typename U2::Vector_2
|
|
operator()(const typename U1::Vector_2& v) const
|
|
{
|
|
return k2.construct_vector_2_object()(conv(k1.compute_x_2_object()(v)),
|
|
conv(k1.compute_y_2_object()(v)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Direction_2<U1>::value && has_Direction_2<U2>::value, int> = 0>
|
|
typename U2::Direction_2
|
|
operator()(const typename U1::Direction_2& d) const
|
|
{
|
|
return k2.construct_direction_2_object()(conv(k1.compute_dx_2_object()(d)),
|
|
conv(k1.compute_dy_2_object()(d)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Segment_2<U1>::value && has_Segment_2<U2>::value, int> = 0>
|
|
typename U2::Segment_2
|
|
operator()(const typename U1::Segment_2& s) const
|
|
{
|
|
return k2.construct_segment_2_object()(operator()(k1.construct_source_2_object()(s)),
|
|
operator()(k1.construct_target_2_object()(s)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Line_2<U1>::value && has_Line_2<U2>::value, int> = 0>
|
|
typename U2::Line_2
|
|
operator()(const typename U1::Line_2& l) const
|
|
{
|
|
return k2.construct_line_2_object()(conv(k1.compute_a_2_object()(l)),
|
|
conv(k1.compute_b_2_object()(l)),
|
|
conv(k1.compute_c_2_object()(l)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Ray_2<U1>::value && has_Ray_2<U2>::value, int> = 0>
|
|
typename U2::Ray_2
|
|
operator()(const typename U1::Ray_2& r) const
|
|
{
|
|
return k2.construct_ray_2_object()(operator()(k1.construct_source_2_object()(r)),
|
|
operator()(k1.construct_second_point_2_object()(r)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Circle_2<U1>::value && has_Circle_2<U2>::value, int> = 0>
|
|
typename U2::Circle_2
|
|
operator()(const typename U1::Circle_2& c) const
|
|
{
|
|
return k2.construct_circle_2_object()(operator()(k1.construct_center_2_object()(c)),
|
|
conv(k1.compute_squared_radius_2_object()(c)),
|
|
k1.orientation_2_object()(c));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Triangle_2<U1>::value && has_Triangle_2<U2>::value, int> = 0>
|
|
typename U2::Triangle_2
|
|
operator()(const typename U1::Triangle_2& tr) const
|
|
{
|
|
return k2.construct_triangle_2_object()(operator()(k1.construct_vertex_2_object()(tr,0)),
|
|
operator()(k1.construct_vertex_2_object()(tr,1)),
|
|
operator()(k1.construct_vertex_2_object()(tr,2))
|
|
);
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Iso_rectangle_2<U1>::value && has_Iso_rectangle_2<U2>::value, int> = 0>
|
|
typename U2::Iso_rectangle_2
|
|
operator()(const typename U1::Iso_rectangle_2& ir) const
|
|
{
|
|
return k2.construct_iso_rectangle_2_object()(operator()(k1.construct_min_vertex_2_object()(ir)),
|
|
operator()(k1.construct_max_vertex_2_object()(ir)),
|
|
0);
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Point_3<U1>::value && has_Point_3<U2>::value, int> = 0>
|
|
typename U2::Point_3
|
|
operator()(const typename U1::Point_3& p) const
|
|
{
|
|
return k2.construct_point_3_object()(conv(k1.compute_x_3_object()(p)),
|
|
conv(k1.compute_y_3_object()(p)),
|
|
conv(k1.compute_z_3_object()(p)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Weighted_point_3<U1>::value && has_Weighted_point_3<U2>::value, int> = 0>
|
|
typename U2::Weighted_point_3
|
|
operator()(const typename U1::Weighted_point_3& wp) const
|
|
{
|
|
return k2.construct_weighted_point_3_object()(operator()(k1.construct_point_3_object()(wp)),
|
|
conv(k1.compute_weight_3_object()(wp)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Vector_3<U1>::value && has_Vector_3<U2>::value, int> = 0>
|
|
typename U2::Vector_3
|
|
operator()(const typename U1::Vector_3& v) const
|
|
{
|
|
return k2.construct_vector_3_object()(conv(k1.compute_x_3_object()(v)),
|
|
conv(k1.compute_y_3_object()(v)),
|
|
conv(k1.compute_z_3_object()(v)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Direction_3<U1>::value && has_Direction_3<U2>::value, int> = 0>
|
|
typename U2::Direction_3
|
|
operator()(const typename U1::Direction_3& d) const
|
|
{
|
|
return k2.construct_direction_3_object()(conv(k1.compute_dx_3_object()(d)),
|
|
conv(k1.compute_dy_3_object()(d)),
|
|
conv(k1.compute_dz_3_object()(d)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Segment_3<U1>::value && has_Segment_3<U2>::value, int> = 0>
|
|
typename U2::Segment_3
|
|
operator()(const typename U1::Segment_3& s) const
|
|
{
|
|
return k2.construct_segment_3_object()(operator()(k1.construct_source_3_object()(s)),
|
|
operator()(k1.construct_target_3_object()(s)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Line_3<U1>::value && has_Line_3<U2>::value, int> = 0>
|
|
typename U2::Line_3
|
|
operator()(const typename U1::Line_3& l) const
|
|
{
|
|
return k2.construct_line_3_object()(operator()(k1.construct_point_on_3_object()(l)),
|
|
operator()(k1.construct_vector_3_object()(l)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Ray_3<U1>::value && has_Ray_3<U2>::value, int> = 0>
|
|
typename U2::Ray_3
|
|
operator()(const typename U1::Ray_3& r) const
|
|
{
|
|
return k2.construct_ray_3_object()(operator()(k1.construct_source_3_object()(r)),
|
|
operator()(k1.construct_second_point_3_object()(r)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Sphere_3<U1>::value && has_Sphere_3<U2>::value, int> = 0>
|
|
typename U2::Sphere_3
|
|
operator()(const typename U1::Sphere_3& s) const
|
|
{
|
|
return k2.construct_sphere_3_object()(operator()(k1.construct_center_3_object()(s)),
|
|
conv(k1.compute_squared_radius_3_object()(s)),
|
|
k1.orientation_3_object()(s));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Circle_3<U1>::value && has_Circle_3<U2>::value, int> = 0>
|
|
typename U2::Circle_3
|
|
operator()(const typename U1::Circle_3& c) const
|
|
{
|
|
return k2.construct_circle_3_object()(operator()(k1.construct_sphere_3_object()(c)),
|
|
operator()(k1.construct_plane_3_object()(c)),
|
|
1);
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Triangle_3<U1>::value && has_Triangle_3<U2>::value, int> = 0>
|
|
typename U2::Triangle_3
|
|
operator()(const typename U1::Triangle_3& tr) const
|
|
{
|
|
return k2.construct_triangle_3_object()(operator()(k1.construct_vertex_3_object()(tr,0)),
|
|
operator()(k1.construct_vertex_3_object()(tr,1)),
|
|
operator()(k1.construct_vertex_3_object()(tr,2)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Tetrahedron_3<U1>::value && has_Tetrahedron_3<U2>::value, int> = 0>
|
|
typename U2::Tetrahedron_3
|
|
operator()(const typename U1::Tetrahedron_3& tet) const
|
|
{
|
|
return k2.construct_tetrahedron_3_object()(operator()(k1.construct_vertex_3_object()(tet,0)),
|
|
operator()(k1.construct_vertex_3_object()(tet,1)),
|
|
operator()(k1.construct_vertex_3_object()(tet,2)),
|
|
operator()(k1.construct_vertex_3_object()(tet,3)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Plane_3<U1>::value && has_Plane_3<U2>::value, int> = 0>
|
|
typename U2::Plane_3
|
|
operator()(const typename U1::Plane_3& pl) const
|
|
{
|
|
return k2.construct_plane_3_object()(conv(k1.compute_a_3_object()(pl)),
|
|
conv(k1.compute_b_3_object()(pl)),
|
|
conv(k1.compute_c_3_object()(pl)),
|
|
conv(k1.compute_d_3_object()(pl)));
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Iso_cuboid_3<U1>::value && has_Iso_cuboid_3<U2>::value, int> = 0>
|
|
typename U2::Iso_cuboid_3
|
|
operator()(const typename U1::Iso_cuboid_3& ic) const
|
|
{
|
|
return k2.construct_iso_cuboid_3_object()(operator()(k1.construct_min_vertex_3_object()(ic)),
|
|
operator()(k1.construct_max_vertex_3_object()(ic)),
|
|
0);
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Point_2<U1>::value && has_Point_2<U2>::value, int> = 0>
|
|
std::pair<typename U2::Point_2, typename U2::Point_2>
|
|
operator()(const std::pair<typename U1::Point_2, typename U1::Point_2>& pp) const
|
|
{
|
|
return std::make_pair(operator()(pp.first), operator()(pp.second));
|
|
}
|
|
|
|
BOOST_MPL_HAS_XXX_TRAIT_DEF(Aff_transformation_2);
|
|
BOOST_MPL_HAS_XXX_TRAIT_DEF(Aff_transformation_3);
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Aff_transformation_2<U1>::value &&
|
|
has_Aff_transformation_2<U2>::value, int> = 0>
|
|
typename U2::Aff_transformation_2
|
|
operator()(const typename U1::Aff_transformation_2& a) const
|
|
{
|
|
return { conv(a.m(0,0)), conv(a.m(0,1)), conv(a.m(0,2)),
|
|
conv(a.m(1,0)), conv(a.m(1,1)), conv(a.m(1,2)),
|
|
conv(a.m(2,2)) };
|
|
}
|
|
|
|
template <typename U1 = K1, typename U2 = K2,
|
|
std::enable_if_t<has_Aff_transformation_3<U1>::value &&
|
|
has_Aff_transformation_3<U2>::value, int> = 0>
|
|
typename U2::Aff_transformation_3
|
|
operator()(const typename U1::Aff_transformation_3& a) const
|
|
{
|
|
return { conv(a.m(0,0)), conv(a.m(0,1)), conv(a.m(0,2)), conv(a.m(0,3)),
|
|
conv(a.m(1,0)), conv(a.m(1,1)), conv(a.m(1,2)), conv(a.m(1,3)),
|
|
conv(a.m(2,0)), conv(a.m(2,1)), conv(a.m(2,2)), conv(a.m(2,3)),
|
|
conv(a.m(3,3)) };
|
|
}
|
|
|
|
private:
|
|
Converter conv;
|
|
K1 k1;
|
|
K2 k2;
|
|
};
|
|
|
|
// Specialization when converting to the same kernel,
|
|
// to avoid making copies.
|
|
template < class K, class C >
|
|
class Cartesian_converter <K, K, C>
|
|
{
|
|
public:
|
|
typedef K Source_kernel;
|
|
typedef K Target_kernel;
|
|
typedef C Number_type_converter;
|
|
|
|
template < typename T >
|
|
const T& operator()(const T& t) const { return t; }
|
|
};
|
|
|
|
} //namespace CGAL
|
|
|
|
#endif // CGAL_CARTESIAN_CONVERTER_H
|