Edit File: shapes.py
#coding:utf-8 # Author: mozman # Purpose: svg shapes # Created: 08.09.2010 # # Copyright (C) 2010 Manfred Moitzi # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from svgwrite.base import BaseElement from svgwrite.mixins import Presentation, Markers, Transform class Line(BaseElement, Transform, Presentation, Markers): """ The **line** element defines a line segment that starts at one point and ends at another. """ elementname = 'line' def __init__(self, start=(0, 0), end=(0, 0), **extra): """ :param 2-tuple start: start point (**x1**, **y1**) :param 2-tuple end: end point (**x2**, **y2**) :param extra: additional SVG attributs as keyword-arguments """ super(Line, self).__init__(**extra) x1, y1 = start x2, y2 = end self['x1'] = x1 self['y1'] = y1 self['x2'] = x2 self['y2'] = y2 class Rect(BaseElement, Transform, Presentation): """ The **rect** element defines a rectangle which is axis-aligned with the current user coordinate system. Rounded rectangles can be achieved by setting appropriate values for attributes **rx** and **ry**. """ elementname = 'rect' def __init__(self, insert=(0, 0), size=(1, 1), rx=None, ry=None, **extra): """ :param 2-tuple insert: insert point (**x**, **y**), left-upper point :param 2-tuple size: (**width**, **height**) :param <length> rx: corner x-radius :param <length> ry: corner y-radius :param extra: additional SVG attributs as keyword-arguments """ super(Rect, self).__init__(**extra) x, y = insert width, height = size self['x'] = x self['y'] = y self['width'] = width self['height'] = height if rx is not None: self['rx'] = rx if ry is not None: self['ry'] = ry class Circle(BaseElement, Transform, Presentation): """ The **circle** element defines a circle based on a center point and a radius. """ elementname = 'circle' def __init__(self, center=(0, 0), r=1, **extra): """ :param 2-tuple center: circle center point (**cx**, **cy**) :param length r: circle-radius **r** :param extra: additional SVG attributs as keyword-arguments """ super(Circle, self).__init__(**extra) cx, cy = center self['cx'] = cx self['cy'] = cy self['r'] = r class Ellipse(BaseElement, Transform, Presentation): """ The **ellipse** element defines an ellipse which is axis-aligned with the current user coordinate system based on a center point and two radii. """ elementname = 'ellipse' def __init__(self, center=(0, 0), r=(1, 1), **extra): """ :param 2-tuple center: ellipse center point (**cx**, **cy**) :param 2-tuple r: ellipse radii (**rx**, **ry**) :param extra: additional SVG attributs as keyword-arguments """ super(Ellipse, self).__init__(**extra) cx, cy = center rx, ry = r self['cx'] = cx self['cy'] = cy self['rx'] = rx self['ry'] = ry class Polyline(BaseElement, Transform, Presentation, Markers): """ The **polyline** element defines a set of connected straight line segments. Typically, **polyline** elements define open shapes. """ elementname = 'polyline' def __init__(self, points=[], **extra): """ :param `iterable` points: `iterable` of points (points are `2-tuples`) :param extra: additional SVG attributs as keyword-arguments """ super(Polyline, self).__init__(**extra) self.points = list(points) if self.debug: for point in self.points: x, y = point self.validator.check_svg_type(x, 'number') self.validator.check_svg_type(y, 'number') def get_xml(self): self.attribs['points'] = self.points_to_string(self.points) return super(Polyline, self).get_xml() def points_to_string(self, points): """ Convert a `list` of points `2-tuples` to a `string` ``'p1x,p1y p2x,p2y ...'``. """ strings = [] for point in points: if len(point) != 2: raise TypeError('got %s values, but expected 2 values.' % len(point)) x, y = point if self.debug: self.validator.check_svg_type(x, 'coordinate') self.validator.check_svg_type(y, 'coordinate') if self.profile == 'tiny': if isinstance(x, float): x = round(x, 4) if isinstance(y, float): y = round(y, 4) point = "%s,%s" % (x, y) strings.append(point) return ' '.join(strings) class Polygon(Polyline): """ The **polygon** element defines a closed shape consisting of a set of connected straight line segments. Same as :class:`~svgwrite.shapes.Polyline` but closed. """ elementname = 'polygon'