OCR-D / core

# end class MathsRegionType

class SeparatorRegionType(RegionType):

    """SeparatorRegionType --

    Separators are lines that lie between columns and

    paragraphs and can be used to logically separate

    different articles from each other.

    * 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

    * colour --

      The colour of the separator

    """

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

        MemberSpec_('orientation', 'float', 0, 1, {'use': 'optional', 'name': 'orientation'}),

        MemberSpec_('colour', 'pc:ColourSimpleType', 0, 1, {'use': 'optional', 'name': 'colour'}),

    ]

    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, colour=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("SeparatorRegionType"), 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.colour = _cast(None, colour)

        self.colour_nsprefix_ = "pc"

    def factory(*args_, **kwargs_):

        if CurrentSubclassModule_ is not None:

            subclass = getSubclassFromModule_(

                CurrentSubclassModule_, SeparatorRegionType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if SeparatorRegionType.subclass:

            return SeparatorRegionType.subclass(*args_, **kwargs_)

        else:

            return SeparatorRegionType(*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):

        self.orientation = orientation

    def get_colour(self):

        return self.colour

    def set_colour(self, colour):

        self.colour = colour

    def validate_ColourSimpleType(self, value):

        # Validate type pc:ColourSimpleType, a restriction on string.

        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:

            if not isinstance(value, str):

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, })

                return False

            value = value

            enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other']

            if value not in enumerations:

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} )

                result = False

    def has__content(self):

        if (

            super(SeparatorRegionType, self).has__content()

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='SeparatorRegionType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SeparatorRegionType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'SeparatorRegionType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='SeparatorRegionType')

        if self.has__content():

            outfile.write('>%s' % (eol_, ))

            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SeparatorRegionType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='SeparatorRegionType'):

        super(SeparatorRegionType, self)._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='SeparatorRegionType')

        if self.orientation is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation'))

        if self.colour is not None and 'colour' not in already_processed:

            already_processed.add('colour')

            outfile.write(' colour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.colour), input_name='colour')), ))

    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='SeparatorRegionType', fromsubclass_=False, pretty_print=True):

        super(SeparatorRegionType, self)._exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='SeparatorRegionType', mapping_=None, reverse_mapping_=None, nsmap_=None):

        element = super(SeparatorRegionType, self).to_etree(parent_element, name_, mapping_, reverse_mapping_, nsmap_)

        if self.orientation is not None:

            element.set('orientation', self.gds_format_float(self.orientation))

        if self.colour is not None:

            element.set('colour', self.gds_format_string(self.colour))

        if mapping_ is not None:

            mapping_[id(self)] = element

        if reverse_mapping_ is not None:

            reverse_mapping_[element] = self

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self._buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def _buildAttributes(self, node, attrs, already_processed):

        value = find_attr_value_('orientation', node)

        if value is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            value = self.gds_parse_float(value, node, 'orientation')

            self.orientation = value

        value = find_attr_value_('colour', node)

        if value is not None and 'colour' not in already_processed:

            already_processed.add('colour')

            self.colour = value

            self.validate_ColourSimpleType(self.colour)    # validate type ColourSimpleType

        super(SeparatorRegionType, self)._buildAttributes(node, attrs, already_processed)

    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        super(SeparatorRegionType, self)._buildChildren(child_, node, nodeName_, True)

        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.

        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 SeparatorRegionType

# end class ChemRegionType

class MathsRegionType(RegionType):

    """MathsRegionType --

    Regions containing equations and mathematical symbols

    should be marked as maths regions.

    * 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("MathsRegionType"), 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_, MathsRegionType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if MathsRegionType.subclass:

            return MathsRegionType.subclass(*args_, **kwargs_)

        else:

            return MathsRegionType(*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):

        self.orientation = orientation

    def get_bgColour(self):

        return self.bgColour

    def set_bgColour(self, bgColour):

        self.bgColour = bgColour

    def validate_ColourSimpleType(self, value):

        # Validate type pc:ColourSimpleType, a restriction on string.

        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:

            if not isinstance(value, str):

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, })

                return False

            value = value

            enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other']

            if value not in enumerations:

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} )

                result = False

    def has__content(self):

        if (

            super(MathsRegionType, self).has__content()

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='MathsRegionType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('MathsRegionType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'MathsRegionType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MathsRegionType')

        if self.has__content():

            outfile.write('>%s' % (eol_, ))

            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MathsRegionType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MathsRegionType'):

        super(MathsRegionType, self)._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MathsRegionType')

        if self.orientation is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation'))

        if self.bgColour is not None and 'bgColour' not in already_processed:

            already_processed.add('bgColour')

            outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), ))

    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='MathsRegionType', fromsubclass_=False, pretty_print=True):

        super(MathsRegionType, self)._exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='MathsRegionType', mapping_=None, reverse_mapping_=None, nsmap_=None):

        element = super(MathsRegionType, self).to_etree(parent_element, name_, mapping_, reverse_mapping_, nsmap_)

        if self.orientation is not None:

            element.set('orientation', self.gds_format_float(self.orientation))

        if self.bgColour is not None:

            element.set('bgColour', self.gds_format_string(self.bgColour))

        if mapping_ is not None:

            mapping_[id(self)] = element

        if reverse_mapping_ is not None:

            reverse_mapping_[element] = self

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self._buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def _buildAttributes(self, node, attrs, already_processed):

        value = find_attr_value_('orientation', node)

        if value is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            value = self.gds_parse_float(value, node, 'orientation')

            self.orientation = value

        value = find_attr_value_('bgColour', node)

        if value is not None and 'bgColour' not in already_processed:

            already_processed.add('bgColour')

            self.bgColour = value

            self.validate_ColourSimpleType(self.bgColour)    # validate type ColourSimpleType

        super(MathsRegionType, self)._buildAttributes(node, attrs, already_processed)

    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        super(MathsRegionType, self)._buildChildren(child_, node, nodeName_, True)

        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.

        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 MathsRegionType

# 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):

        self.orientation = orientation

    def get_bgColour(self):

        return self.bgColour

    def set_bgColour(self, bgColour):

        self.bgColour = bgColour

    def validate_ColourSimpleType(self, value):

        # Validate type pc:ColourSimpleType, a restriction on string.

        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:

            if not isinstance(value, str):

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, })

                return False

            value = value

            enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other']

            if value not in enumerations:

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} )

                result = False

    def has__content(self):

        if (

            super(ChemRegionType, self).has__content()

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='ChemRegionType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ChemRegionType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'ChemRegionType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ChemRegionType')

        if self.has__content():

            outfile.write('>%s' % (eol_, ))

            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ChemRegionType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='ChemRegionType'):

        super(ChemRegionType, self)._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ChemRegionType')

        if self.orientation is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation'))

        if self.bgColour is not None and 'bgColour' not in already_processed:

            already_processed.add('bgColour')

            outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), ))

    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='ChemRegionType', fromsubclass_=False, pretty_print=True):

        super(ChemRegionType, self)._exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='ChemRegionType', mapping_=None, reverse_mapping_=None, nsmap_=None):

        element = super(ChemRegionType, self).to_etree(parent_element, name_, mapping_, reverse_mapping_, nsmap_)

        if self.orientation is not None:

            element.set('orientation', self.gds_format_float(self.orientation))

        if self.bgColour is not None:

            element.set('bgColour', self.gds_format_string(self.bgColour))

        if mapping_ is not None:

            mapping_[id(self)] = element

        if reverse_mapping_ is not None:

            reverse_mapping_[element] = self

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self._buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def _buildAttributes(self, node, attrs, already_processed):

        value = find_attr_value_('orientation', node)

        if value is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            value = self.gds_parse_float(value, node, 'orientation')

            self.orientation = value

        value = find_attr_value_('bgColour', node)

        if value is not None and 'bgColour' not in already_processed:

            already_processed.add('bgColour')

            self.bgColour = value

            self.validate_ColourSimpleType(self.bgColour)    # validate type ColourSimpleType

        super(ChemRegionType, self)._buildAttributes(node, attrs, already_processed)

    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        super(ChemRegionType, self)._buildChildren(child_, node, nodeName_, True)

        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.

        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 ChemRegionType

# end class AdvertRegionType

class MusicRegionType(RegionType):

    """MusicRegionType --

    Regions containing musical notations.

    * 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("MusicRegionType"), 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_, MusicRegionType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if MusicRegionType.subclass:

            return MusicRegionType.subclass(*args_, **kwargs_)

        else:

            return MusicRegionType(*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):

        self.orientation = orientation

    def get_bgColour(self):

        return self.bgColour

    def set_bgColour(self, bgColour):

        self.bgColour = bgColour

    def validate_ColourSimpleType(self, value):

        # Validate type pc:ColourSimpleType, a restriction on string.

        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:

            if not isinstance(value, str):

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, })

                return False

            value = value

            enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other']

            if value not in enumerations:

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} )

                result = False

    def has__content(self):

        if (

            super(MusicRegionType, self).has__content()

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='MusicRegionType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('MusicRegionType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'MusicRegionType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MusicRegionType')

        if self.has__content():

            outfile.write('>%s' % (eol_, ))

            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MusicRegionType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MusicRegionType'):

        super(MusicRegionType, self)._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MusicRegionType')

        if self.orientation is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation'))

        if self.bgColour is not None and 'bgColour' not in already_processed:

            already_processed.add('bgColour')

            outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), ))

    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='MusicRegionType', fromsubclass_=False, pretty_print=True):

        super(MusicRegionType, self)._exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='MusicRegionType', mapping_=None, reverse_mapping_=None, nsmap_=None):

        element = super(MusicRegionType, self).to_etree(parent_element, name_, mapping_, reverse_mapping_, nsmap_)

        if self.orientation is not None:

            element.set('orientation', self.gds_format_float(self.orientation))

        if self.bgColour is not None:

            element.set('bgColour', self.gds_format_string(self.bgColour))

        if mapping_ is not None:

            mapping_[id(self)] = element

        if reverse_mapping_ is not None:

            reverse_mapping_[element] = self

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self._buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def _buildAttributes(self, node, attrs, already_processed):

        value = find_attr_value_('orientation', node)

        if value is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            value = self.gds_parse_float(value, node, 'orientation')

            self.orientation = value

        value = find_attr_value_('bgColour', node)

        if value is not None and 'bgColour' not in already_processed:

            already_processed.add('bgColour')

            self.bgColour = value

            self.validate_ColourSimpleType(self.bgColour)    # validate type ColourSimpleType

        super(MusicRegionType, self)._buildAttributes(node, attrs, already_processed)

    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        super(MusicRegionType, self)._buildChildren(child_, node, nodeName_, True)

        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.

        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 MusicRegionType

# end class NoiseRegionType

class AdvertRegionType(RegionType):

    """AdvertRegionType --

    Regions containing advertisements.

    * 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("AdvertRegionType"), 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_, AdvertRegionType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if AdvertRegionType.subclass:

            return AdvertRegionType.subclass(*args_, **kwargs_)

        else:

            return AdvertRegionType(*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):

        self.orientation = orientation

    def get_bgColour(self):

        return self.bgColour

    def set_bgColour(self, bgColour):

        self.bgColour = bgColour

    def validate_ColourSimpleType(self, value):

        # Validate type pc:ColourSimpleType, a restriction on string.

        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:

            if not isinstance(value, str):

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, })

                return False

            value = value

            enumerations = ['black', 'blue', 'brown', 'cyan', 'green', 'grey', 'indigo', 'magenta', 'orange', 'pink', 'red', 'turquoise', 'violet', 'white', 'yellow', 'other']

            if value not in enumerations:

                lineno = self.gds_get_node_lineno_()

                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on ColourSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} )

                result = False

    def has__content(self):

        if (

            super(AdvertRegionType, self).has__content()

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='AdvertRegionType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('AdvertRegionType')

        if imported_ns_def_ is not None:

            namespacedef_ = imported_ns_def_

        if pretty_print:

            eol_ = '\n'

        else:

            eol_ = ''

        if self.original_tagname_ is not None and name_ == 'AdvertRegionType':

            name_ = self.original_tagname_

        if UseCapturedNS_ and self.ns_prefix_:

            namespaceprefix_ = self.ns_prefix_ + ':'

        showIndent(outfile, level, pretty_print)

        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))

        already_processed = set()

        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='AdvertRegionType')

        if self.has__content():

            outfile.write('>%s' % (eol_, ))

            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='AdvertRegionType', pretty_print=pretty_print)

            showIndent(outfile, level, pretty_print)

            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))

        else:

            outfile.write('/>%s' % (eol_, ))

    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='AdvertRegionType'):

        super(AdvertRegionType, self)._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='AdvertRegionType')

        if self.orientation is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            outfile.write(' orientation="%s"' % self.gds_format_float(self.orientation, input_name='orientation'))

        if self.bgColour is not None and 'bgColour' not in already_processed:

            already_processed.add('bgColour')

            outfile.write(' bgColour=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bgColour), input_name='bgColour')), ))

    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='xmlns:pc="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15"', name_='AdvertRegionType', fromsubclass_=False, pretty_print=True):

        super(AdvertRegionType, self)._exportChildren(outfile, level, namespaceprefix_, namespacedef_, name_, True, pretty_print=pretty_print)

    def to_etree(self, parent_element=None, name_='AdvertRegionType', mapping_=None, reverse_mapping_=None, nsmap_=None):

        element = super(AdvertRegionType, self).to_etree(parent_element, name_, mapping_, reverse_mapping_, nsmap_)

        if self.orientation is not None:

            element.set('orientation', self.gds_format_float(self.orientation))

        if self.bgColour is not None:

            element.set('bgColour', self.gds_format_string(self.bgColour))

        if mapping_ is not None:

            mapping_[id(self)] = element

        if reverse_mapping_ is not None:

            reverse_mapping_[element] = self

        return element

    def build(self, node, gds_collector_=None):

        self.gds_collector_ = gds_collector_

        if SaveElementTreeNode:

            self.gds_elementtree_node_ = node

        already_processed = set()

        self.ns_prefix_ = node.prefix

        self._buildAttributes(node, node.attrib, already_processed)

        for child in node:

            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]

            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)

        return self

    def _buildAttributes(self, node, attrs, already_processed):

        value = find_attr_value_('orientation', node)

        if value is not None and 'orientation' not in already_processed:

            already_processed.add('orientation')

            value = self.gds_parse_float(value, node, 'orientation')

            self.orientation = value

        value = find_attr_value_('bgColour', node)

        if value is not None and 'bgColour' not in already_processed:

            already_processed.add('bgColour')

            self.bgColour = value

            self.validate_ColourSimpleType(self.bgColour)    # validate type ColourSimpleType

        super(AdvertRegionType, self)._buildAttributes(node, attrs, already_processed)

    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):

        super(AdvertRegionType, self)._buildChildren(child_, node, nodeName_, True)

        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.

        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 AdvertRegionType