vigra - vigra/stdimage.hxx Source File

[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

stdimage.hxx |

1 /************************************************************************/
2 /* */
3 /* Copyright 1998-2002 by Ullrich Koethe */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35
36
37 #ifndef VIGRA_STDIMAGE_HXX
38 #define VIGRA_STDIMAGE_HXX
39
40 #include "sized_int.hxx"
41 #include "tuple.hxx"
42 #include "basicimage.hxx"
43 #include "iteratortraits.hxx"
44 #include "accessor.hxx"
45 #include "rgbvalue.hxx"
46
47 namespace vigra {
48
49 /** \addtogroup StandardImageTypes Standard Image Types
50
51 \brief The most common instantiations of the \ref vigra::BasicImage template
52 */
53 //@{
54
55 /** Byte (8-bit unsigned) image.
56 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
57 their const counterparts to access the data.
58
59 <b>\#include</b> <vigra/stdimage.hxx><br>
60 Namespace: vigra
61 */
62 typedef BasicImage<UInt8> BImage;
63
64 /** Byte (8-bit unsigned) image.
65 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
66 their const counterparts to access the data.
67
68 <b>\#include</b> <vigra/stdimage.hxx><br>
69 Namespace: vigra
70 */
71 typedef BasicImage<UInt8> UInt8Image;
72
73 /** Signed byte (8-bit signed) image.
74 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
75 their const counterparts to access the data.
76
77 <b>\#include</b> <vigra/stdimage.hxx><br>
78 Namespace: vigra
79 */
80 typedef BasicImage<Int8> Int8Image;
81
82 /** Short integer (16-bit signed) image.
83 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
84 their const counterparts to access the data.
85
86 <b>\#include</b> <vigra/stdimage.hxx><br>
87 Namespace: vigra
88 */
89 typedef BasicImage<Int16> SImage;
90
91 /** Short integer (16-bit unsigned) image.
92 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
93 their const counterparts to access the data.
94
95 <b>\#include</b> <vigra/stdimage.hxx><br>
96 Namespace: vigra
97 */
98 typedef BasicImage<UInt16> UInt16Image;
99
100 /** Short integer (16-bit signed) image.
101 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
102 their const counterparts to access the data.
103
104 <b>\#include</b> <vigra/stdimage.hxx><br>
105 Namespace: vigra
106 */
107 typedef BasicImage<Int16> Int16Image;
108
109 /** Integer (32-bit signed) image.
110 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
111 their const counterparts to access the data.
112
113 <b>\#include</b> <vigra/stdimage.hxx><br>
114 Namespace: vigra
115 */
116 typedef BasicImage<Int32> IImage;
117
118 /** Integer (32-bit unsigned) image.
119 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
120 their const counterparts to access the data.
121
122 <b>\#include</b> <vigra/stdimage.hxx><br>
123 Namespace: vigra
124 */
125 typedef BasicImage<UInt32> UInt32Image;
126
127 /** Integer (32-bit signed) image.
128 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
129 their const counterparts to access the data.
130
131 <b>\#include</b> <vigra/stdimage.hxx><br>
132 Namespace: vigra
133 */
134 typedef BasicImage<Int32> Int32Image;
135
136 /** Float (float) image.
137 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
138 their const counterparts to access the data.
139
140 <b>\#include</b> <vigra/stdimage.hxx><br>
141 Namespace: vigra
142 */
143 typedef BasicImage<float> FImage;
144
145
146 /** Double (double) image.
147 It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and
148 their const counterparts to access the data.
149
150 <b>\#include</b> <vigra/stdimage.hxx><br>
151 Namespace: vigra
152 */
153 typedef BasicImage<double> DImage;
154
155
156 /** Byte (3x 8-bit unsigned) RGB image.
157 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::UInt8>".
158 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
159 their const counterparts to access the data.
160
161 <b>\#include</b> <vigra/stdimage.hxx><br>
162 Namespace: vigra
163 */
164 typedef BasicImage<RGBValue<UInt8> > BRGBImage;
165
166 /** Byte (3x 8-bit unsigned) RGB image.
167 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::UInt8>".
168 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
169 their const counterparts to access the data.
170
171 <b>\#include</b> <vigra/stdimage.hxx><br>
172 Namespace: vigra
173 */
174 typedef BasicImage<RGBValue<UInt8> > UInt8RGBImage;
175
176 /** Byte (3x 8-bit signed) RGB image.
177 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::UInt8>".
178 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
179 their const counterparts to access the data.
180
181 <b>\#include</b> <vigra/stdimage.hxx><br>
182 Namespace: vigra
183 */
184 typedef BasicImage<RGBValue<Int8> > Int8RGBImage;
185
186 /** Short (3x 16-bit signed) RGB image.
187 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int16>".
188 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
189 their const counterparts to access the data.
190
191 <b>\#include</b> <vigra/stdimage.hxx><br>
192 Namespace: vigra
193 */
194 typedef BasicImage<RGBValue<Int16> > SRGBImage;
195
196 /** Short (3x 16-bit unsigned) RGB image.
197 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int16>".
198 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
199 their const counterparts to access the data.
200
201 <b>\#include</b> <vigra/stdimage.hxx><br>
202 Namespace: vigra
203 */
204 typedef BasicImage<RGBValue<UInt16> > UInt16RGBImage;
205
206 /** Short (3x 16-bit signed) RGB image.
207 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int16>".
208 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
209 their const counterparts to access the data.
210
211 <b>\#include</b> <vigra/stdimage.hxx><br>
212 Namespace: vigra
213 */
214 typedef BasicImage<RGBValue<Int16> > Int16RGBImage;
215
216 /** Integer (3x 32-bit signed) RGB image.
217 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int32>".
218 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
219 their const counterparts to access the data.
220
221 <b>\#include</b> <vigra/stdimage.hxx><br>
222 Namespace: vigra
223 */
224 typedef BasicImage<RGBValue<Int32> > IRGBImage;
225
226 /** Integer (3x 32-bit unsigned) RGB image.
227 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int32>".
228 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
229 their const counterparts to access the data.
230
231 <b>\#include</b> <vigra/stdimage.hxx><br>
232 Namespace: vigra
233 */
234 typedef BasicImage<RGBValue<UInt32> > UInt32RGBImage;
235
236 /** Integer (3x 32-bit signed) RGB image.
237 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int32>".
238 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
239 their const counterparts to access the data.
240
241 <b>\#include</b> <vigra/stdimage.hxx><br>
242 Namespace: vigra
243 */
244 typedef BasicImage<RGBValue<Int32> > Int32RGBImage;
245
246
247 /** Floating-point (3x float) RGB image.
248 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<float>".
249 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
250 their const counterparts to access the data.
251
252 <b>\#include</b> <vigra/stdimage.hxx><br>
253 Namespace: vigra
254 */
255 typedef BasicImage<RGBValue<float> > FRGBImage;
256
257
258 /** Double-precision floating-point (3x double) RGB image.
259 The pixel type is \ref vigra::RGBValue "vigra::RGBValue<double>".
260 It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and
261 their const counterparts to access the data.
262
263 <b>\#include</b> <vigra/stdimage.hxx><br>
264 Namespace: vigra
265 */
266 typedef BasicImage<RGBValue<double> > DRGBImage;
267
268 /** Floating-point TinyVector image.
269 The pixel type is \ref vigra::TinyVector "vigra::TinyVector<float, 2>".
270 It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and
271 their const counterparts to access the data.
272
273 <b>\#include</b> <vigra/stdimage.hxx><br>
274 Namespace: vigra
275 */
276 typedef BasicImage<TinyVector<float, 2> > FVector2Image;
277
278 /** Floating-point TinyVector image.
279 The pixel type is \ref vigra::TinyVector "vigra::TinyVector<float, 3>".
280 It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and
281 their const counterparts to access the data.
282
283 <b>\#include</b> <vigra/stdimage.hxx><br>
284 Namespace: vigra
285 */
286 typedef BasicImage<TinyVector<float, 3> > FVector3Image;
287
288 /** Floating-point TinyVector image.
289 The pixel type is \ref vigra::TinyVector "vigra::TinyVector<float, 4>".
290 It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and
291 their const counterparts to access the data.
292
293 <b>\#include</b> <vigra/stdimage.hxx><br>
294 Namespace: vigra
295 */
296 typedef BasicImage<TinyVector<float, 4> > FVector4Image;
297
298 /** Floating-point TinyVector image.
299 The pixel type is \ref vigra::TinyVector "vigra::TinyVector<double, 2>".
300 It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and
301 their const counterparts to access the data.
302
303 <b>\#include</b> <vigra/stdimage.hxx><br>
304 Namespace: vigra
305 */
306 typedef BasicImage<TinyVector<double, 2> > DVector2Image;
307
308 /** Floating-point TinyVector image.
309 The pixel type is \ref vigra::TinyVector "vigra::TinyVector<double, 3>".
310 It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and
311 their const counterparts to access the data.
312
313 <b>\#include</b> <vigra/stdimage.hxx><br>
314 Namespace: vigra
315 */
316 //typedef BasicImage<TinyVector<double, 3> > DVector3Image;
317 typedef BasicImage<TinyVector<double, 3> > DVector3Image;
318
319 /** Floating-point TinyVector image.
320 The pixel type is \ref vigra::TinyVector "vigra::TinyVector<double, 4>".
321 It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and
322 their const counterparts to access the data.
323
324 <b>\#include</b> <vigra/stdimage.hxx><br>
325 Namespace: vigra
326 */
327 typedef BasicImage<TinyVector<double, 4> > DVector4Image;
328
329 //@}
330
331 } // namespace vigra
332
333 #endif // VIGRA_STDIMAGE_HXX
vigra::Int32Image
BasicImage< Int32 > Int32Image
Definition: stdimage.hxx:134
vigra::IRGBImage
BasicImage< RGBValue< Int32 > > IRGBImage
Definition: stdimage.hxx:224
vigra::DVector3Image
BasicImage< TinyVector< double, 3 > > DVector3Image
Definition: stdimage.hxx:317
vigra::FImage
BasicImage< float > FImage
Definition: stdimage.hxx:143
vigra::Int16RGBImage
BasicImage< RGBValue< Int16 > > Int16RGBImage
Definition: stdimage.hxx:214
vigra::UInt32Image
BasicImage< UInt32 > UInt32Image
Definition: stdimage.hxx:125
vigra::Int32RGBImage
BasicImage< RGBValue< Int32 > > Int32RGBImage
Definition: stdimage.hxx:244
vigra::UInt8RGBImage
BasicImage< RGBValue< UInt8 > > UInt8RGBImage
Definition: stdimage.hxx:174
vigra::Int8RGBImage
BasicImage< RGBValue< Int8 > > Int8RGBImage
Definition: stdimage.hxx:184
vigra::FVector3Image
BasicImage< TinyVector< float, 3 > > FVector3Image
Definition: stdimage.hxx:286
vigra::FVector2Image
BasicImage< TinyVector< float, 2 > > FVector2Image
Definition: stdimage.hxx:276
vigra::UInt8Image
BasicImage< UInt8 > UInt8Image
Definition: stdimage.hxx:71
vigra::FRGBImage
BasicImage< RGBValue< float > > FRGBImage
Definition: stdimage.hxx:255
vigra::DVector4Image
BasicImage< TinyVector< double, 4 > > DVector4Image
Definition: stdimage.hxx:327
vigra::BImage
BasicImage< UInt8 > BImage
Definition: stdimage.hxx:62
vigra::UInt16RGBImage
BasicImage< RGBValue< UInt16 > > UInt16RGBImage
Definition: stdimage.hxx:204
vigra::SImage
BasicImage< Int16 > SImage
Definition: stdimage.hxx:89
vigra::SRGBImage
BasicImage< RGBValue< Int16 > > SRGBImage
Definition: stdimage.hxx:194
vigra::FVector4Image
BasicImage< TinyVector< float, 4 > > FVector4Image
Definition: stdimage.hxx:296
vigra::BasicImage
Fundamental class template for images.
Definition: basicimage.hxx:475
vigra::BRGBImage
BasicImage< RGBValue< UInt8 > > BRGBImage
Definition: stdimage.hxx:164
vigra::Int16Image
BasicImage< Int16 > Int16Image
Definition: stdimage.hxx:107
vigra::UInt32RGBImage
BasicImage< RGBValue< UInt32 > > UInt32RGBImage
Definition: stdimage.hxx:234
vigra::DRGBImage
BasicImage< RGBValue< double > > DRGBImage
Definition: stdimage.hxx:266
vigra::DImage
BasicImage< double > DImage
Definition: stdimage.hxx:153
vigra::UInt16Image
BasicImage< UInt16 > UInt16Image
Definition: stdimage.hxx:98
vigra::DVector2Image
BasicImage< TinyVector< double, 2 > > DVector2Image
Definition: stdimage.hxx:306
vigra::Int8Image
BasicImage< Int8 > Int8Image
Definition: stdimage.hxx:80
vigra::IImage
BasicImage< Int32 > IImage
Definition: stdimage.hxx:116

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python vigra 1.11.1 (Fri May 19 2017)