aabb tree: spell check y Patrick Mullen.

AABB_tree/doc_tex/AABB_tree/details.tex

@@ -5,6 +5,6 @@ The AABB tree construction is initialized by computing the AABB of the whole set
 
 The reference id is not used internally but simply used by the AABB tree to refer to the primitive in the results provided to the user. It follows that, while in most cases each reference id corresponds to a unique primitive, this is not a requirement of the component. This way a user may use these reference ids as labels, each of them being shared by several geometric object. \\
 
-A distance query between a query point $q$ and the input primitives is turned into a \emph{ball} query centered at $q$. The ball traverses the tree while recursively querying intersections with the AABBs, and computes the closest point $p$ from the query point to the input primitives at the leafs of the tree. The ball radius is then shrunk to the distance between $p$ and $q$ for all remaining recursive traversals of the tree. Efficiency is achieved through setting the initial ball radius to a small value albeit guaranteed to intersect the input primitives. This is achieved by constructing through the function \ccc{accelerate_distance_queries} an internal secondary data structure which provides a good hint to the algorithm at the beginning of the traversal.
+A distance query between a query point $q$ and the input primitives is turned into a \emph{ball} query centered at $q$. The ball traverses the tree while recursively querying intersections with the AABBs, and computes the closest point $p$ from the query point to the input primitives at the leafs of the tree. The ball radius is then shrunk to the distance between $p$ and $q$ for all remaining recursive traversals of the tree. Efficiency is achieved through setting the initial ball radius to a small value still guaranteed to intersect the input primitives. This is achieved by constructing through the function \ccc{accelerate_distance_queries} an internal secondary data structure which provides a good hint to the algorithm at the beginning of the traversal.
 
 

AABB_tree/doc_tex/AABB_tree/examples.tex

@@ -6,7 +6,7 @@ In the following example a set of 3D triangles is stored in a list. The AABB pri
 \ccIncludeExampleCode{AABB_tree/AABB_triangle_3_example.cpp}
 
 \subsection{Tree of Polyhedron Triangle Facets for Intersection Queries}
-In the following example the AABB primitive wraps a facet handle of a triangle polyhedral surface as \ccc{id} and the corresponding 3D triangle as geometric object. From a segment query we test the intersections, then compute the number of intersections, compute the first encountered intersection (generically a point), compute all intersections (where each intersection is a pair of one CGAL object and one primitive id (here a face handle) and compute all intersected primitives. The latter involves only tests and no predicates and is hence faster than computing all intersections. We also compute the first encountered intersection with a plane query, which is generically a segment.
+In the following example the AABB primitive wraps a facet handle of a triangle polyhedral surface as \ccc{id} and the corresponding 3D triangle as geometric object. From a segment query we test the intersections, then compute the number of intersections, compute the first encountered intersection (generally a point), compute all intersections (where each intersection is a pair of one CGAL object and one primitive id - here a face handle) and compute all intersected primitives. The latter involves only tests and no predicates and is hence faster than computing all intersections. We also compute the first encountered intersection with a plane query, which is generally a segment.
 \ccIncludeExampleCode{AABB_tree/AABB_polyhedron_facet_intersection_example.cpp}
 
 \subsection{Tree of Polyhedron Triangle Facets for Distance Queries}

AABB_tree/doc_tex/AABB_tree/introduction.tex

@@ -3,10 +3,10 @@
 
 The AABB tree component offers a static data structure and algorithms to perform efficient intersection and distance queries against sets of finite 3D geometric objects. The set of geometric objects stored in the data structure can be queried for intersection detection, intersection computation and distance. The intersection queries can be of any type, provided that the corresponding intersection predicates and constructors are implemented in the traits class. The distance queries are limited to point queries.\\
 
-Examples of intersection queries include line objects (rays, lines, segments) against sets of triangles, or plane objects (planes, triangles) against sets of segments. An example of distance query consists of finding the closest point from a point query to a set of triangles.\\
+Examples of intersection queries include line objects (rays, lines, segments) against sets of triangles, or plane objects (planes, triangles) against sets of segments. An example of a distance query consists of finding the closest point from a point query to a set of triangles.\\
 
-The AABB tree data structure takes as input an iterator range of geometric data, which are then converted into primitives. From these primitives a hierarchy of axis-aligned bounding boxes (AABBs) is constructed and used to speed up intersection and distance queries (see Figure~\ref{fig:AABB-tree-anchor}). 
-Each primitive gives access to both one input geometric object (so-called datum) and one reference id to this object. A typical example primitive wraps a 3D triangle as datum and a face handle of a polyhedral surface as id. Each intersection query can return the intersection objects (e.g., 3D points or segments for ray queries) as well the id (here the face handle) of the intersected primitives. Similarly, each distance query can return the closest point from the point query as well the id of the closest primitive. 
+The AABB tree data structure takes as input an iterator range of geometric data, which is then converted into primitives. From these primitives a hierarchy of axis-aligned bounding boxes (AABBs) is constructed and used to speed up intersection and distance queries (see Figure~\ref{fig:AABB-tree-anchor}). 
+Each primitive gives access to both one input geometric object (so-called datum) and one reference id to this object. A typical example primitive wraps a 3D triangle as datum and a face handle of a polyhedral surface as id. Each intersection query can return the intersection objects (e.g., 3D points or segments for ray queries) as well the as id (here the face handle) of the intersected primitives. Similarly, each distance query can return the closest point from the point query as well as the id of the closest primitive. 
 
 % AABB tree over anchor triangle surface mesh model.
 \begin{center}

AABB_tree/doc_tex/AABB_tree/performances.tex

@@ -18,7 +18,7 @@ The surface triangle mesh chosen for benchmarking intersections is the knot mode
   \hline
 \end{tabular}
 
-The following table measures the number of intersection queries per second on the 14,400 triangle version of the knot mesh model for ray, line, segment and plane queries. Each ray query is generated by choosing a random source point within the bounding box of the mesh and a random vector. A line or segment query is generated by choosing two random points within the bounding box. A plane query is generated by picking a random point within the bounding box and a random normal vector. Note that a plane query generically intersects many triangles of the input surface mesh. This explains the low performance numbers for the intersection functions which enumerate all intersections.
+The following table measures the number of intersection queries per second on the 14,400 triangle version of the knot mesh model for ray, line, segment and plane queries. Each ray query is generated by choosing a random source point within the bounding box of the mesh and a random vector. A line or segment query is generated by choosing two random points within the bounding box. A plane query is generated by picking a random point within the bounding box and a random normal vector. Note that a plane query generally intersects many triangles of the input surface mesh. This explains the low performance numbers for the intersection functions which enumerate all intersections.
 
 \begin{tabular}{|l|r|r|r|r|}
   \hline