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

Consistency between doc & code, use OutPolygon if provided, factorize code

This commit is contained in:
Mael Rouxel-Labbé 2025-01-14 15:10:23 +01:00
parent 06e970d886
commit 2f7db1db74
7 changed files with 216 additions and 544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
Straight_skeleton_2/include/CGAL/create_offset_polygons_2.h
View File

@ -24,9 +24,8 @@
#include <CGAL/assertions.h>
#include <CGAL/Cartesian_converter.h>
#include <CGAL/Default.h>
#include <CGAL/Kernel_traits.h>
#include <CGAL/Polygon_2.h>
#include <CGAL/Polygon_with_holes_2.h>
#include <CGAL/tags.h>
#include <boost/optional/optional.hpp>
@ -142,6 +141,8 @@ template<class OutPolygon, class FT, class Skeleton, class K>
std::vector< boost::shared_ptr<OutPolygon> >
create_offset_polygons_2 ( FT const& aOffset, Skeleton const& aSs, K const& , Tag_false )
{
static_assert(!std::is_same_v<OutPolygon, CGAL::Default>);
typedef boost::shared_ptr<OutPolygon> OutPolygonPtr ;
typedef std::vector<OutPolygonPtr> OutPolygonPtrVector ;
@ -166,6 +167,8 @@ template<class OutPolygon, class FT, class Skeleton, class K>
std::vector< boost::shared_ptr<OutPolygon> >
create_offset_polygons_2 ( FT const& aOffset, Skeleton const& aSs, K const& /*k*/, Tag_true )
{
static_assert(!std::is_same_v<OutPolygon, CGAL::Default>);
typedef boost::shared_ptr<OutPolygon> OutPolygonPtr ;
typedef std::vector<OutPolygonPtr> OutPolygonPtrVector ;
@ -190,43 +193,39 @@ Skeleton const& dereference ( boost::shared_ptr<Skeleton> const& ss )
} // namespace CGAL_SS_i
template<class OutPolygon, class FT, class Skeleton, class K>
template<class OutPolygon, class FT, class Skeleton,
class K = Exact_predicates_inexact_constructions_kernel>
std::vector< boost::shared_ptr<OutPolygon> >
inline
create_offset_polygons_2(const FT& aOffset,
const Skeleton& aSs,
const K& k)
const K& k = K())
{
typename CGAL_SS_i::Is_same_type<K, typename Skeleton::Traits>::type same_kernel;
return CGAL_SS_i::create_offset_polygons_2<OutPolygon>(aOffset, aSs, k, same_kernel);
}
template<class Polygon = Polygon_2<Exact_predicates_inexact_constructions_kernel>,
class FT, class Skeleton>
std::vector< boost::shared_ptr<Polygon> >
inline
create_offset_polygons_2(const FT& aOffset,
const Skeleton& aSs)
{
return create_offset_polygons_2<Polygon>(aOffset, aSs, Exact_predicates_inexact_constructions_kernel());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
/// INTERIOR
template<class FT, class APolygon, class HoleIterator, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default,
class FT, class APolygon, class HoleIterator,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector< boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK> > >
inline
create_interior_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aOuterBoundary,
HoleIterator aHolesBegin,
HoleIterator aHolesEnd,
const OfK& ofk,
const SsK& ssk)
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<CGAL::is_iterator<HoleIterator>::value>* = 0)
{
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK>;
return create_offset_polygons_2<OutPolygon>(
aOffset,
CGAL_SS_i::dereference(
@ -240,65 +239,28 @@ create_interior_skeleton_and_offset_polygons_2(const FT& aOffset,
ofk);
}
template<class FT, class APolygon, class HoleIterator, class OfK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
inline
create_interior_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aOuterBoundary,
HoleIterator aHolesBegin,
HoleIterator aHolesEnd,
const OfK& ofk)
{
return create_interior_skeleton_and_offset_polygons_2(aOffset, aOuterBoundary,
aHolesBegin, aHolesEnd,
ofk,
Exact_predicates_inexact_constructions_kernel());
}
// Overload where Polygon actually is a simple polygon (no holes)
template<class FT, class APolygon, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
// Overload where APolygon is a simple polygon (no holes)
template <class OutPolygon_ = CGAL::Default,
class FT, class APolygon,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector< boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK> > >
inline
create_interior_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const OfK& ofk,
const SsK& ssk,
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<
! CGAL_SS_i::has_Hole_const_iterator<APolygon>::value>* = nullptr)
{
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK>;
std::vector<APolygon> no_holes;
return create_interior_skeleton_and_offset_polygons_2(aOffset, aPoly,
return create_interior_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly,
no_holes.begin(), no_holes.end(),
ofk, ssk);
}
// Overloads common to both polygons with and without holes, a simple polygon is returned in any case
template<class FT, class APolygon, class OfK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygon> >
inline
create_interior_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const OfK& ofk)
{
return create_interior_skeleton_and_offset_polygons_2(aOffset, aPoly, ofk,
Exact_predicates_inexact_constructions_kernel());
}
template<class FT, class APolygon,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<
APolygon, Exact_predicates_inexact_constructions_kernel>::type>
std::vector<boost::shared_ptr<OutPolygon> >
inline
create_interior_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly)
{
return create_interior_skeleton_and_offset_polygons_2(aOffset, aPoly,
Exact_predicates_inexact_constructions_kernel());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -307,17 +269,21 @@ create_interior_skeleton_and_offset_polygons_2(const FT& aOffset,
/*! create_exterior_skeleton_and_offset_polygons_2 (no sorting of the result) */
// Overload where Polygon actually is a simple polygon (no holes)
template<class FT, class APolygon, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default,
class FT, class APolygon,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector< boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK> > >
inline
create_exterior_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const OfK& ofk,
const SsK& ssk,
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<
! CGAL_SS_i::has_Hole_const_iterator<APolygon>::value>* = nullptr)
{
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK>;
return create_offset_polygons_2<OutPolygon>(
aOffset,
CGAL_SS_i::dereference(
@ -329,31 +295,6 @@ create_exterior_skeleton_and_offset_polygons_2(const FT& aOffset,
ofk);
}
// Overloads common to both polygons with and without holes, a simple polygons is returned in any case
template<class FT, class APolygon, class OfK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
inline
create_exterior_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const OfK& ofk)
{
return create_exterior_skeleton_and_offset_polygons_2(aOffset, aPoly, ofk,
Exact_predicates_inexact_constructions_kernel());
}
template<class FT, class APolygon,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<
APolygon, Exact_predicates_inexact_constructions_kernel>::type>
std::vector< boost::shared_ptr<OutPolygon> >
inline
create_exterior_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly)
{
return create_exterior_skeleton_and_offset_polygons_2(aOffset, aPoly,
Exact_predicates_inexact_constructions_kernel());
}
} // namespace CGAL
#endif // CGAL_CREATE_OFFSET_POLYGONS_2_H

126
Straight_skeleton_2/include/CGAL/create_offset_polygons_from_polygon_with_holes_2.h
View File

@ -14,10 +14,9 @@
#include <CGAL/license/Straight_skeleton_2.h>
#include <CGAL/Straight_skeleton_2/Straight_skeleton_aux.h>
#include <CGAL/arrange_offset_polygons_2.h>
#include <CGAL/create_offset_polygons_2.h>
#include <CGAL/Polygon_2.h>
#include <CGAL/Polygon_with_holes_2.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
@ -36,60 +35,45 @@ namespace CGAL {
/*! create_interior_skeleton_and_offset_polygons_2 (no sorting of the result) */
// overload where PolygonWithHoles actually is a type of Polygon that supports holes
template<class FT, class PolygonWithHoles, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<PolygonWithHoles, OfK>::type> // Hole-less polygon type
std::vector<boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default,
class FT, class PolygonWithHoles,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, PolygonWithHoles, OfK> > >
inline
create_interior_skeleton_and_offset_polygons_2(const FT& aOffset,
const PolygonWithHoles& aPoly,
const OfK& ofk,
const SsK& ssk,
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<
CGAL_SS_i::has_Hole_const_iterator<PolygonWithHoles>::value>* = nullptr)
{
return create_interior_skeleton_and_offset_polygons_2(aOffset, aPoly.outer_boundary(),
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, PolygonWithHoles, OfK>;
return create_interior_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly.outer_boundary(),
aPoly.holes_begin(), aPoly.holes_end(),
ofk, ssk);
}
/*! create_interior_skeleton_and_offset_polygons_with_holes_2 (orders the resulting polygons) */
// Polygon might be a Polygon with holes or not, but it returns a Polygon with holes
template<class FT, class Polygon, class OfK, class SsK,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<Polygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
// 'Polygon' might be a polygon with holes or not, but it returns a polygon with holes
template <class OutPolygonWithHoles_ = CGAL::Default,
class FT, class Polygon,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_with_holes_return_type<OutPolygonWithHoles_, Polygon, OfK> > >
inline
create_interior_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const OfK& ofk,
const SsK& ssk)
const OfK& ofk = OfK(),
const SsK& ssk = SsK())
{
using OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<Polygon, OfK>::type;
using OutPolygonWithHoles = CGAL_SS_i::Polygon_with_holes_return_type<OutPolygonWithHoles_, Polygon, OfK>;
return arrange_offset_polygons_2<OutPolygonWithHoles>(
create_interior_skeleton_and_offset_polygons_2(aOffset, aPoly, ofk, ssk));
}
template<class FT, class Polygon, class OfK,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<Polygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
inline
create_interior_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const OfK& ofk)
{
return create_interior_skeleton_and_offset_polygons_with_holes_2(aOffset, aPoly, ofk,
Exact_predicates_inexact_constructions_kernel());
}
template<class FT, class Polygon,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<
Polygon, Exact_predicates_inexact_constructions_kernel>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
inline
create_interior_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly)
{
return create_interior_skeleton_and_offset_polygons_with_holes_2(aOffset, aPoly,
Exact_predicates_inexact_constructions_kernel());
create_interior_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly, ofk, ssk));
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -100,18 +84,22 @@ create_interior_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
/*! create_exterior_skeleton_and_offset_polygons_with_holes_2 (orders the resulting polygons) */
// Polygon might be a Polygon with holes or not, but it returns a Polygon with holes
template<class FT, class Polygon, class OfK, class SsK,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<Polygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
template <class OutPolygonWithHoles_ = CGAL::Default,
class FT, class Polygon,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_with_holes_return_type<OutPolygonWithHoles_, Polygon, OfK> > >
inline
create_exterior_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const OfK& ofk,
const SsK& ssk)
const OfK& ofk = OfK(),
const SsK& ssk = SsK())
{
typedef typename CGAL_SS_i::Default_return_polygon_type<Polygon, OfK>::type Polygon_;
std::vector<boost::shared_ptr<Polygon_> > raw_output =
create_exterior_skeleton_and_offset_polygons_2(aOffset, aPoly, ofk, ssk);
using OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<Polygon, OfK>::type;
using OutPolygonWithHoles = CGAL_SS_i::Polygon_with_holes_return_type<OutPolygonWithHoles_, Polygon, OfK>;
std::vector<boost::shared_ptr<OutPolygon> > raw_output =
create_exterior_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly, ofk, ssk);
// filter offset of the outer frame
std::swap(raw_output[0], raw_output.back());
@ -131,58 +119,38 @@ create_exterior_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
/*! create_interior_skeleton_and_offset_polygons_2 with a polygon with holes */
// overload where PolygonWithHoles actually is a type of Polygon that supports holes
template<class FT, class PolygonWithHoles, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<PolygonWithHoles, OfK>::type>
std::vector<boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default,
class FT, class PolygonWithHoles,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, PolygonWithHoles, OfK> > >
inline
create_exterior_skeleton_and_offset_polygons_2(const FT& aOffset,
const PolygonWithHoles& aPoly,
const OfK& ofk,
const SsK& ssk,
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<
CGAL_SS_i::has_Hole_const_iterator<PolygonWithHoles>::value>* = nullptr)
{
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, PolygonWithHoles, OfK>;
std::vector<boost::shared_ptr<OutPolygon> > polygons =
create_exterior_skeleton_and_offset_polygons_2(aOffset, aPoly.outer_boundary(), ofk, ssk);
create_exterior_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly.outer_boundary(), ofk, ssk);
for (typename PolygonWithHoles::Hole_const_iterator hit=aPoly.holes_begin(); hit!=aPoly.holes_end(); ++hit)
{
typename PolygonWithHoles::Polygon_2 hole = *hit;
hole.reverse_orientation();
std::vector<boost::shared_ptr<OutPolygon> > hole_polygons =
create_interior_skeleton_and_offset_polygons_2(aOffset,
create_interior_skeleton_and_offset_polygons_2<OutPolygon>(aOffset,
hole,
ofk,ssk);
ofk, ssk);
polygons.insert(polygons.end(), hole_polygons.begin(), hole_polygons.end());
}
return polygons;
}
template<class FT, class Polygon, class OfK,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<Polygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
inline
create_exterior_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const OfK& ofk)
{
return create_exterior_skeleton_and_offset_polygons_with_holes_2(aOffset, aPoly, ofk,
Exact_predicates_inexact_constructions_kernel());
}
template<class FT, class Polygon,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<
Polygon, Exact_predicates_inexact_constructions_kernel>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
inline
create_exterior_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly)
{
return create_exterior_skeleton_and_offset_polygons_with_holes_2(aOffset, aPoly,
Exact_predicates_inexact_constructions_kernel());
}
} // namespace CGAL
#endif // CGAL_CREATE_OFFSET_POLYGONS_FROM_POLYGON_WITH_HOLES_2_H

96
Straight_skeleton_2/include/CGAL/create_straight_skeleton_2.h
View File

@ -32,14 +32,14 @@
namespace CGAL {
template<class PointIterator, class HoleIterator, class K>
template<class PointIterator, class HoleIterator,
class K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr< Straight_skeleton_2<K> >
create_interior_straight_skeleton_2 ( PointIterator aOuterContour_VerticesBegin
, PointIterator aOuterContour_VerticesEnd
, HoleIterator aHolesBegin
, HoleIterator aHolesEnd
, K const&
)
, const K& = K())
{
typedef Straight_skeleton_2<K> Ss ;
@ -62,30 +62,13 @@ create_interior_straight_skeleton_2 ( PointIterator aOuterContour_VerticesBegin
return ssb.construct_skeleton();
}
template<class PointIterator, class HoleIterator>
boost::shared_ptr< Straight_skeleton_2< Exact_predicates_inexact_constructions_kernel > >
inline
create_interior_straight_skeleton_2 ( PointIterator aOuterContour_VerticesBegin
, PointIterator aOuterContour_VerticesEnd
, HoleIterator aHolesBegin
, HoleIterator aHolesEnd
)
{
return create_interior_straight_skeleton_2(aOuterContour_VerticesBegin
,aOuterContour_VerticesEnd
,aHolesBegin
,aHolesEnd
,Exact_predicates_inexact_constructions_kernel()
);
}
template<class PointIterator, class K>
template<class PointIterator,
class K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr< Straight_skeleton_2<K> >
inline
create_interior_straight_skeleton_2 ( PointIterator aOuterContour_VerticesBegin
, PointIterator aOuterContour_VerticesEnd
, K const& k
)
, const K& k = K())
{
typedef typename std::iterator_traits<PointIterator>::value_type InputPoint ;
typedef typename Kernel_traits<InputPoint>::Kernel InputKernel ;
@ -99,24 +82,12 @@ create_interior_straight_skeleton_2 ( PointIterator aOuterContour_VerticesBegin
);
}
template<class PointIterator>
boost::shared_ptr< Straight_skeleton_2<Exact_predicates_inexact_constructions_kernel> >
inline
create_interior_straight_skeleton_2 ( PointIterator aOuterContour_VerticesBegin
, PointIterator aOuterContour_VerticesEnd
)
{
return create_interior_straight_skeleton_2(aOuterContour_VerticesBegin
,aOuterContour_VerticesEnd
,Exact_predicates_inexact_constructions_kernel()
);
}
template<class Polygon, class K>
template<class Polygon,
class K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr< Straight_skeleton_2<K> >
inline
create_interior_straight_skeleton_2 ( Polygon const& aOutContour,
K const& k,
create_interior_straight_skeleton_2 ( const Polygon& aOutContour,
const K& k = K(),
std::enable_if_t<
! CGAL_SS_i::has_Hole_const_iterator<Polygon>::value>* = nullptr)
{
@ -126,26 +97,18 @@ create_interior_straight_skeleton_2 ( Polygon const& aOutContour,
);
}
template<class Polygon>
boost::shared_ptr< Straight_skeleton_2< Exact_predicates_inexact_constructions_kernel > >
inline
create_interior_straight_skeleton_2 ( Polygon const& aOutContour )
{
return create_interior_straight_skeleton_2(aOutContour, Exact_predicates_inexact_constructions_kernel() );
}
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
/// EXTERIOR
template<class FT, class PointIterator, class K>
template<class FT, class PointIterator,
class K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr< Straight_skeleton_2<K> >
create_exterior_straight_skeleton_2 ( FT const& aMaxOffset
, PointIterator aVerticesBegin
, PointIterator aVerticesEnd
, K const& k
)
, const K& k = K())
{
CGAL_precondition( aMaxOffset > 0 ) ;
@ -195,25 +158,13 @@ create_exterior_straight_skeleton_2 ( FT const& aMaxOffset
return rSkeleton ;
}
template<class FT, class PointIterator>
boost::shared_ptr< Straight_skeleton_2<Exact_predicates_inexact_constructions_kernel> >
inline
create_exterior_straight_skeleton_2 ( FT const& aMaxOffset
, PointIterator aVerticesBegin
, PointIterator aVerticesEnd
)
{
return create_exterior_straight_skeleton_2(aMaxOffset
,aVerticesBegin
,aVerticesEnd
,Exact_predicates_inexact_constructions_kernel()
);
}
template<class FT, class Polygon, class K>
template<class FT, class Polygon,
class K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr< Straight_skeleton_2<K> >
inline
create_exterior_straight_skeleton_2 ( FT const& aMaxOffset, Polygon const& aPoly, K const& k )
create_exterior_straight_skeleton_2(const FT& aMaxOffset,
const Polygon& aPoly,
const K& k = K())
{
return create_exterior_straight_skeleton_2(aMaxOffset
,CGAL_SS_i::vertices_begin(aPoly)
@ -222,17 +173,6 @@ create_exterior_straight_skeleton_2 ( FT const& aMaxOffset, Polygon const& aPoly
);
}
template<class FT, class Polygon>
boost::shared_ptr< Straight_skeleton_2<Exact_predicates_inexact_constructions_kernel> >
inline
create_exterior_straight_skeleton_2 ( FT const& aMaxOffset, Polygon const& aPoly )
{
return create_exterior_straight_skeleton_2(aMaxOffset
,aPoly
,Exact_predicates_inexact_constructions_kernel()
);
}
} // namespace CGAL
#endif // CGAL_CREATE_STRAIGHT_SKELETON_2_H

130
Straight_skeleton_2/include/CGAL/create_weighted_offset_polygons_2.h
View File

@ -26,8 +26,6 @@
#include <CGAL/assertions.h>
#include <CGAL/Cartesian_converter.h>
#include <CGAL/Kernel_traits.h>
#include <CGAL/Polygon_2.h>
#include <CGAL/Polygon_with_holes_2.h>
#include <CGAL/tags.h>
#include <boost/optional/optional.hpp>
@ -202,10 +200,11 @@ create_partial_exterior_weighted_straight_skeleton_2(const FT& aMaxOffset,
////////////////////////////////////////////////////////////////////////////////////////////////////
/// INTERIOR
template<class FT, class APolygon, class HoleIterator, class Weights, class HoleWeightsIterator,
class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default,
class FT, class APolygon, class HoleIterator, class Weights, class HoleWeightsIterator,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector< boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK> > >
inline
create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aOuterBoundary,
@ -214,9 +213,11 @@ create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const Weights& aWeights,
HoleWeightsIterator aHoles_WeightsBegin,
HoleWeightsIterator aHoles_WeightsEnd,
const OfK& ofk,
const SsK& ssk)
const OfK& ofk = OfK(),
const SsK& ssk = SsK())
{
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK>;
if(aHolesBegin == aHolesEnd) // see @partial_wsls_pwh
{
return create_offset_polygons_2<OutPolygon>(
@ -254,71 +255,35 @@ create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
}
}
template<class FT, class APolygon, class HoleIterator, class Weights, class OfK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
inline
create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aOuterBoundary,
HoleIterator aHolesBegin,
HoleIterator aHolesEnd,
const Weights& aWeights,
const OfK& ofk)
{
return create_interior_weighted_skeleton_and_offset_polygons_2(aOffset, aOuterBoundary,
aHolesBegin, aHolesEnd,
aWeights,
ofk,
Exact_predicates_inexact_constructions_kernel());
}
// Overload where Polygon actually is a simple polygon (no holes)
template<class FT, class APolygon, class Weights, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default,
class FT, class APolygon, class Weights,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector< boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK> > >
inline
create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const Weights& aWeights,
const OfK& ofk,
const SsK& ssk,
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<
! CGAL_SS_i::has_Hole_const_iterator<APolygon>::value>* = nullptr)
{
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK>;
using IFT = typename boost::range_value<typename boost::range_value<Weights>::type>::type;
std::vector<APolygon> no_holes;
return create_interior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly,
std::vector<std::vector<IFT> > no_hole_weights;
return create_interior_weighted_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly,
no_holes.begin(), no_holes.end(),
aWeights,
aWeights[0],
no_hole_weights.begin(), no_hole_weights.end(),
ofk, ssk);
}
// Overloads common to both polygons with and without holes, a simple polygon is returned in any case
template<class FT, class APolygon, class Weights, class OfK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygon> >
inline
create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const Weights& aWeights,
const OfK& ofk)
{
return create_interior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly, aWeights, ofk,
Exact_predicates_inexact_constructions_kernel());
}
template<class FT, class APolygon, class Weights,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<
APolygon, Exact_predicates_inexact_constructions_kernel>::type>
std::vector<boost::shared_ptr<OutPolygon> >
inline
create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const Weights& aWeights)
{
return create_interior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly, aWeights,
Exact_predicates_inexact_constructions_kernel());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -327,18 +292,22 @@ create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
/*! create_exterior_skeleton_and_offset_polygons_2 (no sorting of the result) */
// Overload where Polygon actually is a simple polygon (no holes)
template<class FT, class APolygon, class Weights, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default,
class FT, class APolygon, class Weights,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK> > >
inline
create_exterior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const Weights& aWeights,
const OfK& ofk,
const SsK& ssk,
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<
! CGAL_SS_i::has_Hole_const_iterator<APolygon>::value>* = nullptr)
{
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, APolygon, OfK>;
return create_offset_polygons_2<OutPolygon>(
aOffset,
CGAL_SS_i::dereference(
@ -346,39 +315,12 @@ create_exterior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
aOffset,
CGAL_SS_i::vertices_begin(aPoly),
CGAL_SS_i::vertices_end (aPoly),
aWeights[0].begin(),
aWeights[0].end(),
std::begin(aWeights[0]),
std::end(aWeights[0]),
ssk)),
ofk);
}
// Overloads common to both polygons with and without holes, a simple polygons is returned in any case
template<class FT, class APolygon, class Weights, class OfK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<APolygon, OfK>::type>
std::vector< boost::shared_ptr<OutPolygon> >
inline
create_exterior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const Weights& aWeights,
const OfK& ofk)
{
return create_exterior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly, aWeights, ofk,
Exact_predicates_inexact_constructions_kernel());
}
template<class FT, class APolygon, class Weights,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<
APolygon, Exact_predicates_inexact_constructions_kernel>::type>
std::vector< boost::shared_ptr<OutPolygon> >
inline
create_exterior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const APolygon& aPoly,
const Weights& aWeights)
{
return create_exterior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly, aWeights,
Exact_predicates_inexact_constructions_kernel());
}
} // namespace CGAL
#endif // CGAL_CREATE_WEIGHTED_OFFSET_POLYGONS_2_H

130
Straight_skeleton_2/include/CGAL/create_weighted_offset_polygons_from_polygon_with_holes_2.h
View File

@ -14,10 +14,9 @@
#include <CGAL/license/Straight_skeleton_2.h>
#include <CGAL/Straight_skeleton_2/Straight_skeleton_aux.h>
#include <CGAL/arrange_offset_polygons_2.h>
#include <CGAL/create_offset_polygons_2.h>
#include <CGAL/Polygon_2.h>
#include <CGAL/Polygon_with_holes_2.h>
#include <CGAL/create_weighted_offset_polygons_2.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
@ -36,19 +35,23 @@ namespace CGAL {
/*! create_interior_skeleton_and_offset_polygons_2 (no sorting of the result) */
// overload where PolygonWithHoles actually is a type of Polygon that supports holes
template<class FT, class PolygonWithHoles, class Weights, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<PolygonWithHoles, OfK>::type> // Hole-less polygon type
std::vector<boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default, // Hole-less polygon type
class FT, class PolygonWithHoles, class Weights,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, PolygonWithHoles, OfK> > >
inline
create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const PolygonWithHoles& aPoly,
const Weights& aWeights,
const OfK& ofk,
const SsK& ssk,
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<
CGAL_SS_i::has_Hole_const_iterator<PolygonWithHoles>::value>* = nullptr)
{
return create_interior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly.outer_boundary(),
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, PolygonWithHoles, OfK>;
return create_interior_weighted_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly.outer_boundary(),
aPoly.holes_begin(), aPoly.holes_end(),
aWeights[0],
std::next(std::begin(aWeights)),
@ -59,44 +62,23 @@ create_interior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
/*! create_interior_weighted_skeleton_and_offset_polygons_with_holes_2 (orders the resulting polygons) */
// Polygon might be a Polygon with holes or not, but it returns a Polygon with holes
template<class FT, class Polygon, class Weights, class OfK, class SsK,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<Polygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
template <class OutPolygonWithHoles_ = CGAL::Default,
class FT, class Polygon, class Weights,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_with_holes_return_type<OutPolygonWithHoles_, Polygon, OfK> > >
inline
create_interior_weighted_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const Weights& aWeights,
const OfK& ofk,
const SsK& ssk)
const OfK& ofk = OfK(),
const SsK& ssk = SsK())
{
using OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<Polygon, OfK>::type;
using OutPolygonWithHoles = CGAL_SS_i::Polygon_with_holes_return_type<OutPolygonWithHoles_, Polygon, OfK>;
return arrange_offset_polygons_2<OutPolygonWithHoles>(
create_interior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly, aWeights, ofk, ssk));
}
template<class FT, class Polygon, class Weights, class OfK,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<Polygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
inline
create_interior_weighted_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const Weights& aWeights,
const OfK& ofk)
{
return create_interior_weighted_skeleton_and_offset_polygons_with_holes_2(aOffset, aPoly, aWeights, ofk,
Exact_predicates_inexact_constructions_kernel());
}
template<class FT, class Polygon, class Weights,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<
Polygon, Exact_predicates_inexact_constructions_kernel>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
inline
create_interior_weighted_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const Weights& aWeights)
{
return create_interior_weighted_skeleton_and_offset_polygons_with_holes_2(aOffset, aPoly, aWeights,
Exact_predicates_inexact_constructions_kernel());
create_interior_weighted_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly, aWeights, ofk, ssk));
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -104,21 +86,25 @@ create_interior_weighted_skeleton_and_offset_polygons_with_holes_2(const FT& aOf
////////////////////////////////////////////////////////////////////////////////////////////////////
/// EXTERIOR
/*! create_exterior_skeleton_and_offset_polygons_with_holes_2 (orders the resulting polygons) */
/*! create_exterior_weighted_skeleton_and_offset_polygons_with_holes_2 (orders the resulting polygons) */
// Polygon might be a Polygon with holes or not, but it returns a Polygon with holes
template<class FT, class Polygon, class Weights, class OfK, class SsK,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<Polygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
template <class OutPolygonWithHoles_ = CGAL::Default,
class FT, class Polygon, class Weights,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_with_holes_return_type<OutPolygonWithHoles_, Polygon, OfK> > >
create_exterior_weighted_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const Weights& aWeights,
const OfK& ofk,
const SsK& ssk)
const OfK& ofk = OfK(),
const SsK& ssk = SsK())
{
typedef typename CGAL_SS_i::Default_return_polygon_type<Polygon, OfK>::type Polygon_;
std::vector<boost::shared_ptr<Polygon_> > raw_output =
create_exterior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly, aWeights, ofk, ssk);
using OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<Polygon, OfK>::type;
using OutPolygonWithHoles = CGAL_SS_i::Polygon_with_holes_return_type<OutPolygonWithHoles_, Polygon, OfK>;
std::vector<boost::shared_ptr<OutPolygon> > raw_output =
create_exterior_weighted_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly, aWeights, ofk, ssk);
// filter offset of the outer frame
std::swap(raw_output[0], raw_output.back());
@ -138,22 +124,26 @@ create_exterior_weighted_skeleton_and_offset_polygons_with_holes_2(const FT& aOf
/*! create_interior_skeleton_and_offset_polygons_2 with a polygon with holes */
// overload where PolygonWithHoles actually is a type of Polygon that supports holes
template<class FT, class PolygonWithHoles, class Weights, class OfK, class SsK,
class OutPolygon = typename CGAL_SS_i::Default_return_polygon_type<PolygonWithHoles, OfK>::type>
std::vector<boost::shared_ptr<OutPolygon> >
template <class OutPolygon_ = CGAL::Default,
class FT, class PolygonWithHoles, class Weights,
class OfK = Exact_predicates_inexact_constructions_kernel,
class SsK = Exact_predicates_inexact_constructions_kernel>
std::vector<boost::shared_ptr<CGAL_SS_i::Polygon_return_type<OutPolygon_, PolygonWithHoles, OfK> > >
inline
create_exterior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
const PolygonWithHoles& aPoly,
const Weights& aWeights,
const OfK& ofk,
const SsK& ssk,
const OfK& ofk = OfK(),
const SsK& ssk = SsK(),
std::enable_if_t<
CGAL_SS_i::has_Hole_const_iterator<PolygonWithHoles>::value>* = nullptr)
{
using OutPolygon = CGAL_SS_i::Polygon_return_type<OutPolygon_, PolygonWithHoles, OfK>;
CGAL_precondition(aWeights.size() == aPoly.number_of_holes() + 1);
std::vector<boost::shared_ptr<OutPolygon> > polygons =
create_exterior_weighted_skeleton_and_offset_polygons_2(aOffset, aPoly.outer_boundary(), {aWeights[0]}, ofk, ssk);
create_exterior_weighted_skeleton_and_offset_polygons_2<OutPolygon>(aOffset, aPoly.outer_boundary(), aWeights, ofk, ssk);
std::size_t weight_pos = 1;
for(typename PolygonWithHoles::Hole_const_iterator hit=aPoly.holes_begin(); hit!=aPoly.holes_end(); ++hit, ++weight_pos)
@ -161,7 +151,7 @@ create_exterior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
typename PolygonWithHoles::Polygon_2 hole = *hit;
hole.reverse_orientation();
std::vector<boost::shared_ptr<OutPolygon> > hole_polygons =
create_interior_skeleton_and_offset_polygons_2(aOffset,
create_interior_weighted_skeleton_and_offset_polygons_2<OutPolygon>(aOffset,
hole,
{aWeights[weight_pos]},
ofk, ssk);
@ -171,32 +161,6 @@ create_exterior_weighted_skeleton_and_offset_polygons_2(const FT& aOffset,
return polygons;
}
template<class FT, class Polygon, class Weights, class OfK,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<Polygon, OfK>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
inline
create_exterior_weighted_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const Weights& aWeights,
const OfK& ofk)
{
return create_exterior_weighted_skeleton_and_offset_polygons_with_holes_2(aOffset, aPoly, aWeights, ofk,
Exact_predicates_inexact_constructions_kernel());
}
template<class FT, class Polygon, class Weights,
class OutPolygonWithHoles = typename CGAL_SS_i::Default_return_polygon_with_holes_type<
Polygon, Exact_predicates_inexact_constructions_kernel>::type>
std::vector<boost::shared_ptr<OutPolygonWithHoles> >
inline
create_exterior_weighted_skeleton_and_offset_polygons_with_holes_2(const FT& aOffset,
const Polygon& aPoly,
const Weights& aWeights)
{
return create_exterior_weighted_skeleton_and_offset_polygons_with_holes_2(aOffset, aPoly, aWeights,
Exact_predicates_inexact_constructions_kernel());
}
} // namespace CGAL
#endif // CGAL_CREATE_WEIGHTED_OFFSET_POLYGONS_FROM_POLYGON_WITH_HOLES_2_H

111
Straight_skeleton_2/include/CGAL/create_weighted_straight_skeleton_2.h
View File

@ -33,7 +33,7 @@ namespace CGAL {
template <typename PointIterator, typename HoleIterator,
typename WeightIterator, typename HoleWeightsIterator,
typename K>
typename K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr<Straight_skeleton_2<K> >
create_interior_weighted_straight_skeleton_2(PointIterator outer_contour_vertices_begin,
PointIterator outer_contour_vertices_end,
@ -43,7 +43,7 @@ create_interior_weighted_straight_skeleton_2(PointIterator outer_contour_vertice
WeightIterator outer_contour_weights_end,
HoleWeightsIterator holes_weights_begin,
HoleWeightsIterator holes_weights_end,
const K&)
const K& = K())
{
using Skeleton = Straight_skeleton_2<K>;
@ -77,37 +77,16 @@ create_interior_weighted_straight_skeleton_2(PointIterator outer_contour_vertice
return ssb.construct_skeleton();
}
template <typename PointIterator, typename HoleIterator,
typename WeightIterator, typename HoleWeightsIterator,
typename Weights>
boost::shared_ptr<Straight_skeleton_2<Exact_predicates_inexact_constructions_kernel> >
inline
create_interior_weighted_straight_skeleton_2(PointIterator outer_contour_vertices_begin,
PointIterator outer_contour_vertices_end,
HoleIterator holes_begin,
HoleIterator holes_end,
WeightIterator outer_contour_weights_begin,
WeightIterator outer_contour_weights_end,
HoleWeightsIterator holes_weights_begin,
HoleWeightsIterator holes_weights_end)
{
return create_interior_weighted_straight_skeleton_2(outer_contour_vertices_begin, outer_contour_vertices_end,
holes_begin, holes_end,
outer_contour_weights_begin, outer_contour_weights_end,
holes_weights_begin, holes_weights_end,
Exact_predicates_inexact_constructions_kernel());
}
template <typename PointIterator,
typename WeightIterator,
typename K>
typename K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr<Straight_skeleton_2<K> >
inline
create_interior_weighted_straight_skeleton_2(PointIterator outer_contour_vertices_begin,
PointIterator outer_contour_vertices_end,
WeightIterator outer_contour_weights_begin,
WeightIterator outer_contour_weights_end,
const K& k)
const K& k = K())
{
using InputPoint = typename std::iterator_traits<PointIterator>::value_type;
using InputKernel = typename Kernel_traits<InputPoint>::Kernel;
@ -127,51 +106,23 @@ create_interior_weighted_straight_skeleton_2(PointIterator outer_contour_vertice
k);
}
template <typename PointIterator,
typename WeightIterator>
boost::shared_ptr<Straight_skeleton_2<Exact_predicates_inexact_constructions_kernel> >
inline
create_interior_weighted_straight_skeleton_2(PointIterator outer_contour_vertices_begin,
PointIterator outer_contour_vertices_end,
WeightIterator outer_contour_weights_begin,
WeightIterator outer_contour_weights_end)
{
return create_interior_weighted_straight_skeleton_2(outer_contour_vertices_begin,
outer_contour_vertices_end,
outer_contour_weights_begin,
outer_contour_weights_end,
Exact_predicates_inexact_constructions_kernel());
}
template <typename Polygon,
typename Weights,
typename K>
typename K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr<Straight_skeleton_2<K> >
inline
create_interior_weighted_straight_skeleton_2(const Polygon& out_contour,
const Weights& weights,
const K& k,
const K& k = K(),
std::enable_if_t<! CGAL_SS_i::has_Hole_const_iterator<Polygon>::value>* = nullptr)
{
return create_interior_weighted_straight_skeleton_2(CGAL_SS_i::vertices_begin(out_contour),
CGAL_SS_i::vertices_end(out_contour),
weights.begin(),
weights.end(),
weights[0].begin(),
weights[0].end(),
k);
}
template <typename Polygon,
typename Weights>
boost::shared_ptr<Straight_skeleton_2<Exact_predicates_inexact_constructions_kernel> >
inline
create_interior_weighted_straight_skeleton_2(const Polygon& out_contour,
const Weights& weights)
{
return create_interior_weighted_straight_skeleton_2(out_contour,
weights,
Exact_predicates_inexact_constructions_kernel());
}
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -180,14 +131,14 @@ create_interior_weighted_straight_skeleton_2(const Polygon& out_contour,
template <typename FT,
typename PointIterator,
typename WeightIterator,
typename K>
typename K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr<Straight_skeleton_2<K> >
create_exterior_weighted_straight_skeleton_2(const FT& max_offset,
PointIterator vertices_begin,
PointIterator vertices_end,
WeightIterator weights_begin,
WeightIterator weights_end,
const K& k)
const K& k = K())
{
CGAL_precondition(max_offset > 0);
CGAL_precondition(std::distance(weights_begin, weights_end) == std::distance(vertices_begin, vertices_end));
@ -259,59 +210,25 @@ create_exterior_weighted_straight_skeleton_2(const FT& max_offset,
return skeleton;
}
template <typename FT,
typename PointIterator,
typename WeightIterator>
boost::shared_ptr<Straight_skeleton_2<Exact_predicates_inexact_constructions_kernel> >
inline
create_exterior_weighted_straight_skeleton_2(const FT& max_offset,
PointIterator vertices_begin,
PointIterator vertices_end,
WeightIterator weights_begin,
WeightIterator weights_end)
{
return create_exterior_weighted_straight_skeleton_2(max_offset,
vertices_begin,
vertices_end,
weights_begin,
weights_end,
Exact_predicates_inexact_constructions_kernel());
}
template <typename FT,
typename Polygon,
typename Weights,
typename K>
typename K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr<Straight_skeleton_2<K> >
inline
create_exterior_weighted_straight_skeleton_2(const FT& max_offset,
const Polygon& aPoly,
Weights& weights,
const K& k)
const K& k = K())
{
return create_exterior_weighted_straight_skeleton_2(max_offset,
CGAL_SS_i::vertices_begin(aPoly),
CGAL_SS_i::vertices_end(aPoly),
weights.begin(),
weights.end(),
weights[0].begin(),
weights[0].end(),
k);
}
template <typename FT,
typename Weights,
typename Polygon>
boost::shared_ptr<Straight_skeleton_2<Exact_predicates_inexact_constructions_kernel> >
inline
create_exterior_weighted_straight_skeleton_2(const FT& max_offset,
Weights& weights,
const Polygon& aPoly)
{
return create_exterior_weighted_straight_skeleton_2(max_offset,
aPoly,
weights,
Exact_predicates_inexact_constructions_kernel());
}
} // namespace CGAL
#endif // CGAL_CREATE_WEIGHTED_STRAIGHT_SKELETON_2_H

4
Straight_skeleton_2/include/CGAL/create_weighted_straight_skeleton_from_polygon_with_holes_2.h
View File

@ -28,12 +28,12 @@ namespace CGAL {
template <typename Polygon,
typename Weights,
typename K>
typename K = Exact_predicates_inexact_constructions_kernel>
boost::shared_ptr< Straight_skeleton_2<K> >
inline
create_interior_weighted_straight_skeleton_2(const Polygon& poly_with_holes,
const Weights& weights,
const K& k,
const K& k = K(),
std::enable_if_t<
CGAL_SS_i::has_Hole_const_iterator<Polygon>::value>* = nullptr)
{