Make decodeImageFilesToJson returning a json list instead of a list of tuples of origin/json

Author: user4223

source/lib/api/include/DecoderFacade.h

@@ -146,11 +146,17 @@ namespace api
 
         /* Barcodes from image or PDF input file/directory to json, raw byte-array or raw base64-string
          */
-        std::vector<std::pair<std::string, std::string>> decodeImageFilesToJson(std::filesystem::path path);
+        std::vector<std::pair<std::string, std::string>> decodeImageFilesToJson(
+            std::filesystem::path path,
+            std::optional<dip::PreProcessorOptions> preProcessorOptions = std::nullopt);
 
-        std::vector<std::pair<std::string, std::vector<std::uint8_t>>> decodeImageFilesToRawBytes(std::filesystem::path path);
+        std::vector<std::pair<std::string, std::vector<std::uint8_t>>> decodeImageFilesToRawBytes(
+            std::filesystem::path path,
+            std::optional<dip::PreProcessorOptions> preProcessorOptions = std::nullopt);
 
-        std::vector<std::pair<std::string, std::string>> decodeImageFilesToRawBase64(std::filesystem::path path);
+        std::vector<std::pair<std::string, std::string>> decodeImageFilesToRawBase64(
+            std::filesystem::path path,
+            std::optional<dip::PreProcessorOptions> preProcessorOptions = std::nullopt);
 
         /* Pre-loaded image data as input-element to json
          */

source/lib/api/source/DecoderFacade.cpp

@@ -463,23 +463,29 @@ namespace api
         return decodeRawBytesToJson(utility::base64::decode(base64RawData), origin);
     }
 
-    std::vector<std::pair<std::string, std::string>> DecoderFacade::decodeImageFilesToJson(std::filesystem::path path)
+    std::vector<std::pair<std::string, std::string>> DecoderFacade::decodeImageFilesToJson(
+        std::filesystem::path path,
+        std::optional<dip::PreProcessorOptions> preProcessorOptions)
     {
         auto result = std::vector<std::pair<std::string, std::string>>{};
         decodeImageFiles<decoder::api::Result>(path, [&](auto &&decoderResult, auto origin)
                                                { result.emplace_back(std::make_pair(std::move(origin), interpretRawBytes(std::move(decoderResult.payload), origin))); });
         return result;
     }
 
-    std::vector<std::pair<std::string, std::vector<std::uint8_t>>> DecoderFacade::decodeImageFilesToRawBytes(std::filesystem::path path)
+    std::vector<std::pair<std::string, std::vector<std::uint8_t>>> DecoderFacade::decodeImageFilesToRawBytes(
+        std::filesystem::path path,
+        std::optional<dip::PreProcessorOptions> preProcessorOptions)
     {
         auto result = std::vector<std::pair<std::string, std::vector<std::uint8_t>>>{};
         decodeImageFiles<decoder::api::Result>(path, [&](auto &&decoderResult, auto origin)
                                                { result.emplace_back(std::make_pair(std::move(origin), std::move(decoderResult.payload))); });
         return result;
     }
 
-    std::vector<std::pair<std::string, std::string>> DecoderFacade::decodeImageFilesToRawBase64(std::filesystem::path path)
+    std::vector<std::pair<std::string, std::string>> DecoderFacade::decodeImageFilesToRawBase64(
+        std::filesystem::path path,
+        std::optional<dip::PreProcessorOptions> preProcessorOptions)
     {
         auto result = std::vector<std::pair<std::string, std::string>>{};
         decodeImageFiles<decoder::api::Result>(path, [&](auto &&decoderResult, auto origin)

source/python/CMakeLists.txt

@@ -3,6 +3,8 @@
 
 PROJECT(ticket_decoder)
 
+find_package(Boost REQUIRED COMPONENTS headers)
+
 # nanobind is installed via pip on python side and ships the cpp files with the python module,
 # so no additional conan packages required. We only have to tell cmake to find those files.
 #
@@ -42,7 +44,8 @@ target_link_libraries(${PROJECT_NAME} PRIVATE
     easyloggingpp::easyloggingpp
     opencv::opencv_core_alias
     ticket-decoder-api
-    ticket-decoder-dip)
+    ticket-decoder-dip
+    Boost::headers)
 
 IF (SKBUILD_PLATLIB_DIR)
     install(FILES ${PROJECT_SOURCE_DIR}/etc/__init__.py DESTINATION ${SKBUILD_PROJECT_NAME})

source/python/source/Binding.cpp

@@ -10,8 +10,12 @@
 
 #include "lib/api/include/DecoderFacade.h"
 
+#include <boost/algorithm/string.hpp>
+
 #include <memory>
 #include <string>
+#include <sstream>
+#include <ranges>
 
 class DecoderFacadeWrapper
 {
@@ -72,15 +76,21 @@ class DecoderFacadeWrapper
         return get().decodeRawBase64ToJson(base64, origin);
     }
 
-    std::vector<std::pair<std::string, std::string>> decodeFiles(
+    std::string decodeFiles(
         std::string const &path,
         int const rotationDegree,
         unsigned int const scalePercent,
         std::string const &splittingMode,
         unsigned int const flippingMode)
     {
-        auto options = dip::PreProcessorOptions{rotationDegree, scalePercent, splittingMode, flippingMode};
-        return get().decodeImageFilesToJson(path);
+        auto preProcessorOptions = std::make_optional(dip::PreProcessorOptions{rotationDegree, scalePercent, splittingMode, flippingMode});
+        auto result = get().decodeImageFilesToJson(path, std::move(preProcessorOptions))
+                    | std::views::transform([](auto &&pair) { return std::move(pair.second); });
+
+        auto resultJson = std::vector<std::string>(std::begin(result), std::end(result));
+        auto json = std::stringstream();
+        json << "[" << boost::algorithm::join(resultJson, ",\n") << "]";
+        return json.str();
     }
 };
 

source/test/python/test_decode_uic918.py

@@ -35,7 +35,7 @@ def test_decode_pdf_files(self):
         if not len(result):
             self.skipTest("Poppler input support not compiled in: " + self.pdf_input_file)
 
-        records = loads(result[0][1])
+        records = loads(result)[0]
         assert records['records']['U_FLEX']['transportDocuments'][0]['openTicket']['fromStationName'] == 'Kassel+City'
         assert records['validated'] == 'false'
 
@@ -46,11 +46,10 @@ def test_decode_image_files(self):
         decoder_facade = DecoderFacade()
         result = decoder_facade.decode_files(self.image_input_file)
 
-        records = loads(result[0][1])
+        records = loads(result)[0]
         assert records['records']['U_FLEX']['transportDocuments'][0]['openTicket']['tariffs'][0]['tariffDesc'] == 'Deutschland-Ticket'
         assert records['validated'] == 'false'
 
-
     def test_decode_files_not_existing(self):
         with self.assertRaisesRegex(RuntimeError, '^Decoding failed with: Path to load input elements from does not exist: Not existing file$'):
             decoder_facade = DecoderFacade()
@@ -59,7 +58,7 @@ def test_decode_files_not_existing(self):
     def test_decode_files_without_aztec_code(self):
         decoder_facade = DecoderFacade()
         result = decoder_facade.decode_files('source/test/io/etc/minimal.pdf')
-        assert len(result) == 0
+        assert len(loads(result)) == 0
 
     def test_two_instances(self):
         decoder_facadeA = DecoderFacade()