image.h

Go to the documentation of this file.

 
#ifndef _IMAGE_H
#define _IMAGE_H
 
#include <cmath>
#include <cassert>
#include <vector>
#include <algorithm>
 
#include "color.h"
 
 
 
 
class Image
{
protected:
    std::vector<Color> m_pixels;
    int m_width;
    int m_height;
 
public:
    Image( ) : m_pixels(), m_width(0), m_height(0) {}
    Image( const int w, const int h, const Color& color= Black() ) : m_pixels(w*h, color), m_width(w), m_height(h) {}
    
    Color& operator() ( const int x, const int y )
    {
        return m_pixels[offset(x, y)];
    }
    
    Color operator() ( const int x, const int y ) const
    {
        return m_pixels[offset(x, y)];
    }
    
    Color& operator() ( const unsigned offset )
    {
        assert(offset < m_pixels.size());
        return m_pixels[offset];
    }
    
    Color operator() ( const unsigned offset ) const
    {
        assert(offset < m_pixels.size());
        return m_pixels[offset];
    }
    
    Color sample( const float x, const float y ) const
    {
        // interpolation bilineaire 
        float u= x - std::floor(x);
        float v= y - std::floor(y);
        int ix= x;
        int iy= y;
        return (*this)(ix, iy)    * ((1 - u) * (1 - v))
            + (*this)(ix+1, iy)   * (u       * (1 - v))
            + (*this)(ix, iy+1)   * ((1 - u) * v)
            + (*this)(ix+1, iy+1) * (u       * v);
    }
    
    Color texture( const float x, const float y ) const
    {
        return sample(x * m_width, y * m_height);
    }
    
    const void *data( ) const
    {
        assert(!m_pixels.empty());
        return &m_pixels.front();
    }
    
    void *data( )
    {
        assert(!m_pixels.empty());
        return &m_pixels.front();
    }
    
    int width( ) const { return m_width; }
    int height( ) const { return m_height; }
    unsigned size( ) const { return m_width * m_height; }
    
    unsigned offset( const int x, const int y ) const
    {
        int px= x;
        if(px < 0) px= 0;
        if(px > m_width-1) px= m_width-1;
        int py= y;
        if(py < 0) py= 0;
        if(py > m_height-1) py= m_height-1;
        
        assert(py * m_width + px < int(m_pixels.size()));
        return py * m_width + px;
    }
    
    static Image& error( )
    {
        static Image image;
        return image;
    }
    
    bool operator== ( const Image& im ) const
    {
        // renvoie vrai si im ou l'objet est la sentinelle
        return (this == &im);
    }
};
 
#endif