The SDG traits define a tag named Tag_has_bisector_constructions
that is either Tag_false or Tag_true.
If it is Tag_false, the bisector constructions are the hard-coded
ones from the algorithm (essentially they are the L2 ones).
If it is Tag_true, the bisector constructions are taken from the
traits. This is how the Linf traits are implemented.
This way, we avoid SFINAE.
Introduce pointers for functions that insert a point on a segment.
For L2, to keep the same functionality as before, the pointers
point to insert_exact_point_on_segment and insert_point_on_segment
functions.
Classes derived from Segment_Delaunay_graph_2 can change the
pointers to point to more specialized functions. For example, the
Linf implementation will point to different specialized function
defined in the Linf class.
Use an additional optional parameter (SDGLx) in the segment
Delaunay hierarchy template to be able to change the segment
Delaunay graph class that is used per level of the hierarchy.
Since this is the last optional parameter, there is no change
for users of the L2 segment Delaunau graph and hierarchy.
This parameter is necessary to support the Linf segment Delaunay
graph and hierarchy. Again, it is intended that the user of the
Linf classes does not have to be aware of this parameter.
Some additional classes are declared as friends of
Segment_Delaunay_graph_2.
If construction templates for bisectors (line, segment, ray)
exist in the traits, then use them, otherwise, use the L2 traits.
The check is implemented by a type Has_bisector_constructions_type
that might be included in the traits and using the
"Substitution failure is not an error" (SFINAE) principle.
The oriented_side predicate is used with a face corresponding to
the interior of a segment that is split by a vertex contained in
the segment. For an infinite such face the code has to become more
general in order to accomodate the Linf case. For example, in L2
the number of such infinite faces is 0, 2, or 4, whereas in Linf,
it can be any even non-negative integer.
Moreover, the existing code for infinite faces is L2 specific and
ignores the interior of the segment for its decision. In Linf the
interior of the segment is important. For this reason, there is a
new case of the predicate that is general enough to also
accomodate Linf:
// computes the oriented side of the Voronoi vertex of s1, s2, inf
// wrt the line that passes through the point p and its direction
// is the direction of the supporting line of s, rotated by 90
// degrees counterclockwise.
Oriented_side operator()(const Site_2& s1, const Site_2& s2,
const Site_2& s, const Site_2& p) const
The Oriented_side_C2 class is also adapted for L2 to use the new
form of the predicate, which internally calls the old form.
Use vertex conflict instead of orientation in insert_third for
the case of three points. This change is to make SDG more L2
agnostic.
Given are three point sites s1, s2, s3.
The orientation of (s1,s2,s3) is not collinear if and only if the
two vertex conflict quadruples (s1,s2,inf,s3) and (s2,s1,inf,s3)
are of opposite signs.
The orientation of (s1,s2,s3) is right turn if and only if the
vertex conflict quadruple (s2,s1,inf,s3) is NEGATIVE.
Mael Rouxel-Labbé
Andreas Fabri
Sébastien Loriot
Simon Giraudot
Laurent Rineau
Jane Tournois
Marc Glisse
Panagiotis Cheilaris