BlackBorderDetector.h

//#include <iostream>
#pragma once

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

namespace hyperion
{
    struct BlackBorder
    {
        bool unknown;

        int horizontalSize;

        int verticalSize;

        inline bool operator== (const BlackBorder& other) const
        {
            if (unknown)
            {
                return other.unknown;
            }

            return other.unknown==false && horizontalSize==other.horizontalSize && verticalSize==other.verticalSize;
        }
    };

    class BlackBorderDetector
    {
    public:
        BlackBorderDetector(double threshold);


        uint8_t calculateThreshold(double blackborderThreshold);

        template <typename Pixel_T>
        BlackBorder process(const Image<Pixel_T> & image)
        {
            // test center and 33%, 66% of width/heigth
            // 33 and 66 will check left and top
            // center will check right and bottom sids
            int width = image.width();
            int height = image.height();
            int width33percent = width / 3;
            int height33percent = height / 3;
            int width66percent = width33percent * 2;
            int height66percent = height33percent * 2;
            int xCenter = width / 2;
            int yCenter = height / 2;


            int firstNonBlackXPixelIndex = -1;
            int firstNonBlackYPixelIndex = -1;

            width--; // remove 1 pixel to get end pixel index
            height--;

            // find first X pixel of the image
            for (int x = 0; x < width33percent; ++x)
            {
                if (!isBlack(image((width - x), yCenter))
                    || !isBlack(image(x, height33percent))
                    || !isBlack(image(x, height66percent)))
                {
                    firstNonBlackXPixelIndex = x;
                    break;
                }
            }

            // find first Y pixel of the image
            for (int y = 0; y < height33percent; ++y)
            {
                if (!isBlack(image(xCenter, (height - y)))
                    || !isBlack(image(width33percent, y)) 
                    || !isBlack(image(width66percent, y)))
                {
                    firstNonBlackYPixelIndex = y;
                    break;
                }
            }

            // Construct result
            BlackBorder detectedBorder;
            detectedBorder.unknown = firstNonBlackXPixelIndex == -1 || firstNonBlackYPixelIndex == -1;
            detectedBorder.horizontalSize = firstNonBlackYPixelIndex;
            detectedBorder.verticalSize = firstNonBlackXPixelIndex;
            return detectedBorder;
        }


        template <typename Pixel_T>
        BlackBorder process_classic(const Image<Pixel_T> & image)
        {
            // only test the topleft third of the image
            int width = image.width() /3;
            int height = image.height() / 3;
            int maxSize = std::max(width, height);

            int firstNonBlackXPixelIndex = -1;
            int firstNonBlackYPixelIndex = -1;

            // find some pixel of the image
            for (int i = 0; i < maxSize; ++i)
            {
                int x = std::min(i, width);
                int y = std::min(i, height);

                const Pixel_T & color = image(x, y);
                if (!isBlack(color))
                {
                    firstNonBlackXPixelIndex = x;
                    firstNonBlackYPixelIndex = y;
                    break;
                }
            }

            // expand image to the left
            for(; firstNonBlackXPixelIndex > 0; --firstNonBlackXPixelIndex)
            {
                const Pixel_T & color = image(firstNonBlackXPixelIndex-1, firstNonBlackYPixelIndex);
                if (isBlack(color))
                {
                    break;
                }
            }

            // expand image to the top
            for(; firstNonBlackYPixelIndex > 0; --firstNonBlackYPixelIndex)
            {
                const Pixel_T & color = image(firstNonBlackXPixelIndex, firstNonBlackYPixelIndex-1);
                if (isBlack(color))
                {
                    break;
                }
            }

            // Construct result
            BlackBorder detectedBorder;
            detectedBorder.unknown = firstNonBlackXPixelIndex == -1 || firstNonBlackYPixelIndex == -1;
            detectedBorder.horizontalSize = firstNonBlackYPixelIndex;
            detectedBorder.verticalSize = firstNonBlackXPixelIndex;
            return detectedBorder;
        }


        template <typename Pixel_T>
        BlackBorder process_osd(const Image<Pixel_T> & image)
        {
            // find X position at height33 and height66 we check from the left side, Ycenter will check from right side
            // then we try to find a pixel at this X position from top and bottom and right side from top
            int width = image.width();
            int height = image.height();
            int width33percent = width / 3;
            int height33percent = height / 3;
            int height66percent = height33percent * 2;
            int yCenter = height / 2;


            int firstNonBlackXPixelIndex = -1;
            int firstNonBlackYPixelIndex = -1;

            width--; // remove 1 pixel to get end pixel index
            height--;

            // find first X pixel of the image
            int x;
            for (x = 0; x < width33percent; ++x)
            {
                if (!isBlack(image((width - x), yCenter)) 
                    || !isBlack(image(x, height33percent))
                    || !isBlack(image(x, height66percent)))
                {
                    firstNonBlackXPixelIndex = x;
                    break;
                }
            }

            // find first Y pixel of the image
            for (int y = 0; y < height33percent; ++y)
            {
                // left side top + left side bottom + right side top  +  right side bottom
                if (!isBlack(image(x, y)) 
                    || !isBlack(image(x, (height - y)))
                    || !isBlack(image((width - x), y)) 
                    || !isBlack(image((width - x), (height - y))))
                {
//                  std::cout << "y " << y << " lt " << int(isBlack(color1)) << " lb " << int(isBlack(color2)) << " rt " << int(isBlack(color3)) << " rb " << int(isBlack(color4)) << std::endl;
                    firstNonBlackYPixelIndex = y;
                    break;
                }
            }

            // Construct result
            BlackBorder detectedBorder;
            detectedBorder.unknown = firstNonBlackXPixelIndex == -1 || firstNonBlackYPixelIndex == -1;
            detectedBorder.horizontalSize = firstNonBlackYPixelIndex;
            detectedBorder.verticalSize = firstNonBlackXPixelIndex;
            return detectedBorder;
        }



    private:

        template <typename Pixel_T>
        inline bool isBlack(const Pixel_T & color)
        {
            // Return the simple compare of the color against black
            return color.red < _blackborderThreshold && color.green < _blackborderThreshold && color.blue < _blackborderThreshold;
        }

    private:
        const uint8_t _blackborderThreshold;

    };
} // end namespace hyperion