"""This submodule contains tools for creating path objects from SVG files. The main tool being the svg2paths() function.""" # External dependencies from __future__ import division, absolute_import, print_function from xml.dom.minidom import parse from os import path as os_path, getcwd import re # Internal dependencies from .parser import parse_path COORD_PAIR_TMPLT = re.compile( r'([\+-]?\d*[\.\d]\d*[eE][\+-]?\d+|[\+-]?\d*[\.\d]\d*)' + r'(?:\s*,\s*|\s+|(?=-))' + r'([\+-]?\d*[\.\d]\d*[eE][\+-]?\d+|[\+-]?\d*[\.\d]\d*)' ) def ellipse2pathd(ellipse): """converts the parameters from an ellipse or a circle to a string for a Path object d-attribute""" cx = ellipse.get('cx', None) cy = ellipse.get('cy', None) rx = ellipse.get('rx', None) ry = ellipse.get('ry', None) r = ellipse.get('r', None) if r is not None: rx = ry = float(r) else: rx = float(rx) ry = float(ry) cx = float(cx) cy = float(cy) d = '' d += 'M' + str(cx - rx) + ',' + str(cy) d += 'a' + str(rx) + ',' + str(ry) + ' 0 1,0 ' + str(2 * rx) + ',0' d += 'a' + str(rx) + ',' + str(ry) + ' 0 1,0 ' + str(-2 * rx) + ',0' return d def polyline2pathd(polyline_d, is_polygon=False): """converts the string from a polyline points-attribute to a string for a Path object d-attribute""" points = COORD_PAIR_TMPLT.findall(polyline_d) closed = (float(points[0][0]) == float(points[-1][0]) and float(points[0][1]) == float(points[-1][1])) # The `parse_path` call ignores redundant 'z' (closure) commands # e.g. `parse_path('M0 0L100 100Z') == parse_path('M0 0L100 100L0 0Z')` # This check ensures that an n-point polygon is converted to an n-Line path. if is_polygon and closed: points.append(points[0]) d = 'M' + 'L'.join('{0} {1}'.format(x,y) for x,y in points) if is_polygon or closed: d += 'z' return d def polygon2pathd(polyline_d): """converts the string from a polygon points-attribute to a string for a Path object d-attribute. Note: For a polygon made from n points, the resulting path will be composed of n lines (even if some of these lines have length zero). """ return polyline2pathd(polyline_d, True) def rect2pathd(rect): """Converts an SVG-rect element to a Path d-string. The rectangle will start at the (x,y) coordinate specified by the rectangle object and proceed counter-clockwise.""" x0, y0 = float(rect.get('x', 0)), float(rect.get('y', 0)) w, h = float(rect["width"]), float(rect["height"]) x1, y1 = x0 + w, y0 x2, y2 = x0 + w, y0 + h x3, y3 = x0, y0 + h d = ("M{} {} L {} {} L {} {} L {} {} z" "".format(x0, y0, x1, y1, x2, y2, x3, y3)) return d def svg2paths(svg_file_location, return_svg_attributes=False, convert_circles_to_paths=True, convert_ellipses_to_paths=True, convert_lines_to_paths=True, convert_polylines_to_paths=True, convert_polygons_to_paths=True, convert_rectangles_to_paths=True): """Converts an SVG into a list of Path objects and attribute dictionaries. Converts an SVG file into a list of Path objects and a list of dictionaries containing their attributes. This currently supports SVG Path, Line, Polyline, Polygon, Circle, and Ellipse elements. Args: svg_file_location (string): the location of the svg file return_svg_attributes (bool): Set to True and a dictionary of svg-attributes will be extracted and returned. See also the `svg2paths2()` function. convert_circles_to_paths: Set to False to exclude SVG-Circle elements (converted to Paths). By default circles are included as paths of two `Arc` objects. convert_ellipses_to_paths (bool): Set to False to exclude SVG-Ellipse elements (converted to Paths). By default ellipses are included as paths of two `Arc` objects. convert_lines_to_paths (bool): Set to False to exclude SVG-Line elements (converted to Paths) convert_polylines_to_paths (bool): Set to False to exclude SVG-Polyline elements (converted to Paths) convert_polygons_to_paths (bool): Set to False to exclude SVG-Polygon elements (converted to Paths) convert_rectangles_to_paths (bool): Set to False to exclude SVG-Rect elements (converted to Paths). Returns: list: The list of Path objects. list: The list of corresponding path attribute dictionaries. dict (optional): A dictionary of svg-attributes (see `svg2paths2()`). """ if os_path.dirname(svg_file_location) == '': svg_file_location = os_path.join(getcwd(), svg_file_location) doc = parse(svg_file_location) def dom2dict(element): """Converts DOM elements to dictionaries of attributes.""" keys = list(element.attributes.keys()) values = [val.value for val in list(element.attributes.values())] return dict(list(zip(keys, values))) # Use minidom to extract path strings from input SVG paths = [dom2dict(el) for el in doc.getElementsByTagName('path')] d_strings = [el['d'] for el in paths] attribute_dictionary_list = paths # Use minidom to extract polyline strings from input SVG, convert to # path strings, add to list if convert_polylines_to_paths: plins = [dom2dict(el) for el in doc.getElementsByTagName('polyline')] d_strings += [polyline2pathd(pl['points']) for pl in plins] attribute_dictionary_list += plins # Use minidom to extract polygon strings from input SVG, convert to # path strings, add to list if convert_polygons_to_paths: pgons = [dom2dict(el) for el in doc.getElementsByTagName('polygon')] d_strings += [polygon2pathd(pg['points']) for pg in pgons] attribute_dictionary_list += pgons if convert_lines_to_paths: lines = [dom2dict(el) for el in doc.getElementsByTagName('line')] d_strings += [('M' + l['x1'] + ' ' + l['y1'] + 'L' + l['x2'] + ' ' + l['y2']) for l in lines] attribute_dictionary_list += lines if convert_ellipses_to_paths: ellipses = [dom2dict(el) for el in doc.getElementsByTagName('ellipse')] d_strings += [ellipse2pathd(e) for e in ellipses] attribute_dictionary_list += ellipses if convert_circles_to_paths: circles = [dom2dict(el) for el in doc.getElementsByTagName('circle')] d_strings += [ellipse2pathd(c) for c in circles] attribute_dictionary_list += circles if convert_rectangles_to_paths: rectangles = [dom2dict(el) for el in doc.getElementsByTagName('rect')] d_strings += [rect2pathd(r) for r in rectangles] attribute_dictionary_list += rectangles if return_svg_attributes: svg_attributes = dom2dict(doc.getElementsByTagName('svg')[0]) doc.unlink() path_list = [parse_path(d) for d in d_strings] return path_list, attribute_dictionary_list, svg_attributes else: doc.unlink() path_list = [parse_path(d) for d in d_strings] return path_list, attribute_dictionary_list def svg2paths2(svg_file_location, return_svg_attributes=True, convert_circles_to_paths=True, convert_ellipses_to_paths=True, convert_lines_to_paths=True, convert_polylines_to_paths=True, convert_polygons_to_paths=True, convert_rectangles_to_paths=True): """Convenience function; identical to svg2paths() except that return_svg_attributes=True by default. See svg2paths() docstring for more info.""" return svg2paths(svg_file_location=svg_file_location, return_svg_attributes=return_svg_attributes, convert_circles_to_paths=convert_circles_to_paths, convert_ellipses_to_paths=convert_ellipses_to_paths, convert_lines_to_paths=convert_lines_to_paths, convert_polylines_to_paths=convert_polylines_to_paths, convert_polygons_to_paths=convert_polygons_to_paths, convert_rectangles_to_paths=convert_rectangles_to_paths)