ImageToLedsMap.h

#pragma once

// STL includes
#include <cassert>
#include <sstream>

// hyperion-utils includes
#include <utils/Image.h>
#include <utils/Logger.h>

// hyperion includes
#include <hyperion/LedString.h>

namespace hyperion
{

    class ImageToLedsMap
    {
    public:

        ImageToLedsMap(
                const unsigned width,
                const unsigned height,
                const unsigned horizontalBorder,
                const unsigned verticalBorder,
                const std::vector<Led> & leds);

        unsigned width() const;

        unsigned height() const;

        unsigned horizontalBorder() { return _horizontalBorder; };
        unsigned verticalBorder() { return _verticalBorder; };

        template <typename Pixel_T>
        std::vector<ColorRgb> getMeanLedColor(const Image<Pixel_T> & image) const
        {
            std::vector<ColorRgb> colors(_colorsMap.size(), ColorRgb{0,0,0});
            getMeanLedColor(image, colors);
            return colors;
        }

        template <typename Pixel_T>
        void getMeanLedColor(const Image<Pixel_T> & image, std::vector<ColorRgb> & ledColors) const
        {
            // Sanity check for the number of leds
            //assert(_colorsMap.size() == ledColors.size());
            if(_colorsMap.size() != ledColors.size())
            {
                Debug(Logger::getInstance("HYPERION"), "ImageToLedsMap: colorsMap.size != ledColors.size -> %d != %d", _colorsMap.size(), ledColors.size());
                return;
            }

            // Iterate each led and compute the mean
            auto led = ledColors.begin();
            for (auto colors = _colorsMap.begin(); colors != _colorsMap.end(); ++colors, ++led)
            {
                const ColorRgb color = calcMeanColor(image, *colors);
                *led = color;
            }
        }

        template <typename Pixel_T>
        std::vector<ColorRgb> getUniLedColor(const Image<Pixel_T> & image) const
        {
            std::vector<ColorRgb> colors(_colorsMap.size(), ColorRgb{0,0,0});
            getUniLedColor(image, colors);
            return colors;
        }

        template <typename Pixel_T>
        void getUniLedColor(const Image<Pixel_T> & image, std::vector<ColorRgb> & ledColors) const
        {
            // Sanity check for the number of leds
            // assert(_colorsMap.size() == ledColors.size());
            if(_colorsMap.size() != ledColors.size())
            {
                Debug(Logger::getInstance("HYPERION"), "ImageToLedsMap: colorsMap.size != ledColors.size -> %d != %d", _colorsMap.size(), ledColors.size());
                return;
            }


            // calculate uni color
            const ColorRgb color = calcMeanColor(image);
            std::fill(ledColors.begin(),ledColors.end(), color);
        }

    private:
        const unsigned _width;
        const unsigned _height;

        const unsigned _horizontalBorder;

        const unsigned _verticalBorder;

        std::vector<std::vector<unsigned>> _colorsMap;

        template <typename Pixel_T>
        ColorRgb calcMeanColor(const Image<Pixel_T> & image, const std::vector<unsigned> & colors) const
        {
            const auto colorVecSize = colors.size();

            if (colorVecSize == 0)
            {
                return ColorRgb::BLACK;
            }

            // Accumulate the sum of each seperate color channel
            uint_fast16_t cummRed   = 0;
            uint_fast16_t cummGreen = 0;
            uint_fast16_t cummBlue  = 0;
            const auto& imgData = image.memptr();

            for (const unsigned colorOffset : colors)
            {
                const auto& pixel = imgData[colorOffset];
                cummRed   += pixel.red;
                cummGreen += pixel.green;
                cummBlue  += pixel.blue;
            }

            // Compute the average of each color channel
            const uint8_t avgRed   = uint8_t(cummRed/colorVecSize);
            const uint8_t avgGreen = uint8_t(cummGreen/colorVecSize);
            const uint8_t avgBlue  = uint8_t(cummBlue/colorVecSize);

            // Return the computed color
            return {avgRed, avgGreen, avgBlue};
        }

        template <typename Pixel_T>
        ColorRgb calcMeanColor(const Image<Pixel_T> & image) const
        {
            // Accumulate the sum of each seperate color channel
            uint_fast16_t cummRed   = 0;
            uint_fast16_t cummGreen = 0;
            uint_fast16_t cummBlue  = 0;
            const unsigned imageSize = image.width() * image.height();

            const auto& imgData = image.memptr();

            for (unsigned idx=0; idx<imageSize; idx++)
            {
                const auto& pixel = imgData[idx];
                cummRed   += pixel.red;
                cummGreen += pixel.green;
                cummBlue  += pixel.blue;
            }

            // Compute the average of each color channel
            const uint8_t avgRed   = uint8_t(cummRed/imageSize);
            const uint8_t avgGreen = uint8_t(cummGreen/imageSize);
            const uint8_t avgBlue  = uint8_t(cummBlue/imageSize);

            // Return the computed color
            return {avgRed, avgGreen, avgBlue};
        }
    };

} // end namespace hyperion