counter-clockwise -> counterclockwise

Author: afabri

Boolean_set_operations_2/doc/Boolean_set_operations_2/Boolean_set_operations_2.txt

@@ -116,7 +116,7 @@ In our context, a polygon must uphold the following conditions:
 <OL>
 <LI><I>Closed Boundary</I> - the polygon's outer boundary must be a connected sequence of curves, that start and end at the same vertex.
 <LI><I>Simplicity</I> - the polygon must be simple.
-<LI><I>Orientation</I> - the polygon's outer boundary must be <I>counter-clockwise oriented</I>.
+<LI><I>Orientation</I> - the polygon's outer boundary must be <I>counterclockwise oriented</I>.
 </OL>
 
 \subsection bso_ssecpolygon_with_holes_validation Conditions for Valid Polygons with Holes

Cone_spanners_2/include/CGAL/Compute_cone_boundaries_2.h

@@ -137,7 +137,7 @@ class Compute_cone_boundaries_2<Exact_predicates_exact_constructions_kernel_with
 
       The direction of the first ray can be specified by the parameter
       initial_direction, which allows the first ray to start at any direction.
-      The remaining directions are calculated in counter-clockwise order.
+      The remaining directions are calculated in counterclockwise order.
 
       \param cone_number The number of cones
       \param initial_direction The direction of the first ray

Cone_spanners_2/include/CGAL/Construct_theta_graph_2.h

@@ -169,7 +169,7 @@ class Construct_theta_graph_2 {
     /* Construct edges in one cone bounded by two directions.
 
      \param cwBound      The direction of the clockwise boundary of the cone.
-     \param ccwBound     The direction of the counter-clockwise boundary.
+     \param ccwBound     The direction of the counterclockwise boundary.
      \param g            The Theta graph to be built.
     */
     void add_edges_in_cone(const Direction_2& cwBound, const Direction_2& ccwBound, Graph_& g) {

Cone_spanners_2/include/CGAL/Construct_yao_graph_2.h

@@ -164,7 +164,7 @@ class Construct_yao_graph_2 {
     /* Construct edges in one cone bounded by two directions.
 
      \param cwBound      The direction of the clockwise boundary of the cone.
-     \param ccwBound     The direction of the counter-clockwise boundary.
+     \param ccwBound     The direction of the counterclockwise boundary.
      \param g            The Yao graph to be built.
     */
     void add_edges_in_cone(const Direction_2& cwBound, const Direction_2& ccwBound, Graph_& g) {

Heat_method_3/doc/Heat_method_3/Heat_method_3.txt

@@ -149,7 +149,7 @@ Next, the gradient in a given triangle can be expressed as
 
 \f$\nabla u = \frac{1}{2 A_f} \sum_i u_i ( N \times e_i ) \f$
 
-where \f$A_f\f$ is the area of the triangle, \f$N\f$ is its outward unit normal, \f$e_i\f$ is the \f$i\f$th edge vector (oriented counter-clockwise), and \f$u_i\f$ is the value of \f$u\f$ at the opposing vertex. The integrated divergence associated with vertex \f$i\f$ can be written as
+where \f$A_f\f$ is the area of the triangle, \f$N\f$ is its outward unit normal, \f$e_i\f$ is the \f$i\f$th edge vector (oriented counterclockwise), and \f$u_i\f$ is the value of \f$u\f$ at the opposing vertex. The integrated divergence associated with vertex \f$i\f$ can be written as
 
 \f$\nabla \cdot X = \frac{1}{2} \sum_j cot\theta_1 (e_1 \cdot X_j) + cot \theta_2 (e_2 \cdot X_j)\f$
 

Mesh_2/include/CGAL/Mesh_2/Refine_edges_visitor.h

@@ -98,7 +98,7 @@ class Refine_edges_visitor : public ::CGAL::Null_mesh_visitor
     // set fh to the face at the right of [va,v]
 
     typename Tr::Face_circulator fc = tr.incident_faces(v, fh), fcbegin(fc);
-    // circulators are counter-clockwise, so we start at the right of
+    // circulators are counterclockwise, so we start at the right of
     // [va,v]
     do {
       if( !tr.is_infinite(fc) )

Nef_2/include/CGAL/Nef_2/PM_checker.h

@@ -95,12 +95,12 @@ bool is_forward(Halfedge_const_handle e) const
 
 void check_order_preserving_embedding(Vertex_const_handle v) const;
 /*{\Mop checks if the embedding of the targets of the edges in
-the adjacency list |A(v)| is counter-clockwise order-preserving with
+the adjacency list |A(v)| is counterclockwise order-preserving with
 respect to the order of the edges in |A(v)|.}*/
 
 void check_order_preserving_embedding() const;
 /*{\Mop checks if the embedding of all vertices of |P| is
-counter-clockwise order-preserving with respect to the adjacency
+counterclockwise order-preserving with respect to the adjacency
 list ordering of all vertices.}*/
 
 void check_forward_prefix_condition(Vertex_const_handle v) const;

Nef_S2/include/CGAL/Nef_S2/SM_checker.h

@@ -79,12 +79,12 @@ bool is_forward(Halfedge_const_handle e) const
 
 void check_order_preserving_embedding(Vertex_const_handle v) const;
 /*{\Mop checks if the embedding of the targets of the edges in
-the adjacency list |A(v)| is counter-clockwise order-preserving with
+the adjacency list |A(v)| is counterclockwise order-preserving with
 respect to the order of the edges in |A(v)|.}*/
 
 void check_order_preserving_embedding() const;
 /*{\Mop checks if the embedding of all vertices of |P| is
-counter-clockwise order-preserving with respect to the adjacency
+counterclockwise order-preserving with respect to the adjacency
 list ordering of all vertices.}*/
 
 void check_forward_prefix_condition(Vertex_const_handle v) const;

Periodic_2_triangulation_2/doc/Periodic_2_triangulation_2/CGAL/Periodic_2_Delaunay_triangulation_2.h

@@ -212,7 +212,7 @@ class Periodic_2_Delaunay_triangulation_2 : public Periodic_2_triangulation_2<Tr
   contains `p`. It outputs in the container pointed to by
   `eit` the boundary of the zone in conflict with `p`.
   The boundary edges of the conflict zone are output in
-  counter-clockwise order and each edge is described through its
+  counterclockwise order and each edge is described through its
   incident face which is not in conflict with `p`. The function
   returns in a std::pair the resulting output
   iterators. \pre `start` is in conflict with `p` and `p` lies in the original domain `domain`.

Periodic_4_hyperbolic_triangulation_2/doc/Periodic_4_hyperbolic_triangulation_2/CGAL/Hyperbolic_octagon_translation.h

@@ -124,7 +124,7 @@ class Hyperbolic_octagon_translation {
                 Comparison operator.
                  Each translation \f$g\f$ of \f$\mathcal G\f$, when applied to the octagon \f$\mathcal D_O\f$,
                  produces a copy of \f$\mathcal D_O\f$ labeled by the translation \f$g\f$. The copies of
-                 \f$\mathcal D_O\f$ incident to \f$\mathcal D_O\f$ are naturally ordered counter-clockwise around
+                 \f$\mathcal D_O\f$ incident to \f$\mathcal D_O\f$ are naturally ordered counterclockwise around
                  \f$\mathcal D_O\f$. The comparison operator compares two translations based on the ordering
                  of the copies of \f$\mathcal D_O\f$ that they produce. For more details, see Section
                  \ref P4HT2_representation of the User manual.

Periodic_4_hyperbolic_triangulation_2/doc/Periodic_4_hyperbolic_triangulation_2/Concepts/Periodic_4HyperbolicTriangulationFaceBase_2.h

@@ -11,7 +11,7 @@ A refinement of the concept `TriangulationFaceBase_2` that adds an interface for
 
 At the base level, a face stores handles to its incident vertices and to its neighboring faces.
 Compare with Section \ref Section_2D_Triangulations_Software_Design of the 2D Triangulations
-package. The vertices and neighbors are indexed counter-clockwise 0, 1, and 2. Neighbor `i` lies
+package. The vertices and neighbors are indexed counterclockwise 0, 1, and 2. Neighbor `i` lies
 opposite to vertex `i`.
 
 For periodic hyperbolic triangulations, the face base class needs to store three hyperbolic

Periodic_4_hyperbolic_triangulation_2/doc/Periodic_4_hyperbolic_triangulation_2/PackageDescription.txt

@@ -54,7 +54,7 @@ Each face gives access to its three incident vertices and to its three adjacent
 to store additionally three hyperbolic translations. When applied to the three points stored in the vertices of
 the face, these translations produce the canonical representative of the face in the hyperbolic plane.
 
-The three vertices of a face are indexed with 0, 1, and 2 in positive (counter-clockwise) orientation. The
+The three vertices of a face are indexed with 0, 1, and 2 in positive (counterclockwise) orientation. The
 orientation of faces on the Bolza surface is defined as the orientation of their canonical representatives in
 the hyperbolic plane.
 

Polygon_repair/doc/Polygon_repair/Polygon_repair.txt

@@ -123,7 +123,7 @@ strict criteria:
 - Adjacent collinear edges touching at vertices of degree two are merged
 - The sequence of vertices representing a boundary starts from its
 lexicographically smallest vertex
-- Outer boundaries are oriented counter-clockwise and inner boundaries are
+- Outer boundaries are oriented counterclockwise and inner boundaries are
 oriented clockwise
 - The inner boundaries of a polygon with holes are stored in lexicographic
 order

Segment_Delaunay_graph_2/doc/Segment_Delaunay_graph_2/Concepts/SegmentDelaunayGraphDataStructure_2.h

@@ -21,7 +21,7 @@ reverses the action of the other.
 The join and split operations. Left to right: The vertex `v` is split
 into \f$ v_1\f$ and \f$ v_2\f$. The faces \f$ f\f$ and \f$ g\f$ are
 inserted after \f$ f_1\f$ and \f$ f_2\f$, respectively, in the
-counter-clockwise sense. The vertices \f$ v_1\f$, \f$ v_2\f$ and the
+counterclockwise sense. The vertices \f$ v_1\f$, \f$ v_2\f$ and the
 faces \f$ f\f$ and \f$ g\f$ are returned as a `boost::tuple` in that
 order. Right to left: The edge `(f,i)` is collapsed, and thus the
 vertices \f$ v_1\f$ and \f$ v_2\f$ are joined. The vertex `v` is
@@ -60,7 +60,7 @@ Vertex_handle join_vertices(Face_handle f, int i);
 /*!
 Splits the vertex `v` into two vertices `v1` and
 `v2`. The common faces `f` and `g` of `v1` and
-`v2` are created after (in the counter-clockwise sense) the
+`v2` are created after (in the counterclockwise sense) the
 faces `f1` and `f2`. The 4-tuple `(v1,v2,f,g)` is
 returned (see \cgalFigureRef{figsdgdssplitjoin}).
 */

Segment_Delaunay_graph_2/doc/Segment_Delaunay_graph_2/Concepts/SegmentDelaunayGraphTraits_2.h

@@ -206,7 +206,7 @@ returns the sign of the distance of `q` from the Voronoi circle
 of `s1`, `s2`, `s3` (the Voronoi circle of three sites
 `s1`, `s2`, `s3` is a circle co-tangent to all three
 sites, that touches them in that order as we walk on its circumference
-in the counter-clockwise sense).
+in the counterclockwise sense).
 \pre the Voronoi circle of `s1`, `s2`, `s3` must exist.
 
 Must also provide `Sign operator()(Site_2 s1, Site_2 s2, Site_2 q)`, which returns the sign of the distance of

Segment_Delaunay_graph_Linf_2/doc/Segment_Delaunay_graph_Linf_2/Concepts/SegmentDelaunayGraphLinfTraits_2.h

@@ -78,7 +78,7 @@ segment Voronoi diagram.
 /*!
 A constructor for the point \f$ v \f$ at which the three \f$ L_{\infty} \f$
 bisectors between the three given sites `s1`, `s2` and `s3` intersect
-and the regions of `s1`, `s2` and `s3` appear in the counter-clockwise order
+and the regions of `s1`, `s2` and `s3` appear in the counterclockwise order
 `s1`, `s2`, `s3` around \f$ v\f$.
 
 Point \f$ v \f$ is equidistant
@@ -116,7 +116,7 @@ of `s1`, `s2`, `s3`. The \f$ L_{\infty} \f$ Voronoi square
 of three sites
 `s1`, `s2`, `s3` is an axis-parallel square which is passing through all three
 sites and touches them in the `s1`, `s2`, `s3`
-order as we walk on the square in the counter-clockwise sense.
+order as we walk on the square in the counterclockwise sense.
 The center of the square is at the intersection of the three
 \f$ L_{\infty} \f$ bisectors of the three sites.
 
@@ -256,7 +256,7 @@ Since CGAL segments have also an orientation, we also orient
 For an <I>oriented</I> segment \f$ s \f$, we orient its
 \f$L_{\infty}\f$-perpendicular lines so that the lines'
 orientation is closest to the following orientation:
-the orientation of \f$ s \f$ rotated <I>counter-clockwise</I> by
+the orientation of \f$ s \f$ rotated <I>counterclockwise</I> by
 \f$ \pi/2 \f$.
 
 Let `s` be a segment and `p` a point contained in its interior.

Straight_skeleton_2/doc/Straight_skeleton_2/CGAL/Polygon_offset_builder_2.h

@@ -70,7 +70,7 @@ For any given input polygon, its offset polygons at a certain distance are compo
 This method returns all such contours in an unspecified order and with no parental relationship
 between them (that is why it is called `construct_offset_contours()` and not `construct_offset_polygons()`).
 
-Those offset contours in the resulting sequence which are oriented counter-clockwise are outer contours
+Those offset contours in the resulting sequence which are oriented counterclockwise are outer contours
 and those oriented clockwise are holes. It is up to the user to match each hole to its parent in order
 to reconstruct the parent-hole relationship of the conceptual output. It is sufficient to test each hole
 against each parent as there won't be a hole inside a hole, a parent inside any other contour,

Straight_skeleton_2/doc/Straight_skeleton_2/CGAL/Straight_skeleton_2.h

@@ -96,10 +96,10 @@ of the straight skeleton HDS, such border halfedges are oriented such that their
 outwards the polygon. Therefore, the opposite halfedge of any border halfedge is oriented such that
 its left side faces inward the polygon.
 
-This \cgal package requires the input polygon (with holes) to be weakly simple and oriented counter-clockwise.
+This \cgal package requires the input polygon (with holes) to be weakly simple and oriented counterclockwise.
 
 The skeleton halfedges are oriented such that their <I>left</I> side faces inward the region they bound.
-That is, the vertices (both contour and skeleton) of a face are circulated in counter-clockwise order.
+That is, the vertices (both contour and skeleton) of a face are circulated in counterclockwise order.
 There is one and only one contour halfedge incident upon any face.
 
 The contours of the input polygon are traced by the border halfedges of the HDS (those facing outward),
@@ -115,7 +115,7 @@ Thus, the 2 opposite halfedges of a skeleton edge link the edge to its 2 definin
 Starting from any border contour halfedge, circulating the structure walks through border counter
 halfedges and traces the vertices of the polygon's contours (in opposite order).
 
-Starting from any non-border but contour halfedge, circulating the structure walks counter-clockwise
+Starting from any non-border but contour halfedge, circulating the structure walks counterclockwise
 around the face corresponding to that contour halfedge. The vertices around a face always describe
 a non-convex weakly simple polygon.
 

Straight_skeleton_2/doc/Straight_skeleton_2/CGAL/Straight_skeleton_builder_2.h

@@ -169,7 +169,7 @@ whose <I>straight skeleton</I> is to be built.
 
 Each contour must be input in turn starting with the <I>outer contour</I> and following with the holes (if any).
 The order of the holes is unimportant but the outer contour must be entered first.
-The outer contour must be oriented counter-clockwise while holes must be oriented clockwise.
+The outer contour must be oriented counterclockwise while holes must be oriented clockwise.
 
 It is an error to enter more than one outer contour, to enter a hole which is not inside
 the outer contour, to enter a hole that is inside another hole, or to enter a contour which crosses

Straight_skeleton_2/doc/Straight_skeleton_2/Straight_skeleton_2.txt

@@ -175,7 +175,7 @@ for each boundary that does not contain the defining contour edge of its inciden
 </center>
 \cgalFigureCaptionBegin{SLSArtificial}
 A polygon with four holes (black) and its straight skeleton (red).
-Three artificial bisectors (green) are added in a post-processing step to recover the simply-connected
+Three artificial bisectors (green) are added in a postprocessing step to recover the simply-connected
 property for the straight skeleton face (gray) of the rightmost vertical contour edge.
 \cgalFigureCaptionEnd
 
@@ -454,7 +454,7 @@ To construct the straight skeleton of a polygon the user must:
   <li>Instantiate the straight skeleton builder.</li>
   <li> Enter one contour at a time, starting from the outer contour, via the method
        `Straight_skeleton_builder_2::enter_contour()`. The input polygon must be
-       weakly simple and counter-clockwise oriented (see the definitions at the beginning
+       weakly simple and counterclockwise oriented (see the definitions at the beginning
        of this chapter). Collinear edges are allowed. The insertion order of each hole is
        unimportant but the outer contour must be entered first.</li>
   <li>Call `Straight_skeleton_builder_2::construct_skeleton()` once <I>all</I> the contours
@@ -480,18 +480,18 @@ The resulting sequence of offset contours can contain both outer and inner conto
 However, this algorithm returns a sequence of contours in arbitrary order and there is no
 indication whatsoever of the parental relationship between inner and outer contours.
 
-On the other hand, each outer contour is counter-clockwise oriented while each hole is clockwise-oriented.
+On the other hand, each outer contour is counterclockwise oriented while each hole is clockwise-oriented.
 And since offset contours do form simple polygons, it is guaranteed that no hole will be
 inside another hole, no outer contour will be inside any other contour, and each hole will be inside
 exactly 1 outer contour.
 
 Parental relationships are <I>not</I> automatically reconstructed by this algorithm because
-this relation is not directly given by the input polygon and must be done as a post-processing
+this relation is not directly given by the input polygon and must be done as a postprocessing
 step. The function `CGAL::arrange_offset_polygons_2()` can be used to do that efficiently.
 
 A user can reconstruct the parental relationships as a post processing operation by testing
 each inner contour (which is identified by being clockwise) against each outer contour (identified
-as being counter-clockwise) for insideness.
+as being counterclockwise) for insideness.
 
 This algorithm requires exact predicates but not exact constructions.
 Therefore, the `Exact_predicates_inexact_constructions_kernel` should be used.

Stream_support/doc/Stream_support/File_formats/Supported_file_formats.txt

@@ -106,7 +106,7 @@ which offers combinatorial repairing while reading bad inputs.
 \section IOStreamOBJ Wavefront Advanced Visualizer Object Format (OBJ)
 
 The `OBJ` file format, using the file extension `.obj`, is a simple \ascii data format that represents 3D geometry.
-Vertices are stored in a counter-clockwise order by default, making explicit declaration of face normals unnecessary.
+Vertices are stored in a counterclockwise order by default, making explicit declaration of face normals unnecessary.
 
 A precise specification of the format is available <a href="https://www.martinreddy.net/gfx/3d/OBJ.spec">here</a>.
 

TDS_2/doc/TDS_2/CGAL/Triangulation_data_structure_2.h

@@ -134,7 +134,7 @@ Vertex_handle join_vertices(Edges_circulator ec);
 /*!
 splits the vertex `v` into two vertices `v1` and `v2`.
 
-The common faces `f` and `g` of `v1` and `v2` are created after (in the counter-clockwise sense) the
+The common faces `f` and `g` of `v1` and `v2` are created after (in the counterclockwise sense) the
 faces `f1` and `f2`. The 4-tuple `(v1,v2,f,g)` is returned (see Fig. \ref figtdssplitjoin).
 
 \pre `dimension()` must be equal to `2`, `f1` and `f2` must be different from `Face_handle()` and `v` must be a vertex of both `f1` and `f2`.

Triangulation_2/doc/Triangulation_2/CGAL/Constrained_Delaunay_triangulation_2.h

@@ -305,7 +305,7 @@ outputs the boundary edges of the conflict zone of point `p` into an output iter
 
 This functions outputs in the container pointed to by `eit`,
 the boundary of the zone in conflict with `p`. The boundary edges
-of the conflict zone are output in counter-clockwise order
+of the conflict zone are output in counterclockwise order
 and each edge is described through the incident face
 which is not in conflict with `p`.
 The function returns the resulting output iterator.

Triangulation_2/doc/Triangulation_2/CGAL/Delaunay_triangulation_2.h

@@ -221,7 +221,7 @@ i. e., the faces whose circumcircle contains `p`.
 It outputs in the container pointed to by `eit` the
 the boundary of the zone in conflict with `p`.
 The boundary edges
-of the conflict zone are output in counter-clockwise order
+of the conflict zone are output in counterclockwise order
 and each edge is described through its incident face
 which is not in conflict with `p`.
 The function returns in a `std::pair` the resulting output iterators.

Triangulation_2/doc/Triangulation_2/CGAL/Regular_triangulation_2.h

@@ -295,7 +295,7 @@ have negative power wrt. `p`. It outputs in the container
 pointed to by `eit` the boundary of the zone in conflict
 with `p`. It inserts the vertices that would be hidden by `p`
 into the container pointed to by `vit`. The boundary edges of
-the conflict zone are output in counter-clockwise order and each edge
+the conflict zone are output in counterclockwise order and each edge
 is described through its incident face which is not in conflict with
 `p`. The function returns in a `CGAL::Triple` the resulting output
 iterators.