svg.py

# ##### BEGIN GPL LICENSE BLOCK #####
#
#  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 2
#  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, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####

# <pep8 compliant>

"""Reading SVG file format.
"""

__author__ = "howard.trickey@gmail.com"

import re
import xml.dom.minidom
from . import geom

TOL = 1e-5


def ParseSVGFile(filename):
    """Parse an SVG file name and return an Art object for it.

    Args:
      filename: string - name of file to read and parse
    Returns:
      geom.Art
    """

    dom = xml.dom.minidom.parse(filename)
    return _SVGDomToArt(dom)


def ParseSVGString(s):
    """Parse an SVG string and return an Art object for it.

    Args:
      s: string - contains svg
    Returns:
      geom.Art
    """

    dom = xml.dom.minidom.parseString(s)
    return _SVGDomToArg(dom)


class _SState:
    """Holds state that affects the conversion.
    """

    def __init__(self):
        self.ctm = geom.TransformMatrix()
        self.fill = "black"
        self.fillrule = "nonzero"
        self.stroke = "none"
        self.dpi = 90  # default Inkscape DPI


def _SVGDomToArt(dom):
    """Convert an svg file in dom form into an Art object.

    Args:
      dom: xml.dom.minidom.Document
    Returns:
      geom.Art
    """

    art = geom.Art()
    svgs = dom.getElementsByTagName('svg')
    if len(svgs) == 0:
        return art
    gs = _SState()
    gs.ctm.d = -1.0
    _ProcessChildren(svgs[0], art, gs)
    return art


def _ProcessChildren(nodes, art, gs):
    """Process a list of SVG nodes, updating art.

    Args:
      nodes: list of xml.dom.Node
      art: geom.Art
      gs: _SState
    Side effects:
      Maybe adds paths to art.
    """

    for node in nodes.childNodes:
        _ProcessNode(node, art, gs)


def _ProcessNode(node, art, gs):
    """Process an SVG node, updating art.

    Args:
      node: xml.dom.Node
      art: geom.Art
      gs: _SState
    Side effects:
      Maybe adds paths to art.
    """

    if node.nodeType != node.ELEMENT_NODE:
        return
    tag = node.tagName
    if tag == 'g':
        _ProcessChildren(node, art, gs)
    elif tag == 'defs':
        pass  # TODO
    elif tag == 'path':
        _ProcessPath(node, art, gs)
    elif tag == 'polygon':
        _ProcessPolygon(node, art, gs)
    elif tag == 'rect':
        _ProcessRect(node, art, gs)
    elif tag == 'ellipse':
        _ProcessEllipse(node, art, gs)
    elif tag == 'circle':
        _ProcessCircle(node, art, gs)


def _ProcessPolygon(node, art, gs):
    """Process a 'polygon' SVG node, updating art.

    Args:
      node: xml.dom.Node - a 'polygon' node
      arg: geom.Art
      gs: _SState
    Side effects:
      Adds path for polygon to art
    """

    if node.hasAttribute('points'):
        coords = _ParseCoordPairList(node.getAttribute('points'))
        n = len(coords)
        if coords:
            c = [gs.ctm.Apply(coord) for coord in coords]
            sp = geom.Subpath()
            sp.segments = [('L', c[i], c[i % n]) for i in range(n)]
            sp.closed = True
            path = geom.Path()
            _SetPathAttributes(path, node, gs)
            path.subpaths = [sp]
            art.paths.append(path)


def _ProcessPath(node, art, gs):
    """Process a 'polygon' SVG node, updating art.

    Args:
      node: xml.dom.Node - a 'polygon' node
      arg: geom.Art
      gs: _SState
    Side effects:
      Adds path for polygon to art
    """

    if not node.hasAttribute('d'):
        return
    s = node.getAttribute('d')
    i = 0
    path = geom.Path()
    _SetPathAttributes(path, node, gs)
    initpt = (0.0, 0.0)
    subpath = None
    while i < len(s):
        (i, subpath, initpt) = _ParseSubpath(s, i, initpt, gs)
        if subpath:
            if not subpath.Empty():
                path.AddSubpath(subpath)
        else:
            break
    if path.subpaths:
        art.paths.append(path)


def _ParseSubpath(s, i, initpt, gs):
    """Parse a moveto-drawto-command-group starting at s[i] and return Subpath.

    Args:
      s: string - should be the 'd' attribute of a 'path' element
      i: int - index in s to start parsing
      initpt: (float, float) - coordinates of initial point
      gs: _SState - used to transform coordinates
    Returns:
      (int, geom.Subpath, (float, float)) -
          (index after subpath and subsequent whitespace,
          the Subpath itself or Non if there was an error, final point)
    """

    subpath = geom.Subpath()
    i = _SkipWS(s, i)
    n = len(s)
    if i >= n:
        return (i, None, initpt)
    if s[i] == 'M':
        move_cmd = 'M'
    elif s[i] == 'm':
        move_cmd = 'm'
    else:
        return (i, None, initpt)
    (i, cur) = _ParseCoordPair(s, _SkipWS(s, i + 1))
    if not cur:
        return (i, None, initpt)
    prev_cmd = 'L'  # implicit cmd if coords follow directly
    if move_cmd == 'm':
        cur = geom.VecAdd(initpt, cur)
        prev_cmd = 'l'
    while True:
        implicit_cmd = False
        if i < n:
            cmd = s[i]
            if _PeekCoord(s, i):
                cmd = prev_cmd
                implicit_cmd = True
        else:
            cmd = None
        if cmd == 'z' or cmd == 'Z' or cmd == None:
            if cmd:
                i = _SkipWS(s, i + 1)
                subpath.closed = True
            return (i, subpath, cur)
        if not implicit_cmd:
            i = _SkipWS(s, i + 1)
        if cmd == 'l' or cmd == 'L':
            (i, p1) = _ParseCoordPair(s, i)
            if not p1:
                break
            if cmd == 'l':
                p1 = geom.VecAdd(cur, p1)
            subpath.AddSegment(_LineSeg(cur, p1, gs))
            cur = p1
        elif cmd == 'c' or cmd == 'C':
            (i, p1, p2, p3) = _ParseThreeCoordPairs(s, i)
            if not p1:
                break
            if cmd == 'c':
                p1 = geom.VecAdd(cur, p1)
                p2 = geom.VecAdd(cur, p2)
                p3 = geom.VecAdd(cur, p3)
            subpath.AddSegment(_Bezier3Seg(cur, p3, p1, p2, gs))
            cur = p3
        elif cmd == 'a' or cmd == 'A':
            (i, p1, rad, rot, la, ccw) = _ParseArc(s, i)
            if not p1:
                break
            if cmd == 'a':
                p1 = geom.VecAdd(cur, p1)
            subpath.AddSegment(_ArcSeg(cur, p1, rad, rot, la, ccw, gs))
            cur = p1
        elif cmd == 'h' or cmd == 'H':
            (i, x) = _ParseCoord(s, i)
            if x is None:
                break
            if cmd == 'h':
                x += cur[0]
            subpath.AddSegment(_LineSeg(cur, (x, cur[1]), gs))
            cur = (x, cur[1])
        elif cmd == 'v' or cmd == 'V':
            (i, y) = _ParseCoord(s, i)
            if y is None:
                break
            if cmd == 'v':
                y += cur[1]
            subpath.AddSegment(_LineSeg(cur, (cur[0], y), gs))
            cur = (cur[0], y)
        elif cmd == 's' or cmd == 'S':
            (i, p2, p3) = _ParseTwoCoordPairs(s, i)
            if not p2:
                break
            if cmd == 's':
                p2 = geom.VecAdd(cur, p2)
                p3 = geom.VecAdd(cur, p3)
            # p1 is reflection of cp2 of previous command
            # through current point (but p1 is cur if no previous)
            if len(subpath.segments) > 0 and subpath.segments[-1][0] == 'B':
                p4 = subpath.segments[-1][4]
            else:
                p4 = cur
            p1 = geom.VecAdd(cur, geom.VecSub(cur, p4))
            subpath.AddSegment(_Bezier3Seg(cur, p3, p1, p2, gs))
            cur = p3
        else:
            # TODO: quadratic beziers, 'q', and 't'
            break
        i = _SkipCommaSpace(s, i)
        prev_cmd = cmd
    return (i, None, cur)


def _ProcessRect(node, art, gs):
    """Process a 'rect' SVG node, updating art.

    Args:
      node: xml.dom.Node - a 'polygon' node
      arg: geom.Art
      gs: _SState
    Side effects:
      Adds path for rectangle to art
    """

    if not (node.hasAttribute('width') and node.hasAttribute('height')):
        return
    w = _ParseLengthAttrOrDefault(node, 'width', gs, 0.0)
    h = _ParseLengthAttrOrDefault(node, 'height', gs, 0.0)
    if w <= 0.0 or h <= 0.0:
        return
    x = _ParseCoordAttrOrDefault(node, 'x', 0.0)
    y = _ParseCoordAttrOrDefault(node, 'y', 0.0)
    rx = _ParseLengthAttrOrDefault(node, 'rx', gs, 0.0)
    ry = _ParseLengthAttrOrDefault(node, 'ry', gs, 0.0)
    if rx == 0.0 and ry > 0.0:
        rx = ry
    elif rx > 0.0 and ry == 0.0:
        ry = rx
    if rx > w / 2.0:
        rx = w / 2.0
    if ry > h / 2.0:
        ry = h / 2.0
    subpath = geom.Subpath()
    subpath.closed = True
    if rx == 0.0 and ry == 0.0:
        subpath.AddSegment(_LineSeg((x, y), (x + w, y), gs))
        subpath.AddSegment(_LineSeg((x + w, y), (x + w, y + h), gs))
        subpath.AddSegment(_LineSeg((x + w, y + h), (x, y + h), gs))
        subpath.AddSegment(_LineSeg((x, y + h), (x, y), gs))
    else:
        wmid = w - 2 * rx
        hmid = h - 2 * ry
        # top line
        if wmid > TOL:
            subpath.AddSegment(_LineSeg((x + rx, y), (x + rx + wmid, y), gs))
        # top right corner: remember, y positive downward, so this clockwise
        subpath.AddSegment(_ArcSeg((x + rx + wmid, y), (x + w, y + ry),
            (rx, ry), 0.0, False, False, gs))
        # right line
        if hmid > TOL:
            subpath.AddSegment(_LineSeg((x + w, y + ry),
                (x + w, y + ry + hmid), gs))
        # bottom right corner
        subpath.AddSegment(_ArcSeg((x + w, y + ry + hmid),
            (x + rx + wmid, y + h),
            (rx, ry), 0.0, False, False, gs))
        # bottom line
        if wmid > TOL:
            subpath.AddSegment(_LineSeg((x + rx + wmid, y + h),
                (x + rx, y + h), gs))
        # bottom left corner
        subpath.AddSegment(_ArcSeg((x + rx, y + h), (x, y + ry + hmid),
            (rx, ry), 0.0, False, False, gs))
        # left line
        if hmid > TOL:
            subpath.AddSegment(_LineSeg((x, y + ry + hmid), (x, y + ry), gs))
        # top left corner
        subpath.AddSegment(_ArcSeg((x, y + ry), (x + rx, y),
            (rx, ry), 0.0, False, False, gs))
    path = geom.Path()
    _SetPathAttributes(path, node, gs)
    path.subpaths = [subpath]
    art.paths.append(path)


def _ProcessEllipse(node, art, gs):
    """Process an 'ellipse' SVG node, updating art.

    Args:
      node: xml.dom.Node - a 'polygon' node
      arg: geom.Art
      gs: _SState
    Side effects:
      Adds path for ellipse to art
    """

    if not (node.hasAttribute('rx') and node.hasAttribute('ry')):
        return
    rx = _ParseLengthAttrOrDefault(node, 'rx', gs, 0.0)
    ry = _ParseLengthAttrOrDefault(node, 'ry', gs, 0.0)
    if rx < TOL or ry < TOL:
        return
    cx = _ParseCoordAttrOrDefault(node, 'cx', 0.0)
    cy = _ParseCoordAttrOrDefault(node, 'cy', 0.0)
    subpath = _FullEllipseSubpath(cx, cy, rx, ry, gs)
    path = geom.Path()
    path.subpaths = [subpath]
    _SetPathAttributes(path, node, gs)
    art.paths.append(path)


def _ProcessCircle(node, art, gs):
    """Process a 'circle' SVG node, updating art.

    Args:
      node: xml.dom.Node - a 'polygon' node
      arg: geom.Art
      gs: _SState
    Side effects:
      Adds path for circle to art
    """

    if not node.hasAttribute('r'):
        return
    r = _ParseLengthAttrOrDefault(node, 'r', gs, 0.0)
    if r < TOL:
        return
    cx = _ParseCoordAttrOrDefault(node, 'cx', 0.0)
    cy = _ParseCoordAttrOrDefault(node, 'cy', 0.0)
    subpath = _FullEllipseSubpath(cx, cy, r, r, gs)
    path = geom.Path()
    path.subpaths = [subpath]
    _SetPathAttributes(path, node, gs)
    art.paths.append(path)


def _FullEllipseSubpath(cx, cy, rx, ry, gs):
    """Return a Subpath for a full ellipse.

    Args:
      cx: float - center x
      cy: float - center y
      rx: float - x radius
      ry: float - y radius
      gs: _SState - for transform
    Returns:
      geom.Subpath
    """

    # arc starts at 3 o'clock
    # TODO: if gs has rotate transform, figure that out
    # and use that as angle for arc x-rotation
    subpath = geom.Subpath()
    subpath.closed = True
    subpath.AddSegment(_ArcSeg((cx + rx, cy), (cx, cy + ry),
        (rx, ry), 0.0, False, False, gs))
    subpath.AddSegment(_ArcSeg((cx, cy + ry), (cx - rx, cy),
        (rx, ry), 0.0, False, False, gs))
    subpath.AddSegment(_ArcSeg((cx - rx, cy), (cx, cy - ry),
        (rx, ry), 0.0, False, False, gs))
    subpath.AddSegment(_ArcSeg((cx, cy - ry), (cx + rx, cy),
        (rx, ry), 0.0, False, False, gs))
    return subpath


def _LineSeg(p1, p2, gs):
    """Return an 'L' segment, transforming coordinates.

    Args:
      p1: (float, float) - start point
      p2: (float, float) - end point
      gs: _SState - used to transform coordinates
    Returns:
      tuple - an 'L' type geom.Subpath segment
    """

    return ('L', gs.ctm.Apply(p1), gs.ctm.Apply(p2))


def _Bezier3Seg(p1, p2, c1, c2, gs):
    """Return a 'B' segment, transforming coordinates.

    Args:
      p1: (float, float) - start point
      p2: (float, float) - end point
      c1: (float, float) - first control point
      c2: (float, float) - second control point
      gs: _SState - used to transform coordinates
    Returns:
      tuple - an 'L' type geom.Subpath segment
    """

    return ('B', gs.ctm.Apply(p1), gs.ctm.Apply(p2),
        gs.ctm.Apply(c1), gs.ctm.Apply(c2))


def _ArcSeg(p1, p2, rad, rot, la, ccw, gs):
    """Return an 'A' segment, with attempt to transform.

    Our A segments don't allow modeling the effect of
    arbitrary transforms, but we can handle translation
    and scaling.

    Args:
      p1: (float, float) - start point
      p2: (float, float) - end point
      rad: (float, float) - (x radius, y radius)
      rot: float - x axis rotation, in degrees
      la: bool - large arc if True
      ccw: bool - counter-clockwise if True
      gs: _SState - used to transform
    Returns:
      tuple - an 'A' type geom.Subpath segment
    """

    tp1 = gs.ctm.Apply(p1)
    tp2 = gs.ctm.Apply(p2)
    rx = rad[0] * gs.ctm.a
    ry = rad[1] * gs.ctm.d
    # if one of axes is mirrored, invert the ccw flag
    if rx * ry < 0.0:
        ccw = not ccw
    trad = (abs(rx), abs(ry))
    # TODO: abs(gs.ctm.a) != abs(ts.ctm.d), adjust xrot
    return ('A', tp1, tp2, trad, rot, la, ccw)


def _SetPathAttributes(path, node, gs):
    """Set the attributes related to filling/stroking in path.

    Use attribute settings in node, if there, else those in the
    current graphics state, gs.

    Arguments:
      path: geom.Path
      node: xml.dom.Node
      gs: _SState
    Side effects:
      May set filled, fillevenodd, stroked, fillpaint, strokepaint in path.
    """

    fill = gs.fill
    stroke = gs.stroke
    fillrule = gs.fillrule
    if node.hasAttribute('style'):
        style = _CSSInlineDict(node.getAttribute('style'))
        if 'fill' in style:
            fill = style['fill']
        if 'stroke' in style:
            stroke = style['stroke']
        if 'fill-rule' in style:
            fillrule = style['fill-rule']
    if node.hasAttribute('fill'):
        fill = node.getAttribute('fill')
    if fill != 'none':
        paint = _ParsePaint(fill)
        if paint is not None:
            path.fillpaint = paint
            path.filled = True
    if node.hasAttribute('stroke'):
        stroke = node.getAttribute('stroke')
    if stroke != 'none':
        paint = _ParsePaint(stroke)
        if stroke is not None:
            path.strokepaint = paint
            path.stroked = True
    if node.hasAttribute('fill-rule'):
        fillrule = node.getAttribute('fill-rule')
    path.fillevenodd = (fillrule == 'evenodd')


# Some useful regular expressions
_re_float = re.compile(r"(\+|-)?(([0-9]+\.[0-9]*)|(\.[0-9]+)|([0-9]+))")
_re_int = re.compile(r"(\+|-)?[0-9]+")
_re_wsopt = re.compile(r"\s*")
_re_wscommaopt = re.compile(r"(\s*,\s*)|(\s*)")
_re_namevalue = re.compile(r"\s*(\S+)\s*:\s*(\S+)\s*(?:;|$)")


def _CSSInlineDict(s):
    """Parse string s as CSS inline spec, and return a dictionary for it.

    An inline CSS spec is semi-colon separated list of prop : value pairs,
    such as: "fill:none;fill-rule : evenodd"

    Args:
      s: string - inline CSS spec
    Returns:
      dict : maps string (prop name) -> string (value)
    """

    pairs = _re_namevalue.findall(s)
    return dict(pairs)


def _ParsePaint(s):
    """Parse an SVG paint definition and return our version of Paint.

    If is 'none', return None.
    If fail to parse (e.g., a TODO syntax), return black_paint.

    Args:
      s: string - should contain an SVG paint spec
    Returns:
      geom.Paint or None
    """

    if len(s) == 0 or s == 'none':
        return None
    if s[0] == '#':
        if len(s) == 7:
            # 6 hex digits
            return geom.Paint( \
              int(s[1:3], 16) / 255.0,
              int(s[3:5], 16) / 255.0,
              int(s[5:7], 16) / 255.0)
        elif len(s) == 4:
            # 3 hex digits
            return geom.Paint( \
              int(s[1], 16) * 17 / 255.0,
              int(s[2], 16) * 17 / 255.0,
              int(s[3], 16) * 17 / 255.0)
    else:
        if s in geom.ColorDict:
            return geom.ColorDict[s]
    return geom.black_paint


def _ParseLengthAttrOrDefault(node, attr, gs, default):
    """Parse the given attribute as a length, else return default.

    Args:
      node: xml.dom.Node
      attr: string - the attribute name
      gs: _SState - for dots-per-inch, for units conversion
      default: float - to return if no attr or error parsing it
    Returns:
      float - the length
    """

    if not node.hasAttribute(attr):
        return default
    (_, v) = _ParseLength(node.getAttribute(attr), gs, 0)
    if v is None:
        return default
    else:
        return v


def _ParseCoordAttrOrDefault(node, attr, default):
    """Parse the given attribute as a coordinate, else return default.

    Args:
      node: xml.dom.Node
      attr: string - the attribute name
      default: float - to return if no attr or error parsing it
    Returns:
      float - the coordinate
    """

    if not node.hasAttribute(attr):
        return default
    (_, v) = _ParseCoord(node.getAttribute(attr), 0)
    if v is None:
        return default
    else:
        return v


def _ParseCoord(s, i):
    """Parse a coordinate (floating point number).

    Args:
      s: string
      i: int - where to start parsing
    Returns:
      (int, float or None) - int is index after the coordinate
        and subsequent white space
    """

    m = _re_float.match(s, i)
    if m:
        return (_SkipWS(s, m.end()), float(m.group()))
    else:
        return (i, None)


def _PeekCoord(s, i):
    """Return True if s[i] starts a coordinate.

    Args:
      s: string
      i: int - place in s to start looking
    Returns:
      bool - True if s[i] starts a coordinate, perhaps after comma / space
    """

    i = _SkipCommaSpace(s, i)
    m = _re_float.match(s, i)
    return True if m else False


def _ParseCoordPair(s, i):
    """Parse pair of coordinates, with optional comma between.

    Args:
      s: string
      i: int - where to start parsing
    Returns:
      (int, (float, float) or None) - int is index after the coordinate
        and subsequent white space
    """

    (j, x) = _ParseCoord(s, i)
    if x is not None:
        j = _SkipCommaSpace(s, j)
        (j, y) = _ParseCoord(s, j)
        if y is not None:
            return (_SkipWS(s, j), (x, y))
    return (i, None)


def _ParseTwoCoordPairs(s, i):
    """Parse two coordinate pairs, optionally separated by commas.

    Args:
      s: string
      i: int - where to start parsing
    Returns:
      (int, (float, float) or None, (float, float) or None) -
        int is index after the coordinate and subsequent white space
    """

    (j, pair1) = _ParseCoordPair(s, i)
    if pair1:
        j = _SkipCommaSpace(s, j)
        (j, pair2) = _ParseCoordPair(s, j)
        if pair2:
            return (j, pair1, pair2)
    return (i, None, None)


def _ParseThreeCoordPairs(s, i):
    """Parse three coordinate pairs, optionally separated by commas.

    Args:
      s: string
      i: int - where to start parsing
    Returns:
      (int, (float, float) or None, (float, float) or None,
          (float, float) or None) -
        int is index after the coordinateand subsequent white space
    """

    (j, pair1) = _ParseCoordPair(s, i)
    if pair1:
        j = _SkipCommaSpace(s, j)
        (j, pair2) = _ParseCoordPair(s, j)
        if pair2:
            j = _SkipCommaSpace(s, j)
            (j, pair3) = _ParseCoordPair(s, j)
            if pair3:
                return (j, pair1, pair2, pair3)
    return (i, None, None, None)


def _ParseCoordPairList(s):
    """Parse a list of coordinate pairs.

    The numbers should be separated by whitespace
    or a comma with optional whitespace around it.

    Args:
      s: string - should contain coordinate pairs
    Returns:
      list of (float, float)
    """

    ans = []
    i = _SkipWS(s, 0)
    while i < len(s):
        (i, pair) = _ParseCoordPair(s, i)
        if not pair:
            break
        ans.append(pair)
    return ans


# units to be scaled by 'dots-per-inch' with these factors
_UnitDict = {
  'in': 1.0, 'mm': 0.0393700787,
  'cm': 0.393700787, 'pt': 0.0138888889, 'pc': 0.166666667,
  # assume 10pt font, 5pt font x-height
  'em': 0.138888889, 'ex': 0.0138888889 * 5}


def _ParseLength(s, gs, i):
    """Parse a length (floating point number, with possible units).

    Args:
      s: string
      gs: _SState, for dpi if needed for units conversion
      i: int - where to start parsing
    Returns:
      (int, float or None) - int is index after the coordinate
        and subsequent white space; float is converted to user coords
    """

    (i, v) = _ParseCoord(s, i)
    if v is None:
        return (i, None)
    upi = 1.0
    if i < len(s):
        if s[i] == '%':
            # supposed to be percentage of nearest enclosing
            # viewport in appropriate direction.
            # for now, assume viewport is 10in in each dir
            upi = dpi * 10.0 / 100.0
        elif i < len(s) - 1:
            cc = s[i:i + 2]
            if cc == 'px':
                upi = 1.0
                i += 2
            elif cc in _UnitDict:
                upi = gs.dpi * _UnitDict[cc]
                i += 2
    return (i, v * upi)


def _ParseArc(s, i):
    """Parse an elliptical arc specification.

    Args:
      s: string
      i: int - where to start parsing
    Returns:
      (int, (float, float) or None, (float, float), float, bool, bool) -
        int is index after spec and subsequent white space,
        first (float, float) is end point of arc
        second (float, float) is (x-radius, y-radius)
        float is x-axis rotation, in degrees
        first bool is True if larger arc is to be used
        second bool is True if arc follows ccw direction
    """

    (j, rad) = _ParseCoordPair(s, i)
    if rad:
        j = _SkipCommaSpace(s, j)
        (j, rot) = _ParseCoord(s, j)
        if rot is not None:
            j = _SkipCommaSpace(s, j)
            (j, f) = _ParseCoord(s, j)  # should really just look for 0 or 1
            if f is not None:
                laf = (f != 0.0)
                j = _SkipCommaSpace(s, j)
                (j, f) = _ParseCoord(s, j)
                if f is not None:
                    ccw = (f != 0.0)
                    j = _SkipCommaSpace(s, j)
                    (j, pt) = _ParseCoordPair(s, j)
                    if pt:
                        return (j, pt, rad, rot, laf, ccw)
    return (i, None, None, None, None, None)


def _SkipWS(s, i):
    """Skip optional whitespace at s[i]... and return new i.

    Args:
      s: string
      i: int - index into s
    Returns:
      int - index of first none-whitespace character from s[i], or len(s)
    """

    m = _re_wsopt.match(s, i)
    if m:
        return m.end()
    else:
        return i


def _SkipCommaSpace(s, i):
    """Skip optional space with optional comma in it.

    Args:
      s: string
      i: int - index into s
    Returns:
      int - index after optional space with optional comma
    """

    m = _re_wscommaopt.match(s, i)
    if m:
        return m.end()
    else:
        return i