ocrd 3.8.1__py3-none-any.whl → 3.9.1__py3-none-any.whl

ocrd_models/ocrd_page_generateds.py

@@ -2,8 +2,8 @@
 # -*- coding: utf-8 -*-
 
 #
-# Generated Mon Feb 17 10:32:54 2025 by generateDS.py version 2.44.1.
-# Python 3.8.17+ (heads/3.8-dirty:1663f8ba84, Aug 15 2023, 18:13:01)  [GCC 8.3.0]
+# Generated Thu Dec 11 12:03:57 2025 by generateDS.py version 2.44.1.
+# Python 3.8.19 (default, Mar 26 2024, 20:08:11)  [GCC 8.5.0]
 #
 # Command line options:
 #   ('-f', '')
@@ -3766,7 +3766,8 @@ class PageType(GeneratedsSuper):
     def get_AllRegions(self, classes=None, order='document', depth=0):
         """
         Get all the ``*Region`` elements, or only those provided by `classes`.
-        Return in document order, unless `order` is ``reading-order``.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
     
         Arguments:
             classes (list): Classes of regions that shall be returned, \
@@ -3775,7 +3776,8 @@ class PageType(GeneratedsSuper):
                 return regions sorted by document order (``document``, default) or by
                 reading order with regions not in the reading order at the end of the
                 returned list (``reading-order``) or regions not in the reading order
-                omitted (``reading-order-only``)
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
             depth (int): Recursive depth to look for regions at, set to `0` for \
                 all regions at any depth. Default: 0
     
@@ -3800,7 +3802,7 @@ class PageType(GeneratedsSuper):
         if depth < 0:
             raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
         ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
-        if order.startswith('reading-order'):
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
             reading_order = self.get_ReadingOrder()
             if reading_order:
                 reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
@@ -3929,21 +3931,23 @@ class PageType(GeneratedsSuper):
         - :py:class:`.UnoderedGroupType`
         - :py:class:`.UnoderedGroupIndexedType`
         """
+        from collections import OrderedDict as odict
         def get_groupdict(group):
             regionrefs = list()
             if isinstance(group, (OrderedGroupType, OrderedGroupIndexedType)):
                 regionrefs = (group.get_RegionRefIndexed() +
                               group.get_OrderedGroupIndexed() +
                               group.get_UnorderedGroupIndexed())
+                regionrefs = sorted(regionrefs, key=lambda x: x.index)
             if isinstance(group, (UnorderedGroupType, UnorderedGroupIndexedType)):
                 regionrefs = (group.get_RegionRef() +
                               group.get_OrderedGroup() +
                               group.get_UnorderedGroup())
-            refdict = {}
+            refdict = odict()
             for elem in regionrefs:
                 refdict[elem.get_regionRef()] = elem
                 if not isinstance(elem, (RegionRefType, RegionRefIndexedType)):
-                    refdict = {**refdict, **get_groupdict(elem)}
+                    refdict = odict(**refdict, **get_groupdict(elem))
             return refdict
         ro = self.get_ReadingOrder()
         if ro is None:
@@ -12673,6 +12677,106 @@ class AdvertRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -12835,6 +12939,106 @@ class MusicRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -12965,69 +13169,169 @@ class MapRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
-    def set_orientation(self, orientation):
-        """
-        Set deskewing angle to given `orientation` number.
-        Moreover, invalidate self's ``pc:AlternativeImage``s
-        (because they will have been rotated and enlarged
-        with the angle of the previous value).
-        """
-        if hasattr(self, 'invalidate_AlternativeImage'):
-            # PageType, RegionType:
-            self.invalidate_AlternativeImage(feature_selector='deskewed')
-        self.orientation = orientation
-# end class MapRegionType
-
-
-class ChemRegionType(RegionType):
-    """ChemRegionType --
-    Regions containing chemical formulas.
-      
-    * orientation --
-      The angle the rectangle encapsulating a
-      region has to be rotated in clockwise
-      direction in order to correct the present
-      skew (negative values indicate
-      anti-clockwise rotation). Range:
-      -179.999,180
-      
-    * bgColour --
-      The background colour of the region
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
     
-    """
-    __hash__ = GeneratedsSuper.__hash__
-    member_data_items_ = [
-        MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional', 'name': 'orientation'}),
-        MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional', 'name': 'bgColour'}),
-    ]
-    subclass = None
-    superclass = RegionType
-    def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, bgColour=None, gds_collector_=None, **kwargs_):
-        self.gds_collector_ = gds_collector_
-        self.gds_elementtree_node_ = None
-        self.original_tagname_ = None
-        self.parent_object_ = kwargs_.get('parent_object_')
-        self.ns_prefix_ = "pc"
-        super(globals().get("ChemRegionType"), self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion,  **kwargs_)
-        self.orientation = _cast(float, orientation)
-        self.orientation_nsprefix_ = "pc"
-        self.bgColour = _cast(None, bgColour)
-        self.bgColour_nsprefix_ = "pc"
-    def factory(*args_, **kwargs_):
-        if CurrentSubclassModule_ is not None:
-            subclass = getSubclassFromModule_(
-                CurrentSubclassModule_, ChemRegionType)
-            if subclass is not None:
-                return subclass(*args_, **kwargs_)
-        if ChemRegionType.subclass:
-            return ChemRegionType.subclass(*args_, **kwargs_)
-        else:
-            return ChemRegionType(*args_, **kwargs_)
-    factory = staticmethod(factory)
-    def get_ns_prefix_(self):
-        return self.ns_prefix_
-    def set_ns_prefix_(self, ns_prefix):
-        self.ns_prefix_ = ns_prefix
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
+    def set_orientation(self, orientation):
+        """
+        Set deskewing angle to given `orientation` number.
+        Moreover, invalidate self's ``pc:AlternativeImage``s
+        (because they will have been rotated and enlarged
+        with the angle of the previous value).
+        """
+        if hasattr(self, 'invalidate_AlternativeImage'):
+            # PageType, RegionType:
+            self.invalidate_AlternativeImage(feature_selector='deskewed')
+        self.orientation = orientation
+# end class MapRegionType
+
+
+class ChemRegionType(RegionType):
+    """ChemRegionType --
+    Regions containing chemical formulas.
+      
+    * orientation --
+      The angle the rectangle encapsulating a
+      region has to be rotated in clockwise
+      direction in order to correct the present
+      skew (negative values indicate
+      anti-clockwise rotation). Range:
+      -179.999,180
+      
+    * bgColour --
+      The background colour of the region
+    
+    """
+    __hash__ = GeneratedsSuper.__hash__
+    member_data_items_ = [
+        MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional', 'name': 'orientation'}),
+        MemberSpec_('bgColour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional', 'name': 'bgColour'}),
+    ]
+    subclass = None
+    superclass = RegionType
+    def __init__(self, id=None, custom=None, comments=None, continuation=None, AlternativeImage=None, Coords=None, UserDefined=None, Labels=None, Roles=None, TextRegion=None, ImageRegion=None, LineDrawingRegion=None, GraphicRegion=None, TableRegion=None, ChartRegion=None, SeparatorRegion=None, MathsRegion=None, ChemRegion=None, MusicRegion=None, AdvertRegion=None, NoiseRegion=None, UnknownRegion=None, CustomRegion=None, orientation=None, bgColour=None, gds_collector_=None, **kwargs_):
+        self.gds_collector_ = gds_collector_
+        self.gds_elementtree_node_ = None
+        self.original_tagname_ = None
+        self.parent_object_ = kwargs_.get('parent_object_')
+        self.ns_prefix_ = "pc"
+        super(globals().get("ChemRegionType"), self).__init__(id, custom, comments, continuation, AlternativeImage, Coords, UserDefined, Labels, Roles, TextRegion, ImageRegion, LineDrawingRegion, GraphicRegion, TableRegion, ChartRegion, SeparatorRegion, MathsRegion, ChemRegion, MusicRegion, AdvertRegion, NoiseRegion, UnknownRegion, CustomRegion,  **kwargs_)
+        self.orientation = _cast(float, orientation)
+        self.orientation_nsprefix_ = "pc"
+        self.bgColour = _cast(None, bgColour)
+        self.bgColour_nsprefix_ = "pc"
+    def factory(*args_, **kwargs_):
+        if CurrentSubclassModule_ is not None:
+            subclass = getSubclassFromModule_(
+                CurrentSubclassModule_, ChemRegionType)
+            if subclass is not None:
+                return subclass(*args_, **kwargs_)
+        if ChemRegionType.subclass:
+            return ChemRegionType.subclass(*args_, **kwargs_)
+        else:
+            return ChemRegionType(*args_, **kwargs_)
+    factory = staticmethod(factory)
+    def get_ns_prefix_(self):
+        return self.ns_prefix_
+    def set_ns_prefix_(self, ns_prefix):
+        self.ns_prefix_ = ns_prefix
     def get_orientation(self):
         return self.orientation
     def set_orientation(self, orientation):
@@ -13128,6 +13432,106 @@ class ChemRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -13291,6 +13695,106 @@ class MathsRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -13455,6 +13959,106 @@ class SeparatorRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -13696,6 +14300,106 @@ class ChartRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -13991,6 +14695,106 @@ class TableRegionType(RegionType):
         super(TableRegionType, self)._buildChildren(child_, node, nodeName_, True)
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -14199,6 +15003,106 @@ class GraphicRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -14407,6 +15311,106 @@ class LineDrawingRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -14628,6 +15632,106 @@ class ImageRegionType(RegionType):
         pass
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.
@@ -15191,6 +16295,106 @@ class TextRegionType(RegionType):
         super(TextRegionType, self)._buildChildren(child_, node, nodeName_, True)
     def __hash__(self):
         return hash(self.id)
+    # pylint: disable=line-too-long,invalid-name,protected-access,missing-module-docstring
+    def _region_class(self, x): # pylint: disable=unused-argument
+        return x.__class__.__name__.replace('RegionType', '')
+    
+    def _get_recursive_regions(self, regions, level, classes=None):
+        from .constants import PAGE_REGION_TYPES  # pylint: disable=relative-beyond-top-level,import-outside-toplevel
+        if level == 1:
+            # stop recursion, filter classes
+            if classes:
+                return [r for r in regions if self._region_class(r) in classes]
+            if regions and regions[0].__class__.__name__ == 'PageType':
+                regions = regions[1:]
+            return regions
+        # find more regions recursively
+        more_regions = []
+        for region in regions:
+            more_regions.append([])
+            for class_ in PAGE_REGION_TYPES:
+                if class_ == 'Map' and not isinstance(region, PageType): # pylint: disable=undefined-variable
+                    # 'Map' is not recursive in 2019 schema
+                    continue
+                more_regions[-1] += getattr(region, 'get_{}Region'.format(class_))()
+        if not any(more_regions):
+            return self._get_recursive_regions(regions, 1, classes)
+        ret = []
+        for r, more in zip(regions, more_regions):
+            ret.append(r)
+            ret += self._get_recursive_regions(more, level - 1 if level else 0, classes)
+        return self._get_recursive_regions(ret, 1, classes)
+    
+    def _get_recursive_reading_order(self, rogroup):
+        if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = rogroup.get_AllIndexed()
+        if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)): # pylint: disable=undefined-variable
+            elements = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() + rogroup.get_UnorderedGroup())
+        regionrefs = list()
+        for elem in elements:
+            regionrefs.append(elem.get_regionRef())
+            if not isinstance(elem, (RegionRefType, RegionRefIndexedType)): # pylint: disable=undefined-variable
+                regionrefs.extend(self._get_recursive_reading_order(elem))
+        return regionrefs
+    
+    def get_AllRegions(self, classes=None, order='document', depth=0):
+        """
+        Get all the ``*Region`` elements, or only those provided by `classes`.
+        Return in document order, unless the top element is ``Page`` and
+        `order` is ``reading-order``.
+    
+        Arguments:
+            classes (list): Classes of regions that shall be returned, \
+                e.g. ``['Text', 'Image']``
+            order ("document"|"reading-order"|"reading-order-only"): Whether to \
+                return regions sorted by document order (``document``, default) or by
+                reading order with regions not in the reading order at the end of the
+                returned list (``reading-order``) or regions not in the reading order
+                omitted (``reading-order-only``). The latter two are only available
+                on page level.
+            depth (int): Recursive depth to look for regions at, set to `0` for \
+                all regions at any depth. Default: 0
+    
+        Returns:
+            a list of :py:class:`TextRegionType`, :py:class:`ImageRegionType`, \
+                :py:class:`LineDrawingRegionType`, :py:class:`GraphicRegionType`, \
+                :py:class:`TableRegionType`, :py:class:`ChartRegionType`, \
+                :py:class:`MapRegionType`, :py:class:`SeparatorRegionType`, \
+                :py:class:`MathsRegionType`, :py:class:`ChemRegionType`, \
+                :py:class:`MusicRegionType`, :py:class:`AdvertRegionType`, \
+                :py:class:`NoiseRegionType`, :py:class:`UnknownRegionType`, \
+                and/or :py:class:`CustomRegionType`
+    
+        For example, to get all text anywhere on the page in reading order, use:
+        ::
+            '\\n'.join(line.get_TextEquiv()[0].Unicode
+                      for region in page.get_AllRegions(classes=['Text'], depth=0, order='reading-order')
+                      for line in region.get_TextLine())
+        """
+        if order not in ['document', 'reading-order', 'reading-order-only']:
+            raise Exception("Argument 'order' must be either 'document', 'reading-order' or 'reading-order-only', not '{}'".format(order))
+        if depth < 0:
+            raise Exception("Argument 'depth' must be an integer greater-or-equal 0, not '{}'".format(depth))
+        ret = self._get_recursive_regions([self], depth + 1 if depth else 0, classes)
+        if self.__class__.__name__ == 'PageType' and order.startswith('reading-order'):
+            reading_order = self.get_ReadingOrder()
+            if reading_order:
+                reading_order = reading_order.get_OrderedGroup() or reading_order.get_UnorderedGroup()
+            if reading_order:
+                reading_order = self._get_recursive_reading_order(reading_order)
+            if reading_order:
+                id2region = {region.id: region for region in ret}
+                in_reading_order = [id2region[region_id] for region_id in reading_order if region_id in id2region]
+                #  print("ret: {} / in_ro: {} / not-in-ro: {}".format(
+                #      len(ret),
+                #      len([id2region[region_id] for region_id in reading_order if region_id in id2region]),
+                #      len([r for r in ret if r not in in_reading_order])
+                #      ))
+                if order == 'reading-order-only':
+                    ret = in_reading_order
+                else:
+                    ret = in_reading_order + [r for r in ret if r not in in_reading_order]
+        return ret
     def set_orientation(self, orientation):
         """
         Set deskewing angle to given `orientation` number.