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

vigra/stdimage.hxx VIGRA

00001 /************************************************************************/
00002 /*                                                                      */
00003 /*               Copyright 1998-2002 by Ullrich Koethe                  */
00004 /*                                                                      */
00005 /*    This file is part of the VIGRA computer vision library.           */
00006 /*    The VIGRA Website is                                              */
00007 /*        http://hci.iwr.uni-heidelberg.de/vigra/                       */
00008 /*    Please direct questions, bug reports, and contributions to        */
00009 /*        ullrich.koethe@iwr.uni-heidelberg.de    or                    */
00010 /*        vigra@informatik.uni-hamburg.de                               */
00011 /*                                                                      */
00012 /*    Permission is hereby granted, free of charge, to any person       */
00013 /*    obtaining a copy of this software and associated documentation    */
00014 /*    files (the "Software"), to deal in the Software without           */
00015 /*    restriction, including without limitation the rights to use,      */
00016 /*    copy, modify, merge, publish, distribute, sublicense, and/or      */
00017 /*    sell copies of the Software, and to permit persons to whom the    */
00018 /*    Software is furnished to do so, subject to the following          */
00019 /*    conditions:                                                       */
00020 /*                                                                      */
00021 /*    The above copyright notice and this permission notice shall be    */
00022 /*    included in all copies or substantial portions of the             */
00023 /*    Software.                                                         */
00024 /*                                                                      */
00025 /*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
00026 /*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
00027 /*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
00028 /*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
00029 /*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
00030 /*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
00031 /*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
00032 /*    OTHER DEALINGS IN THE SOFTWARE.                                   */                
00033 /*                                                                      */
00034 /************************************************************************/
00035  
00036  
00037 #ifndef VIGRA_STDIMAGE_HXX
00038 #define VIGRA_STDIMAGE_HXX
00039 
00040 #include "sized_int.hxx"
00041 #include "tuple.hxx"
00042 #include "basicimage.hxx"
00043 #include "iteratortraits.hxx"
00044 #include "accessor.hxx"
00045 #include "rgbvalue.hxx"
00046 
00047 namespace vigra { 
00048 
00049 /** \addtogroup StandardImageTypes Standard Image Types
00050 
00051     \brief The most common instantiations of the \ref vigra::BasicImage template
00052 */
00053 //@{
00054 
00055     /** Byte (8-bit unsigned) image.
00056         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00057         their const counterparts to access the data.
00058         
00059         <b>\#include</b> <vigra/stdimage.hxx><br>
00060         Namespace: vigra
00061     */
00062 typedef BasicImage<UInt8> BImage;
00063 
00064     /** Byte (8-bit unsigned) image.
00065         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00066         their const counterparts to access the data.
00067         
00068         <b>\#include</b> <vigra/stdimage.hxx><br>
00069         Namespace: vigra
00070     */
00071 typedef BasicImage<UInt8> UInt8Image;
00072 
00073     /** Signed byte (8-bit signed) image.
00074         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00075         their const counterparts to access the data.
00076         
00077         <b>\#include</b> <vigra/stdimage.hxx><br>
00078         Namespace: vigra
00079     */
00080 typedef BasicImage<Int8> Int8Image;
00081 
00082     /** Short integer (16-bit signed) 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> <vigra/stdimage.hxx><br>
00087         Namespace: vigra
00088     */
00089 typedef BasicImage<Int16> SImage;
00090 
00091     /** Short integer (16-bit unsigned) image.
00092         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00093         their const counterparts to access the data.
00094         
00095         <b>\#include</b> <vigra/stdimage.hxx><br>
00096         Namespace: vigra
00097     */
00098 typedef BasicImage<UInt16> UInt16Image;
00099 
00100     /** Short integer (16-bit signed) image.
00101         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00102         their const counterparts to access the data.
00103         
00104         <b>\#include</b> <vigra/stdimage.hxx><br>
00105         Namespace: vigra
00106     */
00107 typedef BasicImage<Int16> Int16Image;
00108 
00109     /** Integer (32-bit signed) image.
00110         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00111         their const counterparts to access the data.
00112         
00113         <b>\#include</b> <vigra/stdimage.hxx><br>
00114         Namespace: vigra
00115     */
00116 typedef BasicImage<Int32> IImage;
00117 
00118     /** Integer (32-bit unsigned) image.
00119         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00120         their const counterparts to access the data.
00121         
00122         <b>\#include</b> <vigra/stdimage.hxx><br>
00123         Namespace: vigra
00124     */
00125 typedef BasicImage<UInt32> UInt32Image;
00126 
00127     /** Integer (32-bit signed) 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> <vigra/stdimage.hxx><br>
00132         Namespace: vigra
00133     */
00134 typedef BasicImage<Int32> Int32Image;
00135 
00136     /** Float (float) image.
00137         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00138         their const counterparts to access the data.
00139         
00140         <b>\#include</b> <vigra/stdimage.hxx><br>
00141         Namespace: vigra
00142     */
00143 typedef BasicImage<float> FImage;
00144 
00145 
00146     /** Double (double) image.
00147         It uses \ref vigra::BasicImageIterator and \ref vigra::StandardAccessor and 
00148         their const counterparts to access the data.
00149    
00150        <b>\#include</b> <vigra/stdimage.hxx><br>
00151         Namespace: vigra
00152  */
00153 typedef BasicImage<double> DImage;
00154 
00155 
00156     /** Byte (3x 8-bit unsigned) RGB image.
00157         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::UInt8>".
00158         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00159         their const counterparts to access the data.
00160         
00161         <b>\#include</b> <vigra/stdimage.hxx><br>
00162         Namespace: vigra
00163     */
00164 typedef BasicImage<RGBValue<UInt8> > BRGBImage;
00165 
00166     /** Byte (3x 8-bit unsigned) RGB image.
00167         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::UInt8>".
00168         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00169         their const counterparts to access the data.
00170         
00171         <b>\#include</b> <vigra/stdimage.hxx><br>
00172         Namespace: vigra
00173     */
00174 typedef BasicImage<RGBValue<UInt8> > UInt8RGBImage;
00175 
00176     /** Byte (3x 8-bit signed) RGB image.
00177         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::UInt8>".
00178         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00179         their const counterparts to access the data.
00180         
00181         <b>\#include</b> <vigra/stdimage.hxx><br>
00182         Namespace: vigra
00183     */
00184 typedef BasicImage<RGBValue<Int8> > Int8RGBImage;
00185 
00186     /** Short (3x 16-bit signed) RGB image.
00187         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int16>".
00188         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00189         their const counterparts to access the data.
00190         
00191         <b>\#include</b> <vigra/stdimage.hxx><br>
00192         Namespace: vigra
00193     */
00194 typedef BasicImage<RGBValue<Int16> > SRGBImage;
00195 
00196     /** Short (3x 16-bit unsigned) RGB image.
00197         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int16>".
00198         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00199         their const counterparts to access the data.
00200         
00201         <b>\#include</b> <vigra/stdimage.hxx><br>
00202         Namespace: vigra
00203     */
00204 typedef BasicImage<RGBValue<UInt16> > UInt16RGBImage;
00205 
00206     /** Short (3x 16-bit signed) RGB image.
00207         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int16>".
00208         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00209         their const counterparts to access the data.
00210         
00211         <b>\#include</b> <vigra/stdimage.hxx><br>
00212         Namespace: vigra
00213     */
00214 typedef BasicImage<RGBValue<Int16> > Int16RGBImage;
00215 
00216     /** Integer (3x 32-bit signed) RGB image.
00217         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int32>".
00218         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00219         their const counterparts to access the data.
00220         
00221         <b>\#include</b> <vigra/stdimage.hxx><br>
00222         Namespace: vigra
00223     */
00224 typedef BasicImage<RGBValue<Int32> > IRGBImage;
00225 
00226     /** Integer (3x 32-bit unsigned) RGB image.
00227         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int32>".
00228         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00229         their const counterparts to access the data.
00230         
00231         <b>\#include</b> <vigra/stdimage.hxx><br>
00232         Namespace: vigra
00233     */
00234 typedef BasicImage<RGBValue<UInt32> > UInt32RGBImage;
00235 
00236     /** Integer (3x 32-bit signed) RGB image.
00237         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<vigra::Int32>".
00238         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00239         their const counterparts to access the data.
00240         
00241         <b>\#include</b> <vigra/stdimage.hxx><br>
00242         Namespace: vigra
00243     */
00244 typedef BasicImage<RGBValue<Int32> > Int32RGBImage;
00245 
00246 
00247     /** Floating-point (3x float) RGB image.
00248         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<float>".
00249         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00250         their const counterparts to access the data.
00251         
00252         <b>\#include</b> <vigra/stdimage.hxx><br>
00253         Namespace: vigra
00254     */
00255 typedef BasicImage<RGBValue<float> > FRGBImage;
00256 
00257 
00258     /** Double-precision floating-point (3x double) RGB image.
00259         The pixel type is \ref vigra::RGBValue "vigra::RGBValue<double>".
00260         It uses \ref vigra::BasicImageIterator and \ref vigra::RGBAccessor and 
00261         their const counterparts to access the data.
00262         
00263         <b>\#include</b> <vigra/stdimage.hxx><br>
00264         Namespace: vigra
00265     */
00266 typedef BasicImage<RGBValue<double> > DRGBImage;
00267 
00268     /** Floating-point TinyVector image.
00269         The pixel type is \ref vigra::TinyVector "vigra::TinyVector<float, 2>".
00270         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00271         their const counterparts to access the data.
00272         
00273         <b>\#include</b> <vigra/stdimage.hxx><br>
00274         Namespace: vigra
00275     */
00276 typedef BasicImage<TinyVector<float, 2> > FVector2Image; 
00277 
00278     /** Floating-point TinyVector image.
00279         The pixel type is \ref vigra::TinyVector "vigra::TinyVector<float, 3>".
00280         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00281         their const counterparts to access the data.
00282         
00283         <b>\#include</b> <vigra/stdimage.hxx><br>
00284         Namespace: vigra
00285     */
00286 typedef BasicImage<TinyVector<float, 3> > FVector3Image; 
00287 
00288     /** Floating-point TinyVector image.
00289         The pixel type is \ref vigra::TinyVector "vigra::TinyVector<float, 4>".
00290         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00291         their const counterparts to access the data.
00292         
00293         <b>\#include</b> <vigra/stdimage.hxx><br>
00294         Namespace: vigra
00295     */
00296 typedef BasicImage<TinyVector<float, 4> > FVector4Image; 
00297 
00298     /** Floating-point TinyVector image.
00299         The pixel type is \ref vigra::TinyVector "vigra::TinyVector<double, 2>".
00300         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00301         their const counterparts to access the data.
00302         
00303         <b>\#include</b> <vigra/stdimage.hxx><br>
00304         Namespace: vigra
00305     */
00306 typedef BasicImage<TinyVector<double, 2> > DVector2Image; 
00307 
00308     /** Floating-point TinyVector image.
00309         The pixel type is \ref vigra::TinyVector "vigra::TinyVector<double, 3>".
00310         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00311         their const counterparts to access the data.
00312         
00313         <b>\#include</b> <vigra/stdimage.hxx><br>
00314         Namespace: vigra
00315     */
00316 //typedef BasicImage<TinyVector<double, 3> > DVector3Image; 
00317 typedef BasicImage<TinyVector<double, 3> > DVector3Image; 
00318 
00319     /** Floating-point TinyVector image.
00320         The pixel type is \ref vigra::TinyVector "vigra::TinyVector<double, 4>".
00321         It uses \ref vigra::BasicImageIterator and \ref vigra::VectorAccessor and 
00322         their const counterparts to access the data.
00323         
00324         <b>\#include</b> <vigra/stdimage.hxx><br>
00325         Namespace: vigra
00326     */
00327 typedef BasicImage<TinyVector<double, 4> > DVector4Image; 
00328 
00329 //@}
00330 
00331 } // namespace vigra
00332 
00333 #endif // VIGRA_STDIMAGE_HXX

© 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.9.0 (Tue Nov 6 2012)