ocrd 3.6.0__py3-none-any.whl → 3.8.0__py3-none-any.whl

ocrd/cli/__init__.py

@@ -32,12 +32,11 @@ from ..decorators import ocrd_loglevel
 from .ocrd_tool import ocrd_tool_cli
 from .workspace import workspace_cli
 from .process import process_cli
-from .bashlib import bashlib_cli
 from .validate import validate_cli
 from .resmgr import resmgr_cli
 from .zip import zip_cli
-from .log import log_cli
 from .network import network_cli
+from .bashlib import bashlib_cli
 
 
 __all__ = ['cli']
@@ -117,9 +116,8 @@ def cli(**kwargs):  # pylint: disable=unused-argument
 cli.add_command(ocrd_tool_cli)
 cli.add_command(workspace_cli)
 cli.add_command(process_cli)
-cli.add_command(bashlib_cli)
 cli.add_command(zip_cli)
 cli.add_command(validate_cli)
-cli.add_command(log_cli)
 cli.add_command(resmgr_cli)
 cli.add_command(network_cli)
+cli.add_command(bashlib_cli)

ocrd/cli/bashlib.py

@@ -6,24 +6,14 @@ OCR-D CLI: bash library
     :nested: full
 
 """
-from __future__ import print_function
-import sys
-import click
 
+# WARNING: bashlib processors have been deprecated as of v3 of the OCR-D/core API
+#          and will be removed in v3.7.0. We retain the `ocrd bashlib` CLI only
+#          to not break the `ocrd bashlib filename` command, which is used in CD
+#          scripts to get the `share` directory of the core installation. 
+
+import click
 from ocrd.constants import BASHLIB_FILENAME
-import ocrd.constants
-import ocrd_utils.constants
-from ocrd_utils.constants import DEFAULT_METS_BASENAME
-import ocrd_models.constants
-import ocrd_validators.constants
-from ocrd.decorators import (
-    parameter_option,
-    parameter_override_option,
-    ocrd_loglevel,
-    ocrd_cli_wrap_processor
-)
-from ocrd_utils import make_file_id
-from ocrd.processor import Processor
 
 # ----------------------------------------------------------------------
 # ocrd bashlib
@@ -50,104 +40,3 @@ def bashlib_filename():
     """
     print(BASHLIB_FILENAME)
 
-
-@bashlib_cli.command('constants')
-@click.argument('name')
-def bashlib_constants(name):
-    """
-    Query constants from ocrd_utils and ocrd_models
-    """
-    all_constants = {}
-    for src in [ocrd.constants, ocrd_utils.constants, ocrd_models.constants, ocrd_validators.constants]:
-        for k in src.__all__:
-            all_constants[k] = src.__dict__[k]
-    if name in ['*', 'KEYS', '__all__']:
-        print(sorted(all_constants.keys()))
-        sys.exit(0)
-    if name not in all_constants:
-        print("ERROR: name '%s' is not a known constant" % name, file=sys.stderr)
-        sys.exit(1)
-    val = all_constants[name]
-    if isinstance(val, dict):
-        # make this bash-friendly (show initialization for associative array)
-        for key in val:
-            print("[%s]=%s" % (key, val[key]), end=' ')
-    else:
-        print(val)
-
-
-@bashlib_cli.command('input-files')
-@click.option('--ocrd-tool', help="path to ocrd-tool.json of processor to feed", default=None)
-@click.option('--executable', help="name of processor executable in ocrd-tool.json", default=None)
-@click.option('-m', '--mets', help="METS to process", default=DEFAULT_METS_BASENAME)
-@click.option('-U', '--mets-server-url', help='TCP host URI or UDS path of METS server', default=None)
-@click.option('-d', '--working-dir', help="Working Directory")
-@click.option('-I', '--input-file-grp', help='File group(s) used as input.', default=None)
-@click.option('-O', '--output-file-grp', help='File group(s) used as output.', default=None)
-@click.option('-g', '--page-id', help="ID(s) of the pages to process")
-@click.option('--overwrite', is_flag=True, default=False, help="Remove output pages/images if they already exist\n"
-              "(with '--page-id', remove only those).\n"
-              "Short-hand for OCRD_EXISTING_OUTPUT=OVERWRITE")
-@click.option('--debug', is_flag=True, default=False, help="Abort on any errors with full stack trace.\n"
-              "Short-hand for OCRD_MISSING_OUTPUT=ABORT")
-@parameter_option
-@parameter_override_option
-@ocrd_loglevel
-def bashlib_input_files(ocrd_tool, executable, **kwargs):
-    """
-    List input files for processing
-
-    Instantiate a processor and workspace from the given processing options.
-    Then loop through the input files of the input fileGrp, and for each one,
-    print its `url`, `ID`, `mimetype` and `pageId`, as well as its recommended
-    `outputFileId` (from ``make_file_id``).
-
-    (The printing format is one associative array initializer per line.)
-    """
-    class BashlibProcessor(Processor):
-        # go half way of the normal run_processor / process_workspace call tree
-        # by just delegating to process_workspace, overriding process_page_file
-        # to ensure all input files exist locally (without persisting them in the METS)
-        # and print what needs to be acted on in bash-friendly way
-        def process_page_file(self, *input_files):
-            for field in ['url', 'local_filename', 'ID', 'mimetype', 'pageId']:
-                # make this bash-friendly (show initialization for associative array)
-                if len(input_files) > 1:
-                    # single quotes allow us to preserve the list value inside the alist
-                    value = ' '.join(str(getattr(res, field)) for res in input_files)
-                else:
-                    value = str(getattr(input_files[0], field))
-                print(f"[{field}]='{value}'", end=' ')
-            output_file_id = make_file_id(input_files[0], kwargs['output_file_grp'])
-            print(f"[outputFileId]='{output_file_id}'")
-    if ocrd_tool and executable:
-        class FullBashlibProcessor(BashlibProcessor):
-            @property
-            def metadata_location(self):
-                # needed for metadata loading and validation mechanism
-                return ocrd_tool
-
-            @property
-            def executable(self):
-                # needed for ocrd_tool lookup
-                return executable
-        processor_class = FullBashlibProcessor
-    else:
-        # we have no true metadata file, so fill in just to make it work
-        class UnknownBashlibProcessor(BashlibProcessor):
-            @property
-            def ocrd_tool(self):
-                # needed to satisfy the validator
-                return {'executable': '',
-                        # required now
-                        'input_file_grp_cardinality': 1,
-                        'output_file_grp_cardinality': 1,
-                        'steps': ['']}
-
-            @property
-            def version(self):
-                # needed to satisfy the validator and wrapper
-                return '1.0'
-        processor_class = UnknownBashlibProcessor
-
-    ocrd_cli_wrap_processor(processor_class, **kwargs)

ocrd/cli/network.py

@@ -12,6 +12,7 @@ from ocrd_network.cli import (
     client_cli,
     processing_server_cli,
     processing_worker_cli,
+    resource_manager_server_cli
 )
 
 
@@ -26,3 +27,4 @@ def network_cli():
 network_cli.add_command(client_cli)
 network_cli.add_command(processing_server_cli)
 network_cli.add_command(processing_worker_cli)
+network_cli.add_command(resource_manager_server_cli)

ocrd/cli/resmgr.py

@@ -20,6 +20,7 @@ from ocrd_utils import (
     get_ocrd_tool_json,
     initLogging,
     RESOURCE_LOCATIONS,
+    RESOURCE_TYPES
 )
 from ocrd.constants import RESOURCE_USER_LIST_COMMENT
 
@@ -70,16 +71,16 @@ def list_installed(executable=None):
 @resmgr_cli.command('download')
 @click.option('-n', '--any-url', default='', help='URL of unregistered resource to download/copy from')
 @click.option('-D', '--no-dynamic', default=False, is_flag=True,
-              help="Whether to skip looking into each processor's --dump-{json,module-dir} for module-level resources")
-@click.option('-t', '--resource-type', type=click.Choice(['file', 'directory', 'archive']), default='file',
-              help='Type of resource',)
-@click.option('-P', '--path-in-archive', default='.', help='Path to extract in case of archive type')
+              help="Skip looking into each processor's --dump-{json,module-dir} module-registered resources")
+@click.option('-t', '--resource-type', type=click.Choice(RESOURCE_TYPES), default='file',
+              help='Type of resource (when unregistered or incomplete)',)
+@click.option('-P', '--path-in-archive', default='.', help='Path to extract in case of archive type (when unregistered or incomplete)')
 @click.option('-a', '--allow-uninstalled', is_flag=True,
-              help="Allow installing resources for uninstalled processors",)
+              help="Allow installing resources for not installed processors",)
 @click.option('-o', '--overwrite', help='Overwrite existing resources', is_flag=True)
-@click.option('-l', '--location', type=click.Choice(RESOURCE_LOCATIONS),
+@click.option('-l', '--location', type=click.Choice(RESOURCE_LOCATIONS), 
               help="Where to store resources - defaults to first location in processor's 'resource_locations' "
-                   "list or finally 'data'")
+                   "list, i.e. usually 'data'")
 @click.argument('executable', required=True)
 @click.argument('name', required=False)
 def download(any_url, no_dynamic, resource_type, path_in_archive, allow_uninstalled, overwrite, location, executable,
@@ -106,8 +107,6 @@ def download(any_url, no_dynamic, resource_type, path_in_archive, allow_uninstal
         executable = None
     if name == '*':
         name = None
-    is_url = (any_url.startswith('https://') or any_url.startswith('http://')) if any_url else False
-    is_filename = Path(any_url).exists() if any_url else False
     if executable and not which(executable):
         if not allow_uninstalled:
             log.error(f"Executable '{executable}' is not installed. "
@@ -126,65 +125,30 @@ def download(any_url, no_dynamic, resource_type, path_in_archive, allow_uninstal
                 'path_in_archive': path_in_archive}]
             )]
     for this_executable, this_reslist in reslist:
-        for resdict in this_reslist:
-            if 'size' in resdict:
-                registered = "registered"
-            else:
-                registered = "unregistered"
-            if any_url:
-                resdict['url'] = any_url
-            if resdict['url'] == '???':
-                log.warning(f"Cannot download user resource {resdict['name']}")
-                continue
-            if resdict['url'].startswith('https://') or resdict['url'].startswith('http://'):
-                log.info(f"Downloading {registered} resource '{resdict['name']}' ({resdict['url']})")
-                if 'size' not in resdict:
-                    with requests.head(resdict['url']) as r:
-                        resdict['size'] = int(r.headers.get('content-length', 0))
-            else:
-                log.info(f"Copying {registered} resource '{resdict['name']}' ({resdict['url']})")
-                urlpath = Path(resdict['url'])
-                resdict['url'] = str(urlpath.resolve())
-                if Path(urlpath).is_dir():
-                    resdict['size'] = directory_size(urlpath)
-                else:
-                    resdict['size'] = urlpath.stat().st_size
-            if not location:
-                location = get_ocrd_tool_json(this_executable)['resource_locations'][0]
-            elif location not in get_ocrd_tool_json(this_executable)['resource_locations']:
-                log.error(f"The selected --location {location} is not in the {this_executable}'s resource search path, "
-                          f"refusing to install to invalid location")
-                sys.exit(1)
-            if location != 'module':
-                basedir = resmgr.location_to_resource_dir(location)
-            else:
-                basedir = get_moduledir(this_executable)
-                if not basedir:
-                    basedir = resmgr.location_to_resource_dir('data')
-
+        resource_locations = get_ocrd_tool_json(this_executable)['resource_locations']
+        if not location:
+            location = resource_locations[0]
+        elif location not in resource_locations:
+            log.warning(f"The selected --location {location} is not in the {this_executable}'s resource search path, "
+                        f"refusing to install to invalid location. Instead installing to: {resource_locations[0]}")
+        res_dest_dir = resmgr.build_resource_dest_dir(location=location, executable=this_executable)
+        for res_dict in this_reslist:
             try:
-                with click.progressbar(length=resdict['size']) as bar:
-                    fpath = resmgr.download(
-                        this_executable,
-                        resdict['url'],
-                        basedir,
-                        name=resdict['name'],
-                        resource_type=resdict.get('type', resource_type),
-                        path_in_archive=resdict.get('path_in_archive', path_in_archive),
-                        overwrite=overwrite,
-                        no_subdir=location in ['cwd', 'module'],
-                        progress_cb=lambda delta: bar.update(delta)
-                    )
-                if registered == 'unregistered':
-                    log.info(f"{this_executable} resource '{name}' ({any_url}) not a known resource, creating stub "
-                             f"in {resmgr.user_list}'")
-                    resmgr.add_to_user_database(this_executable, fpath, url=any_url)
-                resmgr.save_user_list()
-                log.info(f"Installed resource {resdict['url']} under {fpath}")
+                fpath = resmgr.handle_resource(
+                    res_dict=res_dict,
+                    executable=this_executable,
+                    dest_dir=res_dest_dir,
+                    any_url=any_url,
+                    overwrite=overwrite,
+                    resource_type=resource_type,
+                    path_in_archive=path_in_archive
+                )
+                if not fpath:
+                    continue
             except FileExistsError as exc:
                 log.info(str(exc))
-            log.info(f"Use in parameters as "
-                     f"'{resmgr.parameter_usage(resdict['name'], usage=resdict.get('parameter_usage', 'as-is'))}'")
+            usage = res_dict.get('parameter_usage', 'as-is')
+            log.info(f"Use in parameters as '{resmgr.parameter_usage(res_dict['name'], usage)}'")
 
 
 @resmgr_cli.command('migrate')

ocrd/constants.py

@@ -9,7 +9,6 @@ __all__ = [
     'DOWNLOAD_DIR',
     'DEFAULT_REPOSITORY_URL',
     'BASHLIB_FILENAME',
-    'RESOURCE_LIST_FILENAME',
     'BACKUP_DIR',
     'RESOURCE_USER_LIST_COMMENT',
 ]
@@ -19,6 +18,5 @@ DEFAULT_UPLOAD_FOLDER = '/tmp/uploads-ocrd-core'
 DOWNLOAD_DIR = '/tmp/ocrd-core-downloads'
 DEFAULT_REPOSITORY_URL = 'http://localhost:5000/'
 BASHLIB_FILENAME = resource_filename(__package__, 'lib.bash')
-RESOURCE_LIST_FILENAME = resource_filename(__package__, 'resource_list.yml')
 RESOURCE_USER_LIST_COMMENT = "# OCR-D private resource list (consider sending a PR with your own resources to OCR-D/core)"
 BACKUP_DIR = '.backup'

ocrd/mets_server.py

@@ -258,12 +258,12 @@ class ClientSideOcrdMets:
 
     def add_agent(self, **kwargs):
         if not self.multiplexing_mode:
-            return self.session.request("POST", f"{self.url}/agent", json=OcrdAgentModel.create(**kwargs).dict())
+            return self.session.request("POST", f"{self.url}/agent", json=OcrdAgentModel.create(**kwargs).model_dump())
         else:
             self.session.request(
                 "POST",
                 self.url,
-                json=MpxReq.add_agent(self.ws_dir_path, OcrdAgentModel.create(**kwargs).dict())
+                json=MpxReq.add_agent(self.ws_dir_path, OcrdAgentModel.create(**kwargs).model_dump())
             ).json()
             return OcrdAgentModel.create(**kwargs)
 
@@ -305,7 +305,7 @@ class ClientSideOcrdMets:
             mimetype=mimetype, url=url, local_filename=local_filename
         )
         # add force+ignore
-        kwargs = {**kwargs, **data.dict()}
+        kwargs = {**kwargs, **data.model_dump()}
 
         if not self.multiplexing_mode:
             r = self.session.request("POST", f"{self.url}/file", data=kwargs)
@@ -530,7 +530,7 @@ class OcrdMetsServer:
 
         @app.post(path='/agent', response_model=OcrdAgentModel)
         async def add_agent(agent: OcrdAgentModel):
-            kwargs = agent.dict()
+            kwargs = agent.model_dump()
             kwargs['_type'] = kwargs.pop('type')
             workspace.mets.add_agent(**kwargs)
             response = agent
@@ -575,7 +575,7 @@ class OcrdMetsServer:
                 local_filename=local_filename
             )
             # Add to workspace
-            kwargs = file_resource.dict()
+            kwargs = file_resource.model_dump()
             workspace.add_file(**kwargs, force=force)
             response = file_resource
             self.log.debug(f"POST /file -> {response.__dict__}")

ocrd/processor/base.py

@@ -42,15 +42,14 @@ from .ocrd_page_result import OcrdPageResult
 from ocrd_utils import (
     VERSION as OCRD_VERSION,
     MIMETYPE_PAGE,
-    MIME_TO_EXT,
     config,
     getLogger,
     list_resource_candidates,
-    pushd_popd,
     list_all_resources,
     get_processor_resource_types,
     resource_filename,
     parse_json_file_with_comments,
+    pushd_popd,
     make_file_id,
     deprecation_warning
 )
@@ -608,7 +607,7 @@ class Processor():
         """
         Ensure all input files for a single page are
         downloaded to the workspace, then schedule
-        :py:meth:`.process_process_file` to be run on
+        :py:meth:`.process_page_file` to be run on
         them via `executor` (enforcing a per-page time
         limit of `max_seconds`).
 
@@ -935,9 +934,8 @@ class Processor():
             cwd = self.old_pwd
         else:
             cwd = getcwd()
-        ret = [cand for cand in list_resource_candidates(executable, val,
-                                                         cwd=cwd, moduled=self.moduledir)
-               if exists(cand)]
+        ret = list(filter(exists, list_resource_candidates(executable, val,
+                                                           cwd=cwd, moduled=self.moduledir)))
         if ret:
             self._base_logger.debug("Resolved %s to absolute path %s" % (val, ret[0]))
             return ret[0]
@@ -968,17 +966,9 @@ class Processor():
         """
         List all resources found in the filesystem and matching content-type by filename suffix
         """
-        mimetypes = get_processor_resource_types(None, self.ocrd_tool)
-        for res in list_all_resources(self.ocrd_tool['executable'], moduled=self.moduledir):
+        for res in list_all_resources(self.executable, ocrd_tool=self.ocrd_tool, moduled=self.moduledir):
             res = Path(res)
-            if '*/*' not in mimetypes:
-                if res.is_dir() and 'text/directory' not in mimetypes:
-                    continue
-                # if we do not know all MIME types, then keep the file, otherwise require suffix match
-                if res.is_file() and not any(res.suffix == MIME_TO_EXT.get(mime, res.suffix)
-                                             for mime in mimetypes):
-                    continue
-            yield res
+            yield res.name
 
     @property
     def module(self):

ocrd/processor/builtin/dummy/ocrd-tool.json

@@ -37,6 +37,31 @@
           "description": "Whether to extract an image for each filtered segment and write to the output fileGrp."
         }
       }
+    },
+    "ocrd-command": {
+      "executable": "ocrd-command",
+      "description": "Bare-bones processor runs shell commands to process PAGE files",
+        "steps": ["recognition/text-recognition", "recognition/font-identification", "recognition/post-correction", "layout/segmentation", "layout/analysis"],
+      "categories": [],
+      "input_file_grp_cardinality": [1, -1],
+      "output_file_grp_cardinality": 1,
+      "parameters": {
+        "command": {
+          "type": "string",
+          "default": "cat @INFILE > @OUTFILE",
+          "description": "Shell command to operate on PAGE files, with @INFILE as place-holder for the input file path(s), and @OUTFILE as place-holder for the output file path. If running on multiple input fileGrps, then @INFILE must be repeated as many times."
+        }
+      }
+    },
+    "ocrd-merge": {
+      "executable": "ocrd-merge",
+      "description": "Bare-bones processor merges annotations from multiple fileGrps",
+        "steps": ["layout/segmentation"],
+      "categories": [],
+      "input_file_grp_cardinality": [1, -1],
+      "output_file_grp_cardinality": 1,
+      "parameters": {
+      }
     }
   }
 }

ocrd/processor/builtin/merge_processor.py

@@ -0,0 +1,131 @@
+# pylint: disable=missing-module-docstring,invalid-name
+from typing import Optional
+from itertools import count
+from collections import OrderedDict as odict
+
+import click
+
+from ocrd import Processor, OcrdPageResult
+from ocrd.decorators import ocrd_cli_options, ocrd_cli_wrap_processor
+from ocrd_modelfactory import page_from_file
+from ocrd_models import OcrdPage
+from ocrd_models.ocrd_page import (
+    BorderType,
+    CoordsType,
+    ReadingOrderType,
+    UnorderedGroupType,
+)
+from ocrd_utils import bbox_from_points
+
+_SEGTYPES = [
+    "NoiseRegion",
+    "LineDrawingRegion",
+    "AdvertRegion",
+    "ImageRegion",
+    "ChartRegion",
+    "MusicRegion",
+    "GraphicRegion",
+    "UnknownRegion",
+    "CustomRegion",
+    "SeparatorRegion",
+    "MathsRegion",
+    "TextRegion",
+    "MapRegion",
+    "ChemRegion",
+    "TableRegion",
+    "TextLine",
+    "Word",
+    "Glyph"
+]
+
+
+def get_border_bbox(pcgts):
+    if pcgts.Page.Border is None:
+        return [0, 0, pcgts.Page.imageWidth, pcgts.Page.imageHeight]
+    return bbox_from_points(pcgts.Page.Border.Coords.points)
+
+def rename_segments(pcgts, start=1):
+    renamed = {}
+    rodict = pcgts.Page.get_ReadingOrderGroups()
+    # get everything that has an identifier
+    nodes = pcgts.xpath("//*[@id]")
+    # filter segments
+    segments = [segment for segment in map(pcgts.revmap.get, nodes)
+                # get PAGE objects from matching etree nodes
+                # but allow only hierarchy segments
+                if segment.__class__.__name__.replace('Type', '') in _SEGTYPES]
+    # count segments and rename them
+    # fixme: or perhaps better to have each segment type named and counted differently?
+    num = 0
+    regions = []
+    for num, segment in zip(count(start=start), segments):
+        segtype = segment.original_tagname_
+        #parent = segment.parent_object_
+        newname = "seg%011d" % num
+        assert not segment.id in renamed
+        if segtype.endswith('Region') and segment.id in rodict:
+            # update reading order
+            roelem = rodict[segment.id]
+            roelem.regionRef = newname
+        renamed[segment.id] = newname
+        segment.id = newname
+    return num
+
+class MergeProcessor(Processor):
+    def process_page_pcgts(self, *input_pcgts: Optional[OcrdPage], page_id: Optional[str] = None) -> OcrdPageResult:
+        """
+        Merge PAGE segment hierarchy elements from all input file groups.
+
+        For each page, open and deserialise PAGE input files. Rename all elements
+        of the segment hierarchy to new (clash-free) identifers. Redefine the
+        `Border` coordinates as the convex hull of all input borders. Then add all
+        regions from all input files, concatenating them into a single `ReadingOrder`
+        in the order of input file groups.
+
+        Produce a new PAGE output file by serialising the resulting hierarchy.
+        """
+        actual_pcgts = list(filter(None, input_pcgts))
+        assert len(set(pcgts.Page.imageFilename for pcgts in actual_pcgts)) == 1, \
+            "input files must all reference the same @imageFilename"
+        # create new PAGE for image
+        result = OcrdPageResult(page_from_file(actual_pcgts[0].Page.imageFilename))
+        # unify Border
+        borders = [get_border_bbox(pcgts) for pcgts in actual_pcgts]
+        minx, miny, maxx, maxy = zip(*borders)
+        minx = min(minx)
+        miny = min(miny)
+        maxx = max(maxx)
+        maxy = max(maxy)
+        result.pcgts.Page.set_Border(
+            BorderType(CoordsType(
+                points=f"{minx},{miny} {maxx},{miny} {maxx},{maxy} {minx},{maxy}")))
+        # rename all segments
+        num = 1
+        for pcgts in actual_pcgts:
+            num = rename_segments(pcgts, num)
+        # concatenate all regions
+        ug = UnorderedGroupType(id="merged")
+        result.pcgts.Page.set_ReadingOrder(ReadingOrderType(UnorderedGroup=ug))
+        for pcgts in actual_pcgts:
+            for region in pcgts.Page.get_AllRegions():
+                adder = getattr(result.pcgts.Page, 'add_' + region.original_tagname_)
+                adder(region)
+            if pcgts.Page.ReadingOrder:
+                group = pcgts.Page.ReadingOrder.OrderedGroup or pcgts.Page.ReadingOrder.UnorderedGroup
+                adder = getattr(ug, 'add_' + group.original_tagname_)
+                adder(group)
+        return result
+
+    @property
+    def metadata_filename(self):
+        return 'processor/builtin/dummy/ocrd-tool.json'
+
+    @property
+    def executable(self):
+        return 'ocrd-merge'
+
+
+@click.command()
+@ocrd_cli_options
+def cli(*args, **kwargs):
+    return ocrd_cli_wrap_processor(MergeProcessor, *args, **kwargs)

ocrd/processor/builtin/param_command_header2unordered.json

@@ -0,0 +1,7 @@
+{
+    # requires https://github.com/bertsky/workflow-configuration installed
+    # partitions PAGE-XML ReadingOrder from single OrderedGroup to top
+    # UnorderedGroup divided into OrderedGroups starting at every @type=header
+    # text regions.
+    "command": "page-header2unordered @INFILE > @OUTFILE"
+}

ocrd/processor/builtin/param_command_heading2unordered.json

@@ -0,0 +1,7 @@
+{
+    # requires https://github.com/bertsky/workflow-configuration installed
+    # partitions PAGE-XML ReadingOrder from single OrderedGroup to top
+    # UnorderedGroup divided into OrderedGroups starting at every @type=heading
+    # text regions.
+    "command": "page-heading2unordered @INFILE > @OUTFILE"
+}

ocrd/processor/builtin/param_command_lines2orientation.json

@@ -0,0 +1,6 @@
+{
+    # requires https://github.com/bertsky/workflow-configuration installed
+    # retrieves lines from all paragraphs and geometrically determines
+    # their average skew, annotating the result under /Page/@orientation
+    "command": "page-lines2orientation @INFILE > @OUTFILE"
+}

ocrd/processor/builtin/param_command_page-update-version.json

@@ -0,0 +1,5 @@
+{
+    # requires https://github.com/PRImA-Research-Lab/prima-page-converter installed
+    # with the main JAR file copied to /usr/local/share/
+    "command": "java -jar /usr/local/share/PageConverter.jar -source-xml @INFILE -convert-to LATEST -target-xml @OUTFILE"
+}

ocrd/processor/builtin/param_command_transkribus-to-prima.json

@@ -0,0 +1,8 @@
+{
+    # requires https://github.com/kba/transkribus-to-prima installed
+    # converts PAGE from Transkribus dialect to PRImA standard
+    # also runs various fixes often necessary to make this work:
+    # - ensuring coordinates range within the image size
+    # - ensuring segment identifiers do not start with numbers
+    "command": "page-fix-coordinates @INFILE - | sed -e 's/ id=\"/ id=\"id/' -e 's/regionRef=\"/regionRef=\"id/' | transkribus-to-prima -V - @OUTFILE"
+}