PageRenderTime 26ms CodeModel.GetById 18ms app.highlight 3ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Dependencies/Boost/libs/gil/doc/doxygen/gil_standalone/main.dox

http://hadesmem.googlecode.com/
text | 278 lines | 218 code | 60 blank | 0 comment | 0 complexity | 93d21dc1c10f7f9f94f8f4a4467b6073 MD5 | raw file
  1    /// \defgroup BasicConcepts Basic Concepts
  2    /// \brief Various basic concepts
  3
  4    /// \defgroup Point Point
  5    /// \brief N-dimensional point
  6        /// \defgroup PointConcept Concepts
  7        /// \ingroup Point
  8        /// \brief Concepts for points
  9        
 10        /// \defgroup PointModel Models
 11        /// \ingroup Point
 12        /// \brief Models for points
 13
 14        /// \defgroup PointAlgorithm Algorithms and Utility Functions
 15        /// \ingroup Point
 16        /// \brief Algorithms and Utility Functions for points
 17
 18    /// \defgroup ColorSpaceAndLayout Color, Color Space, and Layout
 19    /// \brief The color space and the layout define the set, ordering and interpretation of channels in a pixel
 20        /// \defgroup ColorSpaceAndLayoutConcept Concepts
 21        /// \ingroup ColorSpaceAndLayout
 22        
 23        /// \defgroup ColorSpaceAndLayoutModel Models
 24        /// \ingroup ColorSpaceAndLayout
 25
 26            /// \defgroup ColorNameModel Color Names
 27            /// \ingroup ColorSpaceAndLayoutModel
 28
 29            /// \defgroup ColorSpaceModel Color Spaces
 30            /// \ingroup ColorSpaceAndLayoutModel
 31            
 32            /// \defgroup LayoutModel Layouts
 33            /// \ingroup ColorSpaceAndLayoutModel
 34
 35    /// \defgroup Channel Channel
 36    /// \brief Channel is the building block of pixel
 37        /// \defgroup ChannelConcept Concepts
 38        /// \ingroup Channel
 39        /// \brief Concepts for channels
 40        
 41        /// \defgroup ChannelModel Models
 42        /// \ingroup Channel
 43        /// \brief Channel models. Although not required by the ChannelConcept, all GIL-provided channels support arithmetic operations
 44
 45        /// \defgroup ChannelAlgorithm Algorithms and Utility Functions
 46        /// \ingroup Channel
 47        /// \brief Channel algorithms, metafunctions and utility functions
 48        
 49/**
 50        \defgroup ColorBase ColorBase
 51        \brief A color base is a container of color elements. 
 52
 53The most common use of color base is in the implementation of a pixel, in which case the color
 54elements are channel values. The color base concept, however, can be used in other scenarios. For example, a planar pixel has channels that are not
 55contiguous in memory. Its reference is a proxy class that uses a color base whose elements are channel references. Its iterator uses a color base
 56whose elements are channel iterators.
 57*/
 58        /// \defgroup ColorBaseConcept Concepts
 59        /// \ingroup ColorBase
 60        /// \brief ColorBase concepts
 61        
 62        /// \defgroup ColorBaseModel Models
 63        /// \ingroup ColorBase
 64        /// \brief ColorBase models
 65
 66        /// \defgroup ColorBaseAlgorithm Algorithms and Utility Functions
 67        /// \ingroup ColorBase
 68        /// \brief ColorBase algorithms, metafunctions and utility functions
 69    
 70/** 
 71    \defgroup PixelBased PixelBased
 72    \brief Concepts for all GIL constructs that are pixel-based (pixels, pixel iterators, locators, views, images).
 73
 74	PixelBasedConcept provides a uniform interface for getting some common properties of pixel-based constructs, such as the number of channels,
 75	the color space, the layout, etc.
 76*/
 77        /// \defgroup PixelBasedConcept Concepts
 78        /// \ingroup PixelBased
 79        /// \brief PixelBased concepts
 80        
 81        /// \defgroup PixelBasedModel Models
 82        /// \ingroup PixelBased
 83        /// \brief PixelBased models
 84
 85        /// \defgroup PixelBasedAlgorithm Algorithms and Utility Functions
 86        /// \ingroup PixelBased
 87        /// \brief PixelBased algorithms, metafunctions and utility functions.
 88
 89/**
 90            \defgroup Pixel Pixel
 91            \brief A pixel is a set of channels defining the color at a given point in an image. 
 92
 93Conceptually, a pixel is little more than a color base whose elements model \p ChannelConcept.
 94Many 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 
 95called <i>heterogeneous</i>. The channels of a pixel may be addressed using semantic or physical indexing, or by color; all color base algorithms 
 96work on pixels as well. Two pixels are <i>compatible</i> if their color spaces are the same and their channels, paired semantically, are compatible. 
 97Note that constness, memory organization and reference/value are ignored. For example, an 8-bit RGB planar reference is compatible to a constant 8-bit 
 98BGR interleaved pixel value. Most pairwise pixel operations (copy construction, assignment, equality, etc.) are only defined for compatible pixels.
 99
100*/
101        /// \defgroup PixelConcept Concepts
102        /// \ingroup Pixel
103        /// \brief Pixel concepts
104        
105        /// \defgroup PixelModel Models
106        /// \ingroup Pixel
107        /// \brief Pixel models
108
109/**
110            \defgroup PixelAlgorithm Algorithms and Utility Functions
111            \ingroup Pixel
112            \brief Pixel algorithms, metafunctions and utility functions.
113
114Since pixels model the ColorBaseConcept, all color-base related algorithms also apply to pixels. See \ref ColorBaseAlgorithm for more.
115
116*/
117
118    /// \defgroup PixelDereferenceAdaptor Pixel Dereference Adaptor
119    /// \brief A function object invoked upon accessing of the pixel of a pixel iterator/locator/view
120
121        /// \defgroup PixelDereferenceAdaptorConcept Concepts
122        /// \ingroup PixelDereferenceAdaptor
123        
124        /// \defgroup PixelDereferenceAdaptorModel Models
125        /// \ingroup PixelDereferenceAdaptor
126
127
128    /// \defgroup PixelIterator Pixel Iterator
129    /// \brief STL Iterators over models of PixelConcept
130
131        /// \defgroup PixelIteratorConcept Concepts
132        /// \ingroup PixelIterator
133        /// \brief Pixel iterator concepts
134        
135        /// \defgroup PixelIteratorModel Models
136        /// \ingroup PixelIterator
137        /// \brief Pixel iterator models
138
139
140    /// \defgroup PixelLocator Pixel Locator
141    /// \brief Generalization of an iterator to multiple dimensions
142
143        /// \defgroup PixelLocatorConcept Concepts
144        /// \ingroup PixelLocator
145        /// \brief Pixel locator concepts
146        
147        /// \defgroup PixelLocatorModel Models
148        /// \ingroup PixelLocator
149        /// \brief Pixel locator models
150
151    /// \defgroup ImageView Image View
152    /// \brief N-dimensional range
153
154        /// \defgroup ImageViewConcept Concepts
155        /// \ingroup ImageView
156        /// \brief Image view concepts
157        
158        /// \defgroup ImageViewModel Models
159        /// \ingroup ImageView
160        /// \brief Image view models
161
162        /// \defgroup ImageViewAlgorithm Algorithms and Utility Functions
163        /// \ingroup ImageView
164        /// \brief Image view algorithms, metafunctions and utility functions
165
166/**    
167    \defgroup Image Image
168    \brief N-dimensional container
169
170  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.
171  
172  Images are regular types (which means they have a default constructor, a copy constructor, \p operator=, \p operator==, \p operator!=, and \p swap)
173  As containers, images own the data, which means they allocate the data in their constructors and deallocate in the destructors. Their copy construction,
174  assignment and equality comparison is deep (i.e. propagates the operation to the values). That makes images expensive to pass by value, unlike views.
175  
176  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 
177  a mutable view over its pixels.
178  
179  Images provide two services: they manage ownership of their data (the pixels) and they can return a view over their pixels.
180  Algorithms predominantly operate on views. This is analogous to the STL: In the STL containers (like \p std::vector) provide ranges (\p vec.begin() 
181  and \p vec.end() ) and algorithms typically operate on ranges. The GIL equivalent of a range is an image view.
182  
183*/
184        /// \defgroup ImageConcept Concepts
185        /// \ingroup Image
186        /// \brief Image concepts
187        
188        /// \defgroup ImageModel Models
189        /// \ingroup Image
190        /// \brief Image models
191
192    /// \defgroup Variant Variant
193    /// \brief A holder of a runtime instantiated type. Used to provide runtime-specified images and views
194
195    /// \defgroup Metafunctions Metafunctions
196    /// \brief Metafunctions to construct or query GIL types
197        /// \defgroup TypeFactory Type Factory Metafunctions
198        /// \ingroup Metafunctions
199        /// \brief Metafunctions that construct GIL types from related types or from components
200
201        /// \defgroup TypeAnalysis Type Analysis Metafunctions
202        /// \ingroup Metafunctions
203        /// \brief Metafunctions that determine properties of GIL types
204        
205    /// \defgroup IO I/O
206    /// \brief Support for reading and writing images to file
207        /// \defgroup JPEG_IO JPEG I/O
208        /// \ingroup IO
209        /// \brief Support for reading and writing JPEG image files
210
211        /// \defgroup TIFF_IO TIFF I/O
212        /// \ingroup IO
213        /// \brief Support for reading and writing TIFF image files
214
215        /// \defgroup PNG_IO PNG I/O
216        /// \ingroup IO
217        /// \brief Support for reading and writing PNG image files
218
219/*! 
220\mainpage Generic Image Library
221
222\section Documentation
223
224- A Quick, Hands-on  \ref GILTutorial "Tutorial".
225- A Detailed \ref GILDesignGuide "Design Guide".
226
227\section Modules
228
229    - \ref BasicConcepts
230    - \ref Point
231        - \ref PointConcept
232        - \ref PointModel
233        - \ref PointAlgorithm
234    - \ref ColorSpaceAndLayout
235        - \ref ColorSpaceAndLayoutConcept
236        - \ref ColorSpaceAndLayoutModel
237    - \ref Channel
238        - \ref ChannelConcept
239        - \ref ChannelModel
240        - \ref ChannelAlgorithm
241    - \ref ColorBase
242        - \ref ColorBaseConcept
243        - \ref ColorBaseModel
244        - \ref ColorBaseAlgorithm
245    - \ref PixelBased
246        - \ref PixelBasedConcept
247        - \ref PixelBasedModel
248        - \ref PixelBasedAlgorithm
249    - \ref Pixel
250        - \ref PixelConcept
251        - \ref PixelModel
252        - \ref PixelAlgorithm
253    - \ref PixelDereferenceAdaptor
254        - \ref PixelDereferenceAdaptorConcept
255        - \ref PixelDereferenceAdaptorModel
256    - \ref PixelIterator
257        - \ref PixelIteratorConcept
258        - \ref PixelIteratorModel
259    - \ref PixelLocator
260        - \ref PixelLocatorConcept
261        - \ref PixelLocatorModel
262    - \ref ImageView
263        - \ref ImageViewConcept
264        - \ref ImageViewModel
265        - \ref ImageViewAlgorithm
266    - \ref Image
267        - \ref ImageConcept
268        - \ref ImageModel
269    - \ref Metafunctions
270        - \ref TypeFactory
271        - \ref TypeAnalysis
272    - \ref Variant
273    - \ref IO
274        - \ref JPEG_IO
275        - \ref TIFF_IO
276        - \ref PNG_IO    
277*/
278