diff --git a/svgpathtools/svg2paths.py b/svgpathtools/svg2paths.py index f9b0cc4..05258e8 100644 --- a/svgpathtools/svg2paths.py +++ b/svgpathtools/svg2paths.py @@ -1,10 +1,11 @@ -"""A submodule of tools for creating path objects from SVG files. +"""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 -import os -import xml.etree.cElementTree as etree +from xml.dom.minidom import parse +from os import path as os_path, getcwd +import re # Internal dependencies from .parser import parse_path @@ -18,8 +19,8 @@ COORD_PAIR_TMPLT = re.compile( def ellipse2pathd(ellipse): - """converts the parameters from an ellipse or a circle to a string - for a Path object d-attribute""" + """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) @@ -45,8 +46,8 @@ def ellipse2pathd(ellipse): def polyline2pathd(polyline_d, is_polygon=False): - """converts the string from a polyline points-attribute to a string - for a Path object d-attribute""" + """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])) @@ -74,7 +75,7 @@ def polygon2pathd(polyline_d): 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)) @@ -88,21 +89,15 @@ def rect2pathd(rect): return d -def line2pathd(l): - return 'M' + l['x1'] + ' ' + l['y1'] + 'L' + l['x2'] + ' ' + l['y2'] - - -CONVERSIONS = {'circle': ellipse2pathd, - 'ellipse': ellipse2pathd, - 'line': line2pathd, - 'polyline': polyline2pathd, - 'polygon': polygon2pathd, - 'rect': rect2pathd} - - -def svg2paths(svg_file_location, return_svg_attributes=False, - conversions=CONVERSIONS, return_tree=False): - """Converts SVG to list of Path objects and attribute dictionaries. +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 @@ -111,81 +106,106 @@ def svg2paths(svg_file_location, return_svg_attributes=False, 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. + 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). 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_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). + 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: + Returns: list: The list of Path objects. list: The list of corresponding path attribute dictionaries. - dict (optional): A dictionary of svg-attributes (see ` - svg2paths2()`). + 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) + if os_path.dirname(svg_file_location) == '': + svg_file_location = os_path.join(getcwd(), svg_file_location) - tree = etree.parse(svg_file_location) + doc = parse(svg_file_location) - # get URI namespace - root_tag = tree.getroot().tag - if root_tag[0] == "{": - prefix = root_tag[:root_tag.find('}') + 1] - else: - prefix = '' - # etree.register_namespace('', prefix) + 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))) - def getElementsByTagName(tag): - return tree.iter(tag=prefix+tag) - - # Get d-strings for Path elements - paths = [el.attrib for el in getElementsByTagName('path')] + # 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 - # Get d-strings for Path-like elements (using `conversions` dict) - for tag, fcn in conversions.items(): - attributes = [el.attrib for el in getElementsByTagName(tag)] - d_strings += [fcn(d) for d in attributes] + # 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 - path_list = [parse_path(d) for d in d_strings] - if return_tree: # svg2paths3 default behavior - return path_list, tree + # 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 - elif return_svg_attributes: # svg2paths2 default behavior - svg_attributes = getElementsByTagName('svg')[0].attrib + 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: # svg2paths default behavior + 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, - conversions=CONVERSIONS, return_tree=False): +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_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, - conversions=conversions, return_tree=return_tree) - - -def svg2paths3(svg_file_location, return_svg_attributes=True, - conversions=CONVERSIONS, return_tree=True): - """Convenience function; identical to svg2paths() except that - return_tree=True. See svg2paths() docstring for more info.""" - return svg2paths(svg_file_location=svg_file_location, - return_svg_attributes=return_svg_attributes, - conversions=conversions, return_tree=return_tree) + 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)