diff --git a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Arc_2.tex b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Arc_2.tex index ad85b9c71ea..08dc510c8d9 100644 --- a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Arc_2.tex +++ b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Arc_2.tex @@ -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} (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} (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 _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} (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} (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} (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) diff --git a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curve_interval_arcno_cache.tex b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curve_interval_arcno_cache.tex index 34874b3975b..22af8443e98 100644 --- a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curve_interval_arcno_cache.tex +++ b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curve_interval_arcno_cache.tex @@ -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} % +------------------------------------------------------------------------+ diff --git a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2.tex b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2.tex index 122a743621e..2c2504726e7 100644 --- a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2.tex +++ b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2.tex @@ -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} % +------------------------------------------------------------------------+ diff --git a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2_functors.tex b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2_functors.tex index d0bc6755cb8..bbda75b6b81 100644 --- a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2_functors.tex +++ b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Curved_kernel_via_analysis_2_functors.tex @@ -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} % +------------------------------------------------------------------------+ diff --git a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Make_x_monotone_2.tex b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Make_x_monotone_2.tex index 797b0287ca8..f7bce0b9a07 100644 --- a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Make_x_monotone_2.tex +++ b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Make_x_monotone_2.tex @@ -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) diff --git a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Point_2.tex b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Point_2.tex index dfd3d9f1f8a..4c99994162b 100644 --- a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Point_2.tex +++ b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/Point_2.tex @@ -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} diff --git a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/intro.tex b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/intro.tex index 1fbc278adfa..e69de29bb2d 100644 --- a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/intro.tex +++ b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/intro.tex @@ -1,4 +0,0 @@ - -\section{CKvA_2} - -%\subsection{CKvA_2} diff --git a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/main.tex b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/main.tex index 11553790ffd..024a8b00e4b 100644 --- a/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/main.tex +++ b/Curved_kernel_via_analysis_2/doc_tex/Curved_kernel_via_analysis_2_ref/main.tex @@ -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} \ No newline at end of file +%\input{Curved_kernel_via_analysis_2_ref/Point_2} \ No newline at end of file