Ejemplo n.º 1
0
    def _pathToPoints(self, path):
        """
        Converts a path into points
        """
        path = SvgPath(path.get('d'))
        coords = path.getCoordList(self._steps, self._length)

        return coords
Ejemplo n.º 2
0
    def _pathToPoints(self, path):
        """
        Converts a path into points
        """
        path = SvgPath(path.get('d'))
        coords = path.getCoordList(self._steps, 
                                   self._length)

        return coords
Ejemplo n.º 3
0
    def __init__(self, shape):

        gerber_lp = None
        mirror = False

        # Invert rotation so it's clock-wise. Inkscape is counter-clockwise and
        # it's unclear to ma what's the "right" direction. clockwise makse more
        # sense to me. This should be the only place to make the change.
        self._inv_rotate = -1

        self._rotate = shape.get('rotate') or 0
        self._rotate *= self._inv_rotate
        self._rotate_point = shape.get('rotate-point') or Point(0,0)
        self._scale = shape.get('scale') or 1
        self._pour_buffer = shape.get('buffer-to-pour')

        try:
            self._type = shape.get('type')
        except:
            msg.error("Shapes must have a 'type' defined")

        if self._type in ['rect', 'rectangle']:
            path = svg.width_and_height_to_path(shape['width'], shape['height'], shape.get('radii'))
        elif self._type in ['circ', 'circle', 'round']:
            path = svg.circle_diameter_to_path(shape['diameter'])
        elif self._type in ['drill']:
            self._diameter = shape['diameter']
            path = svg.drillPath(self._diameter)
        elif self._type in ['text', 'string']:
            try:
                self._text = shape['value']
            except KeyError:
                msg.error("Could not find the text to display. The text to be displayed should be defined in the 'value' field, for example, 'value': 'DEADBEEF\\nhar\\nhar'")

            # Get the fon'ts name
            font = shape.get('font-family') or config.stl['layout']['defaults']['font-family']

            # Search for the font SVG in these paths
            paths = [os.path.join(config.cfg['base-dir']),
                     os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')]

            font_filename = "%s.svg" % font
            filenames = ''
            font_data = None
            for path in paths:
                filename = os.path.join(path,
                                        config.cfg['locations']['fonts'],
                                        font_filename)
                filenames += "  %s \n" % filename
                if os.path.isfile(filename):
                    font_data = et.ElementTree(file=filename)
                    break

            if font_data == None:
                msg.error("Couldn't find style file %s. Looked for it here:\n%s" % (font_filename, filenames))

            try:
                fs = shape['font-size']
            except:
                msg.error("A 'font-size' attribute must be specified for a 'text' type")

            ls = shape.get('letter-spacing') or '0mm'
            lh = shape.get('line-height') or fs

            font_size, letter_spacing, line_height = utils.getTextParams(fs,
                                                                         ls, 
                                                                         lh)

            # With the units-per-em we can figure out the scale factor
            # to use for the desired font size
            units_per_em = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('units-per-em')) or 1000
            self._scale = font_size/units_per_em

            # Get the path to use. This returns the path without
            # scaling, which will be applied later, in the same manner
            # as to the other shape types
            path, gerber_lp = utils.textToPath(font_data,
                                               self._text,
                                               letter_spacing,
                                               line_height,
                                               self._scale)
           
            # In the case where the text is an outline/stroke instead
            # of a fill we get rid of the gerber_lp
            if shape.get('style') == 'stroke':
                gerber_lp = None

            self._rotate += 180

        elif self._type in ['path']:
            path = shape.get('value')
        else:
            msg.error("'%s' is not a recongnised shape type" % self._type)


        self._path = SvgPath(path, gerber_lp)
        self._path.transform(self._scale, self._rotate, self._rotate_point, True)

        self._gerber_lp = (shape.get('gerber-lp') or 
                           shape.get('gerber_lp') or 
                           gerber_lp or 
                           None)

        self._location = utils.toPoint(shape.get('location', [0, 0]))
Ejemplo n.º 4
0
def textToPath(font_data, text, letter_spacing, line_height, scale_factor):
    """
    Convert a text string (unicode and newlines allowed) to a path.
    The 'scale_factor' is needed in order to scale rp 'letter_spacing' and 'line_height'
    to the original scale of the font.
    """

    # This the horizontal advance that applied to all glyphs unless there's a specification for
    # for the glyph itself
    font_horiz_adv_x = float(font_data.find("//n:font", namespaces={'n': config.cfg['namespace']['svg']}).get('horiz-adv-x'))
    
    # This is the number if 'units' per 'em'. The default, in the absence of a definition is 1000
    # according to the SVG spec
    units_per_em = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('units-per-em')) or 1000

    glyph_ascent = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('ascent'))
    glyph_decent = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('descent'))
 
    text_width = 0
    text_path = ''

    # split text into charcters and find unicade chars
    try:
        text = re.findall(r'(\&#x[0-9abcdef]*;|.|\n)', text)
    except:
        throw("There's a problem parsing the text '%s'. Unicode and \\n newline should be fine, by the way." % text)
 

    # instantiate HTML parser
    htmlpar = HTMLParser.HTMLParser()
    gerber_lp = ''
    text_height = 0

    if line_height == None:
        line_height = units_per_em

    for i, symbol in enumerate(text[:]):

        symbol = htmlpar.unescape(symbol)
        # get the glyph definition from the file
        if symbol == '\n':
            text_width = 0
            text_height += units_per_em + (line_height/scale_factor-units_per_em)
        else:
            glyph = font_data.find(u'//n:glyph[@unicode="%s"]' % symbol, namespaces={'n': config.cfg['namespace']['svg']})
            if glyph == None:
                utils.throw("Damn, there's no glyph definition for '%s' in the '%s' font :(" % (symbol, font))
            else:
                # Unless the glyph has its own width, use the global font width
                glyph_width = float(glyph.get('horiz-adv-x') or font_horiz_adv_x)
                if symbol != ' ':
                    glyph_path = SvgPath(glyph.get('d'))
                    first_point = glyph_path.getFirstPoint()
                    offset_x = float(first_point[0])
                    offset_y = float(first_point[1])
                    path = glyph_path.getRelative()
                    path = re.sub('^(m\s?[-\d\.]+\s?,\s?[-\d\.]+)', 'M %s,%s' % (str(text_width+offset_x), str(offset_y-text_height)), path)
                    gerber_lp += (glyph.get('gerber-lp') or 
                                  glyph.get('gerber_lp') or 
                                  "%s" % 'd'*glyph_path.getNumberOfSegments())
                    text_path += "%s " % (path)

            text_width += glyph_width+letter_spacing/scale_factor


    # Mirror text 
    text_path = SvgPath(text_path)
    text_path.transform()
    text_path = text_path.getTransformedMirrored()

    return text_path, gerber_lp
Ejemplo n.º 5
0
def textToPath(font_data, text, letter_spacing, line_height, scale_factor):
    """
    Convert a text string (unicode and newlines allowed) to a path.
    The 'scale_factor' is needed in order to scale rp 'letter_spacing' and 'line_height'
    to the original scale of the font.
    """

    # This the horizontal advance that applied to all glyphs unless there's a specification for
    # for the glyph itself
    font_horiz_adv_x = float(
        font_data.find("//n:font",
                       namespaces={
                           'n': config.cfg['namespace']['svg']
                       }).get('horiz-adv-x'))

    # This is the number if 'units' per 'em'. The default, in the absence of a definition is 1000
    # according to the SVG spec
    units_per_em = float(
        font_data.find("//n:font-face",
                       namespaces={
                           'n': config.cfg['namespace']['svg']
                       }).get('units-per-em')) or 1000

    glyph_ascent = float(
        font_data.find("//n:font-face",
                       namespaces={
                           'n': config.cfg['namespace']['svg']
                       }).get('ascent'))
    glyph_decent = float(
        font_data.find("//n:font-face",
                       namespaces={
                           'n': config.cfg['namespace']['svg']
                       }).get('descent'))

    text_width = 0
    text_path = ''

    # split text into charcters and find unicade chars
    try:
        text = re.findall(r'(\&#x[0-9abcdef]*;|.|\n)', text)
    except:
        throw(
            "There's a problem parsing the text '%s'. Unicode and \\n newline should be fine, by the way."
            % text)

    # instantiate HTML parser
    htmlpar = HTMLParser.HTMLParser()
    gerber_lp = ''
    text_height = 0

    if line_height == None:
        line_height = units_per_em

    for i, symbol in enumerate(text[:]):

        symbol = htmlpar.unescape(symbol)
        # get the glyph definition from the file
        if symbol == '\n':
            text_width = 0
            text_height += units_per_em + (line_height / scale_factor -
                                           units_per_em)
        else:
            glyph = font_data.find(
                u'//n:glyph[@unicode="%s"]' % symbol,
                namespaces={'n': config.cfg['namespace']['svg']})
            if glyph == None:
                utils.throw(
                    "Damn, there's no glyph definition for '%s' in the '%s' font :("
                    % (symbol, font))
            else:
                # Unless the glyph has its own width, use the global font width
                glyph_width = float(
                    glyph.get('horiz-adv-x') or font_horiz_adv_x)
                if symbol != ' ':
                    glyph_path = SvgPath(glyph.get('d'))
                    first_point = glyph_path.getFirstPoint()
                    offset_x = float(first_point[0])
                    offset_y = float(first_point[1])
                    path = glyph_path.getRelative()
                    path = re.sub(
                        '^(m\s?[-\d\.]+\s?,\s?[-\d\.]+)',
                        'M %s,%s' % (str(text_width + offset_x),
                                     str(offset_y - text_height)), path)
                    gerber_lp += (glyph.get('gerber-lp')
                                  or glyph.get('gerber_lp') or "%s" % 'd' *
                                  glyph_path.getNumberOfSegments())
                    text_path += "%s " % (path)

            text_width += glyph_width + letter_spacing / scale_factor

    # Mirror text
    text_path = SvgPath(text_path)
    text_path.transform()
    text_path = text_path.getTransformedMirrored()

    return text_path, gerber_lp
Ejemplo n.º 6
0
    def __init__(self, shape):

        gerber_lp = None
        mirror = False

        self._shape_dict = shape

        # Invert rotation so it's clock-wise. Inkscape is counter-clockwise and
        # it's unclear to ma what's the "right" direction. clockwise makse more
        # sense to me. This should be the only place to make the change.
        self._inv_rotate = -1

        try:
            self._type = shape.get('type')
        except:
            msg.error("Shapes must have a 'type' defined")

        # A 'layer' type is a copy of the outline. Here we copy the
        # outline shape and override the type
        if self._type in ['layer']:
            self._shape_dict = config.brd['outline'].get('shape').copy()
            self._type = self._shape_dict.get('type')

        self._place_mirrored = shape.get('mirror') or False

        self._rotate = shape.get('rotate') or 0
        self._rotate *= self._inv_rotate
        self._rotate_point = shape.get('rotate-point') or Point(0, 0)
        self._scale = shape.get('scale') or 1
        self._pour_buffer = shape.get('buffer-to-pour')

        # A general purpose label field; intended for use for pad
        # labels
        self._label = None

        if self._type in ['rect', 'rectangle']:
            path = svg.width_and_height_to_path(self._shape_dict['width'],
                                                self._shape_dict['height'],
                                                self._shape_dict.get('radii'))
        elif self._type in ['circ', 'circle', 'round']:
            path = svg.circle_diameter_to_path(self._shape_dict['diameter'])
        elif self._type in ['drill']:
            self._diameter = self._shape_dict['diameter']
            path = svg.drillPath(self._diameter)
        elif self._type in ['text', 'string']:
            try:
                self._text = self._shape_dict['value']
            except KeyError:
                msg.error(
                    "Could not find the text to display. The text to be displayed should be defined in the 'value' field, for example, 'value': 'DEADBEEF\\nhar\\nhar'"
                )

            # Get the font's name
            font = self._shape_dict.get('font-family') or config.stl['layout'][
                'defaults']['font-family']

            # Search for the font SVG in these paths
            paths = [
                os.path.join(config.cfg['base-dir']),
                os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')
            ]

            font_filename = "%s.svg" % font
            filenames = ''
            font_data = None
            for path in paths:
                filename = os.path.join(path, config.cfg['locations']['fonts'],
                                        font_filename)
                filenames += "  %s \n" % filename
                if os.path.isfile(filename):
                    font_data = et.ElementTree(file=filename)
                    break

            if font_data == None:
                msg.error(
                    "Couldn't find style file %s. Looked for it here:\n%s" %
                    (font_filename, filenames))

            try:
                fs = self._shape_dict['font-size']
            except:
                msg.error(
                    "A 'font-size' attribute must be specified for a 'text' type"
                )

            ls = self._shape_dict.get('letter-spacing') or '0mm'
            lh = self._shape_dict.get('line-height') or fs

            font_size, letter_spacing, line_height = utils.getTextParams(
                fs, ls, lh)

            # With the units-per-em we can figure out the scale factor
            # to use for the desired font size
            units_per_em = float(
                font_data.find("//n:font-face",
                               namespaces={
                                   'n': config.cfg['namespace']['svg']
                               }).get('units-per-em')) or 1000
            self._scale = font_size / units_per_em

            # Get the path to use. This returns the path without
            # scaling, which will be applied later, in the same manner
            # as to the other shape types
            path, gerber_lp = utils.textToPath(font_data, self._text,
                                               letter_spacing, line_height,
                                               self._scale)

            # In the case where the text is an outline/stroke instead
            # of a fill we get rid of the gerber_lp
            if self._shape_dict.get('style') == 'stroke':
                gerber_lp = None

            self._rotate += 180

        elif self._type in ['path']:
            path = self._shape_dict.get('value')
        else:
            msg.error("'%s' is not a recongnised shape type" % self._type)

        self._path = SvgPath(path, gerber_lp)

        self._path.transform(scale=self._scale,
                             rotate_angle=self._rotate,
                             rotate_point=self._rotate_point,
                             mirror=self._place_mirrored)

        self._gerber_lp = (shape.get('gerber-lp') or shape.get('gerber_lp')
                           or gerber_lp or None)

        self._location = utils.toPoint(shape.get('location', [0, 0]))
Ejemplo n.º 7
0
class Shape():
    """
    """
    def __init__(self, shape):

        gerber_lp = None
        mirror = False

        self._shape_dict = shape

        # Invert rotation so it's clock-wise. Inkscape is counter-clockwise and
        # it's unclear to ma what's the "right" direction. clockwise makse more
        # sense to me. This should be the only place to make the change.
        self._inv_rotate = -1

        self._rotate = shape.get('rotate') or 0
        self._rotate *= self._inv_rotate
        self._rotate_point = shape.get('rotate-point') or Point(0, 0)
        self._scale = shape.get('scale') or 1
        self._pour_buffer = shape.get('buffer-to-pour')

        try:
            self._type = shape.get('type')
        except:
            msg.error("Shapes must have a 'type' defined")

        if self._type in ['rect', 'rectangle']:
            path = svg.width_and_height_to_path(shape['width'],
                                                shape['height'],
                                                shape.get('radii'))
        elif self._type in ['circ', 'circle', 'round']:
            path = svg.circle_diameter_to_path(shape['diameter'])
        elif self._type in ['drill']:
            self._diameter = shape['diameter']
            path = svg.drillPath(self._diameter)
        elif self._type in ['text', 'string']:
            try:
                self._text = shape['value']
            except KeyError:
                msg.error(
                    "Could not find the text to display. The text to be displayed should be defined in the 'value' field, for example, 'value': 'DEADBEEF\\nhar\\nhar'"
                )

            # Get the fon'ts name
            font = shape.get('font-family') or config.stl['layout'][
                'defaults']['font-family']

            # Search for the font SVG in these paths
            paths = [
                os.path.join(config.cfg['base-dir']),
                os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')
            ]

            font_filename = "%s.svg" % font
            filenames = ''
            font_data = None
            for path in paths:
                filename = os.path.join(path, config.cfg['locations']['fonts'],
                                        font_filename)
                filenames += "  %s \n" % filename
                if os.path.isfile(filename):
                    font_data = et.ElementTree(file=filename)
                    break

            if font_data == None:
                msg.error(
                    "Couldn't find style file %s. Looked for it here:\n%s" %
                    (font_filename, filenames))

            try:
                fs = shape['font-size']
            except:
                msg.error(
                    "A 'font-size' attribute must be specified for a 'text' type"
                )

            ls = shape.get('letter-spacing') or '0mm'
            lh = shape.get('line-height') or fs

            font_size, letter_spacing, line_height = utils.getTextParams(
                fs, ls, lh)

            # With the units-per-em we can figure out the scale factor
            # to use for the desired font size
            units_per_em = float(
                font_data.find("//n:font-face",
                               namespaces={
                                   'n': config.cfg['namespace']['svg']
                               }).get('units-per-em')) or 1000
            self._scale = font_size / units_per_em

            # Get the path to use. This returns the path without
            # scaling, which will be applied later, in the same manner
            # as to the other shape types
            path, gerber_lp = utils.textToPath(font_data, self._text,
                                               letter_spacing, line_height,
                                               self._scale)

            # In the case where the text is an outline/stroke instead
            # of a fill we get rid of the gerber_lp
            if shape.get('style') == 'stroke':
                gerber_lp = None

            self._rotate += 180

        elif self._type in ['path']:
            path = shape.get('value')
        else:
            msg.error("'%s' is not a recongnised shape type" % self._type)

        self._path = SvgPath(path, gerber_lp)
        self._path.transform(self._scale, self._rotate, self._rotate_point,
                             True)

        self._gerber_lp = (shape.get('gerber-lp') or shape.get('gerber_lp')
                           or gerber_lp or None)

        self._location = utils.toPoint(shape.get('location', [0, 0]))

    def transformPath(self,
                      scale=1,
                      rotate=0,
                      rotate_point=Point(),
                      mirror=False,
                      add=False):
        if add == False:
            self._path.transform(scale, rotate * self._inv_rotate,
                                 rotate_point, mirror)
        else:
            self._path.transform(scale * self._scale,
                                 rotate * self._inv_rotate + self._rotate,
                                 rotate_point + self._rotate_point, mirror)

    def rotateLocation(self, angle, point=Point()):
        """
        """
        self._location.rotate(angle, point)

    def getRotation(self):
        return self._rotate

    def setRotation(self, rotate):
        self._rotate = rotate

    def getOriginalPath(self):
        """
        Returns that original, unmodified path
        """
        return self._path.getOriginal()

    def getTransformedPath(self, mirrored=False):
        if mirrored == True:
            return self._path.getTransformedMirrored()
        else:
            return self._path.getTransformed()

    def getWidth(self):
        return self._path.getWidth()

    def getHeight(self):
        return self._path.getHeight()

    def getGerberLP(self):
        return self._gerber_lp

    def setStyle(self, style):
        """
        style: Style object
        """
        self._style = style

    def getStyle(self):
        """
        Return the shape's style Style object
        """
        return self._style

    def getStyleString(self):
        style = self._style.getStyleString()
        return style

    def getStyleType(self):
        style = self._style.getStyleType()
        return style

    def getScale(self):
        return self._scale

    def getLocation(self):
        return self._location

    def setLocation(self, location):
        self._location = location

    def getParsedPath(self):
        return self._parsed

    def getPourBuffer(self):
        return self._pour_buffer

    def getType(self):
        return self._type

    def getText(self):
        return self._text

    def getDiameter(self):
        return self._diameter
Ejemplo n.º 8
0
class Shape():
    """
    """

    def __init__(self, shape):

        gerber_lp = None
        mirror = False

        self._shape_dict = shape

        # Invert rotation so it's clock-wise. Inkscape is counter-clockwise and
        # it's unclear to ma what's the "right" direction. clockwise makse more
        # sense to me. This should be the only place to make the change.
        self._inv_rotate = -1

        try:
            self._type = shape.get('type')
        except:
            msg.error("Shapes must have a 'type' defined")

        # A 'layer' type is a copy of the outline. Here we copy the
        # outline shape and override the type
        if self._type in ['layer']:
            self._shape_dict = config.brd['outline'].get('shape').copy()
            self._type = self._shape_dict.get('type')

        self._place_mirrored = shape.get('mirror') or False

        self._rotate = shape.get('rotate') or 0
        self._rotate *= self._inv_rotate
        self._rotate_point = shape.get('rotate-point') or Point(0,0)
        self._scale = shape.get('scale') or 1
        self._pour_buffer = shape.get('buffer-to-pour')

        # A general purpose label field; intended for use for pad
        # labels
        self._label = None

        if self._type in ['rect', 'rectangle']:
            path = svg.width_and_height_to_path(self._shape_dict['width'],
                                                self._shape_dict['height'],
                                                self._shape_dict.get('radii'))
        elif self._type in ['circ', 'circle', 'round']:
            path = svg.circle_diameter_to_path(self._shape_dict['diameter'])
        elif self._type in ['drill']:
            self._diameter = self._shape_dict['diameter']
            path = svg.drillPath(self._diameter)
        elif self._type in ['text', 'string']:
            try:
                self._text = self._shape_dict['value']
            except KeyError:
                msg.error("Could not find the text to display. The text to be displayed should be defined in the 'value' field, for example, 'value': 'DEADBEEF\\nhar\\nhar'")

            # Get the font's name
            font = self._shape_dict.get('font-family') or config.stl['layout']['defaults']['font-family']

            # Search for the font SVG in these paths
            paths = [os.path.join(config.cfg['base-dir']),
                     os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')]

            font_filename = "%s.svg" % font
            filenames = ''
            font_data = None
            for path in paths:
                filename = os.path.join(path,
                                        config.cfg['locations']['fonts'],
                                        font_filename)
                filenames += "  %s \n" % filename
                if os.path.isfile(filename):
                    font_data = et.ElementTree(file=filename)
                    break

            if font_data == None:
                msg.error("Couldn't find style file %s. Looked for it here:\n%s" % (font_filename, filenames))

            try:
                fs = self._shape_dict['font-size']
            except:
                msg.error("A 'font-size' attribute must be specified for a 'text' type")

            ls = self._shape_dict.get('letter-spacing') or '0mm'
            lh = self._shape_dict.get('line-height') or fs

            font_size, letter_spacing, line_height = utils.getTextParams(fs,
                                                                         ls, 
                                                                         lh)

            # With the units-per-em we can figure out the scale factor
            # to use for the desired font size
            units_per_em = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('units-per-em')) or 1000
            self._scale = font_size/units_per_em

            # Get the path to use. This returns the path without
            # scaling, which will be applied later, in the same manner
            # as to the other shape types
            path, gerber_lp = utils.textToPath(font_data,
                                               self._text,
                                               letter_spacing,
                                               line_height,
                                               self._scale)
           
            # In the case where the text is an outline/stroke instead
            # of a fill we get rid of the gerber_lp
            if self._shape_dict.get('style') == 'stroke':
                gerber_lp = None

            self._rotate += 180

        elif self._type in ['path']:
            path = self._shape_dict.get('value')
        else:
            msg.error("'%s' is not a recongnised shape type" % self._type)


        self._path = SvgPath(path, gerber_lp)

        self._path.transform(scale=self._scale, 
                             rotate_angle=self._rotate, 
                             rotate_point=self._rotate_point, 
                             mirror=self._place_mirrored)

        self._gerber_lp = (shape.get('gerber-lp') or 
                           shape.get('gerber_lp') or 
                           gerber_lp or 
                           None)

        self._location = utils.toPoint(shape.get('location', [0, 0]))




    def transformPath(self, scale=1, rotate=0, rotate_point=Point(), mirror=False, add=False):
        if add == False:
            self._path.transform(scale,
                                 rotate*self._inv_rotate,
                                 rotate_point,
                                 mirror)
        else:
            self._path.transform(scale*self._scale,
                                 rotate*self._inv_rotate+self._rotate,
                                 rotate_point+self._rotate_point,
                                 mirror)



    def rotateLocation(self, angle, point=Point()):
        """
        """
        self._location.rotate(angle, point)


    def getRotation(self):
        return self._rotate



    def setRotation(self, rotate):
        self._rotate = rotate



    def getOriginalPath(self):
        """
        Returns that original, unmodified path
        """
        return self._path.getOriginal()



    def getTransformedPath(self, mirrored=False):
        if mirrored == True:
            return self._path.getTransformedMirrored()
        else:
            return self._path.getTransformed()



    def getWidth(self):
        return self._path.getWidth()



    def getHeight(self):
        return self._path.getHeight()



    def getGerberLP(self):
        return self._gerber_lp



    def setStyle(self, style):
        """
        style: Style object
        """
        self._style = style


    def getStyle(self):
        """
        Return the shape's style Style object
        """
        return self._style


    def getStyleString(self):
        style = self._style.getStyleString()
        return style


    def getStyleType(self):
        style = self._style.getStyleType()
        return style


    def getScale(self):
        return self._scale


    def getLocation(self):
        return self._location

  
    def setLocation(self, location):
        self._location = location


    def getParsedPath(self):
        return self._parsed


    def getPourBuffer(self):
        return self._pour_buffer

     
    def getType(self):
        return self._type


    def getText(self):
        return self._text


    def getDiameter(self):
        return self._diameter


    def setLabel(self, label):
        self._label = label


    def getLabel(self):
        return self._label


    def getMirrorPlacement(self):
        return self._place_mirrored