ImageProcessor.h

#pragma once

#include <QString>

// Utils includes
#include <utils/Image.h>

// Hyperion includes
#include <hyperion/LedString.h>
#include <hyperion/ImageToLedsMap.h>
#include <utils/Logger.h>

// settings
#include <utils/settings.h>

// Black border includes
#include <blackborder/BlackBorderProcessor.h>

class Hyperion;

class ImageProcessor : public QObject
{
    Q_OBJECT

public:
    ImageProcessor(const LedString& ledString, Hyperion* hyperion);

    ~ImageProcessor();

    void setSize(const unsigned width, const unsigned height);

    void setLedString(const LedString& ledString);

    bool blackBorderDetectorEnabled();

    const int & getUserLedMappingType() { return _userMappingType; };

    const int & ledMappingType() { return _mappingType; };

    static int mappingTypeToInt(QString mappingType);
    static QString mappingTypeToStr(int mappingType);

    void setHardLedMappingType(int mapType);

public slots:
    void setBlackbarDetectDisable(bool enable);

    void setLedMappingType(int mapType);

public:
    template <typename Pixel_T>
    void setSize(const Image<Pixel_T> &image)
    {
        setSize(image.width(), image.height());
    }

    template <typename Pixel_T>
    std::vector<ColorRgb> process(const Image<Pixel_T>& image)
    {
        std::vector<ColorRgb> colors;
        if (image.width()>0 && image.height()>0)
        {
            // Ensure that the buffer-image is the proper size
            setSize(image);

            // Check black border detection
            verifyBorder(image);

            // Create a result vector and call the 'in place' functionl
            switch (_mappingType)
            {
                case 1: colors = _imageToLeds->getUniLedColor(image); break;
                default: colors = _imageToLeds->getMeanLedColor(image);
            }
        }
        else
        {
            Warning(_log, "ImageProcessor::process called with image size 0");
        }

        // return the computed colors
        return colors;
    }

    template <typename Pixel_T>
    void process(const Image<Pixel_T>& image, std::vector<ColorRgb>& ledColors)
    {
        if ( image.width()>0 && image.height()>0)
        {
            // Ensure that the buffer-image is the proper size
            setSize(image);

            // Check black border detection
            verifyBorder(image);

            // Determine the mean or uni colors of each led (using the existing mapping)
            switch (_mappingType)
            {
                case 1: _imageToLeds->getUniLedColor(image, ledColors); break;
                default: _imageToLeds->getMeanLedColor(image, ledColors);
            }
        }
        else
        {
            Warning(_log, "Called with image size 0");
        }
    }

    bool getScanParameters(size_t led, double & hscanBegin, double & hscanEnd, double & vscanBegin, double & vscanEnd) const;

private:
    template <typename Pixel_T>
    void verifyBorder(const Image<Pixel_T> & image)
    {
        if (!_borderProcessor->enabled() && ( _imageToLeds->horizontalBorder()!=0 || _imageToLeds->verticalBorder()!=0 ))
        {
            Debug(_log, "Reset border");
            _borderProcessor->process(image);
            delete _imageToLeds;
            _imageToLeds = new hyperion::ImageToLedsMap(image.width(), image.height(), 0, 0, _ledString.leds());
        }

        if(_borderProcessor->enabled() && _borderProcessor->process(image))
        {
            const hyperion::BlackBorder border = _borderProcessor->getCurrentBorder();

            // Clean up the old mapping
            delete _imageToLeds;

            if (border.unknown)
            {
                // Construct a new buffer and mapping
                _imageToLeds = new hyperion::ImageToLedsMap(image.width(), image.height(), 0, 0, _ledString.leds());
            }
            else
            {
                // Construct a new buffer and mapping
                _imageToLeds = new hyperion::ImageToLedsMap(image.width(), image.height(), border.horizontalSize, border.verticalSize, _ledString.leds());
            }

            //Debug(Logger::getInstance("BLACKBORDER"),  "CURRENT BORDER TYPE: unknown=%d hor.size=%d vert.size=%d",
            //  border.unknown, border.horizontalSize, border.verticalSize );
        }
    }

private slots:
    void handleSettingsUpdate(const settings::type& type, const QJsonDocument& config);

private:
    Logger * _log;
    LedString _ledString;

    hyperion::BlackBorderProcessor * _borderProcessor;

    hyperion::ImageToLedsMap* _imageToLeds;

    int _mappingType;
    int _userMappingType;
    int _hardMappingType;

    Hyperion* _hyperion;
};