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;
    unsigned m_width;
    unsigned m_height;
 
public:
    Image( ) : m_pixels(), m_width(0), m_height(0) {}
    Image( const unsigned w, const unsigned 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 float *data( ) const
    {
        assert(!m_pixels.empty());
        return (const float *) m_pixels.data();
    }
    
    float *data( )
    {
        assert(!m_pixels.empty());
        return (float *) m_pixels.data();
    }
    
    unsigned width( ) const { return m_width; }
    unsigned height( ) const { return m_height; }
    unsigned size( ) const { return m_width * m_height; }
    
    unsigned offset( const int x, const int y ) const
    {
        unsigned px= (x < 0) ? 0 : unsigned(x);
        if(px >= m_width) px= m_width -1;
        
        unsigned py= (y < 0) ? 0 : unsigned(y);
        if(py >= m_height) py= m_height -1;
        
        unsigned p= py * m_width + px;
        assert(p < m_pixels.size());
        return p;
    }
};

#endif