CImage.h

Go to the documentation of this file.

//==============================================================================
/*
    Software License Agreement (BSD License)
    Copyright (c) 2003-2016, CHAI3D.
    (www.chai3d.org)

    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.

    * Neither the name of CHAI3D nor the names of its contributors may
    be used to endorse or promote products derived from this software
    without specific prior written permission.

    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 OWNER 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. 

    \author    <http://www.chai3d.org>
    \author    Francois Conti
    \version   3.2.0 $Rev: 2149 $
*/
//==============================================================================

//------------------------------------------------------------------------------
#ifndef CImageH
#define CImageH
//------------------------------------------------------------------------------
#include "graphics/CColor.h"
//------------------------------------------------------------------------------
namespace chai3d {
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================

//------------------------------------------------------------------------------
class cImage;
typedef std::shared_ptr<cImage> cImagePtr;
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================
class cImage
{
    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------

public:

    cImage();

    cImage(const unsigned int a_width,
           const unsigned int a_height,
           const GLenum a_format = GL_RGB,
           const GLenum a_type = GL_UNSIGNED_BYTE);

    virtual ~cImage();

    static cImagePtr create() { return (std::make_shared<cImage>()); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GENERAL COMMANDS:
    //--------------------------------------------------------------------------

public:

    cImagePtr copy();

    bool allocate(const unsigned int a_width,
                  const unsigned int a_height,
                  const GLenum a_format = GL_RGB,
                  const GLenum a_type = GL_UNSIGNED_BYTE);

    void erase() { cleanup(); }

    virtual unsigned int getImageCount() const { return (1); }

    inline bool isInitialized() const { return (m_allocated); }

    void setSize(const unsigned int a_width, const unsigned int a_height);

    inline unsigned int getWidth() const { return (m_width); }

    inline unsigned int getHeight() const { return (m_height); }

    inline GLenum getFormat() const { return (m_format); }

    inline GLenum getType() const { return (m_type); }

    inline unsigned int getBitsPerPixel() const { return (8 * m_bytesPerPixel); }

    inline unsigned int getBytesPerPixel() const { return (m_bytesPerPixel); }

    inline unsigned int getSizeInBytes() const { return (m_bytesPerPixel * m_width * m_height); }

    bool convert(const unsigned int a_newFormat);

    static int queryBytesPerPixel(const GLenum a_format,
        const GLenum a_type);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - MEMORY DATA:
    //--------------------------------------------------------------------------

public:

    cImage* getImage() { return (this); }

    virtual unsigned char* getData() { return (m_data); }

    virtual void setData(unsigned char* a_data,
        const unsigned int a_dataSizeInBytes,
        const bool a_dealloc = false);

    bool setProperties(const unsigned int a_width,
        const unsigned int a_height,
        const GLenum a_format,
        const GLenum a_type);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - MANIPULATING PIXELS:
    //--------------------------------------------------------------------------

public:

    virtual void clear();

    virtual void clear(const cColorb& a_color);

    virtual void clear(const unsigned char a_r,
        const unsigned char a_g,
        const unsigned char a_b,
        const unsigned char a_a = 0xff) { clear(cColorb(a_r, a_g, a_b, a_a)); }

    virtual void clear(const unsigned char a_grayLevel) { clear(cColorb(a_grayLevel, a_grayLevel, a_grayLevel)); }

    virtual void getPixelLocation(const cVector3d& a_texCoord, int& a_pixelX, int& a_pixelY, bool a_clampToImageSize = true) const;

    virtual void getPixelLocationInterpolated(const cVector3d& a_texCoord, double& a_pixelX, double& a_pixelY, bool a_clampToImageSize = true) const;

    virtual bool getPixelColor(const unsigned int a_x,
        const unsigned int a_y,
        cColorb& a_color) const;

    virtual bool getPixelColor(const unsigned int a_x,
        const unsigned int a_y,
        cColorf& a_color) const;

    virtual bool getPixelColorInterpolated(const double a_x,
        const double a_y,
        cColorb& a_color) const;

    virtual bool getPixelColorInterpolated(const double a_x,
        const double a_y,
        cColorf& a_color) const;

    virtual void setPixelColor(const unsigned int a_x,
        const unsigned int a_y, 
        const cColorb& a_color);

    virtual void setPixelColor(const unsigned int a_x,
        const unsigned int a_y,
        const unsigned char a_r,
        const unsigned char a_g,
        const unsigned char a_b) { cColorb color(a_r, a_g, a_b); setPixelColor(a_x, a_y, color); }

    virtual void setPixelColor(const unsigned int a_x,
        const unsigned int a_y,
        const unsigned char a_grayLevel);

    virtual  void setTransparentColor(const cColorb &a_color,
        const unsigned char a_transparencyLevel);

    virtual void setTransparentColor(const unsigned char a_r,
        const unsigned char a_g,
        const unsigned char a_b,
        const unsigned char a_transparencyLevel);

    virtual void setTransparency(const unsigned char a_transparencyLevel);

    virtual void flipHorizontal();


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - MANIPULATING VOXELS:
    //--------------------------------------------------------------------------

public:

    virtual void getVoxelLocation(const cVector3d& a_texCoord, int& a_voxelX, int& a_voxelY, int& a_voxelZ, bool a_clampToImageSize = true) const
    { 
        getPixelLocation(a_texCoord, a_voxelX, a_voxelY, a_clampToImageSize);
        a_voxelZ = 0;
    }

    virtual void getVoxelLocationInterpolated(const cVector3d& a_texCoord, double& a_voxelX, double& a_voxelY, double& a_voxelZ, bool a_clampToImageSize = true) const
    {
        getPixelLocationInterpolated(a_texCoord, a_voxelX, a_voxelY, a_clampToImageSize);
        a_voxelZ = 0.0;
    }

    virtual bool getVoxelColor(const unsigned int a_x,
        const unsigned int a_y,
        const unsigned int a_z,
        cColorb& a_color) const 
    {
        return (getPixelColor(a_x, a_y, a_color));
    }

    virtual bool getVoxelColorInterpolated(const double a_x,
        const double a_y,
        const double a_z,
        cColorb& a_color) const
    {
        return (getPixelColorInterpolated(a_x, a_y, a_color));
    }

    virtual bool getVoxelColorInterpolated(const double a_x,
        const double a_y,
        const double a_z,
        cColorf& a_color) const
    {
        return (getPixelColorInterpolated(a_x, a_y, a_color));
    }

    virtual void setVoxelColor(const unsigned int a_x,
        const unsigned int a_y,
        const unsigned int a_z,
        const cColorb& a_color)
    { 
        setPixelColor(a_x, a_y, a_color);
    }

    virtual void setVoxelColor(const unsigned int a_x,
        const unsigned int a_y,
        const unsigned int a_z,
        const unsigned char a_r,
        const unsigned char a_g,
        const unsigned char a_b)
    { 
        cColorb color(a_r, a_g, a_b);
        setVoxelColor(a_x, a_y, a_z, color);
    }

    virtual void setVoxelColor(const unsigned int a_x,
        const unsigned int a_y,
        const unsigned int a_z,
        const unsigned char a_grayLevel)
    {
        setPixelColor(a_x, a_y, a_grayLevel);
    }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - COPYING DATA:
    //--------------------------------------------------------------------------

public:

    void copyTo(const unsigned int a_sourcePosX,
        const unsigned int a_sourcePosY,
        const unsigned int a_sourceSizeX,
        const unsigned int a_sourceSizeY,
        cImagePtr a_destImage,
        const unsigned int a_destPosX = 0,
        const unsigned int a_destPosY = 0);

    void copyTo(cImagePtr a_destImage,
        const unsigned int a_destPosX = 0,
        const unsigned int a_destPosY = 0);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - MULTIMAGE SELECTION:
    //--------------------------------------------------------------------------

public:

    virtual unsigned long getCurrentIndex() 
    { 
        return (0);
    }

    virtual bool selectImage(unsigned long a_index)
    { 
        if (a_index == 0)
        {
            return(C_SUCCESS);
        }
        else
        {
            return (C_ERROR);
        }
    }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - FILES:
    //--------------------------------------------------------------------------

public:

    virtual bool loadFromFile(const std::string& a_filename);

    virtual bool saveToFile(const std::string& a_filename);

    std::string getFilename() const { return (m_filename); }


    //--------------------------------------------------------------------------
    // PUBLIC MEMBERS:
    //--------------------------------------------------------------------------

public:

    cColorb m_borderColor;


    //--------------------------------------------------------------------------
    // PROTECTED  METHODS:
    //--------------------------------------------------------------------------

protected:

    void defaults();

    void cleanup();


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS:
    //--------------------------------------------------------------------------


protected:

    std::string m_filename;

    unsigned int m_width;

    unsigned int m_height;

    GLenum m_format;

    GLenum m_type;

    unsigned int m_bytesPerPixel;

    unsigned char* m_data;

    unsigned int m_memorySize;

    bool m_allocated;

    bool m_responsibleForMemoryAllocation;
};

//------------------------------------------------------------------------------
} // namespace chai3d
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------