diff --git a/build/lib/svgpathtools/svg2paths.py b/build/lib/svgpathtools/svg2paths.py index e8d8aa2..f1ecbea 100644 --- a/build/lib/svgpathtools/svg2paths.py +++ b/build/lib/svgpathtools/svg2paths.py @@ -69,29 +69,29 @@ def svg2paths(svg_file_location, return dict(list(zip(keys, values))) # Use minidom to extract path strings from input SVG - paths = [dom2dict(el) for el in doc.get_elements_by_tag('path')] + paths = [dom2dict(el) for el in doc.getElementsByTagName('path')] d_strings = [el['d'] for el in paths] attribute_dictionary_list = paths # if pathless_svg: - # for el in doc.get_elements_by_tag('path'): + # for el in doc.getElementsByTagName('path'): # el.parentNode.removeChild(el) # 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.get_elements_by_tag('polyline')] + 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.get_elements_by_tag('polygon')] + pgons = [dom2dict(el) for el in doc.getElementsByTagName('polygon')] d_strings += [polyline2pathd(pg['points']) + 'z' for pg in pgons] attribute_dictionary_list += pgons if convert_lines_to_paths: - lines = [dom2dict(el) for el in doc.get_elements_by_tag('line')] + 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 @@ -101,7 +101,7 @@ def svg2paths(svg_file_location, # doc.writexml(f) if return_svg_attributes: - svg_attributes = dom2dict(doc.get_elements_by_tag('svg')[0]) + 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 diff --git a/svgpathtools/svg2paths.py b/svgpathtools/svg2paths.py index cc8374c..fcfe87c 100644 --- a/svgpathtools/svg2paths.py +++ b/svgpathtools/svg2paths.py @@ -1,20 +1,29 @@ -"""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 +from xml.dom.minidom import parse +from os import path as os_path, getcwd +import re import xml.etree.cElementTree as etree # 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 path2pathd(path): return path.get('d', '') 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) @@ -39,23 +48,21 @@ def ellipse2pathd(ellipse): return d -def polyline2pathd(polyline_d): - """converts the string from a polyline points-attribute to a string - for a Path object d-attribute""" - try: - points = polyline_d['points'] - except: - pass - points = polyline_d.replace(', ', ',') - points = points.replace(' ,', ',') - points = points.split() +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])) - closed = points[0] == points[-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' + points.pop(0).replace(',', ' ') - for p in points: - d += 'L' + p.replace(',', ' ') - if closed: + d = 'M' + 'L'.join('{0} {1}'.format(x,y) for x,y in points) + if is_polygon or closed: d += 'z' return d @@ -66,34 +73,12 @@ def polygon2pathd(polyline_d): 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). """ - try: - points = polyline_d['points'] - except: - pass - points = polyline_d.replace(', ', ',') - points = points.replace(' ,', ',') - points = points.split() - - reduntantly_closed = points[0] == points[-1] - - d = 'M' + points[0].replace(',', ' ') - for p in points[1:]: - d += 'L' + p.replace(',', ' ') - - # 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 reduntantly_closed: - d += 'L' + points[0].replace(',', ' ') - - return d + 'z' + 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)) @@ -109,17 +94,15 @@ def rect2pathd(rect): 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 @@ -128,83 +111,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) diff --git a/test/polygons.svg b/test/polygons.svg index ab6c9fd..c310e29 100644 --- a/test/polygons.svg +++ b/test/polygons.svg @@ -1,5 +1,5 @@ - + diff --git a/test/test_svg2paths.py b/test/test_svg2paths.py index 45a4b48..90a23e0 100644 --- a/test/test_svg2paths.py +++ b/test/test_svg2paths.py @@ -20,9 +20,9 @@ class TestSVG2Paths(unittest.TestCase): # triangular quadrilateral (with a redundant 4th "closure" point) path = paths[1] - path_correct = Path(Line(0+0j, 0+100j), - Line(0+100j, 100+100j), - Line(100+100j, 0+0j), + path_correct = Path(Line(0+0j, 0-100j), + Line(0-100j, 0.1-100j), + Line(0.1-100j, 0+0j), Line(0+0j, 0+0j) # result of redundant point ) self.assertTrue(path.isclosed())