DOC: Rename \doxygen/\subdoxygen aliases to \itkref/\itksubref

Examples/DataRepresentation/Image/Image1.cxx

@@ -18,7 +18,7 @@
 
 // Software Guide : BeginLatex
 //
-// This example illustrates how to manually construct an \doxygen{Image}
+// This example illustrates how to manually construct an \itkref{Image}
 // class. The following is the minimal code needed to instantiate, declare
 // and create the \code{Image} class.
 //
@@ -54,7 +54,7 @@ main(int, char *[])
   //
   // The image can then be created by invoking the \code{New()} operator
   // from the corresponding image type and assigning the result
-  // to a \doxygen{SmartPointer}.
+  // to a \itkref{SmartPointer}.
   //
   // \index{itk::Image!Pointer}
   // \index{itk::Image!New()}
@@ -83,8 +83,8 @@ main(int, char *[])
   // instantiated as previously shown, and that regions describing the image
   // are then associated with it.
   //
-  // A region is defined by two classes: the \doxygen{Index} and
-  // \doxygen{Size} classes. The origin of the region within the
+  // A region is defined by two classes: the \itkref{Index} and
+  // \itkref{Size} classes. The origin of the region within the
   // image is defined by the \code{Index}. The extent, or size, of the region
   // is defined by the \code{Size}. When an image is created manually, the
   // user is responsible for defining the image size and the index at which
@@ -112,7 +112,7 @@ main(int, char *[])
   // Software Guide : BeginLatex
   //
   // 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
+  // image (using the \itkref{Size} class). The components of the array are
   // unsigned integers indicating the extent in pixels of the image along
   // every dimension.
   //
@@ -132,7 +132,7 @@ main(int, char *[])
   // Software Guide : BeginLatex
   //
   // Having defined the starting index and the image size, these two
-  // parameters are used to create an \doxygen{ImageRegion} object
+  // parameters are used to create an \itkref{ImageRegion} object
   // which basically encapsulates both concepts.
   // The region is initialized with the starting index and size of the
   // image.

Examples/DataRepresentation/Image/Image2.cxx

@@ -21,7 +21,7 @@
 //  Software Guide : BeginLatex
 //
 //  The first thing required to read an image from a file is to include
-//  the header file of the \doxygen{ImageFileReader} class.
+//  the header file of the \itkref{ImageFileReader} class.
 //
 //  Software Guide : EndLatex
 
@@ -71,7 +71,7 @@ main(int, char * argv[])
   // Software Guide : BeginLatex
   //
   // The reader type can now be used to create one reader object.  A
-  // \doxygen{SmartPointer} (defined by the \code{::Pointer} notation) is used
+  // \itkref{SmartPointer} (defined by the \code{::Pointer} notation) is used
   // to receive the reference to the newly created reader.  The \code{New()}
   // method is invoked to create an instance of the image reader.
   //
@@ -90,7 +90,7 @@ main(int, char * argv[])
   // of the image to be loaded in memory. This is provided through
   // the \code{SetFileName()} method. The file format here is inferred
   // from the filename extension. The user may also explicitly specify
-  // the data format using the \doxygen{ImageIOBase} class (a list
+  // the data format using the \itkref{ImageIOBase} class (a list
   // of possibilities can be found in the inheritance diagram of this
   // class.).
   //

Examples/DataRepresentation/Image/Image3.cxx

@@ -65,7 +65,7 @@ main(int, char *[])
   // unique index. An index is an array of integers that defines the position
   // of the pixel along each dimension of the image. The \code{IndexType}
   // is automatically defined by the image and can be accessed using the
-  // scope operator \doxygen{Index}. The length of the array will match
+  // scope operator \itkref{Index}. The length of the array will match
   // the dimensions of the associated image.
   //
   // The following code illustrates the declaration of an index variable and

Examples/DataRepresentation/Image/Image4.cxx

@@ -43,7 +43,7 @@
 // \end{figure}
 //
 // Figure \ref{fig:ImageOriginAndSpacing} illustrates the main geometrical
-// concepts associated with the \doxygen{Image}.
+// concepts associated with the \itkref{Image}.
 // In this figure, circles are
 // used to represent the center of pixels. The value of the pixel is assumed
 // to exist as a Dirac delta function located at the pixel center. Pixel
@@ -102,7 +102,7 @@ main(int, char *[])
   // the spacing of the image, an array of the corresponding type must be
   // created.  The elements of the array should then be initialized with the
   // spacing between the centers of adjacent pixels. The following code
-  // illustrates the methods available in the \doxygen{Image} class for
+  // illustrates the methods available in the \itkref{Image} class for
   // dealing with spacing and origin.
   //
   // \index{itk::Image!Spacing}
@@ -251,7 +251,7 @@ main(int, char *[])
   // physical space can be mapped into an image index for the purpose of
   // reading the content of the closest pixel.
   //
-  // First, a \doxygen{Point} type must be declared. The point type is
+  // First, a \itkref{Point} type must be declared. The point type is
   // templated over the type used to represent coordinates and over the
   // dimension of the space. In this particular case, the dimension of the
   // point must match the dimension of the image.
@@ -264,8 +264,8 @@ main(int, char *[])
 
   // Software Guide : BeginLatex
   //
-  // The \doxygen{Point} class, like an \doxygen{Index}, is a relatively
-  // small and simple object. This means that no \doxygen{SmartPointer}
+  // The \itkref{Point} class, like an \itkref{Index}, is a relatively
+  // small and simple object. This means that no \itkref{SmartPointer}
   // is used here and the objects are simply declared as instances,
   // like any other C++ class. Once the point is declared, its
   // components can be accessed using traditional array notation. In

Examples/DataRepresentation/Image/Image5.cxx

@@ -18,11 +18,11 @@
 
 // Software Guide : BeginLatex
 //
-// This example illustrates how to import data into the \doxygen{Image}
+// This example illustrates how to import data into the \itkref{Image}
 // class. This is particularly useful for interfacing with other software
 // systems. Many systems use a contiguous block of memory as a buffer
 // for image pixel data. The current example assumes this is the case and
-// feeds the buffer into an \doxygen{ImportImageFilter}, thereby producing an
+// feeds the buffer into an \itkref{ImportImageFilter}, thereby producing an
 // image as output.
 //
 // Here we create a synthetic image with a centered sphere in
@@ -33,7 +33,7 @@
 // \index{itk::ImportImageFilter!Instantiation}
 // \index{itk::ImportImageFilter!Header}
 //
-// First, the header file of the \doxygen{ImportImageFilter} class must be
+// First, the header file of the \itkref{ImportImageFilter} class must be
 // included.
 //
 // Software Guide : EndLatex
@@ -174,7 +174,7 @@ main(int argc, char * argv[])
   // programming languages. Note that ITK
   // does not use \code{for()} loops in its internal code to access
   // pixels. All pixel access tasks are instead performed using an
-  // \doxygen{ImageIterator} that supports the management of
+  // \itkref{ImageIterator} that supports the management of
   // n-dimensional images.
   //
   // Software Guide : EndLatex

Examples/DataRepresentation/Image/ImageAdaptor1.cxx

@@ -18,7 +18,7 @@
 
 // Software Guide : BeginLatex
 //
-// This example illustrates how the \doxygen{ImageAdaptor} can be used to cast
+// This example illustrates how the \itkref{ImageAdaptor} can be used to cast
 // an image from one pixel type to another. In particular, we will
 // \emph{adapt} an \code{unsigned char} image to make it appear as an image of
 // pixel type \code{float}.
@@ -179,7 +179,7 @@ main(int argc, char * argv[])
   // type
   //  \code{float}. Additionally, it should be noted that the adaptor is used
   // as if it was an actual image and not as a filter. ImageAdaptors conform
-  // to the same API as the  \doxygen{Image} class.
+  // to the same API as the  \itkref{Image} class.
   //
   //  Software Guide : EndLatex
 

Examples/DataRepresentation/Image/ImageAdaptor2.cxx

@@ -18,7 +18,7 @@
 
 // Software Guide : BeginLatex
 //
-// This example illustrates how to use the \doxygen{ImageAdaptor}
+// This example illustrates how to use the \itkref{ImageAdaptor}
 // to access the individual components of an RGB image. In this case, we
 // create an ImageAdaptor that will accept a RGB image as input and
 // presents it as a scalar image. The pixel data
@@ -67,7 +67,7 @@ class RedChannelPixelAccessor
 //  Software Guide : BeginLatex
 //
 //  The \code{Get()} method simply calls the \code{GetRed()} method
-//  defined in the \doxygen{RGBPixel} class.
+//  defined in the \itkref{RGBPixel} class.
 //
 //  Software Guide : EndLatex
 
@@ -137,8 +137,8 @@ main(int argc, char * argv[])
 
   //  Software Guide : BeginLatex
   //
-  //  We create an \doxygen{RescaleIntensityImageFilter} and an
-  //  \doxygen{ImageFileWriter} to rescale the dynamic range of the pixel
+  //  We create an \itkref{RescaleIntensityImageFilter} and an
+  //  \itkref{ImageFileWriter} to rescale the dynamic range of the pixel
   //  values and send the extracted channel to an image file. Note that the
   //  image type used for the rescaling filter is the \code{ImageAdaptorType}
   //  itself. That is, the adaptor type is used in the same context as an

Examples/DataRepresentation/Image/ImageAdaptor3.cxx

@@ -18,13 +18,13 @@
 
 // Software Guide : BeginLatex
 //
-// This example illustrates the use of \doxygen{ImageAdaptor}
+// This example illustrates the use of \itkref{ImageAdaptor}
 // to obtain access to the components of a vector image.
 // Specifically, it shows how to manage pixel accessors containing
 // internal parameters. In this example we create an image of vectors by using
 // a gradient filter. Then, we use an image adaptor to extract one of the
 // components of the vector image. The vector type used by the gradient filter
-// is the \doxygen{CovariantVector} class.
+// is the \itkref{CovariantVector} class.
 //
 // We start by including the relevant headers.
 //
@@ -121,8 +121,8 @@ main(int argc, char * argv[])
   //  Software Guide : BeginLatex
   //
   //  In order to test the pixel accessor, we generate an image of vectors
-  //  using the \doxygen{GradientRecursiveGaussianImageFilter}. This filter
-  //  produces an output image of \doxygen{CovariantVector} pixel type.
+  //  using the \itkref{GradientRecursiveGaussianImageFilter}. This filter
+  //  produces an output image of \itkref{CovariantVector} pixel type.
   //  Covariant vectors are the natural representation for gradients since
   //  they are the equivalent of normals to iso-values manifolds.
   //

Examples/DataRepresentation/Image/ImageAdaptor4.cxx

@@ -32,7 +32,7 @@
 //
 // Image adaptors can also be used to perform simple pixel-wise computations
 // on image data. The following example illustrates how to use the
-// \doxygen{ImageAdaptor} for image thresholding.
+// \itkref{ImageAdaptor} for image thresholding.
 //
 // \index{itk::ImageAdaptor!Instantiation}
 // \index{itk::ImageAdaptor!Header}
@@ -222,7 +222,7 @@ main(int argc, char * argv[])
   //  Figure~\ref{fig:ImageAdaptorThresholding} illustrates the result of
   //  applying the thresholding adaptor to a typical gray scale image using
   //  two different threshold values. Note that the same effect could have
-  //  been achieved by using the \doxygen{BinaryThresholdImageFilter} but at
+  //  been achieved by using the \itkref{BinaryThresholdImageFilter} but at
   //  the price of holding an extra copy of the image in memory.
   //
   // Software Guide : EndLatex

Examples/DataRepresentation/Image/RGBImage.cxx

@@ -29,7 +29,7 @@
 //
 //  A class intended to support the RGB pixel type is available in ITK.  You
 //  could also define your own pixel class and use it to instantiate a
-//  custom image type. In order to use the \doxygen{RGBPixel} class, it is
+//  custom image type. In order to use the \itkref{RGBPixel} class, it is
 //  necessary to include its header file.
 //
 //  \index{itk::RGBPixel}
@@ -72,7 +72,7 @@ main(int, char * argv[])
   // Software Guide : BeginLatex
   //
   // The image type can be used to instantiate other filter, for example,
-  // an \doxygen{ImageFileReader} object that will read the image from a
+  // an \itkref{ImageFileReader} object that will read the image from a
   // file.
   //
   // \index{itk::ImageFileReader!RGB Image}
@@ -124,8 +124,8 @@ main(int, char * argv[])
 
   // Software Guide : BeginLatex
   //
-  // The subindex notation can also be used since the \doxygen{RGBPixel}
-  // inherits the \code{[]} operator from the \doxygen{FixedArray} class.
+  // The subindex notation can also be used since the \itkref{RGBPixel}
+  // inherits the \code{[]} operator from the \itkref{FixedArray} class.
   //
   // Software Guide : EndLatex
 

Examples/DataRepresentation/Image/VectorImage.cxx

@@ -23,12 +23,12 @@
 // represent the gradient of a scalar image. The following code illustrates
 // how to instantiate and use an image whose pixels are of vector type.
 //
-// For convenience we use the \doxygen{Vector} class to define the pixel
+// For convenience we use the \itkref{Vector} class to define the pixel
 // type.  The Vector class is intended to represent a geometrical vector in
 // space. It is not intended to be used as an array container like the
 // \href{https://www.sgi.com/tech/stl/Vector.html}{\code{std::vector}} in
 // \href{https://www.sgi.com/tech/stl/}{STL}.  If you are interested in
-// containers, the \doxygen{VectorContainer} class may provide the
+// containers, the \itkref{VectorContainer} class may provide the
 // functionality you want.
 //
 // \index{itk::Vector}
@@ -104,7 +104,7 @@ main(int, char *[])
   // Software Guide : BeginLatex
   //
   // The Vector class inherits the operator \code{[]} from the
-  // \doxygen{FixedArray} class. This makes it possible to access the
+  // \itkref{FixedArray} class. This makes it possible to access the
   // Vector's components using index notation.
   //
   // Software Guide : EndLatex

Examples/DataRepresentation/Mesh/AutomaticMesh.cxx

@@ -18,11 +18,11 @@
 
 //  Software Guide : BeginLatex
 //
-//  The \doxygen{Mesh} class is extremely general and flexible, but
+//  The \itkref{Mesh} class is extremely general and flexible, but
 //  there is some cost to convenience.  If convenience is exactly what
 //  you need, then it is possible to get it, in exchange for some of
 //  that flexibility, by means of the
-//  \doxygen{AutomaticTopologyMeshSource} class.  This class
+//  \itkref{AutomaticTopologyMeshSource} class.  This class
 //  automatically generates an explicit K-Complex, based on the cells
 //  you add.  It explicitly includes all boundary information, so that
 //  the resulting mesh can be easily traversed.  It merges all shared
@@ -67,8 +67,8 @@ main(int, char *[])
   //  type of all vertices and cells be \code{unsigned long}, which is
   //  already the default.  However, if you created a new mesh traits
   //  class to use string tags as identifiers, the resulting mesh
-  //  would not be compatible with \doxygen{AutomaticTopologyMeshSource}.
-  //  An \code{IdentifierArrayType} is simply an \doxygen{Array}
+  //  would not be compatible with \itkref{AutomaticTopologyMeshSource}.
+  //  An \code{IdentifierArrayType} is simply an \itkref{Array}
   //  of \code{IdentifierType} objects.
   //
   //  \index{itk::AutomaticTopologyMeshSource!IdentifierType}

Examples/DataRepresentation/Mesh/Mesh1.cxx

@@ -18,8 +18,8 @@
 
 //  Software Guide : BeginLatex
 //
-//  The \doxygen{Mesh} class is intended to represent shapes in space.  It
-//  derives from the \doxygen{PointSet} class and hence inherits all the
+//  The \itkref{Mesh} class is intended to represent shapes in space.  It
+//  derives from the \itkref{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.
@@ -90,7 +90,7 @@ main(int, char *[])
   //  Software Guide : BeginLatex
   //
   //  Meshes typically require large amounts of memory. For this reason, they
-  //  are reference counted objects, managed using \doxygen{SmartPointers}.
+  //  are reference counted objects, managed using \itkref{SmartPointers}.
   //  The following line illustrates how a mesh is created by invoking the
   //  \code{New()} method on \code{MeshType} and assigning the result to a
   //  \code{SmartPointer}.

Examples/DataRepresentation/Mesh/Mesh2.cxx

@@ -18,10 +18,10 @@
 
 //  Software Guide : BeginLatex
 //
-//  A \doxygen{Mesh} can contain a variety of cell types. Typical cells are
-//  the \doxygen{LineCell}, \doxygen{TriangleCell},
-//  \doxygen{QuadrilateralCell}, \doxygen{TetrahedronCell}, and
-//  \doxygen{PolygonCell}. Additional flexibility is provided for managing
+//  A \itkref{Mesh} can contain a variety of cell types. Typical cells are
+//  the \itkref{LineCell}, \itkref{TriangleCell},
+//  \itkref{QuadrilateralCell}, \itkref{TetrahedronCell}, and
+//  \itkref{PolygonCell}. Additional flexibility is provided for managing
 //  cells at the price of a bit more of complexity than in the case of point
 //  management.
 //
@@ -104,7 +104,7 @@ main(int, char *[])
   //  responsible for allocating and releasing the cells' memory. This
   //  protocol is implemented in the form of a specific type of pointer called
   //  the \code{CellAutoPointer}. This pointer, based on the
-  //  \doxygen{AutoPointer}, differs in many respects from the
+  //  \itkref{AutoPointer}, differs in many respects from the
   //  \code{SmartPointer}. The \code{CellAutoPointer} has an internal pointer
   //  to the actual object and a boolean flag that indicates whether the
   //  \code{CellAutoPointer} is responsible for releasing the cell memory when

Examples/DataRepresentation/Mesh/Mesh3.cxx

@@ -66,7 +66,7 @@ main(int, char *[])
 
   //  Software Guide : BeginLatex
   //
-  //  The \doxygen{LineCell} type can now be instantiated using the traits
+  //  The \itkref{LineCell} type can now be instantiated using the traits
   //  taken from the Mesh.
   //
   //  \index{itk::LineCell!Instantiation}
@@ -145,7 +145,7 @@ main(int, char *[])
 
   //  Software Guide : BeginLatex
   //
-  //  Data associated with cells is inserted in the \doxygen{Mesh} by using
+  //  Data associated with cells is inserted in the \itkref{Mesh} by using
   //  the \code{SetCellData()} method.  It requires the user to provide an
   //  identifier and the value to be inserted. The identifier should match one
   //  of the inserted cells. In this simple example, the square of the cell