]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | ||
53 | The most common use of color base is in the implementation of a pixel, in which case the color | |
54 | 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 | |
55 | 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 | |
56 | whose 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 | ||
93 | Conceptually, a pixel is little more than a color base whose elements model \p ChannelConcept. | |
94 | 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 | |
95 | called <i>heterogeneous</i>. The channels of a pixel may be addressed using semantic or physical indexing, or by color; all color base algorithms | |
96 | 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. | |
97 | 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 | |
98 | BGR 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 | ||
114 | Since 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 |