ltm updates and improved export of depth images in exr format

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

@@ -45,6 +45,7 @@ set(LIB_FILES
     MemoryRemoteGui.cpp
     RemoteGuiAronDataVisitor.cpp
 
+    ltm/base/detail/Processors.cpp
     ltm/base/detail/MemoryItem.cpp
     ltm/base/detail/MemoryBase.cpp
     ltm/base/detail/BufferedMemoryBase.cpp
@@ -60,6 +61,7 @@ set(LIB_FILES
 
     ltm/base/extractor/Extractor.cpp
     ltm/base/extractor/imageExtractor/ImageExtractor.cpp
+    ltm/base/extractor/imageExtractor/DepthImageExtractor.cpp
 
     ltm/base/converter/Converter.cpp
     ltm/base/converter/object/Converter.cpp
@@ -67,6 +69,7 @@ set(LIB_FILES
     ltm/base/converter/object/bson/BsonConverter.cpp
     ltm/base/converter/image/Converter.cpp
     ltm/base/converter/image/png/PngConverter.cpp
+    ltm/base/converter/image/exr/ExrConverter.cpp
 
     ltm/base/forgetter/Forgetter.cpp
     ltm/base/forgetter/LRUForgetter/LRUForgetter.cpp
@@ -120,6 +123,7 @@ set(LIB_HEADERS
     MemoryRemoteGui.h
     RemoteGuiAronDataVisitor.h
 
+    ltm/base/detail/Processors.h
     ltm/base/detail/MemoryItem.h
     ltm/base/detail/MemoryBase.h
     ltm/base/detail/BufferedMemoryBase.h
@@ -135,6 +139,7 @@ set(LIB_HEADERS
 
     ltm/base/extractor/Extractor.h
     ltm/base/extractor/imageExtractor/ImageExtractor.h
+    ltm/base/extractor/imageExtractor/DepthImageExtractor.h
 
     ltm/base/converter/Converter.h
     ltm/base/converter/object/Converter.h
@@ -142,6 +147,7 @@ set(LIB_HEADERS
     ltm/base/converter/object/bson/BsonConverter.h
     ltm/base/converter/image/Converter.h
     ltm/base/converter/image/png/PngConverter.h
+    ltm/base/converter/image/exr/ExrConverter.h
 
 
     ltm/base/forgetter/Forgetter.h

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

@@ -17,17 +17,19 @@ namespace armarx::armem::server::ltm
             Binary
         };
 
-        Converter(const ConverterType t, const std::string& s, const aron::type::Descriptor c):
+        Converter(const ConverterType t, const std::string& id, const std::string& s, const aron::type::Descriptor c):
             type(t),
+            identifier(id),
             suffix(s),
             convertsType(c)
         {}
         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;
+        virtual std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) = 0;
+        virtual aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) = 0;
 
         const ConverterType type;
+        const std::string identifier;
         const std::string suffix;
         const aron::type::Descriptor convertsType;
         bool enabled = false;

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

@@ -3,15 +3,15 @@
 namespace armarx::armem::server::ltm
 {
 
-    std::vector<unsigned char> ImageConverter::convert(const aron::data::VariantPtr& data)
+    std::pair<std::vector<unsigned char>, std::string> 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)
+    aron::data::VariantPtr ImageConverter::convert(const std::vector<unsigned char>& data, const std::string& m)
     {
-        auto d = _convert(data);
+        auto d = _convert(data, m);
         return d;
     }
 

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

@@ -14,17 +14,17 @@ namespace armarx::armem::server::ltm
     class ImageConverter : public Converter
     {
     public:
-        ImageConverter(const ConverterType t, const std::string& s):
-            Converter(t, s, aron::type::Descriptor::eImage)
+        ImageConverter(const ConverterType t, const std::string& id, const std::string& s):
+            Converter(t, id, s, aron::type::Descriptor::eImage)
         {}
 
         virtual ~ImageConverter() = default;
 
-        std::vector<unsigned char> convert(const aron::data::VariantPtr& data) final;
-        aron::data::VariantPtr convert(const std::vector<unsigned char>& data) final;
+        std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) final;
 
     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;
+        virtual std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) = 0;
+        virtual aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) = 0;
     };
 }

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

+#include "ExrConverter.h"
+
+// ArmarX
+#include <RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h>
+
+#include <opencv2/opencv.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+
+
+namespace armarx::armem::server::ltm::converter::image
+{
+    std::pair<std::vector<unsigned char>, std::string> ExrConverter::_convert(const aron::data::NDArrayPtr& data)
+    {
+        ARMARX_CHECK_NOT_NULL(data);
+
+        auto img = aron::converter::AronOpenCVConverter::ConvertToMat(data);
+        std::vector<unsigned char> buffer;
+
+        auto shape = data->getShape(); // we know from the extraction that the shape has 3 elements
+        ARMARX_CHECK_EQUAL(shape.size(), 3);
+        ARMARX_CHECK_EQUAL(shape[2], 4);
+
+        cv::imencode(".exr", img, buffer);
+        return std::make_pair(buffer, "");
+    }
+
+    aron::data::NDArrayPtr ExrConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
+    {
+        cv::Mat img = cv::imdecode(data, cv::IMREAD_ANYDEPTH);
+        return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+    }
+}

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

+#pragma once
+
+// Base Class
+#include "../Converter.h"
+
+namespace armarx::armem::server::ltm::converter::image
+{
+    class ExrConverter : public ImageConverter
+    {
+    public:
+        ExrConverter() :
+            ImageConverter(ConverterType::Binary, "depthimage", ".exr")
+        {
+            enabled = true; // enabled by default
+        }
+
+    protected:
+        std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+    };
+}

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

@@ -10,21 +10,52 @@
 
 namespace armarx::armem::server::ltm::converter::image
 {
-    std::vector<unsigned char> PngConverter::_convert(const aron::data::NDArrayPtr& data)
+    std::pair<std::vector<unsigned char>, std::string> PngConverter::_convert(const aron::data::NDArrayPtr& data)
     {
         ARMARX_CHECK_NOT_NULL(data);
 
         auto img = aron::converter::AronOpenCVConverter::ConvertToMat(data);
-        cv::cvtColor(img, img, CV_RGB2BGR);
         std::vector<unsigned char> buffer;
-        cv::imencode(".png", img, buffer);
-        return buffer;
+
+
+        auto shape = data->getShape(); // we know from the extraction that the shape has 3 elements
+        ARMARX_CHECK_EQUAL(shape.size(), 3);
+
+        if (shape[2] == 3) // its probably a rgb image
+        {
+            cv::cvtColor(img, img, CV_RGB2BGR);
+            cv::imencode(suffix, img, buffer);
+            return std::make_pair(buffer, ".rgb");
+        }
+
+        if (shape[2] == 1) // its probably a grayscale image
+        {
+            cv::imencode(suffix, img, buffer);
+            return std::make_pair(buffer, ".gs");
+        }
+
+        // try to export without conversion
+        cv::imencode(suffix, img, buffer);
+        return std::make_pair(buffer, "");
     }
 
-    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data)
+    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
     {
-        cv::Mat img = cv::imdecode(data, cv::IMREAD_COLOR);
-        cv::cvtColor(img, img, CV_BGR2RGB);
+        if (m == ".rgb")
+        {
+            cv::Mat img = cv::imdecode(data, cv::IMREAD_COLOR);
+            cv::cvtColor(img, img, CV_BGR2RGB);
+            return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+        }
+
+        if (m == ".gs")
+        {
+            cv::Mat img = cv::imdecode(data, cv::IMREAD_GRAYSCALE);
+            return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+        }
+
+        // try to load without conversion
+        cv::Mat img = cv::imdecode(data, cv::IMREAD_ANYCOLOR);
         return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
     }
 }

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

@@ -9,13 +9,13 @@ namespace armarx::armem::server::ltm::converter::image
     {
     public:
         PngConverter() :
-            ImageConverter(ConverterType::Binary, ".png")
+            ImageConverter(ConverterType::Binary, "image", ".png")
         {
             enabled = true; // enabled by default
         }
 
     protected:
-        std::vector<unsigned char> _convert(const aron::data::NDArrayPtr& data) final;
-        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data) final;
+        std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
     };
 }

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

@@ -3,15 +3,15 @@
 namespace armarx::armem::server::ltm
 {
 
-    std::vector<unsigned char> ObjectConverter::convert(const aron::data::VariantPtr& data)
+    std::pair<std::vector<unsigned char>, std::string> ObjectConverter::convert(const aron::data::VariantPtr& data)
     {
         auto d = aron::data::Dict::DynamicCastAndCheck(data);
         return _convert(d);
     }
 
-    aron::data::VariantPtr ObjectConverter::convert(const std::vector<unsigned char>& data)
+    aron::data::VariantPtr ObjectConverter::convert(const std::vector<unsigned char>& data, const std::string& m)
     {
-        auto d = _convert(data);
+        auto d = _convert(data, m);
         return d;
     }
 

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

@@ -14,17 +14,17 @@ namespace armarx::armem::server::ltm
     class ObjectConverter : public Converter
     {
     public:
-        ObjectConverter(const ConverterType t, const std::string& s):
-            Converter(t, s, aron::type::Descriptor::eObject)
+        ObjectConverter(const ConverterType t, const std::string& id, const std::string& s):
+            Converter(t, id, s, aron::type::Descriptor::eObject)
         {}
 
         virtual ~ObjectConverter() = default;
 
-        std::vector<unsigned char> convert(const aron::data::VariantPtr& data) final;
-        aron::data::VariantPtr convert(const std::vector<unsigned char>& data) final;
+        std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) final;
 
     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;
+        virtual std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) = 0;
+        virtual aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) = 0;
     };
 }

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

@@ -10,9 +10,9 @@ namespace armarx::armem::server::ltm::converter::object
     namespace bsoncxxbuilder = bsoncxx::builder::stream;
     namespace bsoncxxdoc = bsoncxx::document;
 
-    std::vector<unsigned char> BsonConverter::_convert(const aron::data::DictPtr& data)
+    std::pair<std::vector<unsigned char>, std::string> BsonConverter::_convert(const aron::data::DictPtr& data)
     {
-        std::vector<unsigned char> jsonVec = jsonConverter.convert(data);
+        auto [jsonVec, str] = jsonConverter.convert(data);
         std::string json(jsonVec.begin(), jsonVec.end());
         auto view = bsoncxx::from_json(json).view();
 
@@ -21,16 +21,16 @@ namespace armarx::armem::server::ltm::converter::object
         {
             std::memcpy(bson.data(), view.data(), view.length());
         }
-        return bson;
+        return std::make_pair(bson, str);
     }
 
-    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data)
+    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
     {
         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());
-        auto v = jsonConverter.convert(jsonVec);
+        auto v = jsonConverter.convert(jsonVec, m);
         return aron::data::Dict::DynamicCast(v);
     }
 }

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

@@ -15,12 +15,12 @@ namespace armarx::armem::server::ltm::converter::object
     {
     public:
         BsonConverter() :
-            ObjectConverter(ConverterType::Binary, ".bson")
+            ObjectConverter(ConverterType::Binary, "dict", ".bson")
         {}
 
     protected:
-        std::vector<unsigned char> _convert(const aron::data::DictPtr& data) final;
-        aron::data::DictPtr _convert(const std::vector<unsigned char>& data) final;
+        std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
 
     private:
         JsonConverter jsonConverter;

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

@@ -4,14 +4,14 @@
 
 namespace armarx::armem::server::ltm::converter::object
 {
-    std::vector<unsigned char> JsonConverter::_convert(const aron::data::DictPtr& data)
+    std::pair<std::vector<unsigned char>, std::string> 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());
+        return std::make_pair(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, const std::string&)
     {
         std::string str(data.begin(), data.end());
         nlohmann::json j = nlohmann::json::parse(str);

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

@@ -12,13 +12,13 @@ namespace armarx::armem::server::ltm::converter::object
     {
     public:
         JsonConverter() :
-            ObjectConverter(ConverterType::Str, ".json")
+            ObjectConverter(ConverterType::Str, "dict", ".json")
         {
             enabled = true; // always true!
         }
 
     protected:
-        std::vector<unsigned char> _convert(const aron::data::DictPtr& data) final;
-        aron::data::DictPtr _convert(const std::vector<unsigned char>& data) final;
+        std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
     };
 }

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

@@ -9,7 +9,6 @@
 #include "CoreSegmentBase.h"
 
 // ArmarX
-#include <ArmarXCore/core/application/properties/Properties.h>
 #include <ArmarXCore/core/time/TimeUtil.h>
 #include <ArmarXCore/core/logging/LoggingUtil.h>
 
@@ -112,19 +111,7 @@ namespace armarx::armem::server::ltm
         /// parameters
         virtual void createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix)
         {
-            // filters
-            defs->optional(processors->memFreqFilter.enabled, prefix + "memFreqFilter.Enabled");
-            defs->optional(processors->memFreqFilter.waitingTimeInMs, prefix + "memFreqFilter.WaitingTime", "Waiting time in MS after each LTM update.");
-            defs->optional(processors->snapFreqFilter.enabled, prefix + "snapFreqFilter.Enabled");
-            defs->optional(processors->snapFreqFilter.waitingTimeInMs, prefix + "snapFreqFilter.WaitingTime", "Waiting time in MS after each Entity update.");
-            defs->optional(processors->snapEqFilter.enabled, prefix + "snapEqFilter.Enabled");
-            defs->optional(processors->snapEqFilter.maxWaitingTimeInMs, prefix + "snapEqFilter.MaxWaitingTime", "Max Waiting time in MS after each Entity update.");
-
-            // extractors
-            defs->optional(processors->imageExtractor.enabled, prefix + "imageExtractor.Enabled");
-
-            // converters
-            defs->optional(processors->pngConverter.enabled, prefix + "pngConverter.Enabled");
+            processors->createPropertyDefinitions(defs, prefix);
         }
 
         /// get level name

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

@@ -5,49 +5,10 @@
 #include <optional>
 #include <string>
 
-#include "../filter/frequencyFilter/FrequencyFilter.h"
-#include "../filter/equalityFilter/EqualityFilter.h"
-#include "../extractor/imageExtractor/ImageExtractor.h"
-#include "../converter/object/json/JsonConverter.h"
-#include "../converter/image/png/PngConverter.h"
-
-#include <RobotAPI/libraries/armem/core/MemoryID.h>
+#include "Processors.h"
 
 namespace armarx::armem::server::ltm
 {
-    /// all necessary classes to filter and convert an entry of the ltm to some other format(s)
-    struct Processors
-    {
-        // Unique Memory Filters
-        std::vector<MemoryFilter*> memFilters;
-        filter::MemoryFrequencyFilter memFreqFilter;
-
-        // Unique Snapshot filters
-        std::vector<SnapshotFilter*> snapFilters;
-        filter::SnapshotFrequencyFilter snapFreqFilter;
-        filter::SnapshotEqualityFilter snapEqFilter;
-
-        // Extractors
-        std::vector<Extractor*> extractors;
-        extractor::ImageExtractor imageExtractor;
-
-        // Converters
-        std::map<aron::type::Descriptor, Converter*> converters;
-        converter::object::JsonConverter jsonConverter;
-        converter::image::PngConverter pngConverter;
-
-        Processors()
-        {
-            // setup containers
-            memFilters.push_back(&memFreqFilter);
-            snapFilters.push_back(&snapFreqFilter);
-            snapFilters.push_back(&snapEqFilter);
-            extractors.push_back(&imageExtractor);
-            converters.insert({jsonConverter.convertsType, &jsonConverter});
-            converters.insert({pngConverter.convertsType, &pngConverter});
-        }
-    };
-
     /// @brief Interface functions for the longterm memory classes
     class MemoryItem
     {

source/RobotAPI/libraries/armem/server/ltm/base/detail/Processors.cpp

+#include "Processors.h"
+
+namespace armarx::armem::server::ltm
+{
+    Processors::Processors()
+    {
+        // setup containers
+        memFilters.push_back(&memFreqFilter);
+        snapFilters.push_back(&snapFreqFilter);
+        snapFilters.push_back(&snapEqFilter);
+        extractors.push_back(&imageExtractor);
+        extractors.push_back(&depthImageExtractor);
+        converters.insert({pngConverter.identifier, &pngConverter});
+        converters.insert({exrConverter.identifier, &exrConverter});
+    }
+
+    void Processors::createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix)
+    {
+        // filters
+        defs->optional(memFreqFilter.enabled, prefix + "memFreqFilter.Enabled");
+        defs->optional(memFreqFilter.waitingTimeInMs, prefix + "memFreqFilter.WaitingTime", "Waiting time in MS after each LTM update.");
+        defs->optional(snapFreqFilter.enabled, prefix + "snapFreqFilter.Enabled");
+        defs->optional(snapFreqFilter.waitingTimeInMs, prefix + "snapFreqFilter.WaitingTime", "Waiting time in MS after each Entity update.");
+        defs->optional(snapEqFilter.enabled, prefix + "snapEqFilter.Enabled");
+        defs->optional(snapEqFilter.maxWaitingTimeInMs, prefix + "snapEqFilter.MaxWaitingTime", "Max Waiting time in MS after each Entity update.");
+
+        // extractors
+        defs->optional(imageExtractor.enabled, prefix + "imageExtractor.Enabled");
+        defs->optional(depthImageExtractor.enabled, prefix + "depthImageExtractor.Enabled");
+
+        // converters
+        defs->optional(pngConverter.enabled, prefix + "pngConverter.Enabled");
+        defs->optional(exrConverter.enabled, prefix + "exrConverter.Enabled");
+    }
+}

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

+#pragma once
+
+#include <map>
+#include <mutex>
+#include <optional>
+#include <string>
+
+#include <ArmarXCore/core/application/properties/Properties.h>
+
+#include "../filter/frequencyFilter/FrequencyFilter.h"
+#include "../filter/equalityFilter/EqualityFilter.h"
+#include "../extractor/imageExtractor/ImageExtractor.h"
+#include "../extractor/imageExtractor/DepthImageExtractor.h"
+#include "../converter/object/json/JsonConverter.h"
+#include "../converter/image/png/PngConverter.h"
+#include "../converter/image/exr/ExrConverter.h"
+
+#include <RobotAPI/libraries/armem/core/MemoryID.h>
+
+namespace armarx::armem::server::ltm
+{
+    /// all necessary classes to filter and convert an entry of the ltm to some other format(s)
+    class Processors
+    {
+    public:
+        Processors();
+        void createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix);
+
+    public:
+        // Unique Memory Filters
+        std::vector<MemoryFilter*> memFilters;
+        filter::MemoryFrequencyFilter memFreqFilter;
+
+        // Unique Snapshot filters
+        std::vector<SnapshotFilter*> snapFilters;
+        filter::SnapshotFrequencyFilter snapFreqFilter;
+        filter::SnapshotEqualityFilter snapEqFilter;
+
+        // Special Extractors
+        std::vector<Extractor*> extractors;
+        extractor::ImageExtractor imageExtractor;
+        extractor::DepthImageExtractor depthImageExtractor;
+
+        // Special Converters
+        std::map<std::string, Converter*> converters;
+        converter::image::PngConverter pngConverter;
+        converter::image::ExrConverter exrConverter;
+
+        // Default converter
+        converter::object::JsonConverter defaultObjectConverter;
+    };
+}

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

@@ -18,13 +18,14 @@ namespace armarx::armem::server::ltm
             std::map<std::string, aron::data::VariantPtr> extraction;
         };
 
-        Extractor(const aron::type::Descriptor t) : extractsType(t) {};
+        Extractor(const aron::type::Descriptor t, const std::string& id) : extractsType(t), identifier(id) {};
         virtual ~Extractor() = default;
 
         virtual Extraction extract(aron::data::DictPtr& data) = 0;
         virtual aron::data::DictPtr merge(Extraction& encoding) = 0;
 
         const aron::type::Descriptor extractsType;
+        const std::string identifier;
         bool enabled = false;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/extractor/imageExtractor/DepthImageExtractor.cpp

+#include "DepthImageExtractor.h"
+
+
+namespace armarx::armem::server::ltm::extractor
+{
+    void DepthImageExtractorVisitor::visitDictOnEnter(Input& data)
+    {
+        ARMARX_CHECK_NOT_NULL(data);
+
+        auto dict = aron::data::Dict::DynamicCastAndCheck(data);
+        for (const auto& [key, child] : dict->getElements())
+        {
+            if (child && child->getDescriptor() == aron::data::Descriptor::eNDArray)
+            {
+                auto ndarray = aron::data::NDArray::DynamicCastAndCheck(child);
+                auto shape = ndarray->getShape();
+                if (shape.size() == 3 && shape[2] == 4 && std::accumulate(std::begin(shape), std::end(shape), 1, std::multiplies<int>()) > 200) // must be big enough to assume an image (instead of 4x4x4 poses)
+                {
+                    depthImages[key] = ndarray;
+                    dict->setElement(key, nullptr);
+                }
+            }
+        }
+    }
+
+    void DepthImageExtractorVisitor::visitUnknown(Input&)
+    {
+        // A member is null. Simply ignore...
+    }
+
+    Extractor::Extraction DepthImageExtractor::extract(aron::data::DictPtr& data)
+    {
+        DepthImageExtractorVisitor visitor;
+        aron::data::VariantPtr var = std::static_pointer_cast<aron::data::Variant>(data);
+        aron::data::VariantPtr p;
+        aron::data::visitRecursive(visitor, var);
+
+        Extraction encoding;
+        encoding.dataWithoutExtraction = data;
+        encoding.extraction = visitor.depthImages;
+        return encoding;
+    }
+
+    aron::data::DictPtr DepthImageExtractor::merge(Extraction& encoding)
+    {
+        return encoding.dataWithoutExtraction;
+    }
+}