peak_icv_region_selector.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/types/geometry/peak_common_rectangle.hpp>
#include <peak_common/types/peak_common_interval.hpp>
#include <peak_icv/selectors/detail/peak_icv__region_selector_c_helper.hpp>
#include <peak_icv/types/peak_icv_region.hpp>
#include <peak_icv_c/selectors/peak_icv_region_selector.h>
 
#include <functional>
 
namespace peak
{
namespace icv
{
class RegionSelector
{
public:
    explicit RegionSelector(const std::vector<Region>& regions);
 
    std::vector<Region> GetRegions();
 
    RegionSelector SelectByArea(const peak::common::IntervalU& interval);
 
    RegionSelector SelectByCenterOfGravityX(const peak::common::IntervalF& interval);
 
    RegionSelector SelectByCenterOfGravityY(const peak::common::IntervalF& interval);
 
    RegionSelector SelectByCenterOfGravityRect(const peak::common::RectangleF& rect);
 
protected:
    RegionSelector() = default;
 
private:
    template <typename T>
    RegionSelector SelectBy(const detail::select_by_get_count_function_t<peak::common::detail::c_type_of_t<T>>& selectByGetCount,
        const detail::select_by_function_t<peak::common::detail::c_type_of_t<T>>& selectBy, const T& interval);
 
    std::vector<Region> m_regions;
};
 
inline RegionSelector::RegionSelector(const std::vector<Region>& regions)
    : m_regions{ regions }
{}
 
inline std::vector<Region> RegionSelector::GetRegions()
{
    return m_regions;
}
 
inline RegionSelector RegionSelector::SelectByArea(const peak::common::IntervalU& interval)
{
    return SelectBy<peak::common::IntervalU>(
        PEAK_ICV_C_ABI_PREFIX peak_icv_Region_SelectByArea_GetCount, PEAK_ICV_C_ABI_PREFIX peak_icv_Region_SelectByArea, interval);
}
 
inline RegionSelector RegionSelector::SelectByCenterOfGravityX(const peak::common::IntervalF& interval)
{
    return SelectBy<peak::common::IntervalF>(PEAK_ICV_C_ABI_PREFIX peak_icv_Region_SelectByCenterOfGravityX_GetCount,
        PEAK_ICV_C_ABI_PREFIX peak_icv_Region_SelectByCenterOfGravityX, interval);
}
 
inline RegionSelector RegionSelector::SelectByCenterOfGravityY(const peak::common::IntervalF& interval)
{
    return SelectBy<peak::common::IntervalF>(PEAK_ICV_C_ABI_PREFIX peak_icv_Region_SelectByCenterOfGravityY_GetCount,
        PEAK_ICV_C_ABI_PREFIX peak_icv_Region_SelectByCenterOfGravityY, interval);
}
 
inline RegionSelector RegionSelector::SelectByCenterOfGravityRect(const peak::common::RectangleF& rect)
{
    return SelectBy<peak::common::RectangleF>(PEAK_ICV_C_ABI_PREFIX peak_icv_Region_SelectByCenterOfGravityRect_GetCount,
        PEAK_ICV_C_ABI_PREFIX peak_icv_Region_SelectByCenterOfGravityRect, rect);
}
 
template <typename T>
RegionSelector RegionSelector::SelectBy(
    const detail::select_by_get_count_function_t<peak::common::detail::c_type_of_t<T>>& selectByGetCount,
    const detail::select_by_function_t<peak::common::detail::c_type_of_t<T>>& selectBy, const T& interval)
{
    if (m_regions.empty())
    {
        return {};
    }
 
    std::vector<peak_icv_region_handle> handles;
    handles.reserve(m_regions.size());
 
    std::transform(m_regions.begin(), m_regions.end(), std::back_inserter(handles), [](const auto& region) {
        return peak::common::detail::BackendAccessor<peak::icv::Region>::BackendHandle(region);
    });
 
    size_t count = 0;
    detail::ExecuteAndMapReturnCodes([&] {
        return selectByGetCount(
            handles.data(), handles.size(), peak::common::detail::BackendAccessor<T>::CreateCType(interval), &count);
    });
 
    if (count == 0)
    {
        return {};
    }
 
    std::vector<peak_icv_region_handle> selectedHandles(count);
    detail::ExecuteAndMapReturnCodes([&] {
        return selectBy(handles.data(), handles.size(), peak::common::detail::BackendAccessor<T>::CreateCType(interval),
            selectedHandles.data(), selectedHandles.size());
    });
    return RegionSelector(peak::common::detail::BackendAccessor<peak::icv::Region>::CreateInstances(selectedHandles));
}
 
} /* namespace icv */
} /* namespace peak */