ImportanceFilter.cpp

Go to the documentation of this file.

#include "ImportanceFilter.h"
 
namespace armarx::armem::server::ltm::processor::filter
{
 
    bool
    SnapshotImportanceFilter::accept(const armem::wm::EntitySnapshot& e, bool simulatedVersion)
    {
        // Thread safety: lock the filter mutex for all mutable state access
        std::lock_guard<std::mutex> lock(filterMutex_);
 
        auto start = std::chrono::high_resolution_clock::now();
        bool instances_accepted = false;
 
        e.forEachInstance(
            [this, &instances_accepted](armem::wm::EntityInstance& i)
            {
                if (!instances_accepted)
                { //if no instance was accepted yet
                    instances_accepted = important(i); //see if another instance triggers acceptance
                }
            });
 
        //set stats:
        auto end = std::chrono::high_resolution_clock::now();
        stats.end_time = end;
        stats.additional_time += (end - start);
        if (instances_accepted)
        {
            stats.accepted += 1;
        }
        else
        {
            stats.rejected += 1;
        }
 
        return instances_accepted;
    }
 
    void
    SnapshotImportanceFilter::configure(const nlohmann::json& json)
    {
        std::lock_guard<std::mutex> lock(filterMutex_);
        if (json.find(PARAM_THRESHOLD) != json.end())
        {
            this->threshold = json.at(PARAM_THRESHOLD);
            ARMARX_INFO << VAROUT(this->threshold);
            stats.additional_info += "Threshold for importance: ";
            stats.additional_info += std::to_string(this->threshold);
        }
        if (json.find(PARAM_TYPE) != json.end())
        {
            auto t = json.at(PARAM_TYPE);
            if (t == "Confidence")
            {
                this->type = ImportanceType::CONFIDENCE;
            }
            if (t == "Accesses")
            {
                this->type = ImportanceType::ACCESSES;
            }
            stats.importance_type = t;
            ARMARX_INFO << VAROUT(stats.importance_type);
        }
 
        stats.start_time = std::chrono::high_resolution_clock::now();
        stats.number_of_compared_objects = 1;
        stats.similarity_type =
            aron::similarity::NDArraySimilarity::Type::NONE; //information for statistics export
    }
 
    SnapshotFilter::FilterStatistics
    SnapshotImportanceFilter::getFilterStatistics()
    {
        std::lock_guard<std::mutex> lock(filterMutex_);
        return this->stats;
    }
 
    std::string
    SnapshotImportanceFilter::getName()
    {
        return this->NAME;
    }
 
    bool
    SnapshotImportanceFilter::important(armem::wm::EntityInstance& i)
    {
        if (this->type == ImportanceType::CONFIDENCE)
        {
            auto c = i.metadata().confidence;
            if (c > this->threshold)
            {
                //for now the whole entity snapshot is accepted if at least one instance has a confidence higher than the threshold
                return true;
            }
        }
        else if (this->type == ImportanceType::ACCESSES)
        {
            auto a = i.metadata().numAccessed;
            if (a > this->threshold)
            {
                return true;
            }
        }
        return false;
    }
 
 
} // namespace armarx::armem::server::ltm::processor::filter