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

Introduce \itkref and \itksubref as the in-tree spellings of the class
and namespaced-class cross-reference aliases, and convert all uses in
Modules and Examples. The historical \doxygen and \subdoxygen aliases
are retained as deprecated synonyms so out-of-tree code and external
tools that still emit them continue to resolve; \subdoxygen was
previously undefined, so this also gives those uses a definition.

Author: hjmjohnson

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