/** \mainpage VIGRA Reference Manual

    <UL class="collapsibleList">

    <LI> \ref Installation
        <BR>&nbsp;&nbsp;&nbsp;<em>how to get started</em>
    <LI> \ref Tutorial
		<BR>&nbsp;&nbsp;&nbsp;<em>first steps with VIGRA</em>
    <LI> <span style="font-weight:bold; color:#0040b0">Data Structures</span>
        <BR>&nbsp;&nbsp;&nbsp;<em>multi-dimensional arrays, graphs, numeric types etc.</em>
        <UL>
        <LI> \ref vigra::TinyVector
             <BR>&nbsp;&nbsp;&nbsp;<em>fixed-size arrays</em>
        <LI> \ref vigra::MultiArrayView
             <BR>&nbsp;&nbsp;&nbsp;<em>multi-dimensional array interface</em>
        <LI> \ref vigra::MultiArray
             <BR>&nbsp;&nbsp;&nbsp;<em>multi-dimensional array class that holds the actual memory</em>
        <LI> \ref vigra::NumpyArray and \ref vigra::NumpyAnyArray
             <BR>&nbsp;&nbsp;&nbsp;<em>wrappers offering VIGRA's multi-array API for Python arrays</em>
        <LI> \ref vigra::linalg::Matrix
             <BR>&nbsp;&nbsp;&nbsp;<em>array specialization for linear algebra</em>
        <LI> \ref ImageContainers
             <BR>&nbsp;&nbsp;&nbsp;<em>classes to manage multiple images and pyramids</em>
        <LI> \ref vigra::SplineImageView
             <BR>&nbsp;&nbsp;&nbsp;<em>on-the-fly interpolation of 2D images and their derivatives</em>
        <LI> \ref ChunkedArrayClasses
            <BR>&nbsp;&nbsp;&nbsp;<em>big data (potentially larger than RAM) stored as a collection of rectangular blocks</em>
        <LI> \ref vigra::AdjacencyListGraph
             <BR>&nbsp;&nbsp;&nbsp;<em>general graph class</em>
        <LI> \ref vigra::GridGraph
             <BR>&nbsp;&nbsp;&nbsp;<em>direct and indirect neighbor graphs on arbitrary dimensional grids</em>
        <LI> \ref vigra::BinaryForest
             <BR>&nbsp;&nbsp;&nbsp;<em>a collection of binary trees</em>
        <LI> <span style="font-weight:bold; color:#0040b0">Pixel and Number Types</span>
            <BR>&nbsp;&nbsp;&nbsp;<em>rationals, complex numbers, RGB tuples etc.</em>
            <UL>
            <LI> \ref FixedSizeInt
            <LI> \ref vigra::RGBValue
            <LI> \ref RGBValueTraits
            <LI> \ref vigra::TinyVector
            <LI> \ref vigra::TinyVectorView
            <LI> \ref TinyVectorTraits
            <LI> \ref vigra::FFTWComplex
            <LI> \ref FFTWComplexTraits
            <LI> \ref vigra::Rational
            <LI> \ref vigra::FixedPoint
            <LI> \ref vigra::FixedPoint16
            </UL>
        <LI> \ref vigra::BucketQueue and \ref vigra::MappedBucketQueue
             <BR>&nbsp;&nbsp;&nbsp;<em>efficient priority queues for integer priorities</em>
        <LI> \ref vigra::Any
             <BR>&nbsp;&nbsp;&nbsp;<em>typesafe storage of arbitrary values</em>
        <LI> \ref vigra::ArrayVector
             <BR>&nbsp;&nbsp;&nbsp;<em>replacement for std::vector with stronger guarantees (deprecated as of C++ 11)</em>
        <LI> \ref vigra::BasicImage
             <BR>&nbsp;&nbsp;&nbsp;<em>deprecated type for 2D images</em>
        <LI> \ref vigra::BasicImageView
             <BR>&nbsp;&nbsp;&nbsp;<em>deprecated type for 2D images that use external memory</em>
        </UL>
    <LI> <span style="font-weight:bold; color:#0040b0">Image and Array I/O</span>
        <BR>&nbsp;&nbsp;&nbsp;<em>read and write data from/to disk</em>
        <UL>
        <LI> \ref VigraImpex
             <BR>&nbsp;&nbsp;&nbsp;<em>highlevel import/export interface for 2D images</em>
        <LI> \ref VolumeImpex
             <BR>&nbsp;&nbsp;&nbsp;<em>import/export interface for volume data</em>
        <LI> \ref VigraHDF5Impex
             <BR>&nbsp;&nbsp;&nbsp;<em>import/export of arbitrary-dimensional arrays in the
             <a href="http://www.hdfgroup.org/HDF5/">HDF5</a> format</em>
        <LI> \ref vigra::ChunkedArrayHDF5
            <BR>&nbsp;&nbsp;&nbsp;<em>automated memory management of huge datasets via HDF5</em>
        <LI> \ref TIFFImpex
             <BR>&nbsp;&nbsp;&nbsp;<em>image import/export interface to call libtiff functions directly</em>
        </UL>
    <LI> \ref ParallelProcessing
        <BR>&nbsp;&nbsp;&nbsp;<em>using std::thread</em>
    <LI> <span style="font-weight:bold; color:#0040b0">Image Processing</span>
        <BR>&nbsp;&nbsp;&nbsp;<em>array arithmetic, convolution filters, morphology, color conversion, registration etc.</em>
        <UL>
        <LI> \ref MultiMathModule
             <BR>&nbsp;&nbsp;&nbsp;<em>arithmetic and algebraic expressions for multi-dimensional arrays</em>
        <LI> \ref MultiPointoperators
             <BR>&nbsp;&nbsp;&nbsp;<em>point operators on multi-dimensional arrays</em>
        <LI> \ref ColorConversions
             <BR>&nbsp;&nbsp;&nbsp;<em>convert between RGB and other color spaces like L*u*v* and Y'PbPr</em>
        <LI> <span style="font-weight:bold; color:#0040b0">Filters</span>
            <BR>&nbsp;&nbsp;&nbsp;<em>Gaussian filters, smoothing and sharpening, gradients etc.</em>
            <UL>
            <LI> \ref ConvolutionFilters
                 <BR>&nbsp;&nbsp;&nbsp;<em>arbitrary-dimensional filters in the spatial and Fourier domains</em>
             <LI> \ref RecursiveConvolution
                 <BR>&nbsp;&nbsp;&nbsp;<em>recursive filters (1st and 2nd order)</em>
            <LI> \ref ResamplingConvolutionFilters
                 <BR>&nbsp;&nbsp;&nbsp;<em>filters changing the array size</em>
            <LI> \ref GaborFilter
                 <BR>&nbsp;&nbsp;&nbsp;<em>Gabor filter creation and related functionality</em>
            <LI> \ref TensorImaging
                 <BR>&nbsp;&nbsp;&nbsp;<em>tensor-valued pixel features</em>
            <LI> \ref vigra::Kernel1D and \ref vigra::Kernel2D
                 <BR>&nbsp;&nbsp;&nbsp;<em>generic discrete convolution kernels</em>
            <LI> \ref SeparableConvolution
                 <BR>&nbsp;&nbsp;&nbsp;<em>1D convolution and separable filters in 2 dimensions</em>
            <LI> \ref BorderTreatmentMode
            </UL>
        <LI> \ref GeometricTransformations "Geometric Transformations and Resizing"
             <BR>&nbsp;&nbsp;&nbsp;<em>arbitrary-dimensional resize and interpolation, mirroring, rotation, affine warping</em>
        <LI> \ref vigra::SplineImageView
             <BR>&nbsp;&nbsp;&nbsp;<em>on-the-fly interpolation of 2D images and their derivatives</em>
        <LI> \ref FourierTransform
             <BR>&nbsp;&nbsp;&nbsp;<em>fast Fourier transform for arrays of arbitrary dimension</em>
        <LI> \ref Correlation
             <BR>&nbsp;&nbsp;&nbsp;<em>estimate the correlation between images</em>
        <LI> \ref Registration
             <BR>&nbsp;&nbsp;&nbsp;<em>transform images into a common coordinate system</em>
        <LI> \ref NonLinearDiffusion
             <BR>&nbsp;&nbsp;&nbsp;<em>edge-preserving smoothing and denoising</em>
        <LI> \ref DistanceTransform
             <BR>&nbsp;&nbsp;&nbsp;<em>distance transforms in arbitrary dimensions</em>
        <LI> \ref MultiArrayMorphology
             <BR>&nbsp;&nbsp;&nbsp;<em>separable morphology with parabola structuring functions in arbitrary dimensions</em>
        <LI> \ref Morphology
             <BR>&nbsp;&nbsp;&nbsp;<em>2D erosion, dilation, and median with disc structuring functions</em>
        <LI> \ref NoiseNormalization
             <BR>&nbsp;&nbsp;&nbsp;<em>transform intensity-dependent noise into additive Gaussian noise</em>
        <LI> \ref SlantedEdgeMTF
             <BR>&nbsp;&nbsp;&nbsp;<em>determine the magnitude transfer function (MTF) of a camera using the slanted edge method</em>
        </UL>
    <LI> <span style="font-weight:bold; color:#0040b0">Image Analysis</span>
        <BR>&nbsp;&nbsp;&nbsp;<em>from pixels to structured data</em>
        <UL>
       <LI> \ref FeatureAccumulators
             <BR>&nbsp;&nbsp;&nbsp;<em>computate multi-dimensional statistics for regions or hte entire image</em>
        <LI> \ref InspectAlgo and \ref InspectFunctor
             <BR>&nbsp;&nbsp;&nbsp;<em>outdated statistical analysis functions</em>
         <LI> \ref vigra::Threshold
             <BR>&nbsp;&nbsp;&nbsp;<em>good old thresholding</em>
        <LI> \ref Labeling
             <BR>&nbsp;&nbsp;&nbsp;<em>connected components labeling</em>
        <LI> \ref LocalMinMax
             <BR>&nbsp;&nbsp;&nbsp;<em>Including extremal plateaus larger than 1 pixel</em>
        <LI> \ref DistanceTransform
             <BR>&nbsp;&nbsp;&nbsp;<em>including vector distance, eccentricity transforms, and skeletons</em>
        <LI> \ref EdgeDetection
             <BR>&nbsp;&nbsp;&nbsp;<em>edge detectors based on first and second derivatives</em>
        <LI> \ref CornerDetection
             <BR>&nbsp;&nbsp;&nbsp;<em>measure the 'cornerness' at each pixel </em>
        <LI> \ref SymmetryDetection
             <BR>&nbsp;&nbsp;&nbsp;<em>measure the local symmetry at each pixel </em>
        <LI> \ref Superpixels
             <BR>&nbsp;&nbsp;&nbsp;<em>watersheds, SLIC superpixels, and seeded region growing</em>
        <LI> \ref GraphDataStructures
            <BR>&nbsp;&nbsp;&nbsp;<em>graph-based segmentation algorithms</em>
        </UL>
    <LI> \ref GraphDataStructures
        <BR>&nbsp;&nbsp;&nbsp;<em>graph classes and graph-based algorithms</em>
    <LI> \ref MachineLearning
        <BR>&nbsp;&nbsp;&nbsp;<em>classification algorithms</em>
    <LI> <span style="font-weight:bold; color:#0040b0">Mathematical Tools</span>
        <BR>&nbsp;&nbsp;&nbsp;<em>number types, special functions, linear algebra and optimization etc.</em>
        <UL>
            <LI> \ref NumericPromotionTraits
                 <BR>&nbsp;&nbsp;&nbsp;<em>meta-information about arithmetic types</em>
            <LI> \ref MathConstants
                 <BR>&nbsp;&nbsp;&nbsp;<em>M_PI, M_SQRT2</em>
            <LI> \ref MathFunctions
                 <BR>&nbsp;&nbsp;&nbsp;<em>and functors</em>
            <LI> <span style="font-weight:bold; color:#0040b0">Number Types</span>
                <UL>
                <LI> \ref vigra::Rational
                <LI> \ref vigra::TinyVector
                <LI> \ref vigra::autodiff::DualVector
                <LI> \ref vigra::FFTWComplex
                <LI> \ref vigra::FixedPoint16
                <LI> \ref vigra::Quaternion
                </UL>
            <LI> \ref RandomNumberGeneration
                 <BR>&nbsp;&nbsp;&nbsp;<em>Mersenne twister class and random number functors</em>
            <LI> \ref Polynomials
                 <BR>&nbsp;&nbsp;&nbsp;<em>Polynomials and root determination</em>
            <LI> \ref vigra::linalg::Matrix
                 <BR>&nbsp;&nbsp;&nbsp;<em>array specialization for linear algebra</em>
            <LI> \ref LinearAlgebraModule "Linear Algebra"
                 <BR>&nbsp;&nbsp;&nbsp;<em>matrix algebra, solution of linear systems, eigenvalue calculation etc.</em>
            <LI> \ref Unsupervised_Decomposition "Unsupervised Decomposition"
                 <BR>&nbsp;&nbsp;&nbsp;<em>Unsupervised matrix decomposition methods (pLSA)</em>
            <LI> \ref Optimization "Optimization and Regression"
                 <BR>&nbsp;&nbsp;&nbsp;<em>ordinary and non-negative least squares, ridge regression, least angle regression (LARS and LASSO)</em>
            <LI> \ref AlgebraicConcepts
                 <BR>&nbsp;&nbsp;&nbsp;<em>Requirements for types that implement arithmetic operations</em>
        </UL>
    <LI> <span style="font-weight:bold; color:#0040b0">Utilities</span>
        <BR>&nbsp;&nbsp;&nbsp;<em>error handling, speed measurement</em>
        <UL>
        <LI> \ref ErrorReporting
             <BR>&nbsp;&nbsp;&nbsp;<em>exceptions and assertions</em>
        <LI> \ref TimingMacros
             <BR>&nbsp;&nbsp;&nbsp;<em>macros for taking execution speed measurements</em>
        <LI> \ref VIGRA_FINALLY
             <BR>&nbsp;&nbsp;&nbsp;<em>emulation of the 'finally' keyword from Python</em>
        <LI> \ref vigra::Any
             <BR>&nbsp;&nbsp;&nbsp;<em>typesafe storage of arbitrary values</em>
        <LI> \ref vigra::BucketQueue and \ref vigra::MappedBucketQueue
             <BR>&nbsp;&nbsp;&nbsp;<em>efficient priority queues for integer priorities</em>
        <LI> \ref RangesAndPoints
             <BR>&nbsp;&nbsp;&nbsp;<em>2-D and N-D positions, extents, and boxes</em>
        <LI> \ref vigra::FilterIterator
             <BR>&nbsp;&nbsp;&nbsp;<em>skip elements in a range that don't fulfill a predicate</em>
        <LI> \ref vigra::IteratorAdaptor
             <BR>&nbsp;&nbsp;&nbsp;<em>quickly create STL-compatible 1D iterator adaptors</em>
        <LI> \ref TupleTypes
             <BR>&nbsp;&nbsp;&nbsp;<em>pair, triple, tuple4, tuple5</em>
        <LI> \ref PixelNeighborhood
             <BR>&nbsp;&nbsp;&nbsp;<em>2D neighborhood definitions (deprecated, use \ref vigra::GridGraph instead)</em>
        <LI> \ref VoxelNeighborhood
             <BR>&nbsp;&nbsp;&nbsp;<em>3D neighborhood definitions (deprecated, use \ref vigra::GridGraph instead)</em>
        <LI> \ref vigra::ArrayVector
             <BR>&nbsp;&nbsp;&nbsp;<em>replacement for std::vector with stronger guarantees (deprecated as of C++ 11)</em>
        </UL>
    <LI> <span style="font-weight:bold; color:#0040b0">Concepts</span>
        <BR>&nbsp;&nbsp;&nbsp;<em>generic interface definitions</em>
        <UL>
        <LI> \ref AlgebraicConcepts
             <BR>&nbsp;&nbsp;&nbsp;<em>requirements for types that implement arithmetic operations</em>
        <LI> \ref ImageIterators
             <BR>&nbsp;&nbsp;&nbsp;<em>2D iterator API</em>
        <LI> \ref MultiIteratorPage
             <BR>&nbsp;&nbsp;&nbsp;<em>multi-dimensional iterator API</em>
        <LI> \ref vigra::MultiArrayNavigator
             <BR>&nbsp;&nbsp;&nbsp;<em>navigator utility for multi-dimensional arrays</em>
        <LI> \ref vigra::FunctorTraits
             <BR>&nbsp;&nbsp;&nbsp;<em>requirements for functor traits</em>
        <LI> \ref CrackEdgeImage
             <BR>&nbsp;&nbsp;&nbsp;<em>topologically correct treatment of interpixel contours</em>
        <LI> \ref DataAccessors
             <BR>&nbsp;&nbsp;&nbsp;<em>requirements for data accessors (deprecated)</em>
        </UL>
    <LI> \ref ExampleList
        <BR>&nbsp;&nbsp;&nbsp;<em>demonstration programs for VIGRA's usage </em>
    <LI> \ref VigraMatlab
        <BR>&nbsp;&nbsp;&nbsp;<em>VIGRA Matlab bindings (unsupported)</em>
    <LI> <a href="../vigranumpy/index.html" style="text-decoration:none; font-weight:bold; color:#0040b0">vigranumpy</a>
        <BR>&nbsp;&nbsp;&nbsp;<em>VIGRA Python bindings</em>
    <LI> \ref CreditsChangelog
        <BR>&nbsp;&nbsp;&nbsp;<em>who contributed what?</em>
    </UL>

    \anchor _details
    <CENTER>
    \section Main VIGRA - Vision with Generic Algorithms
    Version  \vigra_version
    by <a href="http://hci.iwr.uni-heidelberg.de/people/ukoethe/">Ullrich K&ouml;the</a>
    </CENTER>

    VIGRA  is a computer vision library that puts its main emphasis on
    <em>flexible algorithms</em>, because
    algorithms represent the principle know-how of this field.
    The library was consequently built
    using <em>generic programming</em> as introduced by Stepanov
    and Musser  and exemplified in the C++
    <a href=\stl_link>Standard Template Library</a>.
    By writing a few adapters (image iterators and accessors)
    you can use VIGRA's algorithms on top of
    <em>your</em> data structures, within <em>your</em> environment. Alternatively,
    you can also use the data structures provided within VIGRA, which can
    be easily adapted to a wide range of applications. VIGRA's flexibility
    comes almost for free: Since the design uses compile-time polymorphism
    (templates), performance of the compiled program approaches that
    of a traditional, hand tuned, inflexible, solution.

    VIGRA's design is documented in the chapter <em>"Reusable Software in
    Computer Vision"</em> by
    <a href="http://hci.iwr.uni-heidelberg.de/people/ukoethe/">Ullrich K&ouml;the</a>,
    in: B. J&auml;hne, H. Hau&szlig;ecker, P. Gei&szlig;ler: "Handbook on
    Computer Vision and  Applications", volume 3, Academic Press, 1999.
    If you don't have the book,  you may read a
    <a href="http://hci.iwr.uni-heidelberg.de/vigra/documents/GenericProg2D.ps">draft of this article</a>. A shorter
    article <em><a href="http://hci.iwr.uni-heidelberg.de/people/ukoethe/papers/index.php#cite_GenericProg2DCppReport">STL Style Generic Programming with Images</a></em>
    describing some of the
    ideas has appeared in the January 2000 issue of
    <a href="http://www.creport.com/">C++ Report Magazine</a>. The most comprehensive source of information is
    U. K&ouml;the's PhD thesis <em><a href="http://hci.iwr.uni-heidelberg.de/people/ukoethe/papers/index.php#cite_PhD">Generische Programmierung f&uuml;r die Bildverarbeitung</a></em>, but this is written in German.

    VIGRA is subject to this <a href="LICENSE.txt">LICENSE</a>.

    You can also subscribe to the <a href="https://mailhost.informatik.uni-hamburg.de/mailman/listinfo/vigra">VIGRA Mailing List</a> to get instant information about new releases, discuss VIGRA's features and development, and ask the experts for help.
*/

/** \addtogroup ConvolutionFilters Convolution Filters

    The functions in this group implement separable convolutions (e.g. smoothing and sharpening,
    Gaussian derivatives) and related filters (like the gradient magnitude) on
    arbitrary-dimensional arrays. In addition, non-separable filters are supported for 2D images.
    All functions accept the \ref vigra::MultiArrayView API (which can be wrapped around a wide
    variety of data structures) as well as a number of deprecated APIs such as \ref ImageIterators.
*/

/** \addtogroup GeometricTransformations Geometric Transformations

    Resize or warp an array using various interpolation schemes or just pixel repetition.

    See also: \ref Registration, \ref vigra::SplineImageView
*/

/** \addtogroup DistanceTransform Distance Transform

    The functions in this group perform Euclidean distance transforms in arbitrary dimensions,
    as well Manhattan and chessboard distance transforms in 2D (this can easily be extended to nD
    if need arises). In addition, a number of related transforms such as vector distance transforms,
    eccentricity transforms, and 2D skeleton computations are offered.
*/

/** \addtogroup Superpixels Superpixel Creation

    Watersheds, SLIC superpixels, and seeded region growing.
*/

/** \addtogroup ParallelProcessing Parallel Processing

    \sa These algorithms and data structures also support parallel processing:
 */

/** \page ImportExport Image Import and Export

    Conversion from and to other image data types

    <UL style="list-style-image:url(documents/bullet.gif)">
    <LI> \ref VigraImpex
         <BR>&nbsp;&nbsp;&nbsp;<em>VIGRA's highlevel image import/export interface</em>
    <LI> \ref VolumeImpex
         <BR>&nbsp;&nbsp;&nbsp;<em>Import/export interface for volume data</em>
    <LI> \ref VigraHDF5Impex
         <BR>&nbsp;&nbsp;&nbsp;<em>Import/export of images and arrays in
         <a href="http://www.hdfgroup.org/HDF5/">HDF5</a> format</em>
    <LI> \ref TIFFImpex
         <BR>&nbsp;&nbsp;&nbsp;<em>image import/export interface if you want to call libtiff functions directly</em>
    </UL>

    There are two fundamentally different approaches to interfacing between VIGRA and the rest of the world.

    <b>If you already have an image data type in your system:</b>

    Then I recommend using VIGRA's algorithms directly on top of your data type.
    To do this, you simply wrap your data in an \ref vigra::ImageIterator and/or
    \ref vigra::MultiArrayView (depending on the functions you want to call). If
    your data have some exotic properties, that prevent this solution from working,
    you can still implement your own versions or subclasses of the interface classe,
    which isn't very difficult.

    Alternatively, you may use the data structures provided within VIGRA
    and convert your data type into one of them. Take a look at \ref tiffToScalarImage() and
    \ref createScalarTiffImage() to see how this might be done.

    <b>If you don't have an image data type in your system:</b>

    Use the data structures provided within VIGRA and use one of the import/export facilities above.

*/

/** \page AlgebraicConcepts Algebraic Concepts

The algebraic concepts describe requirements for algebraic types, that is
for types that support arithmetic operations. The built-in types are concepts
of \ref AlgebraicField and \ref DivisionAlgebra.

\anchor AlgebraicRing

<h3>Algebraic Ring</h3>

<ul>
    <li>A model of Algebraic Ring implements <tt>Assignable</TT>, <tt>Default Constructible</TT>,
        <tt>Equality Comparable</TT> and <tt>Strict Weakly Comparable</TT>
        as defined in the C++ standard (cf. the
        <a href=\stl_link>Standard Template Library documentation</a>).

    <li>A model of Algebraic Ring implements addition, subtraction and unary negation. The associated
    \link NumericTraits NumericTraits \endlink define a 'zero' element, the type of the
    result of addition and subtraction, and a type conversion function.
    Addition must be commutative.

    \code
    ModelOfAlgebraicRing a, b;
    NumericTraits<ModelOfAlgebraicRing>::Promote c;

    ModelOfAlgebraicRing zero = NumericTraits<ModelOfAlgebraicRing>::zero();

    b += a;
    b -= a;
    b = -a;
    c = a + b;
    c = a - b;
    c = a;
    a = NumericTraits<ModelOfAlgebraicRing>::fromPromote(c);

    assert(a + zero == a);
    assert(a + b == b + a);
    assert(a - b == a + (-b));
    \endcode

    <li>If mixed-type addition and subtraction are supported,
    \link PromoteTraits PromoteTraits \endlink define the result type:

    \code
    ModelOfAlgebraicRing1 a;
    ModelOfAlgebraicRing2 b;

    PromoteTraits<ModelOfAlgebraicRing1, ModelOfAlgebraicRing2>::Promote c;

    c = a + b;
    \endcode

    <li>A model of Algebraic Ring implements multiplication. The associated
    \link NumericTraits NumericTraits \endlink define a 'one' element, the type of the
    result of multiplication, and a type conversion function.

    \code
    ModelOfAlgebraicRing a, b;
    NumericTraits<ModelOfAlgebraicRing>::RealPromote c;

    ModelOfAlgebraicRing one = NumericTraits<ModelOfAlgebraicRing>::one();

    b *= a;
    c = a * b;
    c = a;
    a = NumericTraits<ModelOfAlgebraicRing>::fromRealPromote(c);

    assert(a * one == a);
    \endcode
</ul>

\anchor AlgebraicField
<h3>Algebraic Field</h3>

<ul>
    <li>A model of Algebraic Field implements \ref AlgebraicRing as defined above.

    <li>A model of Algebraic Field implements division. Division is undefined if
    and only if the right operand is 'zero'.

    \code
    ModelOfAlgebraicField a, b;
    typename NumericTraits<ModelOfAlgebraicField>::RealPromote c;

    ModelOfAlgebraicField zero = NumericTraits<ModelOfAlgebraicField>::zero();

    if(a != zero) b /= a;
    if(a != zero) c = b / a;
    \endcode

</ul>


\anchor LinearSpace

<h3>Linear Space</h3>

<ul>
    <li>A model of Linear Space implements <tt>Assignable</TT>, <tt>Default Constructible</TT>
        and <tt>Equality Comparable</TT>
        as defined in the C++ standard (cf. the
        <a href=\stl_link>Standard Template Library documentation</a>).

    <li>A model of Algebraic Ring implements addition, subtraction and unary negation. The associated
    \link NumericTraits NumericTraits \endlink define a 'zero' element, the type of the
    result of addition and subtraction, and a type conversion function.
    Addition must be commutative. (This part of the requirements is identical to
    \ref AlgebraicRing above.)

    \code
    ModelOfAlgebraicRing a, b;
    NumericTraits<ModelOfAlgebraicRing>::Promote c;

    ModelOfAlgebraicRing zero = NumericTraits<ModelOfAlgebraicRing>::zero();

    b += a;
    b -= a;
    b = -a;
    c = a + b;
    c = a - b;
    c = a;
    a = NumericTraits<ModelOfAlgebraicRing>::fromPromote(c);

    assert(a + zero == a);
    assert(a + b == b + a);
    assert(a - b == a + (-b));
    \endcode

    <li>If mixed-type addition and subtraction are supported,
    \link PromoteTraits PromoteTraits \endlink define the result type:

    \code
    ModelOfAlgebraicRing1 a;
    ModelOfAlgebraicRing2 b;

    PromoteTraits<ModelOfAlgebraicRing1, ModelOfAlgebraicRing2>::Promote c;

    c = a + b;
    \endcode

    <li>A model of Algebraic Ring implements multiplication and division with 'double'.
      (Note that the outer product could be defined with an arbitrary model of
      \ref AlgebraicField. For simplicity, VIGRA restricts this to only 'double'.)
      The associated \link NumericTraits NumericTraits \endlink define the type of the
      results, and a type conversion function.

    \code
    ModelOfAlgebraicRing a;
    double f;
    NumericTraits<ModelOfAlgebraicRing>::RealPromote c;


    a *= f;
    c = a * f;
    c = f * a;

    if(f != 0.0) a /= f;
    if(f != 0.0) c = a / f;

    c = a;
    a = NumericTraits<ModelOfAlgebraicRing>::fromRealPromote(c);
    \endcode
</ul>

\anchor LinearAlgebraConcept
<h3>Linear Algebra</h3>

<ul>
    <li>A model of Linear Algebra implements \ref LinearSpace and
        \ref AlgebraicRing as defined above.

</ul>

\anchor DivisionAlgebra
<h3>Division Algebra</h3>

<ul>
    <li>A model of Division Algebra implements \ref LinearSpace and
        \ref AlgebraicField as defined above.

</ul>

*/

/** \page VigraMatlab Vigra Matlab

    Matlab bindings (mex-files) for the most important VIGRA functions are located
    <tt>[vigra_src_dir]/src/matlab</tt>. To compile and install them, start Matlab,
    go into that directory and call the function buildVigraExtensions:

    \code
    buildVigraExtensions('install_path')
    \endcode

    If the compilation fails because includes or libraries are not found, you can
    provide additional search directories like this:

    \code
    buildVigraExtensions('install_path', 'all', struct('flags', '-I/path/to/includes -L/path/to/libs'))
    \endcode

    Additional compiler flags are specified in the same way. Suggestions about typical settings on Linux and
    Windows can be found in the individual .cpp files. For example, on Windows we usually need

    \code
    buildVigraExtensions('install_path', 'all', ...
     struct('flags', '-I[HDF5PATH]/include -L[HDF5PATH]/lib -lhdf5dll -lhdf5_hldll -D_HDF5USEDLL_ -DHDF5CPP_USEDLL'))
    \endcode

    After successful compilation, you can obtain a list of the available VIGRA functions by calling

    \code
    help vigraIndex
    \endcode

    In the same way, you get documentation for the individual functions. More
    information about the glue code behind the bindings is available in
    <a href="http://hci.iwr.uni-heidelberg.de/vigra/documents/tutorial_reference.pdf">this report</a>.

*/

/** \namespace vigra
    all VIGRA functionality is located in namespace vigra
*/


#if 0
//@{


//Include: ../include/vigra/morphological_appropriate_scale.hxx
//Include: ../include/vigra/feature_adjacency_graph.hxx

//@}

#endif

