OCR-D / core

# end class GraphicRegionType

class LineDrawingRegionType(RegionType):

    """LineDrawingRegionType --

    A line drawing is a single colour illustration without

    solid areas.

    * 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

    * penColour --

      The pen (foreground) colour of the region

    * bgColour --

      The background colour of the region

    * embText --

      Specifies whether the region also contains

      text

    """

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

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

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

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

        MemberSpec_('embText', 'boolean', 0, 1, {'use': 'optional', 'name': 'embText'}),

    ]

    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, penColour=None, bgColour=None, embText=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("LineDrawingRegionType"), 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.penColour = _cast(None, penColour)

        self.penColour_nsprefix_ = "pc"

        self.bgColour = _cast(None, bgColour)

        self.bgColour_nsprefix_ = "pc"

        self.embText = _cast(bool, embText)

        self.embText_nsprefix_ = "pc"

    def factory(*args_, **kwargs_):

        if CurrentSubclassModule_ is not None:

            subclass = getSubclassFromModule_(

                CurrentSubclassModule_, LineDrawingRegionType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if LineDrawingRegionType.subclass:

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

        else:

            return LineDrawingRegionType(*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_penColour(self):

        return self.penColour

    def set_penColour(self, penColour):

        self.penColour = penColour

    def get_bgColour(self):

        return self.bgColour

    def set_bgColour(self, bgColour):

        self.bgColour = bgColour

    def get_embText(self):

        return self.embText

    def set_embText(self, embText):

        self.embText = embText

    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(LineDrawingRegionType, 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_='LineDrawingRegionType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('LineDrawingRegionType')

        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_ == 'LineDrawingRegionType':

            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_='LineDrawingRegionType')

        if self.has__content():

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

            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='LineDrawingRegionType', 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_='LineDrawingRegionType'):

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

        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.penColour is not None and 'penColour' not in already_processed:

            already_processed.add('penColour')

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

        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')), ))

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

            already_processed.add('embText')

            outfile.write(' embText="%s"' % self.gds_format_boolean(self.embText, input_name='embText'))

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

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

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

        element = super(LineDrawingRegionType, 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.penColour is not None:

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

        if self.bgColour is not None:

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

        if self.embText is not None:

            element.set('embText', self.gds_format_boolean(self.embText))

        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_('penColour', node)

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

            already_processed.add('penColour')

            self.penColour = value

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

        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

        value = find_attr_value_('embText', node)

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

            already_processed.add('embText')

            if value in ('true', '1'):

                self.embText = True

            elif value in ('false', '0'):

                self.embText = False

            else:

                raise_parse_error(node, 'Bad boolean attribute')

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

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

        super(LineDrawingRegionType, 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 LineDrawingRegionType

# end class TableRegionType

class GraphicRegionType(RegionType):

    """GraphicRegionType --

    Regions containing simple graphics, such as a company

    logo, should be marked as graphic 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

    * type --

      The type of graphic in the region

    * numColours --

      An approximation of the number of colours

      used in the region

    * embText --

      Specifies whether the region also contains

      text.

    """

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

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

        MemberSpec_('type_', 'pc:GraphicsTypeSimpleType', 0, 1, {'use': 'optional', 'name': 'type_'}),

        MemberSpec_('numColours', 'int', 0, 1, {'use': 'optional', 'name': 'numColours'}),

        MemberSpec_('embText', 'boolean', 0, 1, {'use': 'optional', 'name': 'embText'}),

    ]

    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, type_=None, numColours=None, embText=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("GraphicRegionType"), 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.type_ = _cast(None, type_)

        self.type__nsprefix_ = "pc"

        self.numColours = _cast(int, numColours)

        self.numColours_nsprefix_ = "pc"

        self.embText = _cast(bool, embText)

        self.embText_nsprefix_ = "pc"

    def factory(*args_, **kwargs_):

        if CurrentSubclassModule_ is not None:

            subclass = getSubclassFromModule_(

                CurrentSubclassModule_, GraphicRegionType)

            if subclass is not None:

                return subclass(*args_, **kwargs_)

        if GraphicRegionType.subclass:

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

        else:

            return GraphicRegionType(*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_type(self):

        return self.type_

    def set_type(self, type_):

        self.type_ = type_

    def get_numColours(self):

        return self.numColours

    def set_numColours(self, numColours):

        self.numColours = numColours

    def get_embText(self):

        return self.embText

    def set_embText(self, embText):

        self.embText = embText

    def validate_GraphicsTypeSimpleType(self, value):

        # Validate type pc:GraphicsTypeSimpleType, 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 = ['logo', 'letterhead', 'decoration', 'frame', 'handwritten-annotation', 'stamp', 'signature', 'barcode', 'paper-grow', 'punch-hole', '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 GraphicsTypeSimpleType' % {"value" : encode_str_2_3(value), "lineno": lineno} )

                result = False

    def has__content(self):

        if (

            super(GraphicRegionType, 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_='GraphicRegionType', pretty_print=True):

        imported_ns_def_ = GenerateDSNamespaceDefs_.get('GraphicRegionType')

        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_ == 'GraphicRegionType':

            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_='GraphicRegionType')

        if self.has__content():

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

            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='GraphicRegionType', 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_='GraphicRegionType'):

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

        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.type_ is not None and 'type_' not in already_processed:

            already_processed.add('type_')

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

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

            already_processed.add('numColours')

            outfile.write(' numColours="%s"' % self.gds_format_integer(self.numColours, input_name='numColours'))

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

            already_processed.add('embText')

            outfile.write(' embText="%s"' % self.gds_format_boolean(self.embText, input_name='embText'))

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

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

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

        element = super(GraphicRegionType, 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.type_ is not None:

            element.set('type', self.gds_format_string(self.type_))

        if self.numColours is not None:

            element.set('numColours', self.gds_format_integer(self.numColours))

        if self.embText is not None:

            element.set('embText', self.gds_format_boolean(self.embText))

        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_('type', node)

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

            already_processed.add('type')

            self.type_ = value

            self.validate_GraphicsTypeSimpleType(self.type_)    # validate type GraphicsTypeSimpleType

        value = find_attr_value_('numColours', node)

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

            already_processed.add('numColours')

            self.numColours = self.gds_parse_integer(value, node, 'numColours')

        value = find_attr_value_('embText', node)

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

            already_processed.add('embText')

            if value in ('true', '1'):

                self.embText = True

            elif value in ('false', '0'):

                self.embText = False

            else:

                raise_parse_error(node, 'Bad boolean attribute')

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

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

        super(GraphicRegionType, 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 GraphicRegionType