Make decodeImageFilesToJson returning a dict of origin/json-string; Use temp preProcessor options given on method call overruling defaults

Author: user4223

.vscode/launch.json

@@ -15,7 +15,7 @@
       "name": "pythoncpp launch python debugger",
       "type": "debugpy",
       "request": "launch",
-      "program": "source/python/run.py",
+      "program": "source/python/filter_keys.py",
       "console": "integratedTerminal",
       "env": {
         "PYTHONPATH": "${workspaceFolder}/build/Debug/bin"

README.md

@@ -56,9 +56,8 @@ to execute the following minimal Python script:
 ```
 from ticket_decoder import DecoderFacade
 
-decoder_facade = DecoderFacade(fail_on_interpreter_error = False)
-for result in decoder_facade.decode_files('path/2/your/ticket.pdf'):
-   print(result[1])
+decoder_facade = DecoderFacade()
+print(decoder_facade.decode_files('path/2/your/ticket.pdf'))
 ```
 
 ## ticket-analyzer

source/lib/api/include/DecoderFacade.h

@@ -102,10 +102,16 @@ namespace api
         DecoderFacadeBuilder::Options const &options;
 
         template <typename T>
-        void decodeImage(input::api::InputElement image, std::function<void(T &&, std::string)> transformer);
+        void decodeImage(
+            input::api::InputElement image,
+            std::optional<dip::PreProcessorOptions> preProcessorOptions,
+            std::function<void(T &&, std::string)> transformer);
 
         template <typename T>
-        void decodeImageFiles(std::filesystem::path path, std::function<void(T &&, std::string)> transformer);
+        void decodeImageFiles(
+            std::filesystem::path path,
+            std::optional<dip::PreProcessorOptions> preProcessorOptions,
+            std::function<void(T &&, std::string)> transformer);
 
         std::string interpretRawBytes(std::vector<std::uint8_t> bytes, std::string origin);
 

source/lib/api/source/DecoderFacade.cpp

@@ -316,9 +316,12 @@ namespace api
     }
 
     template <typename T>
-    void DecoderFacade::decodeImage(input::api::InputElement inputElement, std::function<void(T &&, std::string)> transformer)
+    void DecoderFacade::decodeImage(
+        input::api::InputElement inputElement,
+        std::optional<dip::PreProcessorOptions> preProcessorOptions,
+        std::function<void(T &&, std::string)> transformer)
     {
-        auto source = internal->preProcessor.get(std::move(inputElement));
+        auto source = internal->preProcessor.get(std::move(inputElement), preProcessorOptions);
         options.visitPreProcessorResult(source);
         if (!source.isValid())
         {
@@ -345,10 +348,13 @@ namespace api
     }
 
     template <typename T>
-    void DecoderFacade::decodeImageFiles(std::filesystem::path path, std::function<void(T &&, std::string)> transformer)
+    void DecoderFacade::decodeImageFiles(
+        std::filesystem::path path,
+        std::optional<dip::PreProcessorOptions> preProcessorOptions,
+        std::function<void(T &&, std::string)> transformer)
     {
         auto loadHandler = [&, this](auto &&inputElement)
-        { decodeImage(std::move(inputElement), transformer); };
+        { decodeImage(std::move(inputElement), preProcessorOptions, transformer); };
 
         if (options.getAsynchronousLoad())
         {
@@ -468,7 +474,7 @@ namespace api
         std::optional<dip::PreProcessorOptions> preProcessorOptions)
     {
         auto result = std::vector<std::pair<std::string, std::string>>{};
-        decodeImageFiles<decoder::api::Result>(path, [&](auto &&decoderResult, auto origin)
+        decodeImageFiles<decoder::api::Result>(path, preProcessorOptions, [&](auto &&decoderResult, auto origin)
                                                { result.emplace_back(std::make_pair(std::move(origin), interpretRawBytes(std::move(decoderResult.payload), origin))); });
         return result;
     }
@@ -478,7 +484,7 @@ namespace api
         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)
+        decodeImageFiles<decoder::api::Result>(path, preProcessorOptions, [&](auto &&decoderResult, auto origin)
                                                { result.emplace_back(std::make_pair(std::move(origin), std::move(decoderResult.payload))); });
         return result;
     }
@@ -488,15 +494,15 @@ namespace api
         std::optional<dip::PreProcessorOptions> preProcessorOptions)
     {
         auto result = std::vector<std::pair<std::string, std::string>>{};
-        decodeImageFiles<decoder::api::Result>(path, [&](auto &&decoderResult, auto origin)
+        decodeImageFiles<decoder::api::Result>(path, preProcessorOptions, [&](auto &&decoderResult, auto origin)
                                                { result.emplace_back(std::make_pair(origin, toMinimalJson(origin, decoderResult.payload, options.getJsonIndent()))); });
         return result;
     }
 
     std::vector<std::string> DecoderFacade::decodeImageToJson(input::api::InputElement inputElement)
     {
         auto result = std::vector<std::string>{};
-        decodeImage<decoder::api::Result>(std::move(inputElement), [&](auto &&decoderResult, auto origin)
+        decodeImage<decoder::api::Result>(std::move(inputElement), std::nullopt, [&](auto &&decoderResult, auto origin)
                                           { result.emplace_back(interpretRawBytes(std::move(decoderResult.payload), origin)); });
         return result;
     }

source/lib/dip/include/PreProcessor.h

@@ -14,6 +14,7 @@
 #include <opencv2/core.hpp>
 
 #include <map>
+#include <optional>
 
 namespace dip
 {
@@ -31,8 +32,6 @@ namespace dip
 
     PreProcessor(infrastructure::Context &context, PreProcessorOptions options);
 
-    void updatePartMap();
-
   public:
     void enable(bool enabled);
 
@@ -52,7 +51,7 @@ namespace dip
 
     std::string reset();
 
-    input::api::InputElement get(input::api::InputElement &&element) const;
+    input::api::InputElement get(input::api::InputElement &&element, std::optional<dip::PreProcessorOptions> options = std::nullopt) const;
 
     ParameterTypeList supplyParameters() const;
 

source/lib/dip/source/PreProcessor.cpp

@@ -63,21 +63,20 @@ namespace dip
     return result;
   }
 
+  std::tuple<unsigned int, unsigned int> updatePartMap(std::map<unsigned int, unsigned int> const &partMap)
+  {
+    return *std::max_element(partMap.begin(), partMap.end(),
+                             [](auto const &a, auto const &b)
+                             { return (std::min(1u, a.second) * a.first) < (std::min(1u, b.second) * b.first); });
+  }
+
   PreProcessor::PreProcessor(infrastructure::Context &context, PreProcessorOptions o)
       : logger(CREATE_LOGGER(context.getLoggerFactory())),
         options(std::move(o)),
         isEnabled(true),
         partMap(splitPairToMap(splitStringToPair(options.splittingMode))),
-        parts()
+        parts(updatePartMap(partMap))
   {
-    updatePartMap();
-  }
-
-  void PreProcessor::updatePartMap()
-  {
-    parts = *std::max_element(partMap.begin(), partMap.end(),
-                              [](auto const &a, auto const &b)
-                              { return (std::min(1u, a.second) * a.first) < (std::min(1u, b.second) * b.first); });
   }
 
   void PreProcessor::enable(bool e)
@@ -99,14 +98,14 @@ namespace dip
   std::string PreProcessor::toggleSplit2()
   {
     ::utility::rotate(partMap.at(2), 2);
-    updatePartMap();
+    parts = updatePartMap(partMap);
     return std::to_string(std::get<0>(parts)) + "/" + std::to_string(std::get<1>(parts));
   }
 
   std::string PreProcessor::toggleSplit4()
   {
     ::utility::rotate(partMap.at(4), 4);
-    updatePartMap();
+    parts = updatePartMap(partMap);
     return std::to_string(std::get<0>(parts)) + "/" + std::to_string(std::get<1>(parts));
   }
 
@@ -129,28 +128,35 @@ namespace dip
   {
     auto const defaultOptions = PreProcessorOptions{};
     partMap = splitPairToMap(splitStringToPair(defaultOptions.splittingMode));
+    parts = updatePartMap(partMap);
     options.rotationDegree = defaultOptions.rotationDegree;
     options.scalePercent = defaultOptions.scalePercent;
     options.flippingMode = defaultOptions.flippingMode;
-    updatePartMap();
     return "";
   }
 
-  input::api::InputElement PreProcessor::get(input::api::InputElement &&element) const
+  input::api::InputElement PreProcessor::get(input::api::InputElement &&element, std::optional<dip::PreProcessorOptions> tempOptions) const
   {
     if (!isEnabled || !element.isValid())
     {
       return std::move(element);
     }
 
+    auto const effectiveOptions = tempOptions.value_or(this->options);
+    auto effectiveParts = std::tuple<unsigned int, unsigned int>(parts);
+    if (tempOptions)
+    {
+      effectiveParts = updatePartMap(splitPairToMap(splitStringToPair(tempOptions->splittingMode)));
+    }
+
     auto image = element.getImage();
-    if (std::get<1>(parts) != 0)
+    if (std::get<1>(effectiveParts) != 0)
     {
-      image = dip::split(image, std::get<0>(parts), std::get<1>(parts));
+      image = dip::split(image, std::get<0>(effectiveParts), std::get<1>(effectiveParts));
     }
-    if (options.flippingMode != 0)
+    if (effectiveOptions.flippingMode != 0)
     {
-      switch (options.flippingMode)
+      switch (effectiveOptions.flippingMode)
       {
       case 1:
         image = dip::flipX(image);
@@ -163,13 +169,13 @@ namespace dip
         break;
       }
     }
-    if (options.rotationDegree != 0)
+    if (effectiveOptions.rotationDegree != 0)
     {
-      image = dip::rotate(image, (float)options.rotationDegree);
+      image = dip::rotate(image, (float)effectiveOptions.rotationDegree);
     }
-    if (options.scalePercent != 100)
+    if (effectiveOptions.scalePercent != 100)
     {
-      image = dip::scale(image, options.scalePercent * 0.01f);
+      image = dip::scale(image, effectiveOptions.scalePercent * 0.01f);
     }
 
     return std::move(element.replaceImage(std::move(image)));

source/python/README.md

@@ -12,7 +12,7 @@ Optional arguments for instance creation of DecoderFacade.
   Relative path to the LDIF file containing VDV certificates to decrypt VDV barcode content.
 * `fail_on_decoder_error` = false  
   Fail when the aztec/barcode decoder gets an error if true or deliver an empty result when false.
-* `fail_on_interpreter_error` = true  
+* `fail_on_interpreter_error` = false  
   Fail when the interpretation of the data gets an error if true or deliver an empty result when false.
 
 Provided python API is in an early state and the class DecoderFacade supports 3 methods right now only.
@@ -27,34 +27,39 @@ Provided python API is in an early state and the class DecoderFacade supports 3
   option, try using 'ISO 8859-1' and cast the result string to raw bytes.
 
 * `decode_files('...')` detects and decodes aztec-codes from file or directories (PDF, image) and decodes barcode
-  data to json. This is using zxing-cpp internally. It returns an array of tuples (input-path and json-result) 
+  data to json. This is using zxing-cpp and opencv internally. It returns a dict (origin/input-path and json-string) 
   of size x, while x is the amount of aztec-codes found on input. An image can contain always multiple barcodes,
-  the the return value is alway a mapping of origin to content.
+  the return value is alway a mapping of origin to json content.
+  * rotation_degree - Rotate image before processing for the given amount of degrees (default 0)
+  * scale_percent - Scale image before processing in percent (default 100)
+  * splitting_mode - Split image, 1st number specifies the no of parts to split, 2nd is the part used for processing, clockwise from top/left (default 11)
+  * flipping_mode - Flip image around X if 1, around Y if 2, and around X and Y if 3 (default 0)
 
 ## Example decoding directly from PDF or image
 ```
 from ticket_decoder import DecoderFacade
 
-decoder_facade = DecoderFacade(fail_on_interpreter_error = False)
-for result in decoder_facade.decode_files('path/2/your/ticket.pdf'):
-   print(result[1])
+decoder_facade = DecoderFacade()
+print(decoder_facade.decode_files('path/2/your/ticket.pdf'))
 ```
 
-## Decoding Aztec-Code in advance using zxingcpp on Python side
+## Example decoding Aztec-Code in advance using zxingcpp and opencv on Python side
 ```
 from ticket_decoder import DecoderFacade
 from zxingcpp import read_barcodes
 from cv2 import imread
 
 image = imread('path/2/your/ticket.jpg')
+if image is None:
+    print("Image not found")
+    exit(1)
 
 barcodes = read_barcodes(image)
-if not barcodes:
+if barcodes is None:
     print("No barcodes found")
     exit(1)
 
 decoder_facade = DecoderFacade(\
-    fail_on_interpreter_error = False,\
     uic_public_key_xml_file = "cert/UIC_PublicKeys.xml",\
     vdv_certificate_ldif_file = "cert/VDV_Certificates.ldif")
 

source/python/filter_keys.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: (C) 2022 user4223 and (other) contributors to ticket-decoder <https://github.com/user4223/ticket-decoder>
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from ticket_decoder import DecoderFacade
+from json import loads
+from jsonpath_ng.ext import parse
+
+decoder_facade = DecoderFacade()
+
+
+UIC918_9_EXPRESSION = parse("$..[firstName, lastName, uniqueTicketKey, issuerPNR, editionTime]")
+result = decoder_facade.decode_files("images/Muster-UIC918-9", splitting_mode='21')
+print(f'### UIC918-9 items found: {len(result)}')
+for origin, value in result.items():
+    print(f'{origin}: {", ".join([x.value for x in UIC918_9_EXPRESSION.find(loads(value))])}')
+
+
+UIC918_3_EXPRESSION = parse("$..fields[S023, S015, S016].value")
+result = decoder_facade.decode_files("images/Muster-UIC918-3", rotation_degree=2, splitting_mode='42')
+print(f'### UIC918-3 items found: {len(result)}')
+for origin, value in result.items():
+    print(f'{origin}: {", ".join([x.value for x in UIC918_3_EXPRESSION.find(loads(value))])}')
+
+
+result = decoder_facade.decode_files("images")
+verified = 0
+for origin, value in result.items():
+    verified += 1 if loads(value).get('validated') == 'true' else 0
+print(f'### Overall items found: {len(result)} (verified: {verified})')

source/python/interpret_only.py

@@ -5,15 +5,18 @@
 from zxingcpp import read_barcodes
 from cv2 import imread
 
-image = imread('source/test/decoder/etc/Muster 918-9 Länderticket Schleswig-Holstein_0_decoded.jpg')
+file = 'source/test/decoder/etc/Muster 918-9 Länderticket Schleswig-Holstein_0_decoded.jpg'
+
+image = imread(file)
+if image is None:
+    print("Image not found")
+    exit(1)
+
 barcodes = read_barcodes(image)
-if not barcodes:
+if barcodes is None:
     print("No barcodes found")
     exit(1)
 
-decoder_facade = DecoderFacade(\
-    fail_on_interpreter_error = False,\
-    uic_public_key_xml_file = "cert/UIC_PublicKeys.xml",\
-    vdv_certificate_ldif_file = "cert/VDV_Certificates.ldif")
+decoder_facade = DecoderFacade()
 
-print(decoder_facade.decode_bytes(barcodes[0].bytes))
+print(decoder_facade.decode_bytes(barcodes[0].bytes, file))

source/python/requirements.txt

@@ -1,3 +1,3 @@
-jsonpath2
+jsonpath-ng
 zxing-cpp
 opencv-python