D:/VL/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlCore/Image.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://www.visualizationlibrary.com                                               */
/*                                                                                    */
/*  Copyright (c) 2005-2010, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef Image_INCUDE_DEFINE
#define Image_INCUDE_DEFINE

#include <vlCore/String.hpp>
#include <vlCore/Buffer.hpp>
#include <vlCore/Vector4.hpp>
#include <vlCore/vlnamespace.hpp>
#include <vlCore/Rect.hpp>
#include <vlCore/KeyValues.hpp>
#include <vector>

namespace vl
{
  class VirtualFile;

  //------------------------------------------------------------------------------
  // Image
  //------------------------------------------------------------------------------
  class VLCORE_EXPORT Image: public Object
  {
    Image(const Image& other): Object(other) {}
  public:
    Image();
    Image(const String& path);
    Image(int x, int y, int z, int bytealign, EImageFormat format, EImageType type);
    virtual const char* className() { return "vl::Image"; }
    virtual ~Image();
    Image& operator=(const Image& other);
    bool isCubemap() const { return mIsCubemap; }
    bool isValid() const;
    EImageDimension dimension() const;
    void allocate();
    void allocate1D(int x, EImageFormat format, EImageType type);
    void allocate2D(int x, int y, int bytealign, EImageFormat format, EImageType type);
    void allocate3D(int x, int y, int z, int bytealign, EImageFormat format, EImageType type);
    void allocateCubemap(int x, int y, int bytealign, EImageFormat format, EImageType type);
    // just sets up the image configuration & clears the local storage
    void reset(int x, int y, int z, int bytealign, EImageFormat format, EImageType type, bool is_cubemap);
    void clear();
    int byteAlignment() const;
    void setByteAlignment(int bytealign);
    static int bitsPerPixel(EImageType type, EImageFormat format);
    int bitsPerPixel() const { return bitsPerPixel(type(),format()); }
    int requiredMemory() const;
    static int requiredMemory(int x, int y, int z, int bytealign, EImageFormat format, EImageType type, bool is_cubemap);
    static int requiredMemory1D(int x, EImageFormat format, EImageType type) { return requiredMemory(x, 0, 0, 1, format, type, false); } 
    static int requiredMemory2D(int x, int y, int bytealign, EImageFormat format, EImageType type) { return requiredMemory(x, y, 0, bytealign, format, type, false); } 
    static int requiredMemory3D(int x, int y, int z, int bytealign, EImageFormat format, EImageType type) { return requiredMemory(x, y, z, bytealign, format, type, false); } 
    static int requiredMemoryCubemap(int x, int y, int bytealign, EImageFormat format, EImageType type) { return requiredMemory(x, y, 0, bytealign, format, type, true); } 
    String print() const;
    String printType() const;
    String printFormat() const;

    void setWidth(int x) { mWidth = x; updatePitch(); }
    void setHeight(int y) { mHeight = y; }
    void setDepth(int z) { mDepth = z; }
    void setFormat(EImageFormat format) { mFormat = format; updatePitch(); }
    void setType(EImageType type) { mType=type; updatePitch(); }

    KeyValues* tags() const { return mTags.get(); }

    void setTags(KeyValues* tags) { mTags = tags; }

    void setImageBuffer(Buffer* buffer) { mPixels = buffer; }

    Buffer* imageBuffer() { return mPixels.get(); }

    const Buffer* imageBuffer() const { return mPixels.get(); }

    const unsigned char* pixels() const { if (mPixels->bytesUsed()) return mPixels->ptr(); else return NULL; }
    unsigned char* pixels() { if (mPixels->bytesUsed()) return mPixels->ptr(); else return NULL; }
    bool empty() { return pixels() == NULL; }
    unsigned char* pixelsZSlice(int slice);
    unsigned char* pixelsXP();
    unsigned char* pixelsXN();
    unsigned char* pixelsYP();
    unsigned char* pixelsYN();
    unsigned char* pixelsZP();
    unsigned char* pixelsZN();
    void setMipmaps(const std::vector< ref<Image> >& mipmaps) { mMipmaps = mipmaps; };
    const std::vector< ref<Image> >& mipmaps() const { return mMipmaps; };
    void clearMipmaps() { mMipmaps.clear(); }
    int width() const { return mWidth; }
    int height() const { return mHeight; }
    int depth() const { return mDepth; }
    int pitch() const { return mPitch; }
    EImageFormat format() const { return mFormat; }
    EImageType type() const { return mType; }
    int alphaBits() const;

    int isCompressedFormat(EImageFormat fmt);

    void flipVertically();

    ref<Image> convertType(EImageType new_type) const;

    ref<Image> convertFormat(EImageFormat new_format) const;

    bool equalize();

    bool contrast(float black, float white);

    bool contrastHounsfieldAuto();

    bool contrastHounsfield(float center, float width, float intercept, float range);

    fvec4 sampleLinear(double x) const;

    fvec4 sampleLinear(double x, double y) const;

    fvec4 sampleLinear(double x, double y, double z) const;

    fvec4 sample(int x, int y=0, int z=0) const;

    ref<Image> subImage(int xstart, int ystart, int width, int height);

    void copySubImage(Image* img_src, RectI src, ivec2 dst);

    void substituteColorRGB_RGBA(unsigned int before, unsigned int after);

    void substituteColorRGB_RGB(unsigned int before, unsigned int after);

    void substituteColorGreenKey(unsigned int col0, unsigned int col1);

  protected:
    void updatePitch();

  protected:
    ref<Buffer> mPixels;
    ref<KeyValues> mTags;

    std::vector< ref<Image> > mMipmaps;
    int mWidth;
    int mHeight;
    int mDepth;
    int mPitch;
    int mByteAlign;
    EImageFormat mFormat;
    EImageType mType;
    bool mIsCubemap;
  };

  ref<Image> createCubemap(const Image* xp, const Image* xn, const Image* yp, const Image* yn, const Image* zp, const Image* zn);

  VLCORE_EXPORT ref<Image> loadCubemap(const String& xp_file, const String& xn_file, const String& yp_file, const String& yn_file, const String& zp_file, const String& zn_file);

  VLCORE_EXPORT ref<Image> loadRAW(VirtualFile* file, long long file_offset, int width, int height, int depth, int bytealign, EImageFormat format, EImageType type);

  VLCORE_EXPORT ref<Image> loadImage(VirtualFile* file);

  VLCORE_EXPORT ref<Image> loadImage(const String& path);

  VLCORE_EXPORT bool loadImagesFromDir(const String& dir_path, const String& ext, std::vector< ref<Image> >& images);

  VLCORE_EXPORT ref<Image> assemble3DImage(const std::vector< ref<Image> >& images);

  VLCORE_EXPORT bool saveImage(Image* img, VirtualFile* file);

  VLCORE_EXPORT bool saveImage(Image* img, const String& path);

  VLCORE_EXPORT ref<Image> makeNonUniformColorSpectrum(size_t width, size_t col_count, const fvec4* colors, const float* col_pos);

  VLCORE_EXPORT ref<Image> makeNonUniformColorSpectrum(int width, const std::vector<fvec4>& colors, const std::vector<float>& col_pos);

  VLCORE_EXPORT ref<Image> makeColorSpectrum(size_t width, const std::vector<fvec4>& colors);

  VLCORE_EXPORT ref<Image> makeColorSpectrum(size_t width, const fvec4& c0, const fvec4& c1);

  VLCORE_EXPORT ref<Image> makeColorSpectrum(size_t width, const fvec4& c0, const fvec4& c1, const fvec4& c2);

  VLCORE_EXPORT ref<Image> makeColorSpectrum(size_t width, const fvec4& c0, const fvec4& c1, const fvec4& c2, const fvec4& c3);

  VLCORE_EXPORT ref<Image> makeColorSpectrum(size_t width, const fvec4& c0, const fvec4& c1, const fvec4& c2, const fvec4& c3, const fvec4& c4);
}

#endif