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

details vigra/stdimage.hxx VIGRA

00001 /************************************************************************/
00002 /*                                                                      */
00003 /*               Copyright 1998-2002 by Ullrich Koethe                  */
00004 /*       Cognitive Systems Group, University of Hamburg, Germany        */
00005 /*                                                                      */
00006 /*    This file is part of the VIGRA computer vision library.           */
00007 /*    ( Version 1.2.0, Aug 07 2003 )                                    */
00008 /*    You may use, modify, and distribute this software according       */
00009 /*    to the terms stated in the LICENSE file included in               */
00010 /*    the VIGRA distribution.                                           */
00011 /*                                                                      */
00012 /*    The VIGRA Website is                                              */
00013 /*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
00014 /*    Please direct questions, bug reports, and contributions to        */
00015 /*        koethe@informatik.uni-hamburg.de                              */
00016 /*                                                                      */
00017 /*  THIS SOFTWARE IS PROVIDED AS IS AND WITHOUT ANY EXPRESS OR          */
00018 /*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED      */
00019 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */
00020 /*                                                                      */
00021 /************************************************************************/
00022  
00023  
00024 #ifndef VIGRA_STDIMAGE_HXX
00025 #define VIGRA_STDIMAGE_HXX
00026 
00027 #include "vigra/tuple.hxx"
00028 #include "vigra/basicimage.hxx"
00029 #include "vigra/iteratortraits.hxx"
00030 #include "vigra/accessor.hxx"
00031 #include "vigra/rgbvalue.hxx"
00032 
00033 namespace vigra { 
00034 
00035 #define VIGRA_DEFINE_ITERATORTRAITS(VALUETYPE, ACCESSOR, CONSTACCESSOR) \
00036     template<> \
00037     struct IteratorTraits< \
00038         BasicImageIterator<VALUETYPE, VALUETYPE **> > \
00039     { \
00040         typedef BasicImageIterator<VALUETYPE, VALUETYPE **> \
00041                                                      Iterator; \
00042         typedef Iterator                             iterator; \
00043         typedef iterator::iterator_category          iterator_category; \
00044         typedef iterator::value_type                 value_type; \
00045         typedef iterator::reference                  reference; \
00046         typedef iterator::index_reference            index_reference; \
00047         typedef iterator::pointer                    pointer; \
00048         typedef iterator::difference_type            difference_type; \
00049         typedef iterator::row_iterator               row_iterator; \
00050         typedef iterator::column_iterator            column_iterator; \
00051         typedef ACCESSOR<VALUETYPE >                 default_accessor; \
00052         typedef ACCESSOR<VALUETYPE >                 DefaultAccessor; \
00053     }; \
00054     template<> \
00055     struct IteratorTraits< \
00056         ConstBasicImageIterator<VALUETYPE, VALUETYPE **> > \
00057     { \
00058         typedef \
00059           ConstBasicImageIterator<VALUETYPE, VALUETYPE **> \
00060                                                      Iterator; \
00061         typedef Iterator                             iterator; \
00062         typedef iterator::iterator_category          iterator_category; \
00063         typedef iterator::value_type                 value_type; \
00064         typedef iterator::reference                  reference; \
00065         typedef iterator::index_reference            index_reference; \
00066         typedef iterator::pointer                    pointer; \
00067         typedef iterator::difference_type            difference_type; \
00068         typedef iterator::row_iterator               row_iterator; \
00069         typedef iterator::column_iterator            column_iterator; \
00070         typedef CONSTACCESSOR<VALUETYPE >            default_accessor; \
00071         typedef CONSTACCESSOR<VALUETYPE >            DefaultAccessor; \
00072     };
00073 
00074 /** \addtogroup StandardImageTypes Standard Image Types
00075 
00076     \brief The most common instantiations of the \ref vigra::BasicImage template
00077 */
00078 //@{
00079 
00080 VIGRA_DEFINE_ITERATORTRAITS(unsigned char, StandardValueAccessor, StandardConstValueAccessor)
00081 
00082     /** Byte (8-bit unsigned) image.
00083         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00084         their const counterparts to access the data.
00085         
00086         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00087         Namespace: vigra
00088     */
00089 typedef BasicImage<unsigned char> BImage;
00090 
00091 VIGRA_DEFINE_ITERATORTRAITS(short, StandardValueAccessor, StandardConstValueAccessor)
00092 
00093 
00094     /** Short integer (16-bit signed) image.
00095         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00096         their const counterparts to access the data.
00097         
00098         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00099         Namespace: vigra
00100     */
00101 typedef BasicImage<short> SImage;
00102 
00103 VIGRA_DEFINE_ITERATORTRAITS(int, StandardValueAccessor, StandardConstValueAccessor)
00104 
00105     /** Integer (32-bit signed) image.
00106         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00107         their const counterparts to access the data.
00108         
00109         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00110         Namespace: vigra
00111     */
00112 typedef BasicImage<int> IImage;
00113 
00114 VIGRA_DEFINE_ITERATORTRAITS(float, StandardValueAccessor, StandardConstValueAccessor)
00115 
00116     /** Float (float) image.
00117         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00118         their const counterparts to access the data.
00119         
00120         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00121         Namespace: vigra
00122     */
00123 typedef BasicImage<float> FImage;
00124 
00125 VIGRA_DEFINE_ITERATORTRAITS(double, StandardValueAccessor, StandardConstValueAccessor)
00126 
00127     /** Double (double) image.
00128         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00129         their const counterparts to access the data.
00130    
00131        <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00132         Namespace: vigra
00133  */
00134 typedef BasicImage<double> DImage;
00135 
00136 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<unsigned char>, RGBAccessor, RGBAccessor)
00137 
00138     /** Byte (3x 8-bit unsigned) RGB image.
00139         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<unsigned char>".
00140         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00141         their const counterparts to access the data.
00142         
00143         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00144         Namespace: vigra
00145     */
00146 typedef BasicImage<RGBValue<unsigned char> > BRGBImage;
00147 
00148 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<int>, RGBAccessor, RGBAccessor)
00149 
00150     /** Integer (3x 32-bit signed) RGB image.
00151         The pixel type is \ref vigra::RGBValue "RGBValue<int>".
00152         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00153         their const counterparts to access the data.
00154         
00155         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00156         Namespace: vigra
00157     */
00158 typedef BasicImage<RGBValue<int> > IRGBImage;
00159 
00160 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<float>, RGBAccessor, RGBAccessor)
00161 
00162     /** Floating-point (3x float) RGB image.
00163         The pixel type is \ref vigra::RGBValue "RGBValue<float>".
00164         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00165         their const counterparts to access the data.
00166         
00167         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00168         Namespace: vigra
00169     */
00170 typedef BasicImage<RGBValue<float> > FRGBImage;
00171 
00172 VIGRA_DEFINE_ITERATORTRAITS(RGBValue<double>, RGBAccessor, RGBAccessor)
00173 
00174     /** Double-precision floating-point (3x double) RGB image.
00175         The pixel type is \ref vigra::RGBValue "RGBValue<double>".
00176         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00177         their const counterparts to access the data.
00178         
00179         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00180         Namespace: vigra
00181     */
00182 typedef BasicImage<RGBValue<double> > DRGBImage;
00183 
00184 #define VIGRA_PIXELTYPE TinyVector<float, 2>
00185 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE, VectorAccessor, VectorAccessor) 
00186 #undef VIGRA_PIXELTYPE 
00187 #define VIGRA_PIXELTYPE TinyVector<float, 3>
00188 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE, VectorAccessor, VectorAccessor) 
00189 #undef VIGRA_PIXELTYPE
00190 #define VIGRA_PIXELTYPE TinyVector<float, 4>
00191 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE, VectorAccessor, VectorAccessor) 
00192 #undef VIGRA_PIXELTYPE
00193 #define VIGRA_PIXELTYPE TinyVector<double, 2>
00194 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE, VectorAccessor, VectorAccessor) 
00195 #undef VIGRA_PIXELTYPE
00196 #define VIGRA_PIXELTYPE TinyVector<double, 3>
00197 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE, VectorAccessor, VectorAccessor) 
00198 #undef VIGRA_PIXELTYPE
00199 #define VIGRA_PIXELTYPE TinyVector<double, 4>
00200 VIGRA_DEFINE_ITERATORTRAITS(VIGRA_PIXELTYPE, VectorAccessor, VectorAccessor) 
00201 #undef VIGRA_PIXELTYPE
00202 
00203     /** Floating-point TinyVector image.
00204         The pixel type is \ref vigra::TinyVector "TinyVector<float, 2>".
00205         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00206         their const counterparts to access the data.
00207         
00208         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00209         Namespace: vigra
00210     */
00211 typedef BasicImage<TinyVector<float, 2> > FVector2Image; 
00212 
00213     /** Floating-point TinyVector image.
00214         The pixel type is \ref vigra::TinyVector "TinyVector<float, 3>".
00215         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00216         their const counterparts to access the data.
00217         
00218         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00219         Namespace: vigra
00220     */
00221 typedef BasicImage<TinyVector<float, 3> > FVector3Image; 
00222 
00223     /** Floating-point TinyVector image.
00224         The pixel type is \ref vigra::TinyVector "TinyVector<float, 4>".
00225         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00226         their const counterparts to access the data.
00227         
00228         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00229         Namespace: vigra
00230     */
00231 typedef BasicImage<TinyVector<float, 4> > FVector4Image; 
00232 
00233     /** Floating-point TinyVector image.
00234         The pixel type is \ref vigra::TinyVector "TinyVector<double, 2>".
00235         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00236         their const counterparts to access the data.
00237         
00238         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00239         Namespace: vigra
00240     */
00241 typedef BasicImage<TinyVector<double, 2> > DVector2Image; 
00242 
00243     /** Floating-point TinyVector image.
00244         The pixel type is \ref vigra::TinyVector "TinyVector<double, 3>".
00245         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00246         their const counterparts to access the data.
00247         
00248         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00249         Namespace: vigra
00250     */
00251 //typedef BasicImage<TinyVector<double, 3> > DVector3Image; 
00252 typedef BasicImage<TinyVector<double, 3> > DVector3Image; 
00253 
00254     /** Floating-point TinyVector image.
00255         The pixel type is \ref vigra::TinyVector "TinyVector<double, 4>".
00256         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00257         their const counterparts to access the data.
00258         
00259         <b>\#include</b> "<a href="stdimage_8hxx-source.html">vigra/stdimage.hxx</a>"<br>
00260         Namespace: vigra
00261     */
00262 typedef BasicImage<TinyVector<double, 4> > DVector4Image; 
00263 
00264 
00265 #undef VIGRA_DEFINE_ITERATORTRAITS
00266 
00267 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
00268 
00269 // define traits for BasicImageIterator instanciations that
00270 // were not explicitly defined above
00271 template <class T>
00272 struct IteratorTraits<BasicImageIterator<T, T **> >
00273 {
00274     typedef BasicImageIterator<T, T **>          Iterator;
00275     typedef Iterator                             iterator;
00276     typedef typename iterator::iterator_category iterator_category;
00277     typedef typename iterator::value_type        value_type;
00278     typedef typename iterator::reference         reference;
00279     typedef typename iterator::index_reference   index_reference;
00280     typedef typename iterator::pointer           pointer;
00281     typedef typename iterator::difference_type   difference_type;
00282     typedef typename iterator::row_iterator      row_iterator;
00283     typedef typename iterator::column_iterator   column_iterator;
00284     typedef StandardAccessor<T>                  DefaultAccessor; 
00285     typedef StandardAccessor<T>                  default_accessor; 
00286 };  
00287 
00288 template <class T>
00289 struct IteratorTraits<ConstBasicImageIterator<T, T **> >
00290 {
00291     typedef ConstBasicImageIterator<T, T **> Iterator;
00292     typedef Iterator                               iterator;
00293     typedef typename iterator::iterator_category   iterator_category;
00294     typedef typename iterator::value_type          value_type;
00295     typedef typename iterator::reference           reference;
00296     typedef typename iterator::index_reference     index_reference;
00297     typedef typename iterator::pointer             pointer;
00298     typedef typename iterator::difference_type     difference_type;
00299     typedef typename iterator::row_iterator        row_iterator;
00300     typedef typename iterator::column_iterator     column_iterator;
00301     typedef StandardConstAccessor<T>               DefaultAccessor; 
00302     typedef StandardConstAccessor<T>               default_accessor; 
00303 };  
00304 
00305 #endif
00306     
00307 //@}
00308 
00309 } // namespace vigra
00310 
00311 #endif // VIGRA_STDIMAGE_HXX

© Ullrich Köthe (koethe@informatik.uni-hamburg.de)
Cognitive Systems Group, University of Hamburg, Germany

html generated using doxygen and Python
VIGRA 1.2.0 (7 Aug 2003)