peak_icv_binning_feature.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/types/peak_common_interval.hpp>
#include <peak_icv/pipeline/detail/peak_icv_downsampling_module.hpp>
#include <peak_icv/pipeline/features/peak_icv_ifeature.hpp>
#include <peak_icv/pipeline/types/peak_icv_binning_mode.hpp>
 
namespace peak
{
namespace pipeline
{
namespace features
{
 
class BinningFeature : public IFeature
{
public:
    explicit BinningFeature(detail::DownsamplingModule& module);
 
    void SetEnabled(bool enabled) override;
 
    PEAK_COMMON_NO_DISCARD bool IsEnabled() const override;
 
    void ResetToDefault() override;
 
    void SetX(uint32_t x);
 
    void SetY(uint32_t y);
 
    PEAK_COMMON_NO_DISCARD uint32_t GetX() const;
 
    PEAK_COMMON_NO_DISCARD uint32_t GetY() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::IntervalU GetRange() const;
 
    void SetMode(const BinningMode& mode);
 
    PEAK_COMMON_NO_DISCARD BinningMode GetMode() const;
 
private:
    detail::DownsamplingModule& m_module;
};
 
inline BinningFeature::BinningFeature(detail::DownsamplingModule& module)
    : m_module(module)
{}
 
inline void BinningFeature::SetEnabled(bool enabled)
{
    m_module.SetEnabled(enabled);
}
 
inline bool BinningFeature::IsEnabled() const
{
    return m_module.IsEnabled();
}
 
inline void BinningFeature::ResetToDefault()
{
    m_module.ResetToDefault();
}
 
inline void BinningFeature::SetX(uint32_t x)
{
    try
    {
        m_module.SetX(x);
    }
    catch (const peak::icv::OutOfRangeException&)
    {
        const auto range = m_module.GetRange();
        throw peak::icv::OutOfRangeException("The specified binning factor " + std::to_string(x)
            + " is incorrect; the expected value must be between " + std::to_string(range.GetMinimum()) + " and "
            + std::to_string(range.GetMaximum()) + ".");
    }
}
 
inline void BinningFeature::SetY(uint32_t y)
{
    try
    {
        m_module.SetY(y);
    }
    catch (const peak::icv::OutOfRangeException&)
    {
        const auto range = m_module.GetRange();
        throw peak::icv::OutOfRangeException("The specified binning factor " + std::to_string(y)
            + " is incorrect; the expected value must be between " + std::to_string(range.GetMinimum()) + " and "
            + std::to_string(range.GetMaximum()) + ".");
    }
}
 
inline uint32_t BinningFeature::GetX() const
{
    return m_module.GetX();
}
 
inline uint32_t BinningFeature::GetY() const
{
    return m_module.GetY();
}
 
inline peak::common::IntervalU BinningFeature::GetRange() const
{
    return m_module.GetRange();
}
 
inline void BinningFeature::SetMode(const BinningMode& mode)
{
    if (mode != BinningMode::Sum && mode != BinningMode::Average)
    {
        throw peak::icv::NotSupportedException("The binning mode is not supported");
    }
    try
    {
        m_module.SetMode(static_cast<detail::DownsamplingMode>(mode));
    }
    catch (const peak::icv::NotSupportedException&)
    {
        throw peak::icv::NotSupportedException("The binning mode is not supported");
    }
}
 
inline BinningMode BinningFeature::GetMode() const
{
    return static_cast<BinningMode>(m_module.GetMode());
}
 
} // namespace features
} // namespace pipeline 
} // namespace peak