282 lines
10 KiB
Plaintext
282 lines
10 KiB
Plaintext
/// \defgroup BasicConcepts Basic Concepts
|
|
/// \brief Various basic concepts
|
|
|
|
/// \defgroup Point Point
|
|
/// \brief N-dimensional point
|
|
/// \defgroup PointConcept Concepts
|
|
/// \ingroup Point
|
|
/// \brief Concepts for points
|
|
|
|
/// \defgroup PointModel Models
|
|
/// \ingroup Point
|
|
/// \brief Models for points
|
|
|
|
/// \defgroup PointAlgorithm Algorithms and Utility Functions
|
|
/// \ingroup Point
|
|
/// \brief Algorithms and Utility Functions for points
|
|
|
|
/// \defgroup ColorSpaceAndLayout Color, Color Space, and Layout
|
|
/// \brief The color space and the layout define the set, ordering and interpretation of channels in a pixel
|
|
/// \defgroup ColorSpaceAndLayoutConcept Concepts
|
|
/// \ingroup ColorSpaceAndLayout
|
|
|
|
/// \defgroup ColorSpaceAndLayoutModel Models
|
|
/// \ingroup ColorSpaceAndLayout
|
|
|
|
/// \defgroup ColorNameModel Color Names
|
|
/// \ingroup ColorSpaceAndLayoutModel
|
|
|
|
/// \defgroup ColorSpaceModel Color Spaces
|
|
/// \ingroup ColorSpaceAndLayoutModel
|
|
|
|
/// \defgroup LayoutModel Layouts
|
|
/// \ingroup ColorSpaceAndLayoutModel
|
|
|
|
/// \defgroup Channel Channel
|
|
/// \brief Channel is the building block of pixel
|
|
/// \defgroup ChannelConcept Concepts
|
|
/// \ingroup Channel
|
|
/// \brief Concepts for channels
|
|
|
|
/// \defgroup ChannelModel Models
|
|
/// \ingroup Channel
|
|
/// \brief Channel models. Although not required by the ChannelConcept, all GIL-provided channels support arithmetic operations
|
|
|
|
/// \defgroup ChannelAlgorithm Algorithms and Utility Functions
|
|
/// \ingroup Channel
|
|
/// \brief Channel algorithms, metafunctions and utility functions
|
|
|
|
/**
|
|
\defgroup ColorBase ColorBase
|
|
\brief A color base is a container of color elements.
|
|
|
|
The most common use of color base is in the implementation of a pixel, in which case the color
|
|
elements are channel values. The color base concept, however, can be used in other scenarios. For example, a planar pixel has channels that are not
|
|
contiguous in memory. Its reference is a proxy class that uses a color base whose elements are channel references. Its iterator uses a color base
|
|
whose elements are channel iterators.
|
|
*/
|
|
/// \defgroup ColorBaseConcept Concepts
|
|
/// \ingroup ColorBase
|
|
/// \brief ColorBase concepts
|
|
|
|
/// \defgroup ColorBaseModel Models
|
|
/// \ingroup ColorBase
|
|
/// \brief ColorBase models
|
|
|
|
/// \defgroup ColorBaseAlgorithm Algorithms and Utility Functions
|
|
/// \ingroup ColorBase
|
|
/// \brief ColorBase algorithms, metafunctions and utility functions
|
|
|
|
/**
|
|
\defgroup PixelBased PixelBased
|
|
\brief Concepts for all GIL constructs that are pixel-based (pixels, pixel iterators, locators, views, images).
|
|
|
|
PixelBasedConcept provides a uniform interface for getting some common properties of pixel-based constructs, such as the number of channels,
|
|
the color space, the layout, etc.
|
|
*/
|
|
/// \defgroup PixelBasedConcept Concepts
|
|
/// \ingroup PixelBased
|
|
/// \brief PixelBased concepts
|
|
|
|
/// \defgroup PixelBasedModel Models
|
|
/// \ingroup PixelBased
|
|
/// \brief PixelBased models
|
|
|
|
/// \defgroup PixelBasedAlgorithm Algorithms and Utility Functions
|
|
/// \ingroup PixelBased
|
|
/// \brief PixelBased algorithms, metafunctions and utility functions.
|
|
|
|
/**
|
|
\defgroup Pixel Pixel
|
|
\brief A pixel is a set of channels defining the color at a given point in an image.
|
|
|
|
Conceptually, a pixel is little more than a color base whose elements model \p ChannelConcept.
|
|
Many properties of pixels inherit from color bases: pixels may be <i>homogeneous</i> if all of their channels have the same type; otherwise they are
|
|
called <i>heterogeneous</i>. The channels of a pixel may be addressed using semantic or physical indexing, or by color; all color base algorithms
|
|
work on pixels as well. Two pixels are <i>compatible</i> if their color spaces are the same and their channels, paired semantically, are compatible.
|
|
Note that constness, memory organization and reference/value are ignored. For example, an 8-bit RGB planar reference is compatible to a constant 8-bit
|
|
BGR interleaved pixel value. Most pairwise pixel operations (copy construction, assignment, equality, etc.) are only defined for compatible pixels.
|
|
|
|
*/
|
|
/// \defgroup PixelConcept Concepts
|
|
/// \ingroup Pixel
|
|
/// \brief Pixel concepts
|
|
|
|
/// \defgroup PixelModel Models
|
|
/// \ingroup Pixel
|
|
/// \brief Pixel models
|
|
|
|
/**
|
|
\defgroup PixelAlgorithm Algorithms and Utility Functions
|
|
\ingroup Pixel
|
|
\brief Pixel algorithms, metafunctions and utility functions.
|
|
|
|
Since pixels model the ColorBaseConcept, all color-base related algorithms also apply to pixels. See \ref ColorBaseAlgorithm for more.
|
|
|
|
*/
|
|
|
|
/// \defgroup PixelDereferenceAdaptor Pixel Dereference Adaptor
|
|
/// \brief A function object invoked upon accessing of the pixel of a pixel iterator/locator/view
|
|
|
|
/// \defgroup PixelDereferenceAdaptorConcept Concepts
|
|
/// \ingroup PixelDereferenceAdaptor
|
|
|
|
/// \defgroup PixelDereferenceAdaptorModel Models
|
|
/// \ingroup PixelDereferenceAdaptor
|
|
|
|
|
|
/// \defgroup PixelIterator Pixel Iterator
|
|
/// \brief STL Iterators over models of PixelConcept
|
|
|
|
/// \defgroup PixelIteratorConcept Concepts
|
|
/// \ingroup PixelIterator
|
|
/// \brief Pixel iterator concepts
|
|
|
|
/// \defgroup PixelIteratorModel Models
|
|
/// \ingroup PixelIterator
|
|
/// \brief Pixel iterator models
|
|
|
|
|
|
/// \defgroup PixelLocator Pixel Locator
|
|
/// \brief Generalization of an iterator to multiple dimensions
|
|
|
|
/// \defgroup PixelLocatorConcept Concepts
|
|
/// \ingroup PixelLocator
|
|
/// \brief Pixel locator concepts
|
|
|
|
/// \defgroup PixelLocatorModel Models
|
|
/// \ingroup PixelLocator
|
|
/// \brief Pixel locator models
|
|
|
|
/// \defgroup ImageView Image View
|
|
/// \brief N-dimensional range
|
|
|
|
/// \defgroup ImageViewConcept Concepts
|
|
/// \ingroup ImageView
|
|
/// \brief Image view concepts
|
|
|
|
/// \defgroup ImageViewModel Models
|
|
/// \ingroup ImageView
|
|
/// \brief Image view models
|
|
|
|
/// \defgroup ImageViewAlgorithm Algorithms and Utility Functions
|
|
/// \ingroup ImageView
|
|
/// \brief Image view algorithms, metafunctions and utility functions
|
|
|
|
/**
|
|
\defgroup Image Image
|
|
\brief N-dimensional container
|
|
|
|
An image is a container of N-dimensional data. GIL provides only one model, a two dimensional image whose \p value_type is a pixel.
|
|
|
|
Images are regular types (which means they have a default constructor, a copy constructor, \p operator=, \p operator==, \p operator!=, and \p swap)
|
|
As containers, images own the data, which means they allocate the data in their constructors and deallocate in the destructors. Their copy construction,
|
|
assignment and equality comparison is deep (i.e. propagates the operation to the values). That makes images expensive to pass by value, unlike views.
|
|
|
|
Also, unlike views, images propagate their constness to the data. An const-qualified image does not allow for modifying its pixels and does not provide
|
|
a mutable view over its pixels.
|
|
|
|
Images provide two services: they manage ownership of their data (the pixels) and they can return a view over their pixels.
|
|
Algorithms predominantly operate on views. This is analogous to the STL: In the STL containers (like \p std::vector) provide ranges (\p vec.begin()
|
|
and \p vec.end() ) and algorithms typically operate on ranges. The GIL equivalent of a range is an image view.
|
|
|
|
*/
|
|
/// \defgroup ImageConcept Concepts
|
|
/// \ingroup Image
|
|
/// \brief Image concepts
|
|
|
|
/// \defgroup ImageModel Models
|
|
/// \ingroup Image
|
|
/// \brief Image models
|
|
|
|
/**
|
|
\defgroup ImageProcessing Image Processing
|
|
\brief Image Processing algorithms
|
|
|
|
Collection of image processing algorithms currently implemented by GIL.
|
|
*/
|
|
|
|
/// \defgroup Variant Variant
|
|
/// \brief A holder of a runtime instantiated type. Used to provide runtime-specified images and views
|
|
|
|
/// \defgroup Metafunctions Metafunctions
|
|
/// \brief Metafunctions to construct or query GIL types
|
|
/// \defgroup TypeFactory Type Factory Metafunctions
|
|
/// \ingroup Metafunctions
|
|
/// \brief Metafunctions that construct GIL types from related types or from components
|
|
|
|
/// \defgroup TypeAnalysis Type Analysis Metafunctions
|
|
/// \ingroup Metafunctions
|
|
/// \brief Metafunctions that determine properties of GIL types
|
|
|
|
/// \defgroup IO I/O
|
|
/// \brief Support for reading and writing images to file
|
|
/// \defgroup JPEG_IO JPEG I/O
|
|
/// \ingroup IO
|
|
/// \brief Support for reading and writing JPEG image files
|
|
|
|
/// \defgroup TIFF_IO TIFF I/O
|
|
/// \ingroup IO
|
|
/// \brief Support for reading and writing TIFF image files
|
|
|
|
/// \defgroup PNG_IO PNG I/O
|
|
/// \ingroup IO
|
|
/// \brief Support for reading and writing PNG image files
|
|
|
|
/*!
|
|
\mainpage API Reference
|
|
|
|
\section Modules
|
|
|
|
- \ref BasicConcepts
|
|
- \ref Point
|
|
- \ref PointConcept
|
|
- \ref PointModel
|
|
- \ref PointAlgorithm
|
|
- \ref ColorSpaceAndLayout
|
|
- \ref ColorSpaceAndLayoutConcept
|
|
- \ref ColorSpaceAndLayoutModel
|
|
- \ref Channel
|
|
- \ref ChannelConcept
|
|
- \ref ChannelModel
|
|
- \ref ChannelAlgorithm
|
|
- \ref ColorBase
|
|
- \ref ColorBaseConcept
|
|
- \ref ColorBaseModel
|
|
- \ref ColorBaseAlgorithm
|
|
- \ref PixelBased
|
|
- \ref PixelBasedConcept
|
|
- \ref PixelBasedModel
|
|
- \ref PixelBasedAlgorithm
|
|
- \ref Pixel
|
|
- \ref PixelConcept
|
|
- \ref PixelModel
|
|
- \ref PixelAlgorithm
|
|
- \ref PixelDereferenceAdaptor
|
|
- \ref PixelDereferenceAdaptorConcept
|
|
- \ref PixelDereferenceAdaptorModel
|
|
- \ref PixelIterator
|
|
- \ref PixelIteratorConcept
|
|
- \ref PixelIteratorModel
|
|
- \ref PixelLocator
|
|
- \ref PixelLocatorConcept
|
|
- \ref PixelLocatorModel
|
|
- \ref ImageView
|
|
- \ref ImageViewConcept
|
|
- \ref ImageViewModel
|
|
- \ref ImageViewAlgorithm
|
|
- \ref Image
|
|
- \ref ImageConcept
|
|
- \ref ImageModel
|
|
- \ref ImageProcessing
|
|
- \ref Metafunctions
|
|
- \ref TypeFactory
|
|
- \ref TypeAnalysis
|
|
- \ref Variant
|
|
- \ref IO
|
|
- \ref JPEG_IO
|
|
- \ref TIFF_IO
|
|
- \ref PNG_IO
|
|
*/
|
|
|