lib/image.h

#ifndef __IMAGE_H__
#define __IMAGE_H__

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

#include "stm_export.h"


extern "C" {

int32_t STM_EXPORT constrain_reflect(int32_t x, uint32_t extent);
int32_t STM_EXPORT constrain_wrap(int32_t x, uint32_t extent);

}

namespace spectral
{

template <typename T> 
class image
{
public:
    image(uint32_t width, 
          uint32_t height,
          uint32_t channels = 1,
          const T *buf = NULL)
    : m_buffer(NULL)
    , m_width(width)
    , m_height(height)
    , m_channels(channels)
    {
        uint32_t size = width * height * channels;

        if(size)
        {
            m_buffer = new T[size];

            if(buf && m_buffer)
            {
                for(uint32_t i=0;i<size;i++)
                {
                     m_buffer[i] = buf[i];
                }
            } 
        }
    }

    virtual ~image()
    {
        if(m_buffer)
        {
            delete [] m_buffer;
        }
    }

    size_t get_index(uint32_t x, uint32_t y) const
    {
        if((x < m_width) && (y < m_height))
        {
            uint32_t idx = x + (y * m_width);
            return (size_t)(idx * m_channels);
        }
        return (size_t)(-1);
    }

    const T *get_pixel(uint32_t x, uint32_t y) const
    {
        T *result = (T *)NULL;
        size_t index = get_index(x, y);

        if(m_buffer)
        {
            result = &(m_buffer[index]);
        }

        return result;
    }

    const T *get_constrained_pixel(uint32_t x, uint32_t y, 
                                   bool wrap_x = false, 
                                   bool wrap_y = false) const
    {
        int xx = (int)x;
        int yy = (int)y;

        if(wrap_x)
        {
            xx = constrain_wrap(xx, m_width);
        }
        else
        {
            xx = constrain_reflect(xx, m_width);
        }
        if(wrap_y)
        {
            yy = constrain_wrap(yy, m_height);
        }
        else
        {
            yy = constrain_reflect(yy, m_height);
        }

        return get_pixel(xx, yy);
    }

    T*       get_buffer(void) const {return m_buffer;}

    uint32_t get_width(void)  const {return m_width;}

    uint32_t get_height(void) const {return m_height;}

    uint32_t get_channels(void) const {return m_channels;}

    void set_pixel(uint32_t x, uint32_t y, const T *pixel)
    {
        size_t index = get_index(x, y);
        if(pixel && m_buffer && (index < (m_width * m_height * m_channels)))
        {
            for(size_t i=0;i<(size_t)m_channels;i++)
            {
                m_buffer[i + index] = pixel[i];
            }
        }
    }
private:

    T *m_buffer;
    uint32_t m_width, m_height, m_channels;
};

// Floating point image.
class STM_EXPORT Image : public image<float>
{
public:
    Image(uint32_t width, uint32_t height, uint32_t cs, float *buffer = NULL);
    Image(const Image &);
    virtual ~Image();

    uint32_t get_colour_space(void) const;
    
    Image *CreateThumbnail(uint32_t width, uint32_t height) const;

    Image *CreateTile(int32_t x, int32_t y,
                      uint32_t width, uint32_t height,
                      bool wrap_x, bool wrap_y) const;

    Image *Expand(uint32_t x_border, uint32_t y_border, 
                  bool wrap_x, bool wrap_y) const;

    Image *Contract(uint32_t x_border, uint32_t y_border) const;

private:
    uint32_t m_cs;    
};

class STM_EXPORT IntegralHistogram : public image<uint32_t>
{
public:
    IntegralHistogram(uint32_t bins, const Image &img,
                      uint32_t x0, uint32_t y0,
                      uint32_t width, uint32_t height,
                      uint32_t(*pixel_to_bin)(uint32_t, 
                                              uint32_t,
                                              const Image *,
                                              void *),
                      void *data = NULL);

    IntegralHistogram(uint32_t bins, const Image &img, 
                      uint32_t(*pixel_to_bin)(uint32_t, 
                                              uint32_t,
                                              const Image *,
                                              void *),
                      void *data = NULL);

    virtual ~IntegralHistogram();

    void GetHistogram(uint32_t x1, uint32_t y1,
                      uint32_t x2, uint32_t y2,
                      uint32_t *result) const;
protected:

    void
    BuildHistogram(uint32_t bins, const Image &img,
                   uint32_t x0, uint32_t y0,
                   uint32_t width, uint32_t height,
                   uint32_t(*pixel_to_bin)(uint32_t, 
                                           uint32_t,
                                           const Image *,
                                           void *),
                   void *data = NULL);
};

}

#endif

---