OCR-D / core

# end class GraphicRegionType

class LineDrawingRegionType(RegionType):

    """A line drawing is a single colour illustration without

    solid areas.

    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

    The pen (foreground) colour of the region

    The background colour of the region

    Specifies whether the region also contains

    text"""

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

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

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

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

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

    ]

    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_ = None

        super(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 hasContent_(self):

        if (

            super(LineDrawingRegionType, self).hasContent_()

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', 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.hasContent_():

            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_='', 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, nsmap_=None):

        element = super(LineDrawingRegionType, self).to_etree(parent_element, name_, mapping_)

        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

        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)

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

    """Regions containing simple graphics, such as a company

    logo, should be marked as graphic regions.

    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

    The type of graphic in the region

    An approximation of the number of colours

    used in the region

    Specifies whether the region also contains

    text."""

    __hash__ = GeneratedsSuper.__hash__

    member_data_items_ = [

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

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

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

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

    ]

    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_ = None

        super(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 hasContent_(self):

        if (

            super(GraphicRegionType, self).hasContent_()

        ):

            return True

        else:

            return False

    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', 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.hasContent_():

            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_='', 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, nsmap_=None):

        element = super(GraphicRegionType, self).to_etree(parent_element, name_, mapping_)

        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

        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)

    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