added base classes for filter classes in ltm

source/RobotAPI/libraries/armem/server/CMakeLists.txt

@@ -47,8 +47,8 @@ set(LIB_FILES
 
     ltm/base/extractor/Extractor.cpp
     ltm/base/extractor/imageExtractor/ImageExtractor.cpp
-    ltm/base/extractor/noExtractor/NoExtractor.cpp
 
+    ltm/base/converter/Converter.cpp
     ltm/base/converter/dict/Converter.cpp
     ltm/base/converter/dict/json/JsonConverter.cpp
     ltm/base/converter/dict/bson/BsonConverter.cpp
@@ -119,8 +119,8 @@ set(LIB_HEADERS
 
     ltm/base/extractor/Extractor.h
     ltm/base/extractor/imageExtractor/ImageExtractor.h
-    ltm/base/extractor/noExtractor/NoExtractor.h
 
+    ltm/base/converter/Converter.h
     ltm/base/converter/dict/Converter.h
     ltm/base/converter/dict/json/JsonConverter.h
     ltm/base/converter/dict/bson/BsonConverter.h

source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.cpp

+#include "Converter.h"

source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h

+#pragma once
+
+// STD/STL
+#include <memory>
+
+// ArmarX
+#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
+
+namespace armarx::armem::server::ltm
+{
+    class Converter
+    {
+    public:
+        enum class ConverterType
+        {
+            Str,
+            Binary
+        };
+
+        Converter(const ConverterType t, const std::string& s):
+            type(t),
+            suffix(s)
+        {}
+        virtual ~Converter() = default;
+
+        virtual std::vector<unsigned char> convert(const aron::data::VariantPtr& data) = 0;
+        virtual aron::data::VariantPtr convert(const std::vector<unsigned char>& data) = 0;
+
+        const ConverterType type;
+        const std::string suffix;
+    };
+}

source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/Converter.cpp

 #include "Converter.h"
+
+namespace armarx::armem::server::ltm
+{
+
+    std::vector<unsigned char> DictConverter::convert(const aron::data::VariantPtr& data)
+    {
+        auto d = aron::data::Dict::DynamicCastAndCheck(data);
+        return _convert(d);
+    }
+
+    aron::data::VariantPtr DictConverter::convert(const std::vector<unsigned char>& data)
+    {
+        auto d = _convert(data);
+        return d;
+    }
+
+}

source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/Converter.h

@@ -3,33 +3,26 @@
 // STD/STL
 #include <memory>
 
+// BaseClass
+#include "../Converter.h"
+
 // ArmarX
 #include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
 
 namespace armarx::armem::server::ltm
 {
-    class DictConverter;
-    using DictConverterPtr = std::shared_ptr<DictConverter>;
-
-    class DictConverter
+    class DictConverter : public Converter
     {
     public:
-        enum class ConverterType
-        {
-            Str,
-            Binary
-        };
+        using Converter::Converter;
 
-        DictConverter(const ConverterType t, const std::string& s):
-            type(t),
-            suffix(s)
-        {}
         virtual ~DictConverter() = default;
 
-        virtual std::vector<unsigned char> convert(const aron::data::DictPtr& data) = 0;
-        virtual aron::data::DictPtr convert(const std::vector<unsigned char>& data) = 0;
+        std::vector<unsigned char> convert(const aron::data::VariantPtr& data) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data) final;
 
-        const ConverterType type;
-        const std::string suffix;
+    protected:
+        virtual std::vector<unsigned char> _convert(const aron::data::DictPtr& data) = 0;
+        virtual aron::data::DictPtr _convert(const std::vector<unsigned char>& data) = 0;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/bson/BsonConverter.cpp

@@ -10,7 +10,7 @@ namespace armarx::armem::server::ltm::converter::dict
     namespace bsoncxxbuilder = bsoncxx::builder::stream;
     namespace bsoncxxdoc = bsoncxx::document;
 
-    std::vector<unsigned char> BsonConverter::convert(const aron::data::DictPtr& data)
+    std::vector<unsigned char> BsonConverter::_convert(const aron::data::DictPtr& data)
     {
         std::vector<unsigned char> jsonVec = jsonConverter.convert(data);
         std::string json(jsonVec.begin(), jsonVec.end());
@@ -24,12 +24,13 @@ namespace armarx::armem::server::ltm::converter::dict
         return bson;
     }
 
-    aron::data::DictPtr BsonConverter::convert(const std::vector<unsigned char>& data)
+    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data)
     {
         bsoncxx::document::view view(data.data(), data.size());
         nlohmann::json json = bsoncxx::to_json(view);
         std::string str = json.dump(2);
         std::vector<unsigned char> jsonVec(str.begin(), str.end());
-        return jsonConverter.convert(jsonVec);
+        auto v = jsonConverter.convert(jsonVec);
+        return aron::data::Dict::DynamicCast(v);
     }
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/bson/BsonConverter.h

@@ -18,8 +18,9 @@ namespace armarx::armem::server::ltm::converter::dict
             DictConverter(ConverterType::Binary, ".bson")
         {}
 
-        virtual std::vector<unsigned char> convert(const aron::data::DictPtr& data) override;
-        virtual aron::data::DictPtr convert(const std::vector<unsigned char>& data) override;
+    protected:
+        std::vector<unsigned char> _convert(const aron::data::DictPtr& data) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data) final;
 
     private:
         JsonConverter jsonConverter;

source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/json/JsonConverter.cpp

@@ -4,14 +4,14 @@
 
 namespace armarx::armem::server::ltm::converter::dict
 {
-    std::vector<unsigned char> JsonConverter::convert(const aron::data::DictPtr& data)
+    std::vector<unsigned char> JsonConverter::_convert(const aron::data::DictPtr& data)
     {
         nlohmann::json j = aron::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(data);
         auto str = j.dump(2);
         return std::vector<unsigned char>(str.begin(), str.end());
     }
 
-    aron::data::DictPtr JsonConverter::convert(const std::vector<unsigned char>& data)
+    aron::data::DictPtr JsonConverter::_convert(const std::vector<unsigned char>& data)
     {
         std::string str(data.begin(), data.end());
         nlohmann::json j = nlohmann::json::parse(str);

source/RobotAPI/libraries/armem/server/ltm/base/converter/dict/json/JsonConverter.h

@@ -8,9 +8,6 @@
 
 namespace armarx::armem::server::ltm::converter::dict
 {
-    class JsonConverter;
-    using JsonConverterPtr = std::shared_ptr<JsonConverter>;
-
     class JsonConverter : public DictConverter
     {
     public:
@@ -18,7 +15,8 @@ namespace armarx::armem::server::ltm::converter::dict
             DictConverter(ConverterType::Str, ".json")
         {}
 
-        virtual std::vector<unsigned char> convert(const aron::data::DictPtr& data) override;
-        virtual aron::data::DictPtr convert(const std::vector<unsigned char>& data) override;
+    protected:
+        std::vector<unsigned char> _convert(const aron::data::DictPtr& data) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data) final;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp

 #include "Converter.h"
+
+namespace armarx::armem::server::ltm
+{
+
+    std::vector<unsigned char> ImageConverter::convert(const aron::data::VariantPtr& data)
+    {
+        auto d = aron::data::NDArray::DynamicCastAndCheck(data);
+        return _convert(d);
+    }
+
+    aron::data::VariantPtr ImageConverter::convert(const std::vector<unsigned char>& data)
+    {
+        auto d = _convert(data);
+        return d;
+    }
+
+}

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h

@@ -3,33 +3,26 @@
 // STD/STL
 #include <memory>
 
+// BaseClass
+#include "../Converter.h"
+
 // ArmarX
 #include <RobotAPI/libraries/aron/core/data/variant/complex/NDArray.h>
 
 namespace armarx::armem::server::ltm
 {
-    class ImageConverter;
-    using ImageConverterPtr = std::shared_ptr<ImageConverter>;
-
-    class ImageConverter
+    class ImageConverter : public Converter
     {
     public:
-        enum class ConverterType
-        {
-            Str,
-            Binary
-        };
+        using Converter::Converter;
 
-        ImageConverter(const ConverterType t, const std::string& s):
-            type(t),
-            suffix(s)
-        {}
         virtual ~ImageConverter() = default;
 
-        virtual std::vector<unsigned char> convert(const aron::data::NDArrayPtr& data) = 0;
-        virtual aron::data::NDArrayPtr convert(const std::vector<unsigned char>& data) = 0;
+        std::vector<unsigned char> convert(const aron::data::VariantPtr& data) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data) final;
 
-        const ConverterType type;
-        const std::string suffix;
+    protected:
+        virtual std::vector<unsigned char> _convert(const aron::data::NDArrayPtr& data) = 0;
+        virtual aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data) = 0;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp

@@ -10,7 +10,7 @@
 
 namespace armarx::armem::server::ltm::converter::image
 {
-    std::vector<unsigned char> PngConverter::convert(const aron::data::NDArrayPtr& data)
+    std::vector<unsigned char> PngConverter::_convert(const aron::data::NDArrayPtr& data)
     {
         ARMARX_CHECK_NOT_NULL(data);
 
@@ -20,10 +20,9 @@ namespace armarx::armem::server::ltm::converter::image
         return buffer;
     }
 
-    aron::data::NDArrayPtr PngConverter::convert(const std::vector<unsigned char>& data)
+    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data)
     {
         cv::Mat img = cv::imdecode(data, cv::IMREAD_COLOR);
-        auto aron = aron::converter::AronOpenCVConverter::ConvertFromMat(img);
-        return aron;
+        return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
     }
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h

@@ -15,7 +15,8 @@ namespace armarx::armem::server::ltm::converter::image
             ImageConverter(ConverterType::Str, ".png")
         {}
 
-        virtual std::vector<unsigned char> convert(const aron::data::NDArrayPtr& data) override;
-        virtual aron::data::NDArrayPtr convert(const std::vector<unsigned char>& data) override;
+    protected:
+        std::vector<unsigned char> _convert(const aron::data::NDArrayPtr& data) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data) final;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/detail/BufferedMemoryBase.h

@@ -13,49 +13,56 @@ namespace armarx::armem::server::ltm
 
     public:
         BufferedMemoryBase() :
-            Base()
+            BufferedMemoryBase({})
         {
         }
 
         BufferedMemoryBase(const MemoryID& id) :
-            Base(id),
-            buffer(id)
+            Base(id)
         {
+            buffer = std::make_shared<armem::wm::Memory>(id);
+            to_store = std::make_shared<armem::wm::Memory>(id);
         }
 
         virtual ~BufferedMemoryBase() = default;
 
         armem::wm::Memory getBuffer() const
         {
-            return buffer;
+            std::lock_guard l(bufferMutex);
+            return *buffer;
         }
 
         void directlyStore(const armem::wm::Memory& memory)
         {
             TIMING_START(LTM_Memory_DirectlyStore);
-            if (!this->pipeline.memFreqFilter->accept(memory))
+            for (auto& f : this->memoryFilters)
             {
-                ARMARX_WARNING << deactivateSpam() << "Ignoring to put a Memory into the LTM because it got filtered.";
-                return;
-            }
-            else
-            {
-                _directlyStore(memory);
+                if (!f.accept(memory))
+                {
+                    ARMARX_WARNING << deactivateSpam() << "Ignoring to put a Memory into the LTM because it got filtered.";
+                    return;
+                }
             }
+            _directlyStore(memory);
             TIMING_END(LTM_Memory_DirectlyStore);
         }
 
         void storeBuffer()
         {
-            std::lock_guard l(bufferMutex);
-            if (buffer.empty())
+            std::lock_guard l(storeMutex);
+            {
+                std::lock_guard l(bufferMutex);
+                to_store = buffer;
+                buffer = std::make_shared<armem::wm::Memory>(this->id());
+            }
+
+            if (to_store->empty())
             {
                 ARMARX_INFO << deactivateSpam() << "Cannot store an empty buffer. Ignoring.";
                 return;
             }
 
-            this->directlyStore(buffer);
-            buffer.clear();
+            this->directlyStore(*to_store);
         }
 
         virtual void createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix) override
@@ -71,7 +78,9 @@ namespace armarx::armem::server::ltm
         void _store(const armem::wm::Memory& memory) override
         {
             std::lock_guard l(bufferMutex);
-            buffer.append(memory);
+            buffer->append(memory);
+
+            // create task if not already exists
             if (!task)
             {
                 int waitingTimeMs = 1000.f / storeFrequency;
@@ -81,12 +90,12 @@ namespace armarx::armem::server::ltm
         }
 
     protected:
-
-        /// Internal memory for data consolidated from wm to ltm (buffer)
+        /// Internal memory for data consolidated from wm to ltm (double-buffer)
         /// The to-put-to-ltm buffer (contains data in plain text)
-        /// This buffer may still be filtered.
+        /// This buffer may still be filtered (e.g. snapshot filters).
         /// This means that it is not guaranteed that all data in the buffer will be stored in the ltm
-        armem::wm::Memory buffer;
+        std::shared_ptr<armem::wm::Memory> buffer;
+        std::shared_ptr<armem::wm::Memory> to_store;
 
         /// The periodic'task to store the content of the buffer to the ltm
         typename armarx::PeriodicTask<BufferedMemoryBase>::pointer_type task = nullptr;
@@ -95,7 +104,8 @@ namespace armarx::armem::server::ltm
         float storeFrequency = 10;
 
         /// a mutex to access the buffer object
-        std::mutex bufferMutex;
+        mutable std::mutex bufferMutex;
+        mutable std::mutex storeMutex;
 
     };
 } // namespace armarx::armem::server::ltm

source/RobotAPI/libraries/armem/server/ltm/base/extractor/Extractor.h

@@ -9,9 +9,6 @@
 
 namespace armarx::armem::server::ltm
 {
-    class Extractor;
-    typedef std::shared_ptr<Extractor> ExtractorPtr;
-
     class Extractor
     {
     public:

source/RobotAPI/libraries/armem/server/ltm/base/extractor/imageExtractor/ImageExtractor.h

@@ -7,9 +7,6 @@
 
 namespace armarx::armem::server::ltm::extractor
 {
-    class ImageExtractor;
-    typedef std::shared_ptr<ImageExtractor> ImageExtractorPtr;
-
     class ImageExtractorVisitor : public aron::data::RecursiveVariantVisitor
     {
     public:
@@ -26,8 +23,5 @@ namespace armarx::armem::server::ltm::extractor
 
         virtual Extraction extract(aron::data::DictPtr& data) override;
         virtual aron::data::DictPtr merge(Extraction& encoding) override;
-
-    public:
-        bool enabled;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/extractor/noExtractor/NoExtractor.cpp

-#include "NoExtractor.h"
-
-
-namespace armarx::armem::server::ltm::extractor
-{
-    Extractor::Extraction NoExtractor::extract(aron::data::DictPtr& data)
-    {
-        Extraction encoding;
-        encoding.dataWithoutExtraction = data;
-        return encoding;
-    }
-
-    aron::data::DictPtr NoExtractor::merge(Extraction& encoding)
-    {
-        return encoding.dataWithoutExtraction;
-    }
-}

source/RobotAPI/libraries/armem/server/ltm/base/extractor/noExtractor/NoExtractor.h

-#pragma once
-
-// Base Class
-#include "../Extractor.h"
-
-namespace armarx::armem::server::ltm::extractor
-{
-    class NoExtractor;
-    typedef std::shared_ptr<NoExtractor> NoExtractorPtr;
-
-    class NoExtractor : public Extractor
-    {
-    public:
-        NoExtractor() = default;
-
-        virtual Extraction extract(aron::data::DictPtr& data) override;
-        virtual aron::data::DictPtr merge(Extraction& encoding) override;
-    };
-}

source/RobotAPI/libraries/armem/server/ltm/base/filter/Filter.h

@@ -9,12 +9,6 @@
 
 namespace armarx::armem::server::ltm
 {
-    class SnapshotFilter;
-    typedef std::shared_ptr<SnapshotFilter> SnapshotFilterPtr;
-
-    class MemoryFilter;
-    typedef std::shared_ptr<MemoryFilter> MemoryFilterPtr;
-
     class MemoryFilter
     {
     public:

source/RobotAPI/libraries/armem/server/ltm/base/filter/frequencyFilter/FrequencyFilter.h

@@ -5,12 +5,6 @@
 
 namespace armarx::armem::server::ltm::filter
 {
-    class SnapshotFrequencyFilter;
-    typedef std::shared_ptr<SnapshotFrequencyFilter> SnapshotFrequencyFilterPtr;
-
-    class MemoryFrequencyFilter;
-    typedef std::shared_ptr<MemoryFrequencyFilter> MemoryFrequencyFilterPtr;
-
     class MemoryFrequencyFilter :
             public MemoryFilter
     {
@@ -35,9 +29,9 @@ namespace armarx::armem::server::ltm::filter
         virtual bool accept(const armem::wm::EntitySnapshot& e) override;
 
     public:
-        int waitingTimeInMs = 1000;
+        int waitingTimeInMs = -1;
 
     private:
-        std::unordered_map<MemoryID, long> timestampLastCommitInMs;
+        std::map<MemoryID, long> timestampLastCommitInMs;
     };
 }