FlatCAM/ParseSVG.py

############################################################
# FlatCAM: 2D Post-processing for Manufacturing            #
# http://flatcam.org                                       #
# Author: Juan Pablo Caram (c)                             #
# Date: 12/18/2015                                         #
# MIT Licence                                              #
#                                                          #
# SVG Features supported:                                  #
#  * Groups                                                #
#  * Rectangles (w/ rounded corners)                       #
#  * Circles                                               #
#  * Ellipses                                              #
#  * Polygons                                              #
#  * Polylines                                             #
#  * Lines                                                 #
#  * Paths                                                 #
#  * All transformations                                   #
#                                                          #
#  Reference: www.w3.org/TR/SVG/Overview.html              #
############################################################

# import xml.etree.ElementTree as ET
from lxml import etree as ET
import re
import itertools
from svg.path import Path, Line, Arc, CubicBezier, QuadraticBezier, parse_path
from svg.path.path import Move
from shapely.geometry import LinearRing, LineString, Point, Polygon
from shapely.affinity import translate, rotate, scale, skew, affine_transform
import numpy as np
import logging

from ParseFont import *

log = logging.getLogger('base2')


def svgparselength(lengthstr):
    """
    Parse an SVG length string into a float and a units
    string, if any.

    :param lengthstr: SVG length string.
    :return: Number and units pair.
    :rtype: tuple(float, str|None)
    """

    integer_re_str = r'[+-]?[0-9]+'
    number_re_str = r'(?:[+-]?[0-9]*\.[0-9]+(?:[Ee]' + integer_re_str + ')?' + r')|' + \
                    r'(?:' + integer_re_str + r'(?:[Ee]' + integer_re_str + r')?)'
    length_re_str = r'(' + number_re_str + r')(em|ex|px|in|cm|mm|pt|pc|%)?'

    match = re.search(length_re_str, lengthstr)
    if match:
        return float(match.group(1)), match.group(2)

    return


def path2shapely(path, object_type, res=1.0):
    """
    Converts an svg.path.Path into a Shapely
    LinearRing or LinearString.

    :rtype : LinearRing
    :rtype : LineString
    :param path: svg.path.Path instance
    :param res: Resolution (minimum step along path)
    :return: Shapely geometry object
    """

    points = []
    geometry = []
    geo_element = None

    for component in path:

        # Line
        if isinstance(component, Line):
            start = component.start
            x, y = start.real, start.imag
            if len(points) == 0 or points[-1] != (x, y):
                points.append((x, y))
            end = component.end
            points.append((end.real, end.imag))
            continue

        # Arc, CubicBezier or QuadraticBezier
        if isinstance(component, Arc) or \
           isinstance(component, CubicBezier) or \
           isinstance(component, QuadraticBezier):

            # How many points to use in the discrete representation.
            length = component.length(res / 10.0)
            steps = int(length / res + 0.5)

            # solve error when step is below 1,
            # it may cause other problems, but LineString needs at least  two points
            if steps == 0:
                steps = 1

            frac = 1.0 / steps

            # print length, steps, frac
            for i in range(steps):
                point = component.point(i * frac)
                x, y = point.real, point.imag
                if len(points) == 0 or points[-1] != (x, y):
                    points.append((x, y))
            end = component.point(1.0)
            points.append((end.real, end.imag))
            continue

        # Move
        if isinstance(component, Move):
            if object_type == 'geometry':
                geo_element = LineString(points)
            elif object_type == 'gerber':
                # Didn't worked out using Polygon because if there is a large outline it will envelope everything
                # and create issues with intersections. I will let the parameter obj_type present though
                # geo_element = Polygon(points)
                geo_element = LineString(points)
            else:
                log.error("[error]: Not a valid target object.")
            if not points:
                continue
            else:
                geometry.append(geo_element)
                points = []
            continue
        log.warning("I don't know what this is: %s" % str(component))
        continue

    # if there are still points in points then add them as a LineString
    if points:
        geo_element = LineString(points)
        geometry.append(geo_element)
        points = []

    # if path.closed:
    #     return Polygon(points).buffer(0)
    #     # return LinearRing(points)
    # else:
    #     return LineString(points)
    return geometry

def svgrect2shapely(rect, n_points=32):
    """
    Converts an SVG rect into Shapely geometry.

    :param rect: Rect Element
    :type rect: xml.etree.ElementTree.Element
    :return: shapely.geometry.polygon.LinearRing
    """
    w = svgparselength(rect.get('width'))[0]
    h = svgparselength(rect.get('height'))[0]
    x_obj = rect.get('x')
    if x_obj is not None:
        x = svgparselength(x_obj)[0]
    else:
        x = 0
    y_obj = rect.get('y')
    if y_obj is not None:
        y = svgparselength(y_obj)[0]
    else:
        y = 0
    rxstr = rect.get('rx')
    rystr = rect.get('ry')

    if rxstr is None and rystr is None:  # Sharp corners
        pts = [
            (x, y), (x + w, y), (x + w, y + h), (x, y + h), (x, y)
        ]

    else:  # Rounded corners
        rx = 0.0 if rxstr is None else svgparselength(rxstr)[0]
        ry = 0.0 if rystr is None else svgparselength(rystr)[0]

        n_points = int(n_points / 4 + 0.5)
        t = np.arange(n_points, dtype=float) / n_points / 4

        x_ = (x + w - rx) + rx * np.cos(2 * np.pi * (t + 0.75))
        y_ = (y + ry) + ry * np.sin(2 * np.pi * (t + 0.75))

        lower_right = [(x_[i], y_[i]) for i in range(n_points)]

        x_ = (x + w - rx) + rx * np.cos(2 * np.pi * t)
        y_ = (y + h - ry) + ry * np.sin(2 * np.pi * t)

        upper_right = [(x_[i], y_[i]) for i in range(n_points)]

        x_ = (x + rx) + rx * np.cos(2 * np.pi * (t + 0.25))
        y_ = (y + h - ry) + ry * np.sin(2 * np.pi * (t + 0.25))

        upper_left = [(x_[i], y_[i]) for i in range(n_points)]

        x_ = (x + rx) + rx * np.cos(2 * np.pi * (t + 0.5))
        y_ = (y + ry) + ry * np.sin(2 * np.pi * (t + 0.5))

        lower_left = [(x_[i], y_[i]) for i in range(n_points)]

        pts = [(x + rx, y), (x - rx + w, y)] + \
            lower_right + \
            [(x + w, y + ry), (x + w, y + h - ry)] + \
            upper_right + \
            [(x + w - rx, y + h), (x + rx, y + h)] + \
            upper_left + \
            [(x, y + h - ry), (x, y + ry)] + \
            lower_left

    return Polygon(pts).buffer(0)
    # return LinearRing(pts)


def svgcircle2shapely(circle):
    """
    Converts an SVG circle into Shapely geometry.

    :param circle: Circle Element
    :type circle: xml.etree.ElementTree.Element
    :return: Shapely representation of the circle.
    :rtype: shapely.geometry.polygon.LinearRing
    """
    # cx = float(circle.get('cx'))
    # cy = float(circle.get('cy'))
    # r = float(circle.get('r'))
    cx = svgparselength(circle.get('cx'))[0]  # TODO: No units support yet
    cy = svgparselength(circle.get('cy'))[0]  # TODO: No units support yet
    r = svgparselength(circle.get('r'))[0]  # TODO: No units support yet

    # TODO: No resolution specified.
    return Point(cx, cy).buffer(r)


def svgellipse2shapely(ellipse, n_points=64):
    """
    Converts an SVG ellipse into Shapely geometry

    :param ellipse: Ellipse Element
    :type ellipse: xml.etree.ElementTree.Element
    :param n_points: Number of discrete points in output.
    :return: Shapely representation of the ellipse.
    :rtype: shapely.geometry.polygon.LinearRing
    """

    cx = svgparselength(ellipse.get('cx'))[0]  # TODO: No units support yet
    cy = svgparselength(ellipse.get('cy'))[0]  # TODO: No units support yet

    rx = svgparselength(ellipse.get('rx'))[0]  # TODO: No units support yet
    ry = svgparselength(ellipse.get('ry'))[0]  # TODO: No units support yet

    t = np.arange(n_points, dtype=float) / n_points
    x = cx + rx * np.cos(2 * np.pi * t)
    y = cy + ry * np.sin(2 * np.pi * t)
    pts = [(x[i], y[i]) for i in range(n_points)]

    return Polygon(pts).buffer(0)
    # return LinearRing(pts)


def svgline2shapely(line):
    """

    :param line: Line element
    :type line: xml.etree.ElementTree.Element
    :return: Shapely representation on the line.
    :rtype: shapely.geometry.polygon.LinearRing
    """

    x1 = svgparselength(line.get('x1'))[0]
    y1 = svgparselength(line.get('y1'))[0]
    x2 = svgparselength(line.get('x2'))[0]
    y2 = svgparselength(line.get('y2'))[0]

    return LineString([(x1, y1), (x2, y2)])


def svgpolyline2shapely(polyline):

    ptliststr = polyline.get('points')
    points = parse_svg_point_list(ptliststr)

    return LineString(points)


def svgpolygon2shapely(polygon):

    ptliststr = polygon.get('points')
    points = parse_svg_point_list(ptliststr)

    return Polygon(points).buffer(0)
    # return LinearRing(points)


def getsvggeo(node, object_type):
    """
    Extracts and flattens all geometry from an SVG node
    into a list of Shapely geometry.

    :param node: xml.etree.ElementTree.Element
    :return: List of Shapely geometry
    :rtype: list
    """
    kind = re.search('(?:\{.*\})?(.*)$', node.tag).group(1)
    geo = []

    # Recurse
    if len(node) > 0:
        for child in node:
            subgeo = getsvggeo(child, object_type)
            if subgeo is not None:
                geo += subgeo

    # Parse
    elif kind == 'path':
        log.debug("***PATH***")
        P = parse_path(node.get('d'))
        P = path2shapely(P, object_type)
        # for path, the resulting geometry is already a list so no need to create a new one
        geo = P

    elif kind == 'rect':
        log.debug("***RECT***")
        R = svgrect2shapely(node)
        geo = [R]

    elif kind == 'circle':
        log.debug("***CIRCLE***")
        C = svgcircle2shapely(node)
        geo = [C]

    elif kind == 'ellipse':
        log.debug("***ELLIPSE***")
        E = svgellipse2shapely(node)
        geo = [E]

    elif kind == 'polygon':
        log.debug("***POLYGON***")
        poly = svgpolygon2shapely(node)
        geo = [poly]

    elif kind == 'line':
        log.debug("***LINE***")
        line = svgline2shapely(node)
        geo = [line]

    elif kind == 'polyline':
        log.debug("***POLYLINE***")
        pline = svgpolyline2shapely(node)
        geo = [pline]

    else:
        log.warning("Unknown kind: " + kind)
        geo = None

    # ignore transformation for unknown kind
    if geo is not None:
        # Transformations
        if 'transform' in node.attrib:
            trstr = node.get('transform')
            trlist = parse_svg_transform(trstr)
            # log.debug(trlist)

            # Transformations are applied in reverse order
            for tr in trlist[::-1]:
                if tr[0] == 'translate':
                    geo = [translate(geoi, tr[1], tr[2]) for geoi in geo]
                elif tr[0] == 'scale':
                    geo = [scale(geoi, tr[0], tr[1], origin=(0, 0))
                           for geoi in geo]
                elif tr[0] == 'rotate':
                    geo = [rotate(geoi, tr[1], origin=(tr[2], tr[3]))
                           for geoi in geo]
                elif tr[0] == 'skew':
                    geo = [skew(geoi, tr[1], tr[2], origin=(0, 0))
                           for geoi in geo]
                elif tr[0] == 'matrix':
                    geo = [affine_transform(geoi, tr[1:]) for geoi in geo]
                else:
                    raise Exception('Unknown transformation: %s', tr)

    return geo


def getsvgtext(node, object_type, units='MM'):
    """
    Extracts and flattens all geometry from an SVG node
    into a list of Shapely geometry.

    :param node: xml.etree.ElementTree.Element
    :return: List of Shapely geometry
    :rtype: list
    """
    kind = re.search('(?:\{.*\})?(.*)$', node.tag).group(1)
    geo = []

    # Recurse
    if len(node) > 0:
        for child in node:
            subgeo = getsvgtext(child, object_type, units=units)
            if subgeo is not None:
                geo += subgeo

    # Parse
    elif kind == 'tspan':
        current_attrib = node.attrib
        txt = node.text
        style_dict = {}
        parrent_attrib = node.getparent().attrib
        style = parrent_attrib['style']

        try:
            style_list = style.split(';')
            for css in style_list:
                style_dict[css.rpartition(':')[0]] = css.rpartition(':')[-1]

            pos_x = float(current_attrib['x'])
            pos_y = float(current_attrib['y'])

            # should have used the instance from FlatCAMApp.App but how? without reworking everything ...
            pf = ParseFont()
            pf.get_fonts_by_types()
            font_name = style_dict['font-family'].replace("'", '')

            if style_dict['font-style'] == 'italic' and style_dict['font-weight'] == 'bold':
                font_type = 'bi'
            elif style_dict['font-weight'] == 'bold':
                font_type = 'bold'
            elif style_dict['font-style'] == 'italic':
                font_type = 'italic'
            else:
                font_type = 'regular'

            # value of 2.2 should have been 2.83 (conversion value from pixels to points)
            # but the dimensions from Inkscape did not corelate with the ones after importing in FlatCAM
            # so I adjusted this
            font_size = svgparselength(style_dict['font-size'])[0] * 2.2
            geo = [pf.font_to_geometry(txt,
                                       font_name=font_name,
                                       font_size=font_size,
                                       font_type=font_type,
                                       units=units,
                                       coordx=pos_x,
                                       coordy=pos_y)
                   ]

            geo = [(scale(g, 1.0, -1.0)) for g in geo]
        except Exception as e:
            log.debug(str(e))
    else:
        geo = None

    # ignore transformation for unknown kind
    if geo is not None:
        # Transformations
        if 'transform' in node.attrib:
            trstr = node.get('transform')
            trlist = parse_svg_transform(trstr)
            # log.debug(trlist)

            # Transformations are applied in reverse order
            for tr in trlist[::-1]:
                if tr[0] == 'translate':
                    geo = [translate(geoi, tr[1], tr[2]) for geoi in geo]
                elif tr[0] == 'scale':
                    geo = [scale(geoi, tr[0], tr[1], origin=(0, 0))
                           for geoi in geo]
                elif tr[0] == 'rotate':
                    geo = [rotate(geoi, tr[1], origin=(tr[2], tr[3]))
                           for geoi in geo]
                elif tr[0] == 'skew':
                    geo = [skew(geoi, tr[1], tr[2], origin=(0, 0))
                           for geoi in geo]
                elif tr[0] == 'matrix':
                    geo = [affine_transform(geoi, tr[1:]) for geoi in geo]
                else:
                    raise Exception('Unknown transformation: %s', tr)

    return geo

def parse_svg_point_list(ptliststr):
    """
    Returns a list of coordinate pairs extracted from the "points"
    attribute in SVG polygons and polyline's.

    :param ptliststr: "points" attribute string in polygon or polyline.
    :return: List of tuples with coordinates.
    """

    pairs = []
    last = None
    pos = 0
    i = 0

    for match in re.finditer(r'(\s*,\s*)|(\s+)', ptliststr.strip(' ')):

        val = float(ptliststr[pos:match.start()])

        if i % 2 == 1:
            pairs.append((last, val))
        else:
            last = val

        pos = match.end()
        i += 1

    # Check for last element
    val = float(ptliststr[pos:])
    if i % 2 == 1:
        pairs.append((last, val))
    else:
        log.warning("Incomplete coordinates.")

    return pairs


def parse_svg_transform(trstr):
    """
    Parses an SVG transform string into a list
    of transform names and their parameters.

    Possible transformations are:

    * Translate: translate(<tx> [<ty>]), which specifies
      a translation by tx and ty. If <ty> is not provided,
      it is assumed to be zero. Result is
      ['translate', tx, ty]

    * Scale: scale(<sx> [<sy>]), which specifies a scale operation
      by sx and sy. If <sy> is not provided, it is assumed to be
      equal to <sx>. Result is: ['scale', sx, sy]

    * Rotate: rotate(<rotate-angle> [<cx> <cy>]), which specifies
      a rotation by <rotate-angle> degrees about a given point.
      If optional parameters <cx> and <cy> are not supplied,
      the rotate is about the origin of the current user coordinate
      system. Result is: ['rotate', rotate-angle, cx, cy]

    * Skew: skewX(<skew-angle>), which specifies a skew
      transformation along the x-axis. skewY(<skew-angle>), which
      specifies a skew transformation along the y-axis.
      Result is ['skew', angle-x, angle-y]

    * Matrix: matrix(<a> <b> <c> <d> <e> <f>), which specifies a
      transformation in the form of a transformation matrix of six
      values. matrix(a,b,c,d,e,f) is equivalent to applying the
      transformation matrix [a b c d e f]. Result is
      ['matrix', a, b, c, d, e, f]

    Note: All parameters to the transformations are "numbers",
    i.e. no units present.

    :param trstr: SVG transform string.
    :type trstr: str
    :return: List of transforms.
    :rtype: list
    """
    trlist = []

    assert isinstance(trstr, str)
    trstr = trstr.strip(' ')

    integer_re_str = r'[+-]?[0-9]+'
    number_re_str = r'(?:[+-]?[0-9]*\.[0-9]+(?:[Ee]' + integer_re_str + ')?' + r')|' + \
                    r'(?:' + integer_re_str + r'(?:[Ee]' + integer_re_str + r')?)'

    # num_re_str = r'[\+\-]?[0-9\.e]+'  # TODO: Negative exponents missing
    comma_or_space_re_str = r'(?:(?:\s+)|(?:\s*,\s*))'
    translate_re_str = r'translate\s*\(\s*(' + \
                       number_re_str + r')(?:' + \
                       comma_or_space_re_str + \
                       r'(' + number_re_str + r'))?\s*\)'
    scale_re_str = r'scale\s*\(\s*(' + \
                   number_re_str + r')' + \
                   r'(?:' + comma_or_space_re_str + \
                   r'(' + number_re_str + r'))?\s*\)'
    skew_re_str = r'skew([XY])\s*\(\s*(' + \
                  number_re_str + r')\s*\)'
    rotate_re_str = r'rotate\s*\(\s*(' + \
                    number_re_str + r')' + \
                    r'(?:' + comma_or_space_re_str + \
                    r'(' + number_re_str + r')' + \
                    comma_or_space_re_str + \
                    r'(' + number_re_str + r'))?\s*\)'
    matrix_re_str = r'matrix\s*\(\s*' + \
                    r'(' + number_re_str + r')' + comma_or_space_re_str + \
                    r'(' + number_re_str + r')' + comma_or_space_re_str + \
                    r'(' + number_re_str + r')' + comma_or_space_re_str + \
                    r'(' + number_re_str + r')' + comma_or_space_re_str + \
                    r'(' + number_re_str + r')' + comma_or_space_re_str + \
                    r'(' + number_re_str + r')\s*\)'

    while len(trstr) > 0:
        match = re.search(r'^' + translate_re_str, trstr)
        if match:
            trlist.append([
                'translate',
                float(match.group(1)),
                float(match.group(2)) if match.group else 0.0
            ])
            trstr = trstr[len(match.group(0)):].strip(' ')
            continue

        match = re.search(r'^' + scale_re_str, trstr)
        if match:
            trlist.append([
                'translate',
                float(match.group(1)),
                float(match.group(2)) if not None else float(match.group(1))
            ])
            trstr = trstr[len(match.group(0)):].strip(' ')
            continue

        match = re.search(r'^' + skew_re_str, trstr)
        if match:
            trlist.append([
                'skew',
                float(match.group(2)) if match.group(1) == 'X' else 0.0,
                float(match.group(2)) if match.group(1) == 'Y' else 0.0
            ])
            trstr = trstr[len(match.group(0)):].strip(' ')
            continue

        match = re.search(r'^' + rotate_re_str, trstr)
        if match:
            trlist.append([
                'rotate',
                float(match.group(1)),
                float(match.group(2)) if match.group(2) else 0.0,
                float(match.group(3)) if match.group(3) else 0.0
            ])
            trstr = trstr[len(match.group(0)):].strip(' ')
            continue

        match = re.search(r'^' + matrix_re_str, trstr)
        if match:
            trlist.append(['matrix'] + [float(x) for x in match.groups()])
            trstr = trstr[len(match.group(0)):].strip(' ')
            continue

        # raise Exception("Don't know how to parse: %s" % trstr)
        log.error("[error] Don't know how to parse: %s" % trstr)

    return trlist

# if __name__ == "__main__":
#     tree = ET.parse('tests/svg/drawing.svg')
#     root = tree.getroot()
#     ns = re.search(r'\{(.*)\}', root.tag).group(1)
#     print(ns)
#     for geo in getsvggeo(root):
#         print(geo)