Image.h

Go to the documentation of this file.

/*
--------------------------------------------------------------------------------
This source file is part of Hydrax.
Visit ---
 
Copyright (C) 2008 Xavier Vergu�n Gonz�lez <xavierverguin@hotmail.com>
                                           <xavyiy@gmail.com>
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
--------------------------------------------------------------------------------
*/
 
#ifndef _Hydrax_Image_H_
#define _Hydrax_Image_H_
 
#include "Prerequisites.h"
 
#include "Help.h"
 
 
 
namespace Hydrax
{
    class Image
    {
    public:
        enum Type
        {
            TYPE_ONE_CHANNEL  = 1,
            TYPE_TWO_CHANNELS = 2,
            TYPE_RGB          = 3,
            TYPE_RGBA         = 4
        };
        enum Type {…};
 
        enum Channel
        {
            CHANNEL_R = 0, // Red
            CHANNEL_G = 1, // Green
            CHANNEL_B = 2, // Blue
            CHANNEL_A = 3  // Alpha
        };
        enum Channel {…};
 
        struct Pixel
        {
            Pixel()
                : red(0)
                , green(0)
                , blue(0)
                , alpha(0)
            {
            }
            Pixel() {…}
 
            Pixel(const float &v)
                : red(v)
                , green(v)
                , blue(v)
                , alpha(v)
            {
            }
            Pixel(const float &v) {…}
 
            Pixel(const float &r,
                  const float &g,
                  const float &b)
                : red(r)
                , green(g)
                , blue(b)
                , alpha(0)
            {
            }
            Pixel(const float &r, {…}
 
            Pixel(const float &r,
                  const float &g,
                  const float &b,
                  const float &a)
                : red(r)
                , green(g)
                , blue(b)
                , alpha(a)
            {
            }
            Pixel(const float &r, {…}
 
            float red,
                  green,
                  blue,
                  alpha;
        };
        struct Pixel {…};
 
        Image(const Size &Size);
 
        Image(const Size &Size, const Type &Type);
 
        Image(const Size &Size, const Type &Type, const float &v);
 
        ~Image();
 
        const float& getValue(const int &x, const int &y, const int &c) const;
 
        float getValueLI(const float &x, const float &y, const int &c) const;
 
        inline const float& getValue(const int &x, const int &y, const Channel &c) const
        {
            return getValue(x, y, static_cast<int>(c));
        }
        inline const float& getValue(const int &x, const int &y, const Channel &c) const {…}
 
        inline float getValueLI(const float &x, const float &y, const Channel &c) const
        {
            return getValueLI(x, y, static_cast<int>(c));
        }
        inline float getValueLI(const float &x, const float &y, const Channel &c) const {…}
 
        Pixel getPixel(const int &x, const int &y) const;
 
        Pixel getPixelLI(const float &x, const float &y) const;
 
        void setValue(const int &x, const int &y, const int &c, const float &v);
 
        inline void setValue(const int &x, const int &y, const Channel &c, const float &v)
        {
            setValue(x, y, static_cast<int>(c), v);
        }
        inline void setValue(const int &x, const int &y, const Channel &c, const float &v) {…}
 
        void setPixel(const int &x, const int &y, const Pixel &p);
 
        inline Size getSize() const
        {
            return Size(mSize.Width-1,mSize.Height-1);
        }
        inline Size getSize() const {…}
 
        inline Type getType() const
        {
            return static_cast<Type>(mChannels);
        }
        inline Type getType() const {…}
 
        inline const int& getNumberOfChannels() const
        {
            return mChannels;
        }
        inline const int& getNumberOfChannels() const {…}
 
    private:
        void _Initialize(const float &v);
 
        Size mSize;
        int mChannels;
 
        float *mData;
    };
    class Image {…};
}
 
 
#endif