peak_icv_threshold.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/detail/peak_common_type_traits.hpp>
#include <peak_common/types/peak_common_interval.hpp>
#include <peak_icv/exceptions/detail/peak_icv_exception_helpers.hpp>
#include <peak_icv/types/peak_icv_image.hpp>
#include <peak_icv/types/peak_icv_region.hpp>
#include <peak_icv/utils/peak_icv_defines.hpp>
#include <peak_icv_c/algorithms/thresholds/peak_icv_threshold.h>
 
namespace peak
{
namespace icv
{
namespace detail
{
template <typename IntervalType>
class Threshold
{
public:
    static_assert(is_threshold_interval_v<IntervalType>, "Template argument of Threshold must be an Interval.");
 
    explicit Threshold(const IntervalType& interval);
 
    explicit Threshold(typename IntervalType::type minimum, typename IntervalType::type maximum);
 
    PEAK_ICV_NO_DISCARD peak::icv::experimental::Region Process(const Image& image) const;
 
    static IntervalType GetRange(const Image& image);
 
private:
    IntervalType m_interval;
};
 
} // namespace detail
 
namespace experimental
{
using Threshold = detail::Threshold<peak::common::Interval>;
 
using ThresholdF = detail::Threshold<peak::common::IntervalF>;
 
} /* namespace experimental */
 
namespace detail
{
template <typename IntervalType>
Threshold<IntervalType>::Threshold(const IntervalType& interval)
    : m_interval(interval)
{}
 
template <typename IntervalType>
Threshold<IntervalType>::Threshold(typename IntervalType::type minimum, typename IntervalType::type maximum)
    : m_interval(minimum, maximum)
{}
 
template <typename IntervalType>
peak::icv::experimental::Region Threshold<IntervalType>::Process(const Image& image) const
{
    auto* const inputImageHandle = peak::common::detail::BackendAccessor<Image>::BackendHandle(image);
 
    peak::icv::experimental::Region region;
    ExecuteAndMapReturnCodes([&] {
        peak::common::detail::c_type_of_t<IntervalType> interval{ m_interval.GetMinimum(), m_interval.GetMaximum() };
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Threshold_Process(inputImageHandle, &interval, sizeof(interval),
            peak::common::detail::BackendAccessor<peak::icv::experimental::Region>::BackendHandleAddress(region));
    });
 
    return region;
}
 
template <typename IntervalType>
IntervalType Threshold<IntervalType>::GetRange(const Image& image)
{
    peak::common::detail::c_type_of_t<IntervalType> interval{};
    ExecuteAndMapReturnCodes([&] {
        auto* const handle = peak::common::detail::BackendAccessor<Image>::BackendHandle(image);
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Threshold_GetRange(handle, &interval, sizeof(interval));
    });
    return { interval.minimum, interval.maximum };
}
} // namespace detail
 
} /* namespace icv */
} /* namespace peak */