Typographical, Grammatical, and Wording Suggestions for Software Guide Examples

Examples/DataRepresentation/Image/Image1.cxx

@@ -20,12 +20,12 @@
 //
 // This example illustrates how to manually construct an \doxygen{Image}
 // class. The following is the minimal code needed to instantiate, declare
-// and create the image class.
+// and create the \code{Image} class.
 //
 // \index{itk::Image!Instantiation}
 // \index{itk::Image!Header}
 //
-// First, the header file of the Image class must be included.
+// First, the header file of the \code{Image} class must be included.
 //
 // Software Guide : EndLatex
 
@@ -39,7 +39,7 @@ int main(int, char *[])
   //
   // Then we must decide with what type to represent the pixels
   // and what the dimension of the image will be. With these two
-  // parameters we can instantiate the image class. Here we create
+  // parameters we can instantiate the \code{Image} class. Here we create
   // a 3D image with \code{unsigned short} pixel data.
   //
   // Software Guide : EndLatex
@@ -110,7 +110,7 @@ int main(int, char *[])
 
   // Software Guide : BeginLatex
   //
-  // The region size is represented by an array of the same dimension of the
+  // The region size is represented by an array of the same dimension as the
   // image (using the \doxygen{Size} class). The components of the array are
   // unsigned integers indicating the extent in pixels of the image along
   // every dimension.

Examples/DataRepresentation/Image/Image3.cxx

@@ -65,7 +65,7 @@ int main(int, char *[])
   //
   // The following code illustrates the declaration of an index variable and
   // the assignment of values to each of its components. Please note that
-  // no SmartPointer is used to access the \code{Index}. This is because
+  // no \code{SmartPointer} is used to access the \code{Index}. This is because
   // \code{Index} is a lightweight object that is not intended to be shared
   // between objects. It is more efficient to produce multiple copies of
   // these small objects than to share them using the SmartPointer

Examples/DataRepresentation/Image/Image4.cxx

@@ -26,7 +26,7 @@
 // position of the image in space with respect to some world coordinate
 // system are extremely important.
 //
-// Image origin, image voxel directions (i.e. orientation) and spacing are fundamental to many
+// Image origin, voxel directions (i.e. orientation), and spacing are fundamental to many
 // applications. Registration, for example, is performed in physical
 // coordinates. Improperly defined spacing, direction, and origins will result in
 // inconsistent results in such processes. Medical images with no spatial

Examples/DataRepresentation/Mesh/Mesh1.cxx

@@ -21,20 +21,19 @@
 //  The \doxygen{Mesh} class is intended to represent shapes in space.  It
 //  derives from the \doxygen{PointSet} class and hence inherits all the
 //  functionality related to points and access to the pixel-data associated
-//  with the points.  The mesh class is also n-dimensional which
-//  allows a great flexibility in its use.
+//  with the points.  The mesh class is also n-dimensional, allowing great
+//  flexibility in its use.
 //
-//  In practice a Mesh class can be seen as a PointSet to
+//  In practice, a \code{Mesh} class can be seen as a \class{PointSet} to
 //  which cells (also known as elements) of many different dimensions and
 //  shapes have been added. Cells in the mesh are defined in terms of the
 //  existing points using their point-identifiers.
 //
-//  In the same way as for the PointSet, two basic styles of
-//  Meshes are available in ITK. They are referred to as \emph{static}
-//  and \emph{dynamic}. The first one is used when the number of
-//  points in the set can be known in advance and it is not expected
+//  Analogous to the \code{PointSet}, \emph{static} and \emph{dynamic}
+//  Meshes are available in ITK.  A static Mesh is used when the number of
+//  points in the set is known in advance and is not expected
 //  to change as a consequence of the manipulations performed on the
-//  set. The dynamic style, on the other hand, is intended to support
+//  set.  A dynamic Mesh, on the other hand, is intended to support
 //  insertion and removal of points in an efficient manner. The reason
 //  for making the distinction between the two styles is to facilitate
 //  fine tuning its behavior with the aim of optimizing
@@ -73,8 +72,8 @@ int main(int, char *[])
   //
   //  The Mesh type extensively uses the capabilities provided by
   //  \href{http://www.boost.org/more/generic_programming.html}{Generic
-  //  Programming}. In particular the Mesh class is parameterized over the
-  //  PixelType and the dimension of the space. PixelType is the type of the
+  //  Programming}. In particular, the Mesh class is parameterized over
+  //  PixelType and spatial dimension. PixelType is the type of the
   //  value associated with every point just as is done with the
   //  PointSet. The following line illustrates a typical
   //  instantiation of the Mesh.
@@ -88,7 +87,6 @@ int main(int, char *[])
   typedef itk::Mesh< PixelType, Dimension >   MeshType;
   // Software Guide : EndCodeSnippet
 
-
   //  Software Guide : BeginLatex
   //
   //  Meshes are expected to take large amounts of memory. For this reason they
@@ -106,11 +104,10 @@ int main(int, char *[])
   MeshType::Pointer  mesh = MeshType::New();
   // Software Guide : EndCodeSnippet
 
-
   //  Software Guide : BeginLatex
   //
   //  The management of points in the Mesh is exactly the same as in
-  //  the PointSet. The type point associated with the mesh can be
+  //  the PointSet. The type of point associated with the mesh can be
   //  obtained through the \code{PointType} trait. The following code shows the
   //  creation of points compatible with the mesh type defined above and the
   //  assignment of values to its coordinates.
@@ -168,7 +165,7 @@ int main(int, char *[])
   //  Software Guide : BeginLatex
   //
   //  The points can now be efficiently accessed using the Iterator to the
-  //  PointsContainer as it was done in the previous section for the
+  //  PointsContainer as was done in the previous section for the
   //  PointSet.  First, the point iterator type is extracted through
   //  the mesh traits.
   //
@@ -199,7 +196,7 @@ int main(int, char *[])
 
   //  Software Guide : BeginLatex
   //
-  //  The \code{++} operator on the iterator is now used to advance from one
+  //  The \code{++} operator is used to advance the iterator from one
   //  point to the next. The actual value of the Point to which the iterator is
   //  pointing can be obtained with the \code{Value()} method. The loop for
   //  walking through all the points is controlled by comparing the current

Examples/DataRepresentation/Mesh/PointSet1.cxx

@@ -23,7 +23,7 @@
 //  class for the \code{itk::Mesh} providing the methods necessary to
 //  manipulate sets of point. Points can have values associated with
 //  them. The type of such values is defined by a template parameter of the
-//  \code{itk::PointSet} class (i.e., \code{TPixelType}. Two basic
+//  \code{itk::PointSet} class (i.e., \code{TPixelType}). Two basic
 //  interaction styles of PointSets are available in ITK. These styles are
 //  referred to as \emph{static} and \emph{dynamic}. The first style is used
 //  when the number of points in the set is known in advance and is not
@@ -92,12 +92,11 @@ int main(int, char *[])
   //
   //  Following the principles of Generic Programming, the \code{PointSet} class has a
   //  set of associated defined types to ensure that interacting objects can be
-  //  declared with compatible types. This set of type definitions is
-  //  commonly known as a set of \emph{traits}.  Among them we can find the
-  //  \code{PointType} type, for example.  This is the type used by the point set to
-  //  represent points in space.  The following declaration takes the point
-  //  type as defined in the \code{PointSet} traits and renames it to be conveniently
-  //  used in the global namespace.
+  //  declared with compatible types. This set of type definitions is commonly known
+  //  as a set of \emph{traits}.  Among the traits of the \code{PointSet} class is
+  //  \code{PointType}, which is used by the point set to represent points in space.
+  //  The following declaration takes the point type as defined in the \code{PointSet}
+  //  traits and renames it to be conveniently used in the global namespace.
   //
   //  \index{itk::PointSet!PointType}
   //

Examples/DataRepresentation/Mesh/PointSet2.cxx

@@ -60,8 +60,8 @@ int main(int, char *[])
   //  type of point container is an VectorContainer.  Both the map
   //  and vector container are templated over the type of the elements they
   //  contain. In this case they are templated over PointType.
-  //  Containers are reference counted object. They are then created with the
-  //  \code{New()} method and assigned to a \doxygen{SmartPointer} after
+  //  Containers are reference counted objects, and are therefore created with
+  //  the \code{New()} method and assigned to a \doxygen{SmartPointer} after
   //  creation.  The following line creates a point container compatible with
   //  the type of the PointSet from which the trait has been taken.
   //

Examples/DataRepresentation/Mesh/PointSet3.cxx

@@ -18,14 +18,14 @@
 
 //  Software Guide : BeginLatex
 //
-//  The \doxygen{PointSet} class was designed to interact with the Image class.
+//  The \doxygen{PointSet} class was designed to interact with the \code{Image} class.
 //  For this reason it was found convenient to allow the points in the set to
 //  hold values that could be computed from images. The value associated with
 //  the point is referred as \code{PixelType} in order to make it consistent
 //  with image terminology. Users can define the type as they please thanks to
 //  the flexibility offered by the Generic Programming approach used in the
 //  toolkit.  The \code{PixelType} is the first template parameter of the
-//  PointSet.
+//  \code{PointSet}.
 //
 //  \index{itk::PointSet!PixelType}
 //

Examples/DataRepresentation/Mesh/PointSetWithCovariantVectors.cxx

@@ -18,13 +18,13 @@
 
 //  Software Guide : BeginLatex
 //
-//  It is common to represent geometric object by using points on their surfaces
+//  It is common to represent geometric objects by using points on their surfaces
 //  and normals associated with those points.  This structure can be easily
 //  instantiated with the \doxygen{PointSet} class.
 //
 //  The natural class for representing normals to surfaces and
 //  gradients of functions is the \doxygen{CovariantVector}. A
-//  covariant vector differs from a vector in the way they behave
+//  covariant vector differs from a vector in the way it behaves
 //  under affine transforms, in particular under anisotropic
 //  scaling. If a covariant vector represents the gradient of a
 //  function, the transformed covariant vector will still be the valid
@@ -34,13 +34,14 @@
 //  \index{itk::PointSet!itk::CovariantVector}
 //  \index{itk::CovariantVector!itk::PointSet}
 //
-//  The following code shows how vector values can be used as pixel type on the
-//  PointSet class.  The CovariantVector class is used here as the
-//  pixel type. The example illustrates how a deformable model could move under
-//  the influence of the gradient of potential function.
+//  The following example demonstrates how a \code{CovariantVector} can
+//  be used as the \code{PixelType} for the \code{PointSet} class.  The
+//  example illustrates how a deformable model could move under
+//  the influence of the gradient of a potential function.
 //
-//  In order to use the CovariantVector class it is necessary to
-//  include its header file along with the header of the point set.
+//  In order to use the \code{CovariantVector} class it is necessary to
+//  include its header file.  We additionally include the header file
+//  for the \code{PointSet} class.
 //
 //  \index{itk::CovariantVector!Header}
 //
@@ -88,7 +89,7 @@ int main(int, char *[])
 
   //  Software Guide : BeginLatex
   //
-  //  The following code generates a sphere and assigns gradient values to
+  //  The following code generates a circle and assigns gradient values to
   //  the points. The components of the CovariantVectors in this example are
   //  computed to represent the normals to the circle.
   //

Examples/DataRepresentation/Mesh/PointSetWithVectors.cxx

@@ -49,9 +49,9 @@ int main(int, char *[])
   //    \caption[PointSet with Vectors as PixelType]{Vectors as PixelType.\label{fig:PointSetWithVectors}}
   //  \end{floatingfigure}
   //
-  //  The Vector class is templated over the type used to represent
+  //  The \code{Vector} class is templated over the type used to represent
   //  the spatial coordinates and over the space dimension.  Since the
-  //  PixelType is independent of the PointType, we are free to select any
+  //  \code{PixelType} is independent of the PointType, we are free to select any
   //  dimension for the vectors to be used as pixel type. However, for the
   //  sake of producing an interesting example, we will use vectors that
   //  represent displacements of the points in the PointSet. Those vectors

Examples/DataRepresentation/Mesh/RGBPointSet.cxx

@@ -64,7 +64,7 @@ int main(int, char *[])
 
   //  Software Guide : BeginLatex
   //
-  //  The following code is generating a sphere and assigning RGB values to
+  //  The following code generates a circle and assigns RGB values to
   //  the points. The components of the RGB values in this example are
   //  computed to represent the position of the points.
   //