peak_afl_weighted_rois.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_afl/peak_afl.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_ifeature.hpp>
 
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak_common/types/geometry/peak_common_rectangle.hpp>
 
#include <memory>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{
enum class Weight
{
    Weak,
    Medium,
    Strong
};

enum class RoiPreset
{
    Center = PEAK_AFL_CONTROLLER_ROI_PRESET_CENTER,
};

struct WeightedROI
{
    peak::common::Rectangle rect;

    Weight weight;
};

PEAK_COMMON_NO_DISCARD inline std::string ToString(Weight weight)
{
    switch (weight)
    {
    case Weight::Weak:
        return "Weak";
    case Weight::Medium:
        return "Medium";
    case Weight::Strong:
        return "Strong";
    }
 
    throw peak::afl::error::InternalErrorException("Invalid weight!", PEAK_AFL_STATUS_ERROR);
}

inline std::ostream& operator<<(std::ostream& os, Weight weight)
{
    return os << ToString(weight);
}
 
namespace features
{
namespace detail
{
PEAK_COMMON_NO_DISCARD inline Weight ToWeight(const std::string& name)
{
    if (name == "Weak")
    {
        return Weight::Weak;
    }
    if (name == "Medium")
    {
        return Weight::Medium;
    }
    if (name == "Strong")
    {
        return Weight::Strong;
    }
    throw peak::afl::error::InternalErrorException("Invalid weight!", PEAK_AFL_STATUS_ERROR);
}
 
PEAK_COMMON_NO_DISCARD inline peak_afl_roi_weight ToCType(Weight weight)
{
    switch (weight)
    {
    case Weight::Weak:
        return PEAK_AFL_CONTROLLER_ROI_WEIGHT_WEAK;
    case Weight::Medium:
        return PEAK_AFL_CONTROLLER_ROI_WEIGHT_MEDIUM;
    case Weight::Strong:
        return PEAK_AFL_CONTROLLER_ROI_WEIGHT_STRONG;
    }
 
    throw peak::afl::error::InternalErrorException("Invalid weight!", PEAK_AFL_STATUS_ERROR);
}
 
PEAK_COMMON_NO_DISCARD inline Weight ToWeight(peak_afl_roi_weight weight)
{
    switch (weight)
    {
    case PEAK_AFL_CONTROLLER_ROI_WEIGHT_WEAK:
        return Weight::Weak;
    case PEAK_AFL_CONTROLLER_ROI_WEIGHT_MEDIUM:
        return Weight::Medium;
    case PEAK_AFL_CONTROLLER_ROI_WEIGHT_STRONG:
        return Weight::Strong;
    }
 
    throw peak::afl::error::InternalErrorException("Invalid weight!", PEAK_AFL_STATUS_ERROR);
}
 
PEAK_COMMON_NO_DISCARD inline peak_afl_weighted_rectangle ToCType(WeightedROI roi)
{
    peak_afl_weighted_rectangle result;
    result.roi.x = static_cast<uint32_t>(roi.rect.GetX());
    result.roi.y = static_cast<uint32_t>(roi.rect.GetY());
    result.roi.width = roi.rect.GetWidth();
    result.roi.height = roi.rect.GetHeight();
    result.weight = ToCType(roi.weight);
    return result;
}
 
PEAK_COMMON_NO_DISCARD inline WeightedROI ToWeightedROI(peak_afl_weighted_rectangle roi)
{
    const peak::common::Rectangle rect{ { static_cast<int32_t>(roi.roi.x), static_cast<int32_t>(roi.roi.y) },
        { roi.roi.width, roi.roi.height } };
    const auto weight = ToWeight(roi.weight);
    return { rect, weight };
}
} // namespace detail

class WeightedRois : public IFeature<std::vector<WeightedROI>>
{
public:
    explicit WeightedRois(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const WeightedROI& value)
    {
        m_controller->SetWeightedROI(detail::ToCType(value));
    }

    void Set(const std::vector<WeightedROI>& value) override
    {
        std::vector<peak_afl_weighted_rectangle> cRois;
        cRois.reserve(value.size());
        std::transform(value.cbegin(), value.cend(), std::back_inserter(cRois), [](const auto& roi) { return detail::ToCType(roi); });
        m_controller->SetWeightedROIs(cRois);
    }

    void SetPreset(RoiPreset preset)
    {
        m_controller->SetROIPreset(static_cast<peak_afl_roi_preset>(preset));
    }

    PEAK_COMMON_NO_DISCARD std::vector<WeightedROI> Get() const override
    {
        const auto cRois = m_controller->GetWeightedROIs();
 
        std::vector<WeightedROI> rois;
        rois.reserve(cRois.size());
        std::transform(
            cRois.cbegin(), cRois.cend(), std::back_inserter(rois), [](const auto& cRoi) { return detail::ToWeightedROI(cRoi); });
        return rois;
    }

    void Serialize(peak::common::serialization::IArchive& archive) const override
    {
        std::vector<std::shared_ptr<peak::common::serialization::IArchive>> archives;
        const auto weightedRois = Get();
        for (const auto& roi : weightedRois)
        {
            auto subArchives = archive.CreateArchive();
            subArchives->SetInt("X", roi.rect.GetX());
            subArchives->SetInt("Y", roi.rect.GetY());
            subArchives->SetInt("Width", roi.rect.GetWidth());
            subArchives->SetInt("Height", roi.rect.GetHeight());
            subArchives->SetString("Weight", ToString(roi.weight));
 
            archives.push_back(subArchives);
        }
 
        archive.SetArchiveArray("WeightedRois", archives);
    }

    void Deserialize(const peak::common::serialization::IArchive& archive) override
    {
        std::vector<WeightedROI> rois;
        const auto archives = archive.GetArchiveArray("WeightedRois");
        for (const auto& subArchive : archives)
        {
            peak_afl_weighted_rectangle roi;
            roi.roi.x = static_cast<uint32_t>(subArchive->GetInt("X"));
            roi.roi.y = static_cast<uint32_t>(subArchive->GetInt("Y"));
            roi.roi.width = static_cast<uint32_t>(subArchive->GetInt("Width"));
            roi.roi.height = static_cast<uint32_t>(subArchive->GetInt("Height"));
            roi.weight = detail::ToCType(detail::ToWeight(subArchive->GetString("Weight")));
            rois.emplace_back(detail::ToWeightedROI(roi));
        }
 
        Set(rois);
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};
} // namespace features
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak