ticket-decoder 0.19.1__tar.gz → 0.19.3__tar.gz

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ticket-decoder
-Version: 0.19.1
+Version: 0.19.3
 Summary: Train ticket barcode to json decoding library, using zxing-cpp decoding in combination with record interpreter, to transform content into json structure
 Keywords: train-ticket,barcode,aztec-code,uic918,vdv,sbb,oebb
 Author: user4223
@@ -24,7 +24,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.
@@ -39,34 +39,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")
 

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/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

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/pyproject.toml

@@ -3,7 +3,7 @@
 
 [project]
 name = "ticket-decoder"
-version = "v0.19.1"
+version = "v0.19.3"
 description = "Train ticket barcode to json decoding library, using zxing-cpp decoding in combination with record interpreter, to transform content into json structure"
 license = "GPL-3.0-or-later"
 authors = [ { name = "user4223" } ]

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/source/lib/api/include/DecoderFacade.h

@@ -7,6 +7,8 @@
 #include <lib/infrastructure/include/ParameterCollector.h>
 #include <lib/infrastructure/include/ContextFwd.h>
 
+#include <lib/dip/include/PreProcessorOptions.h>
+
 #include <lib/input/api/include/InputElement.h>
 #include <lib/input/api/include/LoadResult.h>
 
@@ -100,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);
 
@@ -144,11 +152,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
          */

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/source/lib/api/source/DecoderFacade.cpp

@@ -43,7 +43,7 @@ namespace api
         std::optional<unsigned int> loadOptionDpi;
         std::optional<int> imageRotation;
         std::optional<unsigned int> imageScale;
-        std::optional<std::string> imageSplit;
+        std::optional<std::string> imageSplitting;
         std::optional<unsigned int> imageFlipping;
         std::optional<detector::api::DetectorType> detectorType;
         std::optional<bool> pureBarcode;
@@ -62,7 +62,7 @@ namespace api
 
         unsigned int getImageScale() const { return imageScale.value_or(dip::PreProcessorOptions::DEFAULT.scalePercent); }
 
-        std::string getImageSplit() const { return imageSplit.value_or(dip::PreProcessorOptions::DEFAULT.split); }
+        std::string getImageSplit() const { return imageSplitting.value_or(dip::PreProcessorOptions::DEFAULT.splittingMode); }
 
         unsigned int getImageFlipping() const { return imageFlipping.value_or(dip::PreProcessorOptions::DEFAULT.flippingMode); }
 
@@ -199,7 +199,7 @@ namespace api
 
     DecoderFacadeBuilder &DecoderFacadeBuilder::withImageSplit(std::string split)
     {
-        options->imageSplit = std::make_optional(split);
+        options->imageSplitting = std::make_optional(split);
         return *this;
     }
 
@@ -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())
         {
@@ -463,26 +469,32 @@ 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)
+        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;
     }
 
-    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)
+        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;
     }
 
-    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)
+        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;
     }
@@ -490,7 +502,7 @@ namespace api
     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;
     }

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/source/lib/dip/include/PreProcessor.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include "PreProcessorOptions.h"
+
 #include "lib/input/api/include/InputElement.h"
 
 #include "lib/infrastructure/include/ParameterSupplier.h"
@@ -12,19 +14,10 @@
 #include <opencv2/core.hpp>
 
 #include <map>
+#include <optional>
 
 namespace dip
 {
-  struct PreProcessorOptions
-  {
-    int rotationDegree = 0;
-    unsigned int scalePercent = 100u;
-    std::string split = "11";
-    unsigned int flippingMode = 0; // 0 nothing, 1 flip around X, 2 flip around Y, 3 flip around X and Y
-
-    static PreProcessorOptions const DEFAULT;
-  };
-
   std::pair<unsigned int, unsigned int> splitStringToPair(std::string input);
 
   std::map<unsigned int, unsigned int> splitPairToMap(std::pair<unsigned int, unsigned int> input);
@@ -39,8 +32,6 @@ namespace dip
 
     PreProcessor(infrastructure::Context &context, PreProcessorOptions options);
 
-    void updatePartMap();
-
   public:
     void enable(bool enabled);
 
@@ -60,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;
 

ticket_decoder-0.19.3/source/lib/dip/include/PreProcessorOptions.h

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: (C) 2026 user4223 and (other) contributors to ticket-decoder <https://github.com/user4223/ticket-decoder>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <string>
+
+namespace dip
+{
+  class OptionsBuilder;
+
+  struct PreProcessorOptions
+  {
+    int rotationDegree = 0;
+    unsigned int scalePercent = 100u;
+    std::string splittingMode = "11"; // 11 first of one part, 2x x of two parts, 4x x of four parts
+    unsigned int flippingMode = 0;    // 0 nothing, 1 flip around X, 2 flip around Y, 3 flip around X and Y
+
+    static PreProcessorOptions const DEFAULT;
+
+    OptionsBuilder create();
+  };
+
+  class OptionsBuilder
+  {
+    PreProcessorOptions options;
+
+    OptionsBuilder(PreProcessorOptions o);
+
+  public:
+    friend PreProcessorOptions;
+
+    PreProcessorOptions build();
+  };
+}

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/source/lib/dip/source/PreProcessor.cpp

@@ -11,8 +11,6 @@
 
 namespace dip
 {
-  PreProcessorOptions const PreProcessorOptions::DEFAULT = PreProcessorOptions{};
-
   std::pair<unsigned int, unsigned int> splitStringToPair(std::string input)
   {
     if (input.size() != 2)
@@ -65,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.split))),
-        parts()
-  {
-    updatePartMap();
-  }
-
-  void PreProcessor::updatePartMap()
+        partMap(splitPairToMap(splitStringToPair(options.splittingMode))),
+        parts(updatePartMap(partMap))
   {
-    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)
@@ -101,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));
   }
 
@@ -130,29 +127,36 @@ namespace dip
   std::string PreProcessor::reset()
   {
     auto const defaultOptions = PreProcessorOptions{};
-    partMap = splitPairToMap(splitStringToPair(defaultOptions.split));
+    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);
@@ -165,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)));

ticket_decoder-0.19.3/source/lib/dip/source/PreProcessorOptions.cpp

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: (C) 2026 user4223 and (other) contributors to ticket-decoder <https://github.com/user4223/ticket-decoder>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "../include/PreProcessorOptions.h"
+
+namespace dip
+{
+
+  PreProcessorOptions const PreProcessorOptions::DEFAULT = PreProcessorOptions{};
+
+  OptionsBuilder::OptionsBuilder(PreProcessorOptions o)
+      : options(std::move(o))
+  {
+  }
+
+  PreProcessorOptions OptionsBuilder::build()
+  {
+    return std::move(options);
+  }
+
+  OptionsBuilder PreProcessorOptions::create()
+  {
+    return OptionsBuilder(DEFAULT);
+  }
+}

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/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})

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/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")
 

ticket_decoder-0.19.3/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})')

ticket_decoder-0.19.3/source/python/interpret_only.py

@@ -0,0 +1,22 @@
+# 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 zxingcpp import read_barcodes
+from cv2 import imread
+
+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 barcodes is None:
+    print("No barcodes found")
+    exit(1)
+
+decoder_facade = DecoderFacade()
+
+print(decoder_facade.decode_bytes(barcodes[0].bytes, file))

{ticket_decoder-0.19.1 → ticket_decoder-0.19.3}/source/python/requirements.txt

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