VirtualRenderingSystem: image.h Source File

00001 /******************************************************************************
00002  * VRS - The Virtual Rendering System
00003  * Copyright (C) 2000-2007 Computer Graphics Systems Group at the 
00004  * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
00005  *
00006  * This  library  is  free  software; you can redistribute it and/or  modify it
00007  * under the terms of the GNU Lesser General Public  License  as  published  by
00008  * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
00009  * your option) any later version. This library  is  distributed  in  the  hope
00010  * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
00011  * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
00012  * GNU Lesser General Public License for more details. You should have received
00013  * a copy of the GNU Lesser+ General Public License along with this library; if
00014  * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
00015  * Boston, MA, 02111-1307, USA.
00016  ******************************************************************************/
00017 
00018 // $Id: image.h 6628 2009-01-13 14:08:52Z Manuel_Wellmann $
00019 
00020 #ifndef VRS_IMAGE_IMAGE_H
00021 #define VRS_IMAGE_IMAGE_H
00022 
00023 #include <vrs/area.h>
00024 #include <vrs/color.h>
00025 #include <vrs/sharedobj.h>
00026 
00027 namespace VRS {
00028 
00029 class ImageConvolutionKernel;
00030 template<typename S, typename T> class Callback2;
00031 template<typename T> class Iterator2D;
00032 
00033 //
00034 // supported image pixel data types
00035 //
00036 typedef unsigned char  ImageU8;
00037 typedef unsigned short ImageU16;
00038 typedef unsigned int   ImageU32;
00039 
00040 //
00041 // meta information on pixel data types.
00042 // T must be ImageU8, ImageU16 or ImageU32
00043 //
00044 template<class T>
00045 struct ImageInfoTraits {
00046     typedef T Type;
00047     static int          size()      { return sizeof(T); }
00048     static T            maxT()      { return T(-1); }
00049     static unsigned int maxInt()    { return T(-1); }
00050     static double       maxDouble() { return double(T(-1)); }
00051     static double       normalize() { return 1.0 / double(T(-1)); }
00052 };
00053 
00055 class VRS_CORE_API Image : public SharedObj {
00056 public:
00057 
00058     enum LayerSequence { 
00059         L = 1,      // luminance layer
00060         LA = 2,     // luminance and alpha layer
00061         RGB = 3,    // rgb color image
00062         RGBA = 4,   // rgb color image with alpha layer
00063         R, G, B, A, // single layers
00064         I,          // intensity image
00065         BGR,        // bgr color image
00066         BGRA,       // bgr color image with alpha layer
00067         ABGR,       // bgr color image with alpha layer
00068         INDEX,      // indexed color image
00069         COMPRESSED  // compressed image
00070     };
00071     VRS_SERIALIZABLE_CLASS_ENUM(LayerSequence);
00072 
00073     Image(LayerSequence layerSequence = Image::RGB, int dataType = Image::U8);
00078     bool operator==(const Image& other) const;
00079 
00080     LayerSequence layerSequence() const;
00081     int numberOfLayers() const;
00088     enum Layer { 
00089         Red = 1, 
00090         Green = 2, 
00091         Blue = 4, 
00092         Alpha = 8, 
00093         Luminance = 16,
00094         Intensity = 32, 
00095         Index = 64, 
00096         All = 127 
00097     };
00098     VRS_SERIALIZABLE_CLASS_ENUM(Layer);
00099 
00100     virtual int hasLayers() const; 
00101     virtual bool hasLayers(int layers) const;
00102     virtual int layerNumber(int layer) const;
00103     virtual Layer layerType(int layerIndex) const;
00113     virtual int width()  const = 0;
00114     virtual int height() const = 0;
00115     unsigned int sizeX() const { return width();  }
00116     unsigned int sizeY() const { return height(); }
00118 
00119     virtual void* pixelComponents(int x, int y, int component = 0) const = 0;
00120     ImageU8* pixelComponentsU8(int x, int y, int component = 0) const;
00121     ImageU16* pixelComponentsU16(int x, int y, int component = 0) const;
00122     ImageU32* pixelComponentsU32(int x, int y, int component = 0) const;
00126     virtual void* lineComponents(   int y) const;
00127     ImageU8* lineComponentsU8( int y) const;
00128     ImageU16* lineComponentsU16(int y) const;
00129     ImageU32* lineComponentsU32(int y) const;
00131 
00132     virtual Color getColor(int x, int y) const;
00133     virtual void setColor(int x, int y, const Color& col);
00147     void setRegionOfInterest(const Area& region = Area(0, 0, -1, -1));
00148     Area getRegionOfInterest() const;
00155     void setLayersOfInterest(int layers = Image::All);
00156     void addLayersOfInterest(int layers = Image::All);
00157     void removeLayersOfInterest(int layers = Image::All);
00158     int  getLayersOfInterest() const;
00159     bool areLayersOfInterest(int layers) const;
00165     //
00166     // Per-Pixel Operations
00167     //
00168     virtual void setValue(double value, Image* destImage = 0);
00169     virtual void addValue(double value, Image* destImage = 0);
00170     virtual void subValue(double value, Image* destImage = 0);
00174     virtual void setScaledValue(double normalizedValue, Image* destImage = 0);
00175     virtual void addScaledValue(double normalizedValue, Image* destImage = 0);
00176     virtual void subScaledValue(double normalizedValue, Image* destImage = 0);
00181     virtual void multValue(double value, Image* destImage = 0);
00182     virtual void squareValue(Image* destImage = 0);
00183     virtual void gammaValue(double gamma = 2.2, Image* destImage = 0);
00187     virtual void andValue(double value, Image* destImage = 0);
00188     virtual void orValue(double value, Image* destImage = 0);
00189     virtual void xorValue(double value, Image* destImage = 0);
00190     virtual void notValue(double value, Image* destImage = 0);
00191     virtual void lshiftValue(double shifts, Image* destImage = 0);
00192     virtual void rshiftValue(double shifts, Image* destImage = 0);
00194 
00195     virtual void filter(Callback2<void*, void*>* filterFunction, Image* destImage = 0);
00202     virtual void colorFilter(const Color& refColor, const Color& substColor, double tolerance=0.0,  Image* destImage = 0);
00210     virtual void alphaFilter(const Color& refColor, double alpha, double tolerance=0.0,  Image* destImage = 0);
00219     //
00220     // Image-Region Operations
00221     //
00222     virtual void blur(int  sizeX, int sizeY, Image* destImage = 0);
00223     virtual void mosaic(int sizeX, int sizeY, Image* destImage = 0);
00224     virtual void flip(bool flipX, bool flipY, Image* destImage = 0);
00232     virtual void convolution(const ImageConvolutionKernel* kernel, Image* destImage = 0);
00237     //
00238     // Dyadic Image Operations
00239     // 
00240     virtual void addImage(Image* image2, Image* dest = 0); // not implemented
00241     virtual void subImage(Image* image2, Image* dest = 0); // not implemented
00242     virtual void multImage(Image* image2, Image* dest = 0); // not implemented
00243 
00244     virtual void copy(Image* destImage, bool scale = true, bool ignoreROIandLOI = false);
00245     virtual void copyLayer(int srcLayer, Image* destImage, int destLayer, bool scale = true, bool ignoreROI = false);
00246 
00247     virtual void exchange(Image* destImage, bool scale = true, bool ignoreROIandLOI = false);
00248 
00249     virtual void greyScale(Image* destImage = 0, bool scale = true, bool ignoreROIandLOI = false);
00250 
00251     virtual Image* copyToPow2();
00252         
00254     virtual SO<Iterator<SO<Image> > > createMipmapPyramid();
00255 
00256     //
00257     //Image Layer Conversion
00258     //
00259     void changeLayerSequence(LayerSequence newLayerSequence, bool forceChange = false);
00265     //
00266     // Pixel Data Type 
00267     //
00268     enum DataType { 
00269         U8 = 1,    // unsigned char pixel component
00270         U16 = 2,   // unsigned short pixel component
00271         U32 = 4    // unsigned int pixel component
00272     };
00273     VRS_SERIALIZABLE_CLASS_ENUM(DataType);
00274     int dataType() const;
00280     enum MemoryLayout { Increasing = +1, Decreasing = -1 };
00281     VRS_SERIALIZABLE_CLASS_ENUM(MemoryLayout);
00282     virtual MemoryLayout memoryLayout() const;
00287     virtual int alignment() const;
00291     virtual int padding() const;
00293 
00294     virtual int bitsPerPixel() const;
00296 
00297     Iterator2D<Color>* newIterator2D() const;
00300     Iterator2D<float>* newIterator2D(int layer, bool normalize = true, float scale = 1.0, float bias = 0.0) const;
00310 
00311 
00312     virtual SO<Image> uncompressed(bool storeReference = false) const;
00313 
00314     VRS_SERIALIZABLE_ABSTRACT_CLASS(Image);
00315     
00316     VRS_TYPEINFO(Image, SharedObj);
00317 
00318 private:
00319     int layerSequence_;
00320     int numberOfLayers_;
00321     int actualLayers_;
00322     int layerNo_[8];
00323     int dataType_;
00324     int memoryLayout_;
00325     mutable int alignment_;
00326     mutable int padding_;
00327 
00328     Area roi_;
00329     int loi_;
00330 }; // class Image
00331 
00332 class VRS_CORE_API DecoratedImage : public Image {
00333 public:
00334     DecoratedImage(LayerSequence layerSequence = Image::RGB, int dataType = Image::U8);
00335 
00336     virtual Image* master() const = 0;
00338 
00339     virtual Image::MemoryLayout memoryLayout() const;
00340     virtual int alignment() const;
00341     virtual int padding() const;
00342     virtual int bitsPerPixel() const;
00344 
00345     virtual const TransactionNo& lastTransactionNo() const;
00347 
00350     static SO<Image> GetUndecoratedImage(SO<Image> image);
00351 
00352     VRS_TYPEINFO(DecoratedImage, Image);
00353 
00354 }; // class DecoratedImage
00355 
00356 } // namespace VRS
00357 
00358 #endif // VRS_IMAGE_IMAGE_H