dynamsoft/barcode-reader-python-samples/dbr-python-sample-creator

Image Input → CaptureVisionRouter (with template) → CapturedResult
                                                      └── DecodedBarcodesResult

from dynamsoft_barcode_reader_bundle import *

    # 1. Initialize license.
    # You can request and extend a trial license from https://www.dynamsoft.com/customer/license/trialLicense?product=dbr&utm_source=samples&package=python
    # The string 'DLS2eyJoYW5kc2hha2VDb2RlIjoiMjAwMDAxLTEwNTI2NzQwMSJ9' here is a free public trial license. Note that network connection is required for this license to work.

    # 1. Initialize license.
    # You can request and extend a trial license from https://www.dynamsoft.com/customer/license/trialLicense?product=dbr&utm_source=samples&package=python
    # The string 'DLS2eyJoYW5kc2hha2VDb2RlIjoiMjAwMDAxLTEwNTI2NzQwMSJ9' here is a free public trial license. Note that network connection is required for this license to work.
    error_code, error_msg = LicenseManager.init_license("DLS2eyJoYW5kc2hha2VDb2RlIjoiMjAwMDAxLTEwNTI2NzQwMSJ9")
    if error_code != EnumErrorCode.EC_OK and error_code != EnumErrorCode.EC_LICENSE_WARNING:
        print("License initialization failed: ErrorCode:", error_code, ", ErrorString:", error_msg)
    else:
        # proceed with the rest of the sample
        ...

cvr_instance = CaptureVisionRouter()

error_code, error_msg = cvr_instance.init_settings_from_file("path/to/template.json")
if error_code != EnumErrorCode.EC_OK:
    print("Init template failed:", error_msg)

result = cvr_instance.capture(image_path, EnumPresetTemplate.PT_READ_BARCODES)

result_array = cvr_instance.capture_multi_pages(image_path, EnumPresetTemplate.PT_READ_BARCODES)
results = result_array.get_results()
for i, result in enumerate(results):
    # process each page's result
    ...

# Set up image source
fetcher = DirectoryFetcher()  # or custom ImageSourceAdapter subclass
fetcher.set_directory("path/to/images")
cvr_instance.set_input(fetcher)
# Set up result receiver
receiver = MyCapturedResultReceiver()  # subclass of CapturedResultReceiver
cvr_instance.add_result_receiver(receiver)
# Set up state listener (to know when processing is done)
listener = MyImageSourceStateListener(cvr_instance)
cvr_instance.add_image_source_state_listener(listener)
# Start processing
cvr_instance.start_capturing(EnumPresetTemplate.PT_READ_BARCODES, True)

if result.get_error_code() != EnumErrorCode.EC_OK:
    print("Error:", result.get_error_code(), result.get_error_string())

barcode_result = result.get_decoded_barcodes_result()
if barcode_result is not None and barcode_result.get_items() != 0:
    for item in barcode_result.get_items():
        print("Format:", item.get_format_string())
        print("Text:", item.get_text())

{
    "CaptureVisionTemplates": [...],       // Main entry: names, ROI refs, timeout
    "TargetROIDefOptions": [...],          // ROI definitions → task references
    "BarcodeReaderTaskSettingOptions": [...], // Barcode reading config
    "ImageParameterOptions": [...],        // Image processing parameters
    "BarcodeFormatSpecificationOptions": [...] // Barcode-format-specific settings
}

cvr_instance.init_settings_from_file("path/to/template.json")
# Then use the template name from the JSON:
result = cvr_instance.capture(image, "TemplateName")

err_code, err_str, settings = cvr_instance.get_simplified_settings(EnumPresetTemplate.PT_READ_BARCODES)
# Adjust barcode settings
settings.barcode_settings.barcode_format_ids = EnumBarcodeFormat.BF_QR_CODE | EnumBarcodeFormat.BF_PDF417
settings.barcode_settings.expected_barcodes_count = 10
settings.barcode_settings.grayscale_transformation_modes[0] = EnumGrayscaleTransformationMode.GTM_AUTO
# Adjust ROI
settings.roi_measured_in_percentage = 1
points = settings.roi.points
points[0].x, points[0].y = 0, 0
points[1].x, points[1].y = 100, 0
points[2].x, points[2].y = 100, 100
points[3].x, points[3].y = 0, 100
# Apply
cvr_instance.update_settings(EnumPresetTemplate.PT_READ_BARCODES, settings)

result_array = cvr_instance.capture_multi_pages(image_path, template)
results = result_array.get_results()
if results is None or len(results) == 0:
    print("No results.")
else:
    for i, result in enumerate(results):
        page_number = i + 1
        tag = result.get_original_image_tag()
        if isinstance(tag, FileImageTag):
            page_number = tag.get_page_number() + 1
        if result.get_error_code() == EnumErrorCode.EC_UNSUPPORTED_JSON_KEY_WARNING:
            print("Warning:", result.get_error_code(), result.get_error_string())
        elif result.get_error_code() != EnumErrorCode.EC_OK:
            print("Error:", result.get_error_code(), result.get_error_string())
        # ... extract barcode results here

class MyVideoFetcher(ImageSourceAdapter):
    def has_next_image_to_fetch(self) -> bool:
        return True
# Setup
fetcher = MyVideoFetcher()
fetcher.set_max_image_count(100)
fetcher.set_buffer_overflow_protection_mode(EnumBufferOverflowProtectionMode.BOPM_UPDATE)
fetcher.set_colour_channel_usage_type(EnumColourChannelUsageType.CCUT_AUTO)
cvr_instance.set_input(fetcher)
# Add cross-frame filter for dedup
filter = MultiFrameResultCrossFilter()
filter.enable_result_cross_verification(EnumCapturedResultItemType.CRIT_BARCODE, True)
filter.enable_result_deduplication(EnumCapturedResultItemType.CRIT_BARCODE, True)
filter.set_duplicate_forget_time(EnumCapturedResultItemType.CRIT_BARCODE, 5000)
cvr_instance.add_result_filter(filter)
# Feed frames from OpenCV
tag = FileImageTag("", 0, 0)
tag.set_image_id(image_id)
image = ImageData(frame.tobytes(), width, height, stride, EnumImagePixelFormat.IPF_RGB_888, 0, tag)
fetcher.add_image_to_buffer(image)

class MyIRR(IntermediateResultReceiver):
    def on_localized_barcodes_received(self, result, info):
        if info.is_section_level_result:
            for i in range(result.get_count()):
                element = result.get_localized_barcode(i)
                location = element.get_location()
irm = cvr_instance.get_intermediate_result_manager()
irr = MyIRR()
irm.add_result_receiver(irr)

# Read image
io = ImageIO()
err, image = io.read_from_file("input.png")
# Save image
io.save_to_file(image_data, "output.png")
# Draw on image
drawer = ImageDrawer()
image = drawer.draw_on_image(image, quadrilaterals, 0xFF00FF00, 2)  # green, thickness 2