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

vigra/stdimage.hxx |

    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)