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

Documentation

This commit is contained in:
Pavel Emeliyanenko 2008-03-15 17:20:57 +00:00
parent 19f7695618
commit 5340bd524d
8 changed files with 888 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

667
Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Arc_2.tex
View File

@ -24,7 +24,11 @@
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccDefinition)
class defines a point on a generic curve
Class defines an arc on a curve that can be analyzed.
An arc is either non-vertical or vertical. If it is non-vertical, we can assign a constant arc number to its interior and we may can assign (non-identical) arc numbers to its end-points. It depends on whether the arc toches the bondary of the parameter space or not. If it is vertical, no arc number is available.
We distinguish between interior arcs, rays, and branches. An interior arc lies completely in the parameter space, while a ray has one end that lies on the boundary of the parameter space, and both ends of a branch lie on the boundary.
%END-AUTO(\ccDefinition)
@ -47,6 +51,11 @@ class \ccc{Arc_2};
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccTypes)
\ccNestedType{Curved_kernel_via_analysis_2}
{
this instance's first template parameter
}
\ccGlue
\ccNestedType{Rep}
{
this instance's second template parameter
@ -72,6 +81,10 @@ type of an x-coordinate
type of a finite point on curve
}
\ccGlue
\ccNestedType{Boundary}
{
}
\ccGlue
\ccNestedType{Curve_analysis_2}
{
type of analysis of a pair of curves
@ -84,7 +97,7 @@ type of analysis of a pair of curves
\ccGlue
\ccNestedType{Point_2}
{
type of a point on generic curve
type of a kernel point
}
\ccGlue
\ccNestedType{Kernel_arc_2}
@ -92,6 +105,15 @@ type of a point on generic curve
type of kernel arc
}
\ccGlue
\ccNestedType{Base}
{
the handle superclass
}
\ccGlue
\ccNestedType{SCA_2}
{
}
\ccGlue
%END-AUTO(\ccTypes)
@ -100,57 +122,107 @@ type of kernel arc
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccHeading{Variables})
\ccMethod{CGAL::Arr_parameter_space location(CGAL::Arr_curve_end end) const;}
\ccMethod{CGAL::Arr_parameter_space location(CGAL::Arr_curve_end ce) const;}
{
returns location of arc's end in parameter space
}
\ccGlue
\ccMethod{void set_location(CGAL::Arr_curve_end end, CGAL::Arr_parameter_space loc) const;}
{
sets boundary type for curve end end
it's supposed that the user thoroughly understands malicious consequences that may result from the misuse of boundary conditions
}
\ccGlue
\ccMethod{bool is_finite(CGAL::Arr_curve_end end) const;}
{
returns whether curve-end can be accessed
}
\ccGlue
\ccMethod{Point_2 curve_end(CGAL::Arr_curve_end end) const;}
{
returns arc's finite curve end end
location of arc's end
}
\ccGlue
\begin{description}
\item[Precondition:]accessed curve end has finite x/y-coordinates \end{description}
\item[Parameters:]
\begin{description}
\item[ce]The intended end \end{description}
\end{description}
\begin{description}
\item[Returns:]The location of arc's ce in parameterspace \end{description}
\ccGlue
\ccMethod{X_coordinate_1 curve_end_x(CGAL::Arr_curve_end end) const;}
\ccMethod{void set_location(CGAL::Arr_curve_end ce, CGAL::Arr_parameter_space loc) const;}
{
returns arc's curve end end x-coordinate
Sets boundary type for an end of an arc.
It's supposed that the user thoroughly understands malicious consequences that may result from the misuse of the location
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[ce]The intended end \item[loc]The location to store \end{description}
\end{description}
\ccGlue
\ccMethod{bool is_finite(CGAL::Arr_curve_end ce) const;}
{
Is a curve-end finite?
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[ce]The intended end \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if finite, false, otherwise \end{description}
\ccGlue
\ccMethod{Point_2 curve_end(CGAL::Arr_curve_end ce) const;}
{
returns arc's interior curve end
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[ce]The intended end \end{description}
\end{description}
\begin{description}
\item[Returns:]The minimal point of the arc, or the maximal point of the arc\end{description}
\begin{description}
\item[Precondition:]accessed curve end has finite coordinates \end{description}
\ccGlue
\ccMethod{X_coordinate_1 curve_end_x(CGAL::Arr_curve_end ce) const;}
{
returns x-coordinate of arc's curve end
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[ce]The intended end \end{description}
\end{description}
\begin{description}
\item[Returns:]x-coordinate of arc's end at ce \end{description}
\begin{description}
\item[Precondition:]accessed curve end has finite x-coordinate \end{description}
\ccGlue
\ccMethod{const Curve_analysis_2& curve() const;}
{
returns supporting curve of the arc
}
\ccGlue
\ccMethod{int arcno() const;}
{
returns arc number
supporting curve of the arc
}
\ccGlue
\begin{description}
\item[Returns:]supporting curve of the arc \end{description}
\ccGlue
\ccMethod{int arcno() const;}
{
arc number in interior
}
\ccGlue
\begin{description}
\item[Returns:]arc number\end{description}
\begin{description}
\item[Precondition:]!\ccc{is_vertical}() \end{description}
\ccGlue
\ccMethod{int arcno(CGAL::Arr_curve_end end) const;}
\ccMethod{int arcno(CGAL::Arr_curve_end ce) const;}
{
returns this arc's end arc number
!\ccc{is_vertical}()
arc number of end of arc, which may be different from arc number in its interior
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[ce]The intended end \end{description}
\end{description}
\begin{description}
\item[Returns:]Arc number of intended end \end{description}
\begin{description}
\item[Precondition:]!\ccc{is_vertical}() \end{description}
\ccGlue
\ccMethod{int arcno(const X_coordinate_1& x0) const;}
{
arc number at given x-coordinate
@ -158,6 +230,13 @@ If x0 equals to source's or target's x-coordinate, then the arc number of that p
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[x0]queried x-coordinate \end{description}
\end{description}
\begin{description}
\item[Returns:]arcnumber at x0 \end{description}
\begin{description}
\item[Precondition:]!\ccc{is_vertical}()
x0 must be within arcs's x-range. \end{description}
\ccGlue
@ -166,12 +245,17 @@ x0 must be within arcs's x-range. \end{description}
checks if the arc is vertical
}
\ccGlue
\begin{description}
\item[Returns:]true, if vertical, false, otherwise \end{description}
\ccGlue
\ccMethod{const X_coordinate_1& x() const;}
{
returns x-coordinate of vertical arc
}
\ccGlue
\begin{description}
\item[Returns:]x-coordinate line that contains vertical arc \end{description}
\begin{description}
\item[Precondition:]\ccc{is_vertical} \end{description}
\ccGlue
\ccMethod{int interval_id() const;}
@ -180,6 +264,8 @@ returns the index of an open interval between two events $\ast$this arc belongs
}
\ccGlue
\begin{description}
\item[Returns:]interval id of supporting curve for this arc \end{description}
\begin{description}
\item[Precondition:]!\ccc{is_vertical}() \end{description}
\ccGlue
\ccMethod{Boundary boundary_in_x_range_interior() const;}
@ -187,58 +273,59 @@ returns the index of an open interval between two events $\ast$this arc belongs
returns boundary value in interior of x-range of non-vertical interval
}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_x_near_boundary(CGAL::Arr_curve_end end, const Point_2& p) const;}
\begin{description}
\item[Returns:]a rational x-coordinate in the interior of the arc's x-range \end{description}
\begin{description}
\item[Precondition:]!\ccc{is_vertical}() \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_x_near_boundary(CGAL::Arr_curve_end ce, const Point_2& p) const;}
{
Compare the relative positions of a vertical curve and unbounded this arc's end
Compare the relative x-positions of an interior point this arc's end on a bottom or top boundary
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[p]A reference point; we refer to a vertical line incident to p. \item[end]\ccc{ARR_MIN_END} if we refer to cv's minimal end, \ccc{ARR_MAX_END} if we refer to its maximal end. \end{description}
\item[p]A reference point; we refer to a vertical line incident to p. \item[ce]\ccc{ARR_MIN_END} if we refer to cv's minimal end, \ccc{ARR_MAX_END} if we refer to its maximal end. \end{description}
\end{description}
\begin{description}
\item[Precondition:]curve's relevant end is defined at y = +/- oo. \end{description}
\item[Returns:]\ccc{CGAL::SMALLER} if p lies to the left of cv; \ccc{CGAL::LARGER} if p lies to the right of cv; \ccc{CGAL::EQUAL} in case of an overlap.\end{description}
\begin{description}
\item[Returns:]SMALLER if p lies to the left of cv; LARGER if p lies to the right of cv; EQUAL in case of an overlap. \end{description}
\item[Precondition:]curve's relevant end is on bottom or top boundary \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_x_near_boundary(CGAL::Arr_curve_end end1, const Kernel_arc_2& cv2, CGAL::Arr_curve_end end2) const;}
\ccMethod{CGAL::Comparison_result compare_x_near_boundary(CGAL::Arr_curve_end ce1, const Kernel_arc_2& cv2, CGAL::Arr_curve_end ce2) const;}
{
Compare the relative positions of the unbounded curve ends of this and cv2
Compare the relative x-positions of the curve ends of $\ast$this and cv2.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[end1]\ccc{ARR_MIN_END} if we refer to this' minimal end, \ccc{ARR_MAX_END} if we refer to this' maximal end. \item[cv2]The second curve. \item[end2]\ccc{ARR_MIN_END} if we refer to its minimal end, \ccc{ARR_MAX_END} if we refer to its maximal end. \end{description}
\item[ce1]\ccc{ARR_MIN_END} if we refer to this' minimal end, \ccc{ARR_MAX_END} if we refer to this' maximal end. \item[cv2]The second curve. \item[ce2]\ccc{ARR_MIN_END} if we refer to its minimal end, \ccc{ARR_MAX_END} if we refer to its maximal end. \end{description}
\end{description}
\begin{description}
\item[Precondition:]the curve ends have a bounded x-coord and unbounded y-coord, namely each of this and cv2 is vertical or asymptotic \end{description}
\item[Returns:]\ccc{CGAL::SMALLER} if this lies to the left of cv2; \ccc{CGAL::LARGER} if this lies to the right of cv2; \ccc{CGAL::EQUAL} in case of an overlap.\end{description}
\begin{description}
\item[Returns:]SMALLER if this lies to the left of cv2; LARGER if this lies to the right of cv2; EQUAL in case of an overlap. \end{description}
\item[Precondition:]the curve end lies on the bottom or top boundary \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_x_near_boundary(CGAL::Arr_curve_end end1, const Kernel_arc_2& cv2, CGAL::Arr_curve_end end2) const;}
\ccMethod{CGAL::Comparison_result compare_y_near_boundary(const Kernel_arc_2& cv2, CGAL::Arr_curve_end ce) const;}
{
}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_y_near_boundary(const Kernel_arc_2& cv2, CGAL::Arr_curve_end end) const;}
{
Compare the relative y-positions of two arcs at x = +/- oo.
Compare the relative y-positions of two arcs whose ends approach the left or right boundary from the same side.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second curve \item[end]\ccc{ARR_MIN_END} if we compare at x = -oo; \ccc{ARR_MAX_END} if we compare at x = +oo. \end{description}
\item[cv2]The second arc \item[ce]\ccc{ARR_MIN_END} if we compare near left boundary \ccc{ARR_MAX_END} if we compare near right boundary \end{description}
\end{description}
\begin{description}
\item[Precondition:]The curves are defined at x = +/- oo. \end{description}
\item[Returns:]\ccc{CGAL::SMALLER} if this arc lies below cv2; \ccc{CGAL::LARGER} if this arc lies above cv2; \ccc{CGAL::EQUAL} in case of an overlap.\end{description}
\begin{description}
\item[Returns:]SMALLER if this arc lies below cv2; LARGER if this arc lies above cv2; EQUAL in case of an overlap. \end{description}
\item[Precondition:]The ends are defined on left or right boundary \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_y_at_x(const Point_2& p) const;}
{
Return the location of the given point with respect to this arc
Compares the relative vertical alignment of a point with this arc.
}
\ccGlue
\begin{description}
@ -247,43 +334,41 @@ Return the location of the given point with respect to this arc
\item[p]The point. \end{description}
\end{description}
\begin{description}
\item[Precondition:]p is in the x-range of the arc. \end{description}
\item[Returns:]\ccc{CGAL::SMALLER} if y(p) $<$ arc(x(p)), i.e. the point is below the arc; \ccc{CGAL::LARGER} if y(p) $>$ arc(x(p)), i.e. the point is above the arc; \ccc{CGAL::EQUAL} if p lies on the arc.\end{description}
\begin{description}
\item[Returns:]SMALLER if y(p) $<$ arc(x(p)), i.e. the point is below the arc; LARGER if y(p) $>$ arc(x(p)), i.e. the point is above the arc; EQUAL if p lies on the arc. \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_y_at_x(const Point_2& p) const;}
{
}
\item[Precondition:]p is in the x-range of the arc. \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_y_at_x_left(const Kernel_arc_2& cv2, const Point_2& p) const;}
{
Compares the y value of two x-monotone curves immediately to the left of their intersection point. If one of the curves is vertical (emanating downward from p), it's always considered to be below the other curve.
Compares the relative aligment of this arc with a second immediately to the left of one of their intersection points.
If one of the curves is vertical (emanating downward from p), it's always considered to be below the other curve.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second curve. \item[p]The intersection point. \end{description}
\item[cv2]The second arc \item[p]The intersection point\end{description}
\end{description}
\begin{description}
\item[Precondition:]The point p lies on both curves, and both of them must be also be defined (lexicographical) to its left. \end{description}
\item[Returns:]The relative vertical alignment this arc with respect to cv2 immediately to the left of p: SMALLER, LARGER or EQUAL.\end{description}
\begin{description}
\item[Returns:]The relative position of this arc with respect to cv2 immdiately to the left of p: SMALLER, LARGER or EQUAL. \end{description}
\item[Precondition:]The point p lies on both curves, and both of them must be also be defined (lexicographical) to its left. \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_y_at_x_right(const Kernel_arc_2& cv2, const Point_2& p) const;}
{
Compares the y value of two x-monotone curves immediately to the right of their intersection point. If one of the curves is vertical (emanating upward from p), it's always considered to be above the other curve.
Compares the relative aligment of this arc with a second immediately to the right of one of their intersection points.
If one of the curves is vertical (emanating downward from p), it's always considered to be below the other curve.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv1]The first curve. \item[cv2]The second curve. \item[p]The intersection point. \end{description}
\item[cv2]The second arc \item[p]The intersection point\end{description}
\end{description}
\begin{description}
\item[Precondition:]The point p lies on both curves, and both of them must be also be defined (lexicographically) to its right. \end{description}
\item[Returns:]The relative vertical alignment this arc with respect to cv2 immediately to the right of p: SMALLER, LARGER or EQUAL.\end{description}
\begin{description}
\item[Returns:]The relative position of cv1 with respect to cv2 immdiately to the right of p: SMALLER, LARGER or EQUAL. \end{description}
\item[Precondition:]The point p lies on both curves, and both of them must be also be defined (lexicographical) to its right. \end{description}
\ccGlue
\ccMethod{bool is_in_x_range(const X_coordinate_1& x, bool * eq_min = NULL, bool * eq_max = NULL) const;}
{
@ -295,22 +380,48 @@ Check if the given x-value is in the x-range of the arc inclusive.
\begin{description}
\item[x]The x-value. \item[$\ast$\ccc{eq_min}]Output: Is this value equal to the x-coordinate of the \ccc{ARR_MIN_END} point. \item[$\ast$\ccc{eq_max}]Output: Is this value equal to the x-coordinate of the \ccc{ARR_MAX_END} point. \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if p.x() is in x-range of arc, false otherwise \end{description}
\ccGlue
\ccMethod{bool is_in_x_range_interior(const X_coordinate_1& x) const;}
{
checks whether x-coordinate x belongs to this arc's interior
Checks whether an x-coordinate lies in the interiors of this arc's x-range.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[x]The query coordinate \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if x lies in the interior of this arc's x-range, false otherwise \end{description}
\ccGlue
\ccMethod{bool is_equal(const Kernel_arc_2& cv2) const;}
{
returns true iff this arc is equal to cv
Checks whether a given arcs is equal to this one.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The query arc \end{description}
\end{description}
\begin{description}
\item[Returns:]true iff this arc is equal to cv, false otherwise \end{description}
\ccGlue
\ccMethod{bool do_overlap(const Kernel_arc_2& cv2) const;}
{
checks whether two curve arcs have infinitely many intersection points, i.e., they overlap
checks whether this arcs overlaps with another
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The query arc \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if both arcs have infinitely many intersection points, false otherwise \end{description}
\ccGlue
\ccMethod{int multiplicity_of_intersection(const Kernel_arc_2& cv2, const Point_2& p) const;}
{
multiplicity of intersection
@ -318,105 +429,375 @@ The intersection multiplicity of $\ast$this and cv2 at point p is returned.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second arc \item[p]The intersection point \end{description}
\end{description}
\begin{description}
\item[Precondition:]p must be an intersection point. \end{description}
\ccGlue
\ccMethod{OutputIterator intersections(const Kernel_arc_2& cv2, OutputIterator oi) const;}
{
Find all intersections of the two given curves and insert them to the output iterator. If two arcs intersect only once, only a single will be placed to the iterator. Type of output iterator is \ccc{CGAL::Object} containing either an \ccc{Arc_2} object (overlap) or a \ccc{Point_2} object with multiplicity (point-wise intersections) are inserted to the output iterator oi as objects of type $<$tt$>$\ccc{std::pair<Point_2, unsigned int>} (intersection point + multiplicity).
Find all intersections of this arc with another one and insert them to the output iterator.
Type of output iterator is \ccc{CGAL::Object}. It either contains an \ccc{Arc_2} object (overlap) or a \ccc{std::pair<Point_2, unsigned int>} (intersection point + multiplicity). A past-the-end iterator is returned.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second arc \item[oi]The outputiterator \end{description}
\end{description}
\begin{description}
\item[Returns:]A past-the-end iterator of oi \end{description}
\ccGlue
\ccMethod{bool intersect_right_of_point(const Kernel_arc_2& cv2, const Point_2& p, Point_2& intersection) const;}
{
computes the next intersection of $\ast$this and cv2 right of p in lexicographical order and returns it through intersection argument
Computes the next intersection of $\ast$this and cv2 right of p in lexicographical order and returns it through intersection argument.
\ccc{intersect_right_of_point} is not called when using \ccc{sweep_curves}() with intersection dictionary and without validation of internal structures (as is standard). Hence we can be lazy here for the moment without losing performance.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second arc \item[p]The minimal bound point \item[intersection]The next intersection \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if there is a next intersection and intersection has been set properly, false otherwise \end{description}
\begin{description}
\item[Precondition:]The arcs are not allowed to overlap \end{description}
\ccGlue
\ccMethod{bool intersect_left_of_point(const Kernel_arc_2& cv2, const Point_2& p, Point_2& intersection) const;}
{
computes the next intersection of $\ast$this and cv2 left of p in lexicographical order and returns it through intersection argument
Computes the next intersection of $\ast$this and cv2 left of p in lexicographical order and returns it through intersection argument.
\ccc{intersect_right_of_point} is not called when using \ccc{sweep_curves}() with intersection dictionary and without validation of internal structures (as is standard). Hence we can be lazy here for the moment without losing performance.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second arc \item[p]The maximal bound point \item[intersection]The next intersection \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if there is a next intersection and intersection has been set properly, false otherwise \end{description}
\begin{description}
\item[Precondition:]The arcs are not allowed to overlap \end{description}
\ccGlue
\ccMethod{Kernel_arc_2 trim(const Point_2& p, const Point_2& q) const;}
{
returns a trimmed version of this arc with new end-points p and q; lexicographical order of the end-points is ensured in case of need.
Returns a trimmed version of an arc.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[p]the new first endpoint \item[q]the new second endpoint \end{description}
\end{description}
\begin{description}
\item[Returns:]The trimmed arc\end{description}
\begin{description}
\item[Precondition:]p != q
p and q lie on $\ast$this arc \end{description}
both points must be interior and must lie on cv \end{description}
\ccGlue
\ccMethod{void split(const Point_2& p, Kernel_arc_2& s1, Kernel_arc_2& s2) const;}
{
Splits a given x-monotone curve at a given point into two sub-curves.
Split a arc at a given point into two sub-arc.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[p]The split point. \item[c1]Output: The left resulting subcurve (p is its right endpoint) \item[c2]Output: The right resulting subcurve (p is its left endpoint) \end{description}
\item[p]The split point \item[s1]Output: The left resulting subcurve (p is its right endpoint) \item[s2]Output: The right resulting subcurve (p is its left endpoint)\end{description}
\end{description}
\begin{description}
\item[Precondition:]p lies on this arc but is not one of its curve ends \end{description}
\item[Precondition:]p lies on cv but is not one of its end-points. \end{description}
\ccGlue
\ccMethod{bool are_mergeable(const Kernel_arc_2& cv2) const;}
{
Check whether two given curves (arcs) are mergeable.
Check whether this arc can be merged with a second.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv]The second curve. \end{description}
\item[cv2]The second arc \end{description}
\end{description}
\begin{description}
\item[Returns:](true) if the two arcs are mergeable, i.e., they are supported by the same curve and share a common endpoint; (false) otherwise. \end{description}
\item[Returns:]true if the two arcs are mergeable, i.e., they are supported by the same curve and share a common endpoint; false otherwise. \end{description}
\ccGlue
\ccMethod{Kernel_arc_2 merge(const Kernel_arc_2& cv2) const;}
{
Merge two given x-monotone curves into a single one.
Merges this arc with a second.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second curve. \item[c]Output: The resulting curve. \end{description}
\item[cv2]The second arc \end{description}
\end{description}
\begin{description}
\item[Precondition:]Two curves are mergeable,if they are supported by the same curve and share a common end-point. \end{description}
\item[Returns:]The resulting arc\end{description}
\begin{description}
\item[Precondition:]The two arcs are mergeable, that is they are supported by the same curve and share a common endpoint. \end{description}
\ccGlue
\ccMethod{static bool simplify(const Kernel_arc_2& cv, const Xy_coordinate_2& p);}
{
[static] \\
simplifies representation of cv and/or p in case they have non-coprime supporting curves.
returns true if simplification took place
}
\ccGlue
\begin{description}
\item[Returns:]true if simplification took place, false otherwise \end{description}
\ccGlue
\ccMethod{static bool simplify(const Kernel_arc_2& cv1, const Kernel_arc_2& cv2);}
{
[static] \\
simplifies representation of cv1 and/or cv2 in case they have non-coprime supporting curves.
returns true if simplification took place
}
\ccGlue
\begin{description}
\item[Returns:]true if simplification took place, false otherwise \end{description}
\ccGlue
\ccMethod{Kernel_arc_2 _trim(const Point_2& p, const Point_2& q) const;}
{
[protected] \\
Returns a trimmed version of an arc (internal version that does not use functor).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[p]the new first endpoint \item[q]the new second endpoint \end{description}
\end{description}
\begin{description}
\item[Returns:]The trimmed arc\end{description}
\begin{description}
\item[Precondition:]p != q
both points must be interior and must lie on cv \end{description}
\ccGlue
\ccMethod{bool trim_by_arc(const Kernel_arc_2& cv2, Kernel_arc_2& trimmed1, Kernel_arc_2& trimmed2) const;}
{
Trims this arc and cv2 to the common x-range, if it is non-trivial.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]the second arc \item[trimmed1]Output: trimmed version of $\ast$this to joint x-range of $\ast$this and cv2 \item[trimmed1]Output: trimmed version of cv2 to joint x-range of $\ast$this and cv2 \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if $\ast$this and cv2 share a non-trivial common x-range, false otherwise \end{description}
\ccGlue
\ccMethod{void _fix_curve_ends_order();}
{
[protected] \\
function to ensure lexicographical order of the curve ends
must be called once from constructor
}
\ccGlue
\ccMethod{void _check_pt_arcno_and_coprimality(const Point_2& pt, int arcno_on_c, const Curve_analysis_2& c) const;}
{
[protected] \\
establishes preconditions that point pt lies on the curve c with arc number \ccc{arcno_on_c}, also checks that point's supporting curve and c are coprime
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[pt]Given point \item[\ccc{arcno_on_c}]Arcno on curve \item[c]Supporting curve \end{description}
\end{description}
\ccGlue
\ccMethod{void _check_arc_interior() const;}
{
[protected] \\
establishes preconditions to ensure that there are no event points in the arc's interior (only at source and target) and its arc number is constant
}
\ccGlue
\begin{description}
\item[Precondition:]before calling this method source and target must be sorted using \ccc{_fix_curve_ends_order}() \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result _compare_arc_numbers(const Kernel_arc_2& cv2, CGAL::Arr_parameter_space where, X_coordinate_1 x0 = X_coordinate_1(), CGAL::Sign perturb = CGAL::ZERO) const;}
{
[protected] \\
compares y-coordinates of two arcs over an open (or closed) interval or at exact x-coordinate
where specifies whether to compare at negative/positive boundary or at finite point. if where = \ccc{ARR_INTERIOR} perturb defines to compare slightly to the left, on, or to the right of x0
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]the second arc \item[where]the location in parameter space \item[x0]The x-coordinate \item[perturb]determines whether to pertub slightly to the left/right \end{description}
\end{description}
\begin{description}
\item[Returns:]the relative vertical alignment\end{description}
\begin{description}
\item[Precondition:]!\ccc{is_on_bottom_top}(where) \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result _compare_coprime(const Kernel_arc_2& cv2, CGAL::Arr_parameter_space where, X_coordinate_1 x0, CGAL::Sign perturb) const;}
{
[protected] \\
computes vertical ordering of $\ast$this and cv2 having coprime supporting curves
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]the second arc \item[where]the location in parameter space \item[x0]The x-coordinate \item[perturb]determines whether to pertub slightly to the left/right \end{description}
\end{description}
\begin{description}
\item[Returns:]the relative vertical alignment \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result _same_arc_compare_xy(const Point_2& p, const Point_2& q, bool equal_x = false, bool only_x = false) const;}
{
[protected] \\
}
\ccGlue
\ccMethod{const Point_2& _minpoint() const;}
{
[protected] \\
min end-point of this arc (provided for code readability)
}
\ccGlue
\begin{description}
\item[Returns:]min endpoint of arc (may lie on a boundary!) \end{description}
\ccGlue
\ccMethod{const Point_2& _maxpoint() const;}
{
[protected] \\
max end-point of this arc (provided for code readability)
}
\ccGlue
\begin{description}
\item[Returns:]max endpoint of arc (may lie on a boundary!) \end{description}
\ccGlue
\ccMethod{int _compute_interval_id() const;}
{
[protected] \\
computes this arc's interval index
}
\ccGlue
\begin{description}
\item[Precondition:]!\ccc{is_vertical}() \end{description}
\ccGlue
\ccMethod{Boundary _compute_boundary_in_interval() const;}
{
[protected] \\
computes this rational value in the interiors of the arc's x-range
}
\ccGlue
\begin{description}
\item[Precondition:]!\ccc{is_vertical}() \end{description}
\ccGlue
\ccMethod{std::pair<Kernel_arc_2, CGAL::Comparison_result> _replace_endpoints(const Point_2& p1, const Point_2& p2, int arcno1 = -1, int arcno2 = -1) const;}
{
[protected] \\
Replaces this arc's end-points by p1 and p2 with arcnos arcno1 and arcno2.
new curve ends are sorted lexicographical in case of need; all preconditions must be checked by the caller
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[p1]new first endpoint \item[p2]new second endpoint \item[arcno1]new first arcno (at p1) \item[arcno1]new second arcno (at p2) \end{description}
\end{description}
\begin{description}
\item[Returns:]pair whose first entry represent the refined arc, and whose second entry reports the lexicographic comparison of p1 and p2 \end{description}
\ccGlue
\ccMethod{void _simplify_by(const Curve_pair_analysis_2& cpa_2) const;}
{
[protected] \\
Simplifies representation of the arc !! DEPRECATED FUNCTION !!
Given a decomposition of the arcs's supporting curve into a pair of two curves \ccc{cpa_2}, we search for a curve this arc lies on and reset arc's supporting curve and arcnos appropriately.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[\ccc{cpa_2}]analysis o curve pair that should be used in simplification \end{description}
\end{description}
\begin{description}
\item[Precondition:]\ccc{cpa_2} must correspond to a decomposition of this arc's supporting curve \end{description}
\ccGlue
\ccMethod{bool _trim_if_overlapped(const Kernel_arc_2& cv2, OutputIterator oi) const;}
{
[protected] \\
returns true if the two arcs $\ast$this and cv2 overlap, overlapping part(s) are inserted to the output iterator oi (of type \ccc{Kernel_arc_2} ); if no overlapping parts found - returns false
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second arc \item[oi]Report overlapping parts to this output iterator \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if there was an overlap, false otherwise \end{description}
\ccGlue
\ccMethod{static OutputIterator _intersection_points(const Kernel_arc_2& cv1, const Kernel_arc_2& cv2, OutputIterator oi);}
{
[static, protected] \\
computes zero-dimensional intersections of cv1 with cv2.
Intersection points are inserted to the output iterator oi as objects of type \ccc{std::pair<Point_2, unsigned int>} (intersection point + multiplicity)
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv1]the first arc \item[cv2]the second arc \item[oi]reporting zero-dimensional intersection through this output iterator \end{description}
\end{description}
\begin{description}
\item[Precondition:]!cv1.\ccc{do_overlap}() \end{description}
\ccGlue
\ccMethod{static OutputIterator _intersect_at_endpoints(const Kernel_arc_2& cv1, const Kernel_arc_2& cv2, OutputIterator oi);}
{
[static, protected] \\
computes intersection of two arcs meeting only at their curve ends.
Intersection points are returned in the output interator oi as object of type \ccc{std::pair<Point_2, int>} (intersection + multiplicity)
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv1]the first arc \item[cv2]the second arc \item[oi]reporting zero-dimensional intersection through this output iterator \end{description}
\end{description}
\ccGlue
\ccMethod{bool _joint_x_range(const Kernel_arc_2& cv2, Point_2& pt_low, Point_2& pt_high) const;}
{
[protected] \\
computes a joint x-range of two arcs and returns true if arcs' x-ranges overlap; otherwise returns false
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv2]The second arc \item[\ccc{pt_low}]Output: Point indicating the lower bound of the the joint x-range \item[\ccc{pt_high}]Output: Point indicating the upper bound of the the joint x-range \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if arcs overlap, false otherwise\end{description}
\begin{description}
\item[Precondition:]both arcs are not vertical \end{description}
\ccGlue
\ccMethod{static OutputIterator _intersect_coprime_support(const Kernel_arc_2& cv1, const Kernel_arc_2& cv2, OutputIterator oi);}
{
[static, protected] \\
computes zero-dimensional intersection of two arcs having coprime supporting curves
intersection points are inserted to the output iterator oi as objects of type \ccc{std::pair<Point_2, unsigned int>} (intersection point + multiplicity)
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[cv1]the first arc \item[cv2]the second arc \item[oi]reporting zero-dimensional intersection through this output iterator \end{description}
\end{description}
\ccGlue
\ccMethod{void write(std::ostream& os) const;}
{
output operator
}
{
write arc to os
\subsubsection{Friends And Related Function Documentation}
\ccMethod{std::ostream& operator<<(std::ostream& os, const Arc_2< CurvedKernelViaAnalysis_2, Rep_>& arc);}
{
[related] \\
output operator
\subsubsection{Member Data Documentation}
\ccVariable{name publuic typedefs* typedef CurvedKernelViaAnalysis_2 Curved_kernel_via_analysis_2;}
{
this instance's first template parameter
writes arc to os
}
\ccGlue
@ -442,74 +823,148 @@ copy constructor
\ccGlue
\ccConstructor{Arc_2(const Point_2& p, const Point_2& q, const Curve_analysis_2& c, int arcno, int arcno_p, int arcno_q);}
{
constructs an arc with two finite end-points, supported by curve c with arcno (segment)
\ccc{arcno_p} and \ccc{arcno_q} define arcnos of p and q w.r.t. the curve c
Constructs an arc with two interior end-points (segment).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[p]first endpoint \item[q]second endpoint \item[c]The supporting curve \item[arcno]The arcnumber wrt c in the interior of the arc \item[\ccc{arcno_p}]The arcnumber wrt c of the arc at p \item[\ccc{arcno_q}]The arcnumber wrt c of the arc at q \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed segment\end{description}
\begin{description}
\item[Precondition:]p.x() != q.x() \end{description}
\ccGlue
\ccConstructor{Arc_2(const Point_2& origin, CGAL::Arr_curve_end inf_end, const Curve_analysis_2& c, int arcno, int arcno_o);}
{
constructs an arc with one finite end-point origin and one x-infinite end, supported by curve c with arcno (ray I)
\ccc{inf_end} defines whether the ray emanates from +/- x-infinity, \ccc{arcno_o} defines an arcno of point origin w.r.t. curve c
Constructs an arc with one interior end-point and another end at the left or right boundary of the parameter space (ray I).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[origin]The interior end-point of the ray \item[\ccc{inf_end}]Defining whether the arcs emanates from the left or right boundary \item[c]The supporting curve \item[arcno]The arcnumber wrt c in the interior of the arc \item[\ccc{arcno_o}]The arcnumber wrt c of the arc at origin \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed ray \end{description}
\ccGlue
\ccConstructor{Arc_2(const Point_2& origin, const X_coordinate_1& asympt_x, CGAL::Arr_curve_end inf_end, const Curve_analysis_2& c, int arcno, int arcno_o);}
{
constructs an arc with one finite end-point origin and one asymtpotic (y-infinite) end given by x-coordinate \ccc{asympt_x} (ray II)
\ccc{inf_end} specifies +/-oo an asymptotic end is approaching, \ccc{arcno_o} defines an arcno of point origin (arcno of asymptotic end is the same as arcno )
Constructs a non-vertical arc with one interior end-point and whose other end approaches a vertical asymptote (ray II).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[origin]The interior end-point \item[\ccc{asympt_x}]The x-coordinate of the vertical asymptote \item[\ccc{inf_end}]Arc is approaching the bottom or top boundary \item[c]The supporting curve \item[arcno]The arcnumber wrt c in the interior of the arc \item[\ccc{arcno_o}]The arcnumber wrt c of the arc at origin \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed ray\end{description}
\begin{description}
\item[Precondition:]origin.x() != \ccc{asympt_x} \end{description}
\ccGlue
\ccConstructor{Arc_2(const Curve_analysis_2& c, int arcno);}
{
constructs an arc with two x-infinite ends supported by curve c with arcno (branch I)
Constructs a non-vertical arc with two non-interior ends at the left and right boundary (branch I).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[c]The supporting curve \item[arcno]The arcnumber wrt to c in the interior of the arc \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed branch \end{description}
\ccGlue
\ccConstructor{Arc_2(const X_coordinate_1& asympt_x1, CGAL::Arr_curve_end inf_end1, const X_coordinate_1& asympt_x2, CGAL::Arr_curve_end inf_end2, const Curve_analysis_2& c, int arcno);}
{
constructs an arc with two asymptotic ends defined by \ccc{asympt_x1} and \ccc{asympt_x2} respectively, supported by curve c with arcno (branch II)
\ccc{inf_end1}/2 define +/-oo the repspective asymptotic end is approaching
Constructs a non-vertical arc with two ends approaching vertical asymptotes (branch II).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[\ccc{asympt_x1}]The x-coordinate of the first asymptote \item[\ccc{inf_end1}]Arc is approaching the bottom or top boundary at \ccc{asympt_x1} \item[\ccc{asympt_x2}]The x-coordinate of the second asymptote \item[\ccc{inf_end2}]Arc is approaching the bottom or top boundary at \ccc{asympt_x2} \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed branch\end{description}
\begin{description}
\item[Precondition:]\ccc{asympt_x1} != \ccc{asympt_x2} \end{description}
\ccGlue
\ccConstructor{Arc_2(CGAL::Arr_curve_end inf_endx, const X_coordinate_1& asympt_x, CGAL::Arr_curve_end inf_endy, const Curve_analysis_2& c, int arcno);}
{
constructs an arc with one x-infinite end and one asymptotic end defined by x-coordinate \ccc{asympt_x} supported by curve c with arcno (branch III)
\ccc{inf_endx} specifies whether the branch goes to +/- x-infinity, \ccc{inf_endy} specifies +/-oo the asymptotic end approaches
Construct a non-vertical arc with one left- or right-boundary end and one end that approaches a vertical asymptote (branch III).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[\ccc{inf_endx}]Defining whether the arc emanates from the left or right boundary \item[\ccc{asympt_x}]The x-coordinate of the asymptote \item[\ccc{inf_endy}]Arc is approaching the bottom or top boundary at \ccc{asympt_x} \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed branch \end{description}
\ccGlue
\ccConstructor{Arc_2(const Point_2& p, const Point_2& q, const Curve_analysis_2& c);}
{
constructs a vertcial arc with two finite end-points p and q , supported by curve c (vertical segment)
Constructs a vertical arc with two interior end-points (vertical segment).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[p]The first end-point \item[q]The second end-point \item[c]The supporting curve \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed arc\end{description}
\begin{description}
\item[Precondition:]p != q \&\& p.x() == q.x()
c must have a vertical component at this x \end{description}
\ccGlue
\ccConstructor{Arc_2(const Point_2& origin, CGAL::Arr_curve_end inf_end, const Curve_analysis_2& c);}
{
constructs a vertical arc with one finite end-point origin and one y-infinite end, supported by curve c (vertical ray)
\ccc{inf_end} defines whether the ray emanates from +/- y-infninty,
Constructs a vertical arc with one interior end-point and one that reaches the bottom or top boundary (vertical ray).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[origin]The interior end-point \item[\ccc{inf_end}]Ray emanates from bottom or top boundary \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed ray\end{description}
\begin{description}
\item[Precondition:]c must have a vertical line component at this x \end{description}
\ccGlue
\ccConstructor{Arc_2(const X_coordinate_1& x, const Curve_analysis_2& c);}
{
constructs a vertical arc with two y-infinite ends, at x-coordinate x , supported by curve c (vertical branch)
Constructs a vertical arc that connects bottom with top boundary (vertical branch).
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[x]The x-coordinate of the arc \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed branch\end{description}
\begin{description}
\item[Precondition:]c must have a vertical line component at this x \end{description}
\ccGlue
\ccConstructor{Arc_2(Rep rep);}
{
[protected] \\
Constructs an arc from a given representation used in rebind.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[rep]Input representation \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed arc \end{description}
\ccGlue
%END-AUTO(\ccCreation)

21
Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curve_interval_arcno_cache.tex
View File

@ -110,10 +110,17 @@ event arc number descriptor: stores an arc number along with curve's end type (+
\ccMethod{result_type operator()(const Status_line_1& cv_line, bool side, int interval_arcno) const;}
{
given arcno over an interval, this computes a corresponding event arcno on status line \ccc{cv_line} lying on the given side w.r.t. the interval
side = true: left side; side = false: right side
Given arcno over an interval, this computes a corresponding event arcno on status line \ccc{cv_line} lying on the given side w.r.t. the interval.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[\ccc{cv_line}]Status line \item[side]side = true: left side; side = false: right side \item[\ccc{interval_arcno}]Arcnumber of interval \end{description}
\end{description}
\begin{description}
\item[Returns:]Arcnumber information at event line \end{description}
\ccGlue
%END-AUTO(\ccHeading{Variables})
@ -127,14 +134,18 @@ side = true: left side; side = false: right side
\ccConstructor{Curve_interval_arcno_cache(Curved_kernel_via_analysis_2 * kernel);}
{
standard constructor
Standard constructor.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[kernel]The kernel that is used internally \end{description}
\end{description}
\ccGlue
%END-AUTO(\ccCreation)
\ccOperations
\end{ccRefFunctionObjectClass}
% +------------------------------------------------------------------------+

76
Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2.tex
View File

@ -56,6 +56,37 @@ class \ccc{Curved_kernel_via_analysis_2};
\ccNestedType{Curve_kernel_2}
{
this instance's template argument
}
\ccGlue
\ccNestedType{CKvA}
{
[protected] \\
this instance's second template parameter
}
\ccGlue
\ccNestedType{Point}
{
[protected] \\
this instance's third template parameter
}
\ccGlue
\ccNestedType{Arc}
{
[protected] \\
this instance's fourth template parameter
}
\ccGlue
\ccNestedType{Self}
{
[protected] \\
myself
}
\ccGlue
\ccNestedType{CKvA_2}
{
[protected] \\
type of \ccc{CKvA_2} used internally
}
\ccGlue
\ccNestedType{Curve_2}
@ -65,12 +96,12 @@ type of \ccc{curve_2}
\ccGlue
\ccNestedType{Point_2}
{
type of a point on generic curve
type of a point on a curve that can be analyzed
}
\ccGlue
\ccNestedType{Arc_2}
{
type of an arc on generic curve
type of an arc on a curve that can be analyzed
}
\ccGlue
\ccNestedType{X_monotone_curve_2}
@ -78,6 +109,30 @@ type of an arc on generic curve
type of weakly x-monotone arc for \ccc{ArrangementTraits_2}
}
\ccGlue
\ccNestedType{Base_kernel}
{
[protected] \\
class collecting basic types
}
\ccGlue
\ccNestedType{Base_functors}
{
[protected] \\
class collecting basic functors
}
\ccGlue
\ccNestedType{Construct_point_2}
{
}
\ccGlue
\ccNestedType{Construct_point_on_arc_2}
{
}
\ccGlue
\ccNestedType{Construct_arc_2}
{
}
\ccGlue
%END-AUTO(\ccTypes)
@ -86,17 +141,17 @@ type of weakly x-monotone arc for \ccc{ArrangementTraits_2}
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccHeading{Variables})
\ccMethod{CGAL_CKvA_2_functor_cons(Construct_point_2, construct_point_2_object);}
\ccMethod{Construct_point_2 construct_point_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Construct_point_on_arc_2, construct_point_on_arc_2_object);}
\ccMethod{Construct_point_on_arc_2 construct_point_on_arc_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Construct_arc_2, construct_arc_2_object);}
\ccMethod{Construct_arc_2 construct_arc_2_object() const;}
{
\subsubsection{Member Data Documentation}
}
\ccGlue
%END-AUTO(\ccHeading{Variables})
@ -119,12 +174,15 @@ default constructor
construct from kernel
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[kernel]Kernel to use internally \end{description}
\end{description}
\ccGlue
%END-AUTO(\ccCreation)
%% \ccIncludeExampleCode{Package/Curved_kernel_via_analysis_2.C}
\end{ccRefClass}
% +------------------------------------------------------------------------+

140
Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2_functors.tex
View File

@ -69,6 +69,98 @@ this instance's third template parameter
this instance's fourth template parameter
}
\ccGlue
\ccNestedType{Compare_x_2}
{
}
\ccGlue
\ccNestedType{Compare_xy_2}
{
}
\ccGlue
\ccNestedType{Is_vertical_2}
{
}
\ccGlue
\ccNestedType{Is_bounded_2}
{
}
\ccGlue
\ccNestedType{Parameter_space_in_x_2}
{
}
\ccGlue
\ccNestedType{Parameter_space_in_y_2}
{
}
\ccGlue
\ccNestedType{Construct_min_vertex_2}
{
}
\ccGlue
\ccNestedType{Construct_max_vertex_2}
{
}
\ccGlue
\ccNestedType{Compare_x_near_boundary_2}
{
}
\ccGlue
\ccNestedType{Compare_y_near_boundary_2}
{
}
\ccGlue
\ccNestedType{Compare_y_at_x_2}
{
}
\ccGlue
\ccNestedType{Compare_y_at_x_left_2}
{
}
\ccGlue
\ccNestedType{Compare_y_at_x_right_2}
{
}
\ccGlue
\ccNestedType{Equal_2}
{
}
\ccGlue
\ccNestedType{Is_in_x_range_2}
{
}
\ccGlue
\ccNestedType{Do_overlap_2}
{
}
\ccGlue
\ccNestedType{Intersect_2}
{
}
\ccGlue
\ccNestedType{Trim_2}
{
}
\ccGlue
\ccNestedType{Split_2}
{
}
\ccGlue
\ccNestedType{Are_mergeable_2}
{
}
\ccGlue
\ccNestedType{Merge_2}
{
}
\ccGlue
\ccNestedType{Is_on_2}
{
}
\ccGlue
\ccNestedType{Make_x_monotone_2}
{
}
\ccGlue
%END-AUTO(\ccTypes)
@ -77,95 +169,95 @@ this instance's fourth template parameter
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccHeading{Variables})
\ccMethod{CGAL_CKvA_2_functor_pred(Compare_x_2, compare_x_2_object);}
\ccMethod{Compare_x_2 compare_x_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Compare_xy_2, compare_xy_2_object);}
\ccMethod{Compare_xy_2 compare_xy_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Is_vertical_2, is_vertical_2_object);}
\ccMethod{Is_vertical_2 is_vertical_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Is_bounded_2, is_bounded_2_object);}
\ccMethod{Is_bounded_2 is_bounded_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Parameter_space_in_x_2, parameter_space_in_x_2_object);}
\ccMethod{Parameter_space_in_x_2 parameter_space_in_x_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Parameter_space_in_y_2, parameter_space_in_y_2_object);}
\ccMethod{Parameter_space_in_y_2 parameter_space_in_y_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Construct_min_vertex_2, construct_min_vertex_2_object);}
\ccMethod{Construct_min_vertex_2 construct_min_vertex_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Construct_max_vertex_2, construct_max_vertex_2_object);}
\ccMethod{Construct_max_vertex_2 construct_max_vertex_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Compare_x_near_boundary_2, compare_x_near_boundary_2_object);}
\ccMethod{Compare_x_near_boundary_2 compare_x_near_boundary_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Compare_y_near_boundary_2, compare_y_near_boundary_2_object);}
\ccMethod{Compare_y_near_boundary_2 compare_y_near_boundary_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Compare_y_at_x_2, compare_y_at_x_2_object);}
\ccMethod{Compare_y_at_x_2 compare_y_at_x_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Compare_y_at_x_left_2, compare_y_at_x_left_2_object);}
\ccMethod{Compare_y_at_x_left_2 compare_y_at_x_left_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Compare_y_at_x_right_2, compare_y_at_x_right_2_object);}
\ccMethod{Compare_y_at_x_right_2 compare_y_at_x_right_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Equal_2, equal_2_object);}
\ccMethod{Equal_2 equal_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Is_in_x_range_2, is_in_x_range_2_object);}
\ccMethod{Is_in_x_range_2 is_in_x_range_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Do_overlap_2, do_overlap_2_object);}
\ccMethod{Do_overlap_2 do_overlap_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Intersect_2, intersect_2_object);}
\ccMethod{Intersect_2 intersect_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Trim_2, trim_2_object);}
\ccMethod{Trim_2 trim_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Split_2, split_2_object);}
\ccMethod{Split_2 split_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Are_mergeable_2, are_mergeable_2_object);}
\ccMethod{Are_mergeable_2 are_mergeable_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Merge_2, merge_2_object);}
\ccMethod{Merge_2 merge_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_pred(Is_on_2, is_on_2_object);}
\ccMethod{Is_on_2 is_on_2_object() const;}
{
}
\ccGlue
\ccMethod{CGAL_CKvA_2_functor_cons(Make_x_monotone_2, make_x_monotone_2_object);}
\ccMethod{Make_x_monotone_2 make_x_monotone_2_object() const;}
{
}
\ccGlue
@ -177,8 +269,6 @@ this instance's fourth template parameter
\ccConstructor{Curved_kernel_via_analysis_2_functors();}{default constructor.}
\ccOperations
\end{ccRefClass}
% +------------------------------------------------------------------------+

18
Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Make_x_monotone_2.tex
View File

@ -108,9 +108,17 @@ type of curve arc
\ccMethod{OutputIterator operator()(Curve_analysis_2 curve, OutputIterator oi);}
{
Splits curve into x-monotone arcs and isolated points, copies them through oi, and returns the past-the-end iterator for oi.
Splits a curve into x-monotone arcs and isolated points.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[curve]The input curve \item[oi]Output iterator that stores \ccc{CGAL::Object}, which either encapsulates \ccc{Point_2} or \ccc{Arc_2} \end{description}
\end{description}
\begin{description}
\item[Returns:]Past-the-end iterator of oi \end{description}
\ccGlue
%END-AUTO(\ccHeading{Variables})
@ -124,9 +132,15 @@ Splits curve into x-monotone arcs and isolated points, copies them through oi, a
\ccConstructor{Make_x_monotone_2(Curved_kernel_via_analysis_2 * kernel);}
{
standard constructor
Standard constructor.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[kernel]The kernel instance to use \end{description}
\end{description}
\ccGlue
%END-AUTO(\ccCreation)

147
Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Point_2.tex
View File

@ -24,9 +24,9 @@
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccDefinition)
class defines a point on a curve that can be analyzed
Class defines a point on a curve that can be analyzed.
only points with finite x/y-coordinates can be constructed explicitly (by the user). Points at infinity use special private constructors and required to represent infinite ends of curve arcs.
Only points with interior can be constructed explicitly (by the user). Points on the boundary use special private constructors and required to represent ends of curve arcs on the boundary.
%END-AUTO(\ccDefinition)
@ -102,32 +102,44 @@ type of kernel point
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccHeading{Variables})
\ccMethod{const Xy_coordinate_2& xy() const;}
\ccMethod{const X_coordinate_1& x() const;}
{
access to underlying \ccc{Xy_coordinate_2} object
Access to the point's x-coordinate (y-coordinate can be undefined).
}
\ccGlue
\begin{description}
\item[Precondition:]finite x/y coordinates must be set by construction \end{description}
\ccGlue
\ccMethod{const X_coordinate_1& x() const;}
{
access to the point's x-coordinate (y-coordinate can be undefined)
}
\ccGlue
\item[Returns:]The stored x-coordinate \end{description}
\begin{description}
\item[Precondition:]the point's x must be finite (set by construction) \end{description}
\ccGlue
\ccMethod{const Xy_coordinate_2& xy() const;}
{
Access to underlying \ccc{Xy_coordinate_2} object.
}
\ccGlue
\begin{description}
\item[Returns:]The stored xy-coordinate \end{description}
\begin{description}
\item[Precondition:]finite x/y coordinates must be set by construction, i.e., interior point \end{description}
\ccGlue
\ccMethod{Curve_analysis_2 curve() const;}
{
returns the supporting curve of underlying \ccc{Xy_coordinate_2} object
supporting curve of point
}
\ccGlue
\begin{description}
\item[Returns:]supporting curve of point \end{description}
\ccGlue
\ccMethod{int arcno() const;}
{
returns an arc number of underlying \ccc{Xy_coordinate_2} object
Arc number of point.
}
\ccGlue
\begin{description}
\item[Returns:]arcno of point \end{description}
\begin{description}
\item[Precondition:]Is not endpoint of a vertical ray or branch \end{description}
\ccGlue
\ccMethod{void set_location(CGAL::Arr_parameter_space loc) const;}
{
sets location of a point in parameter space to loc
@ -135,45 +147,79 @@ sets location of a point in parameter space to loc
\ccGlue
\ccMethod{CGAL::Arr_parameter_space location() const;}
{
returns location of a point in parameter space
location of a point in parameter space
}
\ccGlue
\begin{description}
\item[Returns:]location in parameter space \end{description}
\ccGlue
\ccMethod{bool is_on_left_right() const;}
{
checks if the point lies on left/right boundary inaccessible)
checks if the point lies on left/right boundary
}
\ccGlue
\begin{description}
\item[Returns:]true if it lies on left/right boundary, false otherwise \end{description}
\ccGlue
\ccMethod{bool is_on_bottom_top() const;}
{
checks if the point lies on top/bottom boundary
checks if the point lies on bottom/top boundary
}
\ccGlue
\begin{description}
\item[Returns:]true if it lies on bottom/top boundary, false otherwise \end{description}
\ccGlue
\ccMethod{bool is_finite() const;}
{
returns whether the point is finite
checks whether the point is finite
}
\ccGlue
\begin{description}
\item[Returns:]true, if point is finite, false otherwise \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_x(const Kernel_point_2& q) const;}
{
compares x-coordinates of two points
Compares x-coordinates of this point with another.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[q]The other point \end{description}
\end{description}
\begin{description}
\item[Returns:]\ccc{CGAL::LARGER} if x($\ast$this) $>$ x(q); \ccc{CGAL::SMALLER} if x($\ast$this) $<$ x(q); \ccc{CGAL::EQUAL} if x($\ast$this) = x(q). \end{description}
\begin{description}
\item[Precondition:]compared points are in the interior of parameter space \end{description}
\ccGlue
\ccMethod{CGAL::Comparison_result compare_xy(const Kernel_point_2& q, bool equal_x = false) const;}
{
compares two points lexicographical
Compares this point with another point lexicographically.
}
\ccGlue
\begin{description}
\item[Precondition:]compared points are in the interior of parameter space \end{description}
\item[Parameters:]
\begin{description}
\item[q]The other point \end{description}
\end{description}
\begin{description}
\item[Returns:]\ccc{CGAL::LARGER} if x($\ast$this) $>$ x(q), or if x(8this) = x(q) and y($\ast$this) $>$ y(q); \ccc{CGAL::SMALLER} if x($\ast$this) $<$ x(q), or if x($\ast$this) = x(q) and y($\ast$this) $<$ y(q); \ccc{CGAL::EQUAL} if the two points are equal. \end{description}
\begin{description}
\item[Precondition:]Compared points are in the interior of parameter space \end{description}
\ccGlue
\ccMethod{bool is_on(const typename Curved_kernel_via_analysis_2::Curve_2& curve) const;}
{
checks if the point lies on curve
Checks if a point lies on on a curve.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[curve]The curve to check \end{description}
\end{description}
\begin{description}
\item[Returns:]true, if $\ast$this lies on curve, false otherwise \end{description}
\ccGlue
\ccMethod{bool operator==(const Kernel_point_2& q) const;}
{
equality
@ -207,18 +253,6 @@ greater-equal in (x,y) lexicographic order
\ccMethod{void write(std::ostream& os) const;}
{
writes point to os
}
\ccGlue
\ccMethod{CGAL_BEFRIEND_CKvA_2_FUNCTOR(Construct_point_2);}
{
}
\ccGlue
\ccMethod{CGAL_BEFRIEND_CKvA_2_FUNCTOR(Compare_x_2);}
{
}
\ccGlue
\ccMethod{CGAL_BEFRIEND_CKvA_2_FUNCTOR(Compare_xy_2);}
{
\subsubsection{Friends And Related Function Documentation}
\ccMethod{std::ostream& operator<<(std::ostream& os, const Point_2< CurvedKernelViaAnalysis_2, Rep_>& pt);}
{
@ -249,14 +283,55 @@ copy constructor
\ccGlue
\ccConstructor{Point_2(const X_coordinate_1& x, const Curve_analysis_2& c, int arcno);}
{
Constructs a finite point with x-coordinate x on curve c with arc number arcno.
implies no boundary conditions in x/y
}
\ccGlue
\ccConstructor{Point_2(CGAL::Arr_curve_end inf_end, const Curve_analysis_2& c, int arcno);}
{
[protected] \\
Constructs a point with x-coordinate at the left/right boundary.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[\ccc{inf_end}]Determines whether point is on left or right boundary \item[c]The supporting curve \item[arcno]Arcno of point on on left/right boundary \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed point \end{description}
\ccGlue
\ccConstructor{Point_2(const X_coordinate_1& x, const Curve_analysis_2& c, CGAL::Arr_curve_end inf_end);}
{
[protected] \\
Constructs a point on bottom or top boundary.
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[x]The x-coordinate of point \item[c]The supporting curve \item[\ccc{inf_end}]Defines whether point is on bottom or top boundary \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed point \end{description}
\ccGlue
\ccConstructor{Point_2(Rep rep);}
{
[protected] \\
constructs from a given represenation
Constructor for for rebind
}
\ccGlue
\begin{description}
\item[Parameters:]
\begin{description}
\item[rep]The representation \end{description}
\end{description}
\begin{description}
\item[Returns:]The constructed point \end{description}
\ccGlue
%END-AUTO(\ccCreation)
%% \ccIncludeExampleCode{Package/Point_2.C}
% \ccIncludeExampleCode{Package/Point_2.C}
\end{ccRefClass}

4
Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/intro.tex
View File

@ -1,4 +0,0 @@
\section{CKvA_2}
%\subsection{CKvA_2}

4
Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/main.tex
View File

@ -9,7 +9,7 @@
\input{Curved_kernel_via_analysis_2_ref/Point_2}
\input{Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2_functors}
\input{Curved_kernel_via_analysis_2_ref/Make_x_monotone_2}
\input{Curved_kernel_via_analysis_2_ref/Curve_interval_arcno_cache}
\input{Curved_kernel_via_analysis_2_ref/Curve_interval_arcno_cache}
%\input{Curved_kernel_via_analysis_2_ref/Point_2}