HeatmapImage.h

#pragma once

#include "HeatmapShapes.h"
#include "Types.h"
#include "Graphics.h"

#include <vector>

namespace Eegeo
{
    namespace Shapes
    {
        namespace Heatmaps
        {
            class HeatmapImage
            {
            public:
                HeatmapImage();

                HeatmapImage(int width,int height);

                HeatmapImage(const HeatmapImage& other);

                HeatmapImage& operator=(const HeatmapImage& other);

                int GetWidth() const { return m_width; }
                int GetHeight() const { return m_height; }
                const std::vector<float>& GetImageData() const { return m_imageData; }

                inline float GetPixel(int x, int y) const;
                inline void SetPixel(int x, int y, float value);
                inline bool Contains(int x, int y) const;
                void Fill(float value);
                float GetMin() const;
                float GetMax() const;
                void Multiply(float value);
                void MultiplyAdd(float scale, float sum);
                float GetPixelAtIndex(int index) const { return m_imageData[index]; }
                inline int IndexOf(int x, int y) const;
                void SetPixelAtIndex(int index, float value) { m_imageData[index] = value; }
                void SumPixelAtIndex(int index, float value) { m_imageData[index] += value; }

            private:

                int m_width;
                int m_height;
                std::vector<float> m_imageData;
            };

            inline float HeatmapImage::GetPixel(int x, int y) const
            {
                const int index = IndexOf(x, y);
                return m_imageData[index];
            }

            inline void HeatmapImage::SetPixel(int x, int y, float value)
            {
                const int index = IndexOf(x, y);
                m_imageData[index] = value;
            }

            inline bool HeatmapImage::Contains(int x, int y) const
            {
                return x >= 0 && x < m_width && y >= 0 && y < m_height;
            }

            inline int HeatmapImage::IndexOf(int x, int y) const
            {
                if (!Contains(x, y))
                {
                    return -1;
                }
                return (y*m_width) + x;
            }

        }
    }
}