Commit ad83dd5a authored by Jordi Inglada's avatar Jordi Inglada

Corrections namespace pour doxygen

parent 459d41fe
......@@ -31,7 +31,7 @@
// Software Guide : BeginLatex
//
// This example illustrates the use of the \doxygen{otb::LeeImageFilter}.
// This example illustrates the use of the \doxygen{otb}{LeeImageFilter}.
// This filter belongs to the family of the edge-preserving smoothing
// filters which are usually used for speckle reduction in radar
// images. The Lee filter \cite{LeeFilter} aplies a linear regression
......@@ -96,7 +96,7 @@ int main( int argc, char * argv[] )
// Software Guide : BeginLatex
//
// An \doxygen{otb::ImageFileReader} class is also instantiated in order to read
// An \doxygen{otb}{ImageFileReader} class is also instantiated in order to read
// image data from a file.
//
// Software Guide : EndLatex
......@@ -107,7 +107,7 @@ int main( int argc, char * argv[] )
// Software Guide : BeginLatex
//
// An \doxygen{otb::ImageFileWriter} is instantiated in order to write the
// An \doxygen{otb}{ImageFileWriter} is instantiated in order to write the
// output image to a file.
//
// Software Guide : EndLatex
......@@ -138,7 +138,7 @@ int main( int argc, char * argv[] )
// Software Guide : BeginLatex
//
// The image obtained with the reader is passed as input to the
// \doxygen{otb::LeeImageFilter}.
// \doxygen{otb}{LeeImageFilter}.
//
// \index{otb::LeeImageFilter!SetInput()}
// \index{otb::FileImageReader!GetOutput()}
......@@ -199,13 +199,13 @@ int main( int argc, char * argv[] )
// \includegraphics[width=0.44\textwidth]{GomaSmall.eps}
// \includegraphics[width=0.44\textwidth]{GomaSmallLeeFiltered.eps}
// \itkcaption[Lee Filter Application]{Result of applying the
// \doxygen{otb::LeeImageFilter} to a SAR image.}
// \doxygen{otb}{LeeImageFilter} to a SAR image.}
// \label{fig:LEE_FILTER}
// \end{figure}
//
// \relatedClasses
// \begin{itemize}
// \item \doxygen{otb::FrostImageFilter}
// \item \doxygen{otb}{FrostImageFilter}
// \end{itemize}
//
// Software Guide : EndLatex
......
......@@ -29,7 +29,7 @@
// This example illustrates the Change Detector framework implemented
// in OTB. This framework uses the generic programming approach. All
// change detection filters are
// \doxygen{otb::BinaryFunctorNeighborhoodImageFilter}s, that is, they
// \doxygen{otb}{BinaryFunctorNeighborhoodImageFilter}s, that is, they
// are filters taking two images as input and providing one image as
// output. The change detection computation itself is performed on a
// the neighborhood of each pixel of the input images.
......@@ -62,7 +62,7 @@
//
// Since the change detectors operate on neighborhoods, the functor
// call will take 2 arguments which are
// \doxygen{itk::ConstNeighborhoodIterator}s.
// \doxygen{itk}{ConstNeighborhoodIterator}s.
//
// The change detector functor is templated over the types of the
// input iterators and the output result type. The core of the change
......@@ -106,7 +106,7 @@ public:
//
// The next step is the definition of the change detector filter. As
// stated above, this filter will inherit from
// \doxygen{otb::BinaryFunctorNeighborhoodImageFilter} which is
// \doxygen{otb}{BinaryFunctorNeighborhoodImageFilter} which is
// templated over the 2 input image types, the output image type and
// the functor used to perform the change detection operation.
//
......@@ -157,7 +157,7 @@ private:
//
// Pay attention to the fact that no \code{.txx} file is needed, since
// filtering operation is implemented in the
// \doxygen{otb::BinaryFunctorNeighborhoodImageFilter} class. So all
// \doxygen{otb}{BinaryFunctorNeighborhoodImageFilter} class. So all
// the algorithmics part is inside the functor.
//
// We can now write a program using the change detector.
......@@ -198,7 +198,7 @@ int main(int argc, char* argv[] )
// Software Guide : BeginLatex
//
// We declare the readers, the writer, but also the
// \doxygen{itk::RescaleIntensityImageFilter} which will be used to
// \doxygen{itk}{RescaleIntensityImageFilter} which will be used to
// rescale the result before writing it to a file.
//
// SoftwareGuide : EndLatex
......
......@@ -32,7 +32,7 @@
// Software Guide : BeginLatex
// This example illustrates the class
// \doxygen{otb::CorrelationChangeDetector} for detecting changes
// \doxygen{otb}{CorrelationChangeDetector} for detecting changes
// between pairs of images. This filter computes the correlation coefficient in
// the neighborhood of each pixel of the pair of images to be compared. This
// example will use the images shown in
......@@ -88,7 +88,7 @@ int main(int argc, char* argv[] )
// can be vey large, we will force the pipeline to use
// streaming. For this purpose, the file writer will be
// streamed. This is achieved by using the
// \doxygen{otb::StreamingImageFileWriter} class.
// \doxygen{otb}{StreamingImageFileWriter} class.
//
// Software Guide : EndLatex
......@@ -115,7 +115,7 @@ int main(int argc, char* argv[] )
// Software Guide : BeginLatex
//
// The \doxygen{otb::CorrelationChangeDetector} is templated over
// The \doxygen{otb}{CorrelationChangeDetector} is templated over
// the types of the two input images and the type of the generated change
// image.
//
......
......@@ -35,7 +35,7 @@
// Software Guide : BeginLatex
// This example illustrates the class
// \doxygen{otb::MeanDifferenceImageFilter} for detecting changes
// \doxygen{otb}{MeanDifferenceImageFilter} for detecting changes
// between pairs of images. This filter computes the mean intensity in
// the neighborhood of each pixel of the pair of images to be compared
// and uses the difference of means as a change indicator. This
......@@ -104,7 +104,7 @@ int main(int argc, char* argv[] )
// can be vey large, we will force the pipeline to use
// streaming. For this purpose, the file writer will be
// streamed. This is achieved by using the
// \doxygen{otb::StreamingImageFileWriter} class.
// \doxygen{otb}{StreamingImageFileWriter} class.
//
// Software Guide : EndLatex
......@@ -119,7 +119,7 @@ int main(int argc, char* argv[] )
// The change detector will give positive and negative values
// depending on the sign of the difference. We are usually
// interested only in the asbolute value of the difference. For
// this purpose, we will use the \doxygen{itk::AbsImageFilter}. Also, before
// this purpose, we will use the \doxygen{itk}{AbsImageFilter}. Also, before
// saving the image to a file in, for instance, PNG format, we will
// rescale the results of the change detection in order to use all
// the output pixel type range of values.
......@@ -136,7 +136,7 @@ int main(int argc, char* argv[] )
// Software Guide : BeginLatex
//
// The \doxygen{otb::MeanDifferenceImageFilter} is templated over
// The \doxygen{otb}{MeanDifferenceImageFilter} is templated over
// the types of the two input images and the type of the generated change
// image.
//
......
......@@ -26,7 +26,7 @@
// Software Guide : BeginLatex
// This example illustrates the class
// \doxygen{otb::MeanRatioImageFilter} for detecting changes
// \doxygen{otb}{MeanRatioImageFilter} for detecting changes
// between pairs of images. This filter computes the mean intensity in
// the neighborhood of each pixel of the pair of images to be compared
// and uses the ratio of means as a change indicator. This change
......@@ -96,7 +96,7 @@ int main(int argc, char* argv[] )
// can be vey large, we will force the pipeline to use
// streaming. For this purpose, the file writer will be
// streamed. This is achieved by using the
// \doxygen{otb::StreamingImageFileWriter} class.
// \doxygen{otb}{StreamingImageFileWriter} class.
//
// Software Guide : EndLatex
......@@ -126,7 +126,7 @@ int main(int argc, char* argv[] )
// Software Guide : BeginLatex
//
// The \doxygen{otb::MeanRatioImageFilter} is templated over
// The \doxygen{otb}{MeanRatioImageFilter} is templated over
// the types of the two input images and the type of the generated change
// image.
//
......
......@@ -30,12 +30,12 @@
// all the components of the classifier system and the data flow. This system
// differs with the previous k-means clustering algorithms in several
// ways. The biggest difference is that this classifier uses the
// \subdoxygen{itk::Statistics}{GaussianDensityFunction}s as membership functions
// instead of the \subdoxygen{itk::Statistics}{EuclideanDistance}. Since the
// \subdoxygen{itk}{Statistics}{GaussianDensityFunction}s as membership functions
// instead of the \subdoxygen{itk}{Statistics}{EuclideanDistance}. Since the
// membership function is different, the membership function requires a
// different set of parameters, mean vectors and covariance matrices. We
// choose the \subdoxygen{itk::Statistics}{MeanCalculator} (sample mean) and the
// \subdoxygen{itk::Statistics}{CovarianceCalculator} (sample covariance) for the
// choose the \subdoxygen{itk}{Statistics}{MeanCalculator} (sample mean) and the
// \subdoxygen{itk}{Statistics}{CovarianceCalculator} (sample covariance) for the
// estimation algorithms of the two parameters. If we want more robust
// estimation algorithm, we can replace these estimation algorithms with more
// alternatives without changing other components in the classifier system.
......@@ -52,10 +52,10 @@
// \protect\label{fig:BayesianPluginClassifier}
// \end{figure}
//
// We use the \subdoxygen{itk::Statistics}{ListSample} as the sample (test
// and training). The \doxygen{itk::Vector} is our measurement vector
// We use the \subdoxygen{itk}{Statistics}{ListSample} as the sample (test
// and training). The \doxygen{itk}{Vector} is our measurement vector
// class. To store measurement vectors into two separate sample
// containers, we use the \subdoxygen{itk::Statistics}{Subsample} objects.
// containers, we use the \subdoxygen{itk}{Statistics}{Subsample} objects.
//
// Software Guide : EndLatex
......@@ -93,7 +93,7 @@
// Software Guide : BeginLatex
//
// We will fill the sample with random variables from two normal
// distribution using the \subdoxygen{itk::Statistics}{NormalVariateGenerator}.
// distribution using the \subdoxygen{itk}{Statistics}{NormalVariateGenerator}.
//
// Software Guide : EndLatex
......
......@@ -68,13 +68,13 @@
// distributions belonging to exponential family such as Poisson,
// Binomial, Exponential, and Normal distributions have analytical
// solutions for updating the parameter set. The
// \subdoxygen{itk::Statistics}{ExpectationMaximizationMixtureModelEstimator}
// \subdoxygen{itk}{Statistics}{ExpectationMaximizationMixtureModelEstimator}
// class assumes that such type of components.
//
// In the following example we use the \subdoxygen{itk::Statistics}{ListSample} as
// the sample (test and training). The \subdoxygen{itk::Vector} is our measurement
// In the following example we use the \subdoxygen{itk}{Statistics}{ListSample} as
// the sample (test and training). The \subdoxygen{itk}{Vector} is our measurement
// vector class. To store measurement vectors into two separate sample
// container, we use the \subdoxygen{itk::Statistics}{Subsample} objects.
// container, we use the \subdoxygen{itk}{Statistics}{Subsample} objects.
//
// Software Guide : EndLatex
......@@ -97,7 +97,7 @@
// Software Guide : BeginLatex
//
// We will fill the sample with random variables from two normal
// distribution using the \subdoxygen{itk::Statistics}{NormalVariateGenerator}.
// distribution using the \subdoxygen{itk}{Statistics}{NormalVariateGenerator}.
//
// Software Guide : EndLatex
......
......@@ -42,13 +42,13 @@
// measurement vector that changes its cluster membership from the
// previous iteration, then the algorithm stops.
//
// The \subdoxygen{itk::Statistics}{KdTreeBasedKmeansEstimator} is a variation of
// The \subdoxygen{itk}{Statistics}{KdTreeBasedKmeansEstimator} is a variation of
// this logic. The k-means clustering algorithm is computationally very
// expensive because it has to recalculate the mean at each iteration. To
// update the mean values, we have to calculate the distance between k means
// and each and every measurement vector. To reduce the computational burden,
// the KdTreeBasedKmeansEstimator uses a special data structure: the
// k-d tree (\subdoxygen{itk::Statistics}{KdTree}) with additional
// k-d tree (\subdoxygen{itk}{Statistics}{KdTree}) with additional
// information. The additional information includes the number and the vector
// sum of measurement vectors under each node under the tree architecture.
//
......@@ -61,8 +61,8 @@
// \cite{Kanungo2000}. Our implementation of this scheme follows the
// article by the Kanungo et al \cite{Kanungo2000}.
//
// We use the \subdoxygen{itk::Statistics}{ListSample} as the input sample, the
// \doxygen{itk::Vector} as the measurement vector. The following code
// We use the \subdoxygen{itk}{Statistics}{ListSample} as the input sample, the
// \doxygen{itk}{Vector} as the measurement vector. The following code
// snippet includes their header files.
//
// Software Guide : EndLatex
......@@ -74,12 +74,12 @@
// Software Guide : BeginLatex
//
// Since this k-means algorithm requires a \subdoxygen{itk::Statistics}{KdTree}
// Since this k-means algorithm requires a \subdoxygen{itk}{Statistics}{KdTree}
// object as an input, we include the KdTree class header file. As mentioned
// above, we need a k-d tree with the vector sum and the number of
// measurement vectors. Therefore we use the
// \subdoxygen{itk::Statistics}{WeightedCentroidKdTreeGenerator} instead of the
// \subdoxygen{itk::Statistics}{KdTreeGenerator} that generate a k-d tree without
// \subdoxygen{itk}{Statistics}{WeightedCentroidKdTreeGenerator} instead of the
// \subdoxygen{itk}{Statistics}{KdTreeGenerator} that generate a k-d tree without
// such additional information.
//
// Software Guide : EndLatex
......@@ -104,10 +104,10 @@
// Software Guide : BeginLatex
//
// To generate the clusters, we must create k instances of
// \subdoxygen{itk::Statistics}{EuclideanDistance} function as the membership
// \subdoxygen{itk}{Statistics}{EuclideanDistance} function as the membership
// functions for each cluster and plug that---along with a sample---into an
// \subdoxygen{itk::Statistics}{SampleClassifier} object to get a
// \subdoxygen{itk::Statistics}{MembershipSample} that stores pairs of measurement
// \subdoxygen{itk}{Statistics}{SampleClassifier} object to get a
// \subdoxygen{itk}{Statistics}{MembershipSample} that stores pairs of measurement
// vectors and their associated class labels (k labels).
//
// Software Guide : EndLatex
......@@ -121,7 +121,7 @@
// Software Guide : BeginLatex
//
// We will fill the sample with random variables from two normal
// distribution using the \subdoxygen{itk::Statistics}{NormalVariateGenerator}.
// distribution using the \subdoxygen{itk}{Statistics}{NormalVariateGenerator}.
//
// Software Guide : EndLatex
......@@ -281,7 +281,7 @@ int main()
// the estimated k means and the measurement vectors. We use the
// EuclideanDistance class as membership functions. Our choice
// for the decision rule is the
// \subdoxygen{itk::Statistics}{MinimumDecisionRule} that returns the
// \subdoxygen{itk}{Statistics}{MinimumDecisionRule} that returns the
// index of the membership functions that have the smallest value for
// a measurement vector.
//
......
......@@ -30,7 +30,7 @@
// This example shows how to use the KMeans model for classifying the pixel of
// a scalar image.
//
// The \subdoxygen{itk::Statistics}{ScalarImageKmeansImageFilter} is used for taking
// The \subdoxygen{itk}{Statistics}{ScalarImageKmeansImageFilter} is used for taking
// a scalar image and applying the K-Means algorithm in order to define classes
// that represents statistical distributions of intensity values in the pixels.
// The classes are then used in this filter for generating a labeled image where
......@@ -65,7 +65,7 @@ int main( int argc, char * argv [] )
//
// First we define the pixel type and dimension of the image that we intend to
// classify. With this image type we can also declare the
// \doxygen{otb::ImageFileReader} needed for reading the input image, create one and
// \doxygen{otb}{ImageFileReader} needed for reading the input image, create one and
// set its input filename.
//
// Software Guide : EndLatex
......@@ -87,7 +87,7 @@ int main( int argc, char * argv [] )
// Software Guide : BeginLatex
//
// With the \code{ImageType} we instantiate the type of the
// \doxygen{itk::ScalarImageKmeansImageFilter} that will compute the K-Means model
// \doxygen{itk}{ScalarImageKmeansImageFilter} that will compute the K-Means model
// and then classify the image pixels.
//
// Software Guide : EndLatex
......@@ -166,11 +166,11 @@ int main( int argc, char * argv [] )
// Software Guide : BeginLatex
//
// The \doxygen{itk::ScalarImageKmeansImageFilter} is predefined for producing an 8
// The \doxygen{itk}{ScalarImageKmeansImageFilter} is predefined for producing an 8
// bits scalar image as output. This output image contains labels associated
// to each one of the classes in the K-Means algorithm. In the following lines
// we use the \code{OutputImageType} in order to instantiate the type of a
// \doxygen{otb::ImageFileWriter}. Then create one, and connect it to the output of
// \doxygen{otb}{ImageFileWriter}. Then create one, and connect it to the output of
// the classification filter.
//
// Software Guide : EndLatex
......
......@@ -26,7 +26,7 @@
//
// This example shows how to compute the KMeans model of an Scalar Image.
//
// The \subdoxygen{itk::Statistics}{KdTreeBasedKmeansEstimator} is used for taking
// The \subdoxygen{itk}{Statistics}{KdTreeBasedKmeansEstimator} is used for taking
// a scalar image and applying the K-Means algorithm in order to define classes
// that represents statistical distributions of intensity values in the pixels.
// One of the drawbacks of this technique is that the spatial
......
......@@ -31,7 +31,7 @@
// This example shows how to use the Markov Random Field approach for
// classifying the pixel of a scalar image.
//
// The \subdoxygen{itk::Statistics}{MRFImageFilter} is used for refining an initial
// The \subdoxygen{itk}{Statistics}{MRFImageFilter} is used for refining an initial
// classification by introducing the spatial coherence of the labels. The user
// should provide two images as input. The first image is the one to be
// classified while the second image is an image of labels representing an
......@@ -110,7 +110,7 @@ int main( int argc, char * argv [] )
//
// First we define the pixel type and dimension of the image that we intend to
// classify. With this image type we can also declare the
// \doxygen{otb::ImageFileReader} needed for reading the input image, create one and
// \doxygen{otb}{ImageFileReader} needed for reading the input image, create one and
// set its input filename.
//
// Software Guide : EndLatex
......@@ -155,7 +155,7 @@ int main( int argc, char * argv [] )
// whose pixels have multiple components, that is, images of vector type, we
// must adapt our scalar image in order to satisfy the interface expected by
// the \code{MRFImageFilter}. We do this by using the
// \doxygen{itk::ScalarToArrayCastImageFilter}. With this filter we will present our
// \doxygen{itk}{ScalarToArrayCastImageFilter}. With this filter we will present our
// scalar image as a vector image whose vector pixels contain a single
// component.
//
......@@ -179,7 +179,7 @@ int main( int argc, char * argv [] )
//
// With the input image type \code{ImageType} and labeled image type
// \code{LabelImageType} we instantiate the type of the
// \doxygen{itk::MRFImageFilter} that will apply the Markov Random Field algorithm
// \doxygen{itk}{MRFImageFilter} that will apply the Markov Random Field algorithm
// in order to refine the pixel classification.
//
// Software Guide : EndLatex
......@@ -234,7 +234,7 @@ int main( int argc, char * argv [] )
// Given that the MRF filter needs to continually relabel the pixels, it needs
// access to a set of membership functions that will measure to what degree
// every pixel belongs to a particular class. The classification is performed
// by the \doxygen{itk::ImageClassifierBase} class, that is instantiated using the
// by the \doxygen{itk}{ImageClassifierBase} class, that is instantiated using the
// type of the input vector image and the type of the labeled image.
//
// Software Guide : EndLatex
......@@ -273,7 +273,7 @@ int main( int argc, char * argv [] )
// Software Guide : BeginLatex
//
// We now instantiate the membership functions. In this case we use the
// \subdoxygen{itk::Statistics}{DistanceToCentroidMembershipFunction} class
// \subdoxygen{itk}{Statistics}{DistanceToCentroidMembershipFunction} class
// templated over the pixel type of the vector image, which in our example
// happens to be a vector of dimension 1.
//
......@@ -369,7 +369,7 @@ int main( int argc, char * argv [] )
// functions have comparable value. This is necessary since the label
// image and the input image can have different dynamic ranges. The fidelity
// function is usually computed using a distance function, such as the
// \doxygen{itk::DistanceToCentroidMembershipFunction} or one of the other
// \doxygen{itk}{DistanceToCentroidMembershipFunction} or one of the other
// membership functions. They tend to have values in the order of the means
// specified.
// Software Guide : EndLatex
......@@ -408,10 +408,10 @@ int main( int argc, char * argv [] )
// Software Guide : BeginLatex
//
// The output image produced by the \doxygen{itk::MRFImageFilter} has the same pixel
// The output image produced by the \doxygen{itk}{MRFImageFilter} has the same pixel
// type as the labeled input image. In the following lines we use the
// \code{OutputImageType} in order to instantiate the type of a
// \doxygen{otb::ImageFileWriter}. Then create one, and connect it to the output of
// \doxygen{otb}{ImageFileWriter}. Then create one, and connect it to the output of
// the classification filter after passing it through an intensity rescaler
// to rescale it to an 8 bit dynamic range
//
......
......@@ -27,9 +27,9 @@
//
// \index{itk::TreeContainer}
//
// This example shows how to use the \doxygen{TreeContainer} and the
// This example shows how to use the \doxygen{itk}{TreeContainer} and the
// associated TreeIterators.
// The \doxygen{TreeContainer} implements the notion of tree and is
// The \doxygen{itk}{TreeContainer} implements the notion of tree and is
// templated over the type of node so it can virtually handle any
// objects. Each node is supposed to have only one parent so no cycle
// is present in the tree. No checking is done to ensure a cycle-free
......@@ -86,7 +86,7 @@ int main(int, char* [])
tree->Add(7,1);
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
// We define an \doxygen{LevelOrderTreeIterator} to parse the tree in level order.
// We define an \doxygen{itk}{LevelOrderTreeIterator} to parse the tree in level order.
// This particular iterator takes three arguments. The first one is the actual tree
// to be parsed, the second one is the maximum depth level and the third one is the
// starting node. The \code{GetNode()} function return a node given its value. Once
......@@ -118,7 +118,7 @@ int main(int, char* [])
levelIt.CountChildren();
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
// The \doxygen{ChildTreeIterator} provides another way to iterate through a tree
// The \doxygen{itk}{ChildTreeIterator} provides another way to iterate through a tree
// by listing all the children of a node.
// Software Guide : EndLatex
std::cout << "ChildTreeIterator:" << std::endl;
......@@ -156,7 +156,7 @@ int main(int, char* [])
delete childItClone;
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
// The \doxygen{LeafTreeIterator} iterates through the leaves of the tree.
// The \doxygen{itk}{LeafTreeIterator} iterates through the leaves of the tree.
// Software Guide : EndLatex
std::cout << "LeafTreeIterator:" << std::endl;
// Software Guide : BeginCodeSnippet
......@@ -170,7 +170,7 @@ int main(int, char* [])
std::cout << std::endl;
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
// The \doxygen{InOrderTreeIterator} iterates through the tree
// The \doxygen{itk}{InOrderTreeIterator} iterates through the tree
// in the order from left to right.
// Software Guide : EndLatex
std::cout << "InOrderTreeIterator:" << std::endl;
......@@ -185,7 +185,7 @@ int main(int, char* [])
std::cout << std::endl;
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
// The \doxygen{PreOrderTreeIterator} iterates through the tree
// The \doxygen{itk}{PreOrderTreeIterator} iterates through the tree
// from left to right but do a depth first search.
// Software Guide : EndLatex
std::cout << "PreOrderTreeIterator:" << std::endl;
......@@ -200,7 +200,7 @@ int main(int, char* [])
std::cout << std::endl;
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
// The \doxygen{PostOrderTreeIterator} iterates through the tree
// The \doxygen{itk}{PostOrderTreeIterator} iterates through the tree
// from left to right but goes from the leaves to the root in the search.
// Software Guide : EndLatex
std::cout << "PostOrderTreeIterator:" << std::endl;
......@@ -215,7 +215,7 @@ int main(int, char* [])
std::cout << std::endl;
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
// The \doxygen{RootTreeIterator} goes from one node to the
// The \doxygen{itk}{RootTreeIterator} goes from one node to the
// root. The second arguments is the starting node. Here we go from the leaf
// node (value = 6) up to the root.
// Software Guide : EndLatex
......@@ -253,7 +253,7 @@ int main(int, char* [])
PreOrderIt2.Add(5);
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
// The \doxygen{TreeIteratorClone} can be used to have a generic copy of
// The \doxygen{itk}{TreeIteratorClone} can be used to have a generic copy of
// an iterator.
// Software Guide : EndLatex
// Software Guide : BeginCodeSnippet
......
......@@ -24,7 +24,7 @@
// Software Guide : BeginLatex
//
// This example illustrates how to manually construct an \doxygen{otb::Image}
// This example illustrates how to manually construct an \doxygen{otb}{Image}
// class. The following is the minimal code needed to instantiate, declare
// and create the image class.
//
......@@ -63,7 +63,7 @@ int 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{itk::SmartPointer}.
// to a \doxygen{itk}{SmartPointer}.
//
// \index{Image!Pointer}
// \index{Image!New()}
......@@ -92,8 +92,8 @@ int 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{itk::Index} and
// \doxygen{itk::Size} classes. The origin of the region within the
// A region is defined by two classes: the \doxygen{itk}{Index} and
// \doxygen{itk}{Size} classes. The origin of the region within the
// image with which it is associated is defined by Index. The
// extent, or size, of the region is defined by Size. Index
// is represented by a n-dimensional array where each component is an
......
......@@ -27,7 +27,7 @@
// Software Guide : BeginLatex
//
// The first thing required to read an image from a file is to include
// the header file of the \doxygen{otb::ImageFileReader} class.
// the header file of the \doxygen{otb}{ImageFileReader} class.
//
// Software Guide : EndLatex
......@@ -78,7 +78,7 @@ int main( int , char * argv[])
// Software Guide : BeginLatex
//
// The reader type can now be used to create one reader object. A
// \doxygen{itk::SmartPointer} (defined by the \code{::Pointer}
// \doxygen{itk}{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.
......@@ -99,7 +99,7 @@ int 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 explicitly using the \doxygen{itk::ImageIO} (See
// data format explicitly using the \doxygen{itk}{ImageIO} (See
// Chapter~\ref{sec:ImagReadWrite} \pageref{sec:ImagReadWrite} for more
// information):
//
......
......@@ -76,7 +76,7 @@ int main(int, char *[])
// unique index. An index is an array of integers that defines the position
// of the pixel along each coordinate dimension of the image. The IndexType
// is automatically defined by the image and can be accessed using the
// scope operator like \doxygen{itk::Index}. The length of the array will match
// scope operator like \doxygen{itk}{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
......
......@@ -48,7 +48,7 @@
// \end{figure}
//
// Figure \ref{fig:ImageOriginAndSpacing} illustrates the main geometrical
// concepts associated with the \doxygen{otb::Image}. In this figure,
// concepts associated with the \doxygen{otb}{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
......@@ -203,7 +203,7 @@ int main(int, char *[])
// space can be mapped into an image index for the purpose of reading the
// content of the closest pixel.
//
// First, a \doxygen{itk::Point} type must be declared. The point type is
// First, a \doxygen{itk}{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.
......@@ -217,10 +217,10 @@ int main(int, char *[])
// Software Guide : BeginLatex
//
// The Point class, like an \doxygen{itk::Index}, is a relatively small and
// The Point class, like an \doxygen{itk}{Index}, is a relatively small and
// simple object. For this reason, it is not reference-counted like the
// large data objects in OTB. Consequently, it is also not manipulated
// with \doxygen{itk::SmartPointer}s. Point objects are simply declared as
// with \doxygen{itk}{SmartPointer}s. Point objects are simply declared as
// instances of any other C++ class. Once the point is declared, its
// components can be accessed using traditional array notation. In
// particular, the \code{[]} operator is available. For efficiency reasons,
......
......@@ -24,11 +24,11 @@
// Software Guide : BeginLatex
//
// This example illustrates how to import data into the \doxygen{otb::Image}
// This example illustrates how to import data into the \doxygen{otb}{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 \doxygen{itk}{ImportImageFilter}, thereby producing an
// Image as output.
//
......@@ -191,7 +191,7 @@ int 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
// \doxygen{itk::ImageIterator}s that support the management of
// \doxygen{itk}{ImageIterator}s that support the management of
// n-dimensional images.
//
// Software Guide : EndLatex
......
......@@ -35,7 +35,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{itk::RGBPixel} class, it is
// custom image type. In order to use the \doxygen{itk}{RGBPixel} class, it is
// necessary to include its header file.
//
// \index{itk::RGBPixel}
......@@ -80,7 +80,7 @@ int main( int , char * argv[] )
// Software Guide : BeginLatex
//
// The image type can be used to instantiate other filter, for example,
// an \doxygen{otb::ImageFileReader} object that will read the image from a
// an \doxygen{otb}{ImageFileReader} object that will read the image from a
// file.
//
// \index{otb::ImageFileReader!RGB Image}
......@@ -138,8 +138,8 @@ int main( int , char * argv[] )
// Software Guide : BeginLatex
//
// The subindex notation can also be used since the \doxygen{itk::RGBPixel} inherits the
// \code{[]} operator from the \doxygen{itk::FixedArray} class.
// The subindex notation can also be used since the \doxygen{itk}{RGBPixel} inherits the
// \code{[]} operator from the \doxygen{itk}{FixedArray} class.
//
// Software Guide : EndLatex
......
......@@ -28,23 +28,23 @@
// typical example is a multispectral image. The following code illustrates
// how to instantiate and use an image whose pixels are of vector type.
//
// We could use the \doxygen{itk::Vector} class to define the pixel
// We could use the \doxygen{itk}{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{http://www.sgi.com/tech/stl/Vector.html}{\code{std::vector}} in
// \href{http://www.sgi.com/tech/stl/}{STL}. If you are interested in
// containers, the \doxygen{VectorContainer} class may provide the
// containers, the \doxygen{itk}{VectorContainer} class may provide the
// functionality you want.
//
// \index{itk::Vector}
// \index{itk::Vector!header}
//
// However, the \doxygen{itk::Vector} is a fixed size array and it
// However, the \doxygen{itk}{Vector} is a fixed size array and it
// assumes that the number of channels of the image is known at
// compile time. Therefore, we prefer to use the
// \doxygen{otb::VectorImage} class which allows to choose the number
// \doxygen{otb}{VectorImage} class which allows to choose the number
// of channels of the image at runtime. The pixels will be of type
// \doxygen{itk::VariableLengthVector}.
// \doxygen{itk}{VariableLengthVector}.
//
// The first step is to include the header file of the Vector class.
//
......
......@@ -24,8 +24,8 @@
// Software Guide : BeginLatex
//
// The \doxygen{itk::Mesh} class is intended to represent shapes in space. It
// derives from the \doxygen{itk::PointSet} class and hence inherits all the
// The \doxygen{itk}{Mesh} class is intended to represent shapes in space. It
// derives from the \doxygen{itk}{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.
......@@ -101,7 +101,7 @@ int main(int, char *[])
// are reference counted objects and are managed using SmartPointers. The
// following line illustrates how a mesh is created by invoking the
// \code{New()} method of the MeshType and the resulting object is assigned
// to a \doxygen{SmartPointer}.
// to a \doxygen{itk}{SmartPointer}.