BorderDetector.h

Go to the documentation of this file.

#pragma once

#include <math.h>
#include <stdint.h>

namespace nxpcup {

class BorderDetector {
public:
    using ImageType = Camera::ImageType;

    struct Config {
        static constexpr int dataSize = Camera::ImageSize;
        static constexpr int CENTER = dataSize / 2;
        static constexpr int RIGHT_BORDER = dataSize;
        static constexpr int NEIGHBORHOOD = 6;

        static_assert(NEIGHBORHOOD >= 0);
    };

    BorderDetector(Config config)
    {
    }

    void initalize(
        const std::array<ImageType, Config::dataSize>& data,
        const uint8_t percentCoefficient = 100)
    {
        uint16_t maxValue = findMaxValue(data);
        m_threshold = (maxValue * percentCoefficient) / 100;
    }

    int findBorder(const std::array<ImageType, Config::dataSize>& data)
    {
        int16_t previousLeftBorder = m_leftBorder;
        int16_t previousRightBorder = m_rightBorder;
        int16_t middle = (previousRightBorder + previousLeftBorder) / 2;
        m_leftBorder = 0;
        m_rightBorder = Config::RIGHT_BORDER;

        bool findPreviousLeft = isBorderAroundPreviousIndex(data, previousLeftBorder, m_leftBorder);
        bool findPreviousRight = isBorderAroundPreviousIndex(data, previousRightBorder, m_rightBorder);

        if (findPreviousLeft && findPreviousRight) {
            return 1;
        }

        if (!findPreviousLeft) {
            int16_t leftMaxBorderIndex = std::max_element(data.begin(), data.begin() + middle) - data.begin();
            if (data[leftMaxBorderIndex] > m_threshold) {
                m_leftBorder = leftMaxBorderIndex;
            }
        }

        if (!findPreviousRight) {
            int16_t rightMaxBorderIndex = std::max_element(data.begin() + middle, data.end()) - data.begin();
            if (data[rightMaxBorderIndex] > m_threshold) {
                m_rightBorder = rightMaxBorderIndex;
            }
        }

        return 0;
    }

    int leftDistanceFromCenter() const
    {
        return m_distanceCenter - m_leftBorder;
    }

    int rightDistanceFromCenter() const
    {
        return m_rightBorder - m_distanceCenter;
    }

    int error(const int percentCoefficient = 100) const
    {
        int rawError = (rightDistanceFromCenter() - leftDistanceFromCenter()) / 2;

        rawError = (rawError * percentCoefficient) / 100;

        return rawError;
    }

    int leftBorder() const
    {
        return m_leftBorder;
    }

    int rightBorder() const
    {
        return m_rightBorder;
    }

private:
    int findMaxValue(
        const std::array<ImageType, Config::dataSize>& data,
        const uint8_t offset = 5) const
    {
        int at = 0;
        for (int i = offset; i < (Config::RIGHT_BORDER - offset); i++) {
            if (data[i] > data[at]) {
                at = i;
            }
        }
        return data[at];
    }


    bool isBorderAroundPreviousIndex(
        const std::array<ImageType, Config::dataSize>& data,
        const int previousBorder,
        int& border)
    {
        bool find = false;
        uint16_t maxValue = m_threshold;
        int index = nxpcup::clamp<int>(previousBorder - Config::NEIGHBORHOOD, 0, Config::dataSize - 1);
        int indexMax = nxpcup::clamp<int>(previousBorder + Config::NEIGHBORHOOD, 0, Config::dataSize - 1);
        for (; index <= indexMax; ++index) {
            if (data[index] > maxValue) {
                maxValue = data[index];
                border = index;
                find = true;
            }
        }
        return find;
    }

    int m_leftBorder = 0;
    int m_rightBorder = Config::RIGHT_BORDER;
    int m_endflag = 0;

    int m_distanceCenter = Config::CENTER;
    uint16_t m_threshold = 0;
};

} // namespace nxpcup