FrequencyFilter.cpp

Go to the documentation of this file.

#include "FrequencyFilter.h"
 
#include <chrono>
 
namespace armarx::armem::server::ltm::processor::filter
{
 
    bool
    SnapshotFrequencyFilter::accept(const armem::wm::EntitySnapshot &e)
    {
        //accepting to many elements makes the filter slow and brings problems with the buffer with itself!
 
        // set default values for used variables:
        auto start = std::chrono::high_resolution_clock::now();
        bool instances_accepted = false;
        std::int64_t current = 0;
        // get entity id of this snapshot:
        auto memID = e.id().getEntityID();
 
        if(this->lastTimesPerEntity.end() == this->lastTimesPerEntity.find(memID)){
          //this happens if the key is not in the map, which means this is the first time this
          //entity tries to save a snapshot
          ARMARX_INFO << "First time this entity is saved";
          auto firstIndex = e.getInstanceIndices()[0];
          auto firstInsance = e.getInstance(firstIndex);
          auto lastT = firstInsance.metadata().sentTime.toMilliSecondsSinceEpoch();
          //for statistics sake:
          auto end = std::chrono::high_resolution_clock::now();
          stats.end_time = end;
          stats.additional_time += (end - start);
          stats.accepted += 1;
          //add this last time to the map:
          this->lastTimesPerEntity[memID] = lastT;
          return true; //the first one is always accepted
        } else {
 
            auto lastTime = this->lastTimesPerEntity.at(memID);
 
            // check if any one of the instances for this snapshot were sent in the last x
            // milliseconds since a snapshot was accepted last for this entity:
            e.forEachInstance([this, &instances_accepted, &current, &lastTime](armem::wm::EntityInstance& i){
                int difference = std::abs(i.metadata().sentTime.toMilliSecondsSinceEpoch() - lastTime);
                if(difference > this->maxDifference){ //at least one instance is older than the last saved instance
                    instances_accepted = true;
                    current = i.metadata().sentTime.toMilliSecondsSinceEpoch();
                }
            });
 
            if(instances_accepted){ //if one of the instances was accepted the time when an
                //instance was accepted last needs to be changed
                this->lastTimesPerEntity[memID] = current;
            }
        }
 
        //set stats:
        auto end = std::chrono::high_resolution_clock::now();
        stats.end_time = end;
        stats.additional_time += (end - start);
 
        if(instances_accepted){
            this->stats.accepted += 1;
        } else {
            this->stats.rejected += 1;
        }
 
        return instances_accepted;
    }
 
    void
    SnapshotFrequencyFilter::configure(const nlohmann::json& json)
    {
        if (json.find(PARAM_WAITING_TIME) != json.end())
        {
            this->maxDifference = json.at(PARAM_WAITING_TIME);
            ARMARX_INFO << VAROUT(maxDifference);
            stats.additional_info = "Max Difference in ms: " + std::to_string(this->maxDifference);
        }
        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 SnapshotFrequencyFilter::getFilterStatistics()
    {
        stats.end_time = std::chrono::high_resolution_clock::now();
        return this->stats;
    }
 
    std::string SnapshotFrequencyFilter::getName()
    {
        return this->NAME;
    }
} // namespace armarx::armem::server::ltm::processor::filter