Image.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, 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_ONCE
#define Image_INCUDE_ONCE

#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
  {
    VL_INSTRUMENT_CLASS(vl::Image, Object)

  public:
    virtual ~Image();

    Image();

    Image(void* buffer_ptr, int buffer_bytes);

    Image(const String& file_path);

    Image(int x, int y, int z, int bytealign, EImageFormat format, EImageType type);

    Image(const Image& other);

    Image& operator=(const Image& other);

    bool isCubemap() const { return mIsCubemap; }

    bool isValid() const;

    EImageDimension dimension() const;

    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);

    void reset(int x, int y, int z, int bytealign, EImageFormat format, EImageType type, bool is_cubemap);

    void reset();

    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(); }

    bool hasAlpha() const { return mHasAlpha; }

    void setHasAlpha(bool has_alpha) { mHasAlpha = has_alpha; }

    int alphaBits() const;

    bool isNormalMap() const { return mIsNormalMap; }

    void setIsNormalMap(bool is_normalmap) { mIsNormalMap = is_normalmap; }

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

    KeyValues* tags() { 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 zth_slice);

    unsigned char* pixelsXP();
    unsigned char* pixelsXN();
    unsigned char* pixelsYP();
    unsigned char* pixelsYN();
    unsigned char* pixelsZP();
    unsigned char* pixelsZN();

    const unsigned char* pixelsXP() const;
    const unsigned char* pixelsXN() const;
    const unsigned char* pixelsYP() const;
    const unsigned char* pixelsYN() const;
    const unsigned char* pixelsZP() const;
    const unsigned char* pixelsZN() const;

    void setMipmaps(const std::vector< ref<Image> >& mipmaps) { mMipmaps = mipmaps; };

    const std::vector< ref<Image> >& mipmaps() const { return mMipmaps; };

    std::vector< ref<Image> >& mipmaps() { return mMipmaps; };

    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 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);

    const String& filePath() const { return mFilePath; }

    void setFilePath(const String& path) { mFilePath = path; }

  protected:
    void updatePitch();
    void allocate();

  protected:
    ref<Buffer> mPixels;
    ref<KeyValues> mTags;
    String mFilePath;
    std::vector< ref<Image> > mMipmaps;
    int mWidth;
    int mHeight;
    int mDepth;
    int mPitch;
    int mByteAlign;
    EImageFormat mFormat;
    EImageType mType;
    bool mIsCubemap;
    bool mIsNormalMap;
    bool mHasAlpha;
  };

  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);

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

#endif