Port to v3

ocrd_kraken/binarize.py

@@ -1,26 +1,26 @@
 from __future__ import absolute_import
 import os
+from os.path import join
+from typing import Optional
 import kraken.binarization
 from ocrd import Processor
-from ocrd_utils import getLogger, make_file_id, MIMETYPE_PAGE
-from ocrd_models.ocrd_page import AlternativeImageType, to_xml
+from ocrd_utils import assert_file_grp_cardinality, getLogger, make_file_id, MIMETYPE_PAGE
+from ocrd_models.ocrd_page import AlternativeImageType, OcrdPage, to_xml
 from ocrd_modelfactory import page_from_file
 
 from ocrd_kraken.config import OCRD_TOOL
 
 
 class KrakenBinarize(Processor):
 
-    def __init__(self, *args, **kwargs):
-        kwargs['ocrd_tool'] = OCRD_TOOL['tools']['ocrd-kraken-binarize']
-        kwargs['version'] = OCRD_TOOL['version']
-        super(KrakenBinarize, self).__init__(*args, **kwargs)
+    @property
+    def executable(self):
+        return 'ocrd-kraken-binarize'
 
-    def process(self):
+    def process_page_pcgts(self, *input_pcgts : OcrdPage, output_file_id : Optional[str] = None, page_id : Optional[str] = None) -> OcrdPage:
         """Binarize the pages/regions/lines with Kraken.
 
-        Open and deserialise PAGE input files and their respective images,
-        then iterate over the element hierarchy down to the requested
+        Iterate over the input PAGE element hierarchy down to the requested
         ``level-of-operation``.
 
         Next, for each file, crop each segment image according to the layout
@@ -36,64 +36,42 @@ def process(self):
 
         Produce a new output file by serialising the resulting hierarchy.
         """
-        log = getLogger('processor.KrakenBinarize')
-        log.debug('Level of operation: "%s"', self.parameter['level-of-operation'])
-        log.debug('Input file group %s', self.input_file_grp)
-        log.debug('Input files %s', [str(f) for f in self.input_files])
-        for (n, input_file) in enumerate(self.input_files):
-            log.info("INPUT FILE %i / %s", n, input_file.pageId or input_file.ID)
-            file_id = make_file_id(input_file, self.output_file_grp)
-            pcgts = page_from_file(self.workspace.download_file(input_file))
-            page = pcgts.get_Page()
-            page_id = pcgts.pcGtsId or input_file.pageId or input_file.ID # (PageType has no id)
-            self.add_metadata(pcgts)
+        assert self.workspace
+        assert self.output_file_grp
+        self.logger.debug('Level of operation: "%s"', self.parameter['level-of-operation'])
 
-            page_image, page_coords, page_image_info = self.workspace.image_from_page(
-                page, page_id, feature_filter='binarized')
-            if self.parameter['level-of-operation'] == 'page':
-                log.info("Binarizing page '%s'", page_id)
-                bin_image = kraken.binarization.nlbin(page_image)
-                file_path = self.workspace.save_image_file(
-                    bin_image, file_id + '.IMG-BIN',
-                    self.output_file_grp,
-                    page_id=input_file.pageId)
-                page.add_AlternativeImage(AlternativeImageType(
-                    filename=file_path,
-                    comments=page_coords['features'] + ',binarized'))
-            else:
-                for region in page.get_AllRegions(classes=['Text']):
-                    region_image, region_coords = self.workspace.image_from_segment(
-                        region, page_image, page_coords, feature_filter='binarized')
-                    if self.parameter['level-of-operation'] == 'region':
-                        log.info("Binarizing region '%s'", region.id)
-                        bin_image = kraken.binarization.nlbin(region_image)
-                        file_path = self.workspace.save_image_file(
-                            bin_image, file_id + '_' + region.id + '.IMG-BIN',
-                            self.output_file_grp,
-                            page_id=input_file.pageId)
-                        region.add_AlternativeImage(AlternativeImageType(
-                            filename=file_path,
-                            comments=region_coords['features'] + ',binarized'))
-                    else:
-                        for line in region.get_TextLine():
-                            line_image, line_coords = self.workspace.image_from_segment(
-                                line, region_image, region_coords, feature_filter='binarized')
-                            log.info("Binarizing line '%s'", line.id)
-                            bin_image = kraken.binarization.nlbin(line_image)
-                            file_path = self.workspace.save_image_file(
-                                bin_image, file_id + '_' + region.id + '_' + line.id + '.IMG-BIN',
-                                self.output_file_grp,
-                                page_id=input_file.pageId)
-                            line.add_AlternativeImage(AlternativeImageType(
-                                filename=file_path,
-                                comments=line_coords['features'] + ',binarized'))
-            # update METS (add the PAGE file):
-            file_path = os.path.join(self.output_file_grp, file_id + '.xml')
-            pcgts.set_pcGtsId(file_id)
-            out = self.workspace.add_file(
-                ID=file_id,
-                file_grp=self.output_file_grp,
-                pageId=input_file.pageId,
-                local_filename=file_path,
-                mimetype=MIMETYPE_PAGE,
-                content=to_xml(pcgts))
+        pcgts = input_pcgts[0]
+        page = pcgts.get_Page()
+        assert page
+        page_image, page_xywh, _ = self.workspace.image_from_page(
+            page, page_id, feature_filter='binarized')
+        ret = [pcgts]
+        if self.parameter['level-of-operation'] == 'page':
+            self.logger.info("Binarizing page '%s'", page_id)
+            bin_image = kraken.binarization.nlbin(page_image)
+            bin_image_id = f'{output_file_id}.IMG-BIN'
+            bin_image_path = join(self.output_file_grp, f'{bin_image_id}.png')
+            page.add_AlternativeImage(AlternativeImageType(filename=bin_image_path, comments=f'{page_xywh["features"]},binarized'))
+            ret.append((bin_image, bin_image_id, bin_image_path))
+        else:
+            for region in page.get_AllRegions(classes=['Text']):
+                region_image, region_xywh = self.workspace.image_from_segment(
+                    region, page_image, page_xywh, feature_filter='binarized')
+                if self.parameter['level-of-operation'] == 'region':
+                    self.logger.info("Binarizing region '%s'", region.id)
+                    bin_image = kraken.binarization.nlbin(region_image)
+                    bin_image_id = f'{output_file_id}_{region.id}.IMG-BIN'
+                    bin_image_path = join(self.output_file_grp, f'{bin_image_id}.png')
+                    region.add_AlternativeImage(AlternativeImageType(filename=bin_image_path, comments=f'{region_xywh["features"]},binarized'))
+                    ret.append((bin_image, bin_image_id, bin_image_path))
+                else:
+                    for line in region.get_TextLine():
+                        line_image, line_xywh = self.workspace.image_from_segment(
+                            line, region_image, region_xywh, feature_filter='binarized')
+                        self.logger.info("Binarizing line '%s'", line.id)
+                        bin_image = kraken.binarization.nlbin(line_image)
+                        bin_image_id = f'{output_file_id}_{region.id}_{line.id}.IMG-BIN'
+                        bin_image_path = join(self.output_file_grp, f'{bin_image_id}.png')
+                        line.add_AlternativeImage(AlternativeImageType(filename=bin_image_path, comments=f'{page_xywh["features"]},binarized'))
+                        ret.append((bin_image, bin_image_id, bin_image_path))
+        return ret

ocrd_kraken/ocrd-tool.json

@@ -4,8 +4,8 @@
   "tools": {
     "ocrd-kraken-binarize": {
       "executable": "ocrd-kraken-binarize",
-      "input_file_grp": ["OCR-D-IMG", "OCR-D-PRE-CROP", "OCR-D-SEG-REGION", "OCR-D-SEG-LINE"],
-      "output_file_grp": ["OCR-D-PRE-BIN"],
+      "input_file_grp_cardinality": 1,
+      "output_file_grp_cardinality": 1,
       "categories": [
         "Image preprocessing"
       ],
@@ -24,8 +24,8 @@
     },
     "ocrd-kraken-segment": {
       "executable": "ocrd-kraken-segment",
-      "input_file_grp": ["OCR-D-IMG", "OCR-D-PRE-CROP", "OCR-D-PRE-BIN"],
-      "output_file_grp": ["OCR-D-SEG-REGION", "OCR-D-SEG-LINE"],
+      "input_file_grp_cardinality": 1,
+      "output_file_grp_cardinality": 1,
       "categories": [
         "Layout analysis"
       ],
@@ -128,8 +128,8 @@
     },
     "ocrd-kraken-recognize": {
       "executable": "ocrd-kraken-recognize",
-      "input_file_grp": ["OCR-D-SEG-LINE"],
-      "output_file_grp": ["OCR-D-OCR-KRAK"],
+      "input_file_grp_cardinality": 1,
+      "output_file_grp_cardinality": 1,
       "categories": ["Text recognition and optimization"],
       "steps": ["recognition/text-recognition"],
       "description": "Text recognition with Kraken",