picosvgx 0.1.0__py3-none-any.whl

picosvgx/svg_meta.py

@@ -0,0 +1,307 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+from types import MappingProxyType
+from lxml import etree  # pytype: disable=import-error
+from typing import (
+    Any,
+    Container,
+    Generator,
+    Iterable,
+    MutableMapping,
+    Optional,
+    Tuple,
+)
+from picosvgx.geometric_types import Rect
+
+
+SVGCommand = Tuple[str, Tuple[float, ...]]
+SVGCommandSeq = Iterable[SVGCommand]
+SVGCommandGen = Generator[SVGCommand, None, None]
+
+
+def svgns():
+    return "http://www.w3.org/2000/svg"
+
+
+def xlinkns():
+    return "http://www.w3.org/1999/xlink"
+
+
+def splitns(name):
+    qn = etree.QName(name)
+    return qn.namespace, qn.localname
+
+
+def strip_ns(tagname):
+    return splitns(tagname)[1]
+
+
+# https://www.w3.org/TR/SVG11/paths.html#PathData
+_CMD_ARGS = {
+    "m": 2,
+    "z": 0,
+    "l": 2,
+    "h": 1,
+    "v": 1,
+    "c": 6,
+    "s": 4,
+    "q": 4,
+    "t": 2,
+    "a": 7,
+}
+_CMD_ARGS.update({k.upper(): v for k, v in _CMD_ARGS.items()})
+
+
+def check_cmd(cmd, args):
+    cmd_args = num_args(cmd)
+    if cmd_args == 0:
+        if args:
+            raise ValueError(f"{cmd} has no args, {len(args)} invalid")
+    elif len(args) % cmd_args != 0:
+        raise ValueError(f"{cmd} has sets of {cmd_args} args, {len(args)} invalid")
+    return cmd_args
+
+
+def num_args(cmd):
+    if not cmd in _CMD_ARGS:
+        raise ValueError(f'Invalid svg command "{cmd}"')
+    return _CMD_ARGS[cmd]
+
+
+def cmds():
+    return _CMD_ARGS.keys()
+
+
+# For each command iterable of x-coords and iterable of y-coords
+# Helpful if you want to adjust them
+_CMD_COORDS = {
+    "m": ((0,), (1,)),
+    "z": ((), ()),
+    "l": ((0,), (1,)),
+    "h": ((0,), ()),
+    "v": ((), (0,)),
+    "c": ((0, 2, 4), (1, 3, 5)),
+    "s": ((0, 2), (1, 3)),
+    "q": ((0, 2), (1, 3)),
+    "t": ((0,), (1,)),
+    "a": ((5,), (6,)),
+}
+_CMD_COORDS.update({k.upper(): v for k, v in _CMD_COORDS.items()})
+
+
+def cmd_coords(cmd):
+    if not cmd in _CMD_ARGS:
+        raise ValueError(f'Invalid svg command "{cmd}"')
+    return _CMD_COORDS[cmd]
+
+
+def ntos(n: float) -> str:
+    # strip superflous .0 decimals
+    return str(int(n)) if isinstance(n, float) and n.is_integer() else str(n)
+
+
+def number_or_percentage(s: str, scale=1) -> float:
+    return float(s[:-1]) / 100 * scale if s.endswith("%") else float(s)
+
+def parse_css_length(s: str) -> float:
+    """Parse CSS length values with absolute units and convert to pixels.
+
+    Converts absolute CSS units (px, pt, pc, mm, cm, in) to pixels using 96 DPI.
+    Percentages are returned as numeric values without the % sign (caller must handle scaling).
+    Relative units (em, rem, ex, ch, vw, vh) that require context are rejected.
+
+    Args:
+        s: String value like '100px', '12pt', '50%'
+
+    Returns:
+        float: Numeric value in pixels (or percentage value without % for percentages)
+
+    Raises:
+        ValueError: If the value is empty, invalid, or uses unsupported relative units
+    """
+    if not isinstance(s, str):
+        return float(s)
+
+    s = s.strip()
+    if not s:
+        raise ValueError("Empty CSS length value")
+
+    # Handle percentage values - return numeric value, caller handles scaling
+    if s.endswith('%'):
+        return float(s[:-1])
+
+    # Absolute unit conversions to pixels (96 DPI standard)
+    # Reference: https://www.w3.org/TR/css-values-3/#absolute-lengths
+    ABSOLUTE_UNITS = {
+        'px': 1.0,          # pixels (base unit)
+        'pt': 96 / 72,      # points: 1pt = 1/72 inch = 96/72 px
+        'pc': 96 / 6,       # picas: 1pc = 1/6 inch = 16px
+        'in': 96,           # inches: 1in = 96px (CSS standard)
+        'cm': 96 / 2.54,    # centimeters: 1cm = 96/2.54 px
+        'mm': 96 / 25.4,    # millimeters: 1mm = 96/25.4 px
+    }
+
+    # Extract number and unit
+    match = re.match(r'^([+-]?(?:\d+\.?\d*|\.\d+))([a-z]*)$', s, re.IGNORECASE)
+    if not match:
+        raise ValueError(f"Invalid CSS length value: {s!r}")
+
+    number = float(match.group(1))
+    unit = match.group(2).lower()
+
+    if not unit:
+        # No unit specified, treat as pixels
+        return number
+
+    if unit in ABSOLUTE_UNITS:
+        return number * ABSOLUTE_UNITS[unit]
+
+    # Reject relative units that require context (em, rem, ex, ch, vw, vh, etc.)
+    raise ValueError(
+        f"Relative unit '{unit}' requires context and is not supported. "
+        f"Supported units: {', '.join(ABSOLUTE_UNITS.keys())}, %"
+    )
+
+def path_segment(cmd, *args):
+    # put commas between coords, spaces otherwise, author readability pref
+    args_per_cmd = check_cmd(cmd, args)
+    args = [ntos(a) for a in args]
+    combined_args = []
+    xy_coords = set(zip(*_CMD_COORDS[cmd]))
+    if args_per_cmd:
+        for n in range(len(args) // args_per_cmd):
+            sub_args = args[n * args_per_cmd : (n + 1) * args_per_cmd]
+            i = 0
+            while i < len(sub_args):
+                if (i, i + 1) in xy_coords:
+                    combined_args.append(f"{sub_args[i]},{sub_args[i+1]}")
+                    i += 2
+                else:
+                    combined_args.append(sub_args[i])
+                    i += 1
+    return cmd + " ".join(combined_args)
+
+
+def parse_css_declarations(
+    style: str,
+    output: MutableMapping[str, Any],
+    property_names: Optional[Container[str]] = None,
+) -> str:
+    """Parse CSS declaration list into {property: value} XML element attributes.
+
+    Args:
+        style: CSS declaration list without the enclosing braces,
+            as found in an SVG element's "style" attribute.
+        output: a dictionary or lxml.etree._Attrib where to store the parsed properties.
+            Note that lxml validates the attribute names and if a given CSS property name
+            is not a valid XML name (e.g. vendor specific keywords starting with a hyphen,
+            e.g. "-inkscape-font-specification"), it will be silently ignored.
+        property_names: optional set of property names to limit the declarations
+            to be parsed; if not provided, all will be parsed.
+
+    Returns:
+        A string containing the unparsed style declarations, if any.
+
+    Raises:
+        ValueError if CSS declaration is invalid and can't be parsed.
+
+    References:
+    https://www.w3.org/TR/SVG/styling.html#ElementSpecificStyling
+    https://www.w3.org/TR/2013/REC-css-style-attr-20131107/#syntax
+    """
+    unparsed = []
+    for declaration in style.split(";"):
+        declaration = declaration.strip()
+        if declaration.count(":") == 1:
+            property_name, value = declaration.split(":")
+            property_name, value = property_name.strip(), value.strip()
+            if property_names is None or property_name in property_names:
+                try:
+                    output[property_name] = value
+                except ValueError:
+                    # lxml raises if attrib name is invalid (e.g. starts with '-')
+                    unparsed.append(declaration)
+            else:
+                unparsed.append(declaration)
+        elif declaration.strip():
+            raise ValueError(f"Invalid CSS declaration syntax: {declaration}")
+    return "; ".join(unparsed) + ";" if unparsed else ""
+
+
+def parse_view_box(s: str) -> Rect:
+    box = tuple(float(v) for v in re.split(r",|\s+", s))
+    if len(box) != 4:
+        raise ValueError(f"Unable to parse viewBox: {s!r}")
+    return Rect(*box)
+
+
+# SVG attributes that may contain CSS length values with units
+# Define once using Python field naming convention (underscores)
+_LENGTH_FIELDS = frozenset({
+    'width', 'height', 'x', 'y', 'cx', 'cy', 'r', 'rx', 'ry',
+    'x1', 'y1', 'x2', 'y2', 'stroke_width', 'stroke_dashoffset'
+})
+
+# Export both naming conventions
+SVG_LENGTH_FIELDS = _LENGTH_FIELDS
+SVG_LENGTH_ATTRS = frozenset(f.replace('_', '-') for f in _LENGTH_FIELDS)
+
+
+# sentinel object to check if special linked fields such as fx/fy are explicitly set;
+# using a float type instead of None to make the typechecker happy, and also so that one
+# doesn't need to unwrap Optional type whenever accessing those fields
+class _LinkedDefault(float):
+    def __new__(cls, attr_name):
+        self = float.__new__(cls, "NaN")
+        self.attr_name = attr_name
+        return self
+
+    def __call__(self, data_obj):
+        return getattr(data_obj, self.attr_name)
+
+
+# makes dict read-only
+ATTRIB_DEFAULTS = MappingProxyType(
+    {
+        "clip-path": "",
+        "clip-rule": "nonzero",
+        "fill": "black",
+        "fill-opacity": 1.0,
+        "fill-rule": "nonzero",
+        "stroke": "none",
+        "stroke-width": 1.0,
+        "stroke-linecap": "butt",
+        "stroke-linejoin": "miter",
+        "stroke-miterlimit": 4,
+        "stroke-dasharray": "none",
+        "stroke-dashoffset": 0.0,
+        "stroke-opacity": 1.0,
+        "opacity": 1.0,
+        "transform": "",
+        "style": "",
+        "display": "inline",
+        "d": "",
+        "id": "",
+    }
+)
+
+
+def attrib_default(name: str, default: Any = ()) -> Any:
+    if name in ATTRIB_DEFAULTS:
+        return ATTRIB_DEFAULTS[name]
+    if default == ():
+        raise ValueError(f"No entry for '{name}' and no default given")
+    return default

picosvgx/svg_path_iter.py

@@ -0,0 +1,110 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+from typing import Generator, Tuple
+from picosvgx import svg_meta
+
+_CMD_RE = re.compile(f'([{"".join(svg_meta.cmds())}])')
+_SEPARATOR_RE = re.compile("[, ]+")
+_FLOAT_RE = re.compile(
+    r"[-+]?"  # optional sign
+    r"(?:"
+    r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?"  # int or float
+    r"|"
+    r"(?:\.[0-9]+)"  # float with leading dot (e.g. '.42')
+    r")"
+    r"(?:[eE][-+]?[0-9]+)?"  # optional scientific notiation
+)
+_BOOL_RE = re.compile("^[01]")
+_ARC_ARGUMENT_TYPES = (
+    (float, _FLOAT_RE),  # rx
+    (float, _FLOAT_RE),  # ry
+    (float, _FLOAT_RE),  # x-axis-rotation
+    (int, _BOOL_RE),  # large-arc-flag
+    (int, _BOOL_RE),  # sweep-flag
+    (float, _FLOAT_RE),  # x
+    (float, _FLOAT_RE),  # y
+)
+
+# https://www.w3.org/TR/SVG11/paths.html#PathDataMovetoCommands
+# If a moveto is followed by multiple pairs of coordinates,
+# the subsequent pairs are treated as implicit lineto commands
+_IMPLICIT_REPEAT_CMD = {"m": "l", "M": "L"}
+
+
+def _parse_args(cmd: str, args: str) -> Generator[float, None, None]:
+    raw_args = [s for s in _SEPARATOR_RE.split(args) if s]
+    if not raw_args:
+        return
+
+    if cmd.upper() == "A":
+        arg_types = _ARC_ARGUMENT_TYPES
+    else:
+        arg_types = ((float, _FLOAT_RE),)
+    n = len(arg_types)
+
+    i = j = 0
+    while j < len(raw_args):
+        arg = raw_args[j]
+        # modulo to wrap around
+        converter, regex = arg_types[i % n]
+        m = regex.match(arg)
+        if not m:
+            raise ValueError(f"Invalid argument #{i} for '{cmd}': {arg!r}")
+
+        start, end = m.span()
+        yield converter(arg[start:end])
+
+        if end < len(arg):
+            raw_args[j] = arg[end:]
+        else:
+            j += 1
+        i += 1
+
+
+def _explode_cmd(args_per_cmd, cmd, args):
+    cmds = []
+    for i in range(len(args) // args_per_cmd):
+        if i > 0:
+            cmd = _IMPLICIT_REPEAT_CMD.get(cmd, cmd)
+        cmds.append((cmd, tuple(args[i * args_per_cmd : (i + 1) * args_per_cmd])))
+    return cmds
+
+
+def parse_svg_path(
+    svg_path: str, exploded: bool = False
+) -> Generator[Tuple[str, Tuple[float, ...]], None, None]:
+    """Parses an svg path.
+
+    Exploded means when params repeat each the command is reported as
+    if multiplied. For example "M1,1 2,2 3,3" would report as three
+    separate steps when exploded.
+
+    Yields tuples of (cmd, (args))."""
+    command_tuples = []
+    parts = _CMD_RE.split(svg_path)[1:]
+    for i in range(0, len(parts), 2):
+        cmd = parts[i]
+        raw_args = parts[i + 1].strip()
+
+        args = tuple(_parse_args(cmd, raw_args))
+
+        args_per_cmd = svg_meta.check_cmd(cmd, args)
+        if args_per_cmd == 0 or not exploded:
+            command_tuples.append((cmd, args))
+        else:
+            command_tuples.extend(_explode_cmd(args_per_cmd, cmd, args))
+    for t in command_tuples:
+        yield t

picosvgx/svg_pathops.py

@@ -0,0 +1,194 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""SVGPath <=> skia-pathops constructs to enable ops on paths."""
+import functools
+import pathops  # pytype: disable=import-error
+from typing import Sequence, Tuple
+from picosvgx.svg_meta import SVGCommand, SVGCommandGen, SVGCommandSeq
+from picosvgx.svg_transform import Affine2D
+
+
+# Absolutes coords assumed
+# A should never occur because we convert arcs to cubics
+# S,T should never occur because we eliminate shorthand
+_SVG_CMD_TO_SKIA_FN = {
+    "M": pathops.Path.moveTo,
+    "L": pathops.Path.lineTo,
+    "Q": pathops.Path.quadTo,
+    "Z": pathops.Path.close,
+    "C": pathops.Path.cubicTo,
+}
+
+_SVG_TO_SKIA_LINE_CAP = {
+    "butt": pathops.LineCap.BUTT_CAP,
+    "round": pathops.LineCap.ROUND_CAP,
+    "square": pathops.LineCap.SQUARE_CAP,
+}
+
+_SVG_TO_SKIA_LINE_JOIN = {
+    "miter": pathops.LineJoin.MITER_JOIN,
+    "round": pathops.LineJoin.ROUND_JOIN,
+    "bevel": pathops.LineJoin.BEVEL_JOIN,
+    # No arcs or miter-clip
+}
+
+
+def _skia_pts_to_svg(svg_cmd, points) -> SVGCommandGen:
+    # pathops.Path gives us sequences of points, flatten 'em
+    yield (svg_cmd, tuple(c for pt in points for c in pt))
+
+
+_SKIA_CMD_TO_SVG_CMD = {
+    pathops.PathVerb.MOVE: functools.partial(_skia_pts_to_svg, "M"),
+    pathops.PathVerb.LINE: functools.partial(_skia_pts_to_svg, "L"),
+    pathops.PathVerb.QUAD: functools.partial(_skia_pts_to_svg, "Q"),
+    pathops.PathVerb.CUBIC: functools.partial(_skia_pts_to_svg, "C"),
+    pathops.PathVerb.CLOSE: functools.partial(_skia_pts_to_svg, "Z"),
+    # pathops.PathVerb.CONIC... convertConicsToQuads should have taken care of these
+}
+
+_SVG_FILL_RULE_TO_SKIA_FILL_TYPE = {
+    "nonzero": pathops.FillType.WINDING,
+    "evenodd": pathops.FillType.EVEN_ODD,
+}
+
+
+def skia_path(svg_cmds: SVGCommandSeq, fill_rule: str) -> pathops.Path:
+    try:
+        fill_type = _SVG_FILL_RULE_TO_SKIA_FILL_TYPE[fill_rule]
+    except KeyError:
+        raise ValueError(f"Invalid fill rule: {fill_rule!r}")
+    sk_path = pathops.Path(fillType=fill_type)
+    for cmd, args in svg_cmds:
+        if cmd not in _SVG_CMD_TO_SKIA_FN:
+            raise ValueError(f'No mapping to Skia for "{cmd} {args}"')
+        _SVG_CMD_TO_SKIA_FN[cmd](sk_path, *args)
+    return sk_path
+
+
+def svg_commands(skia_path: pathops.Path) -> SVGCommandGen:
+    for verb, points in skia_path:
+        if verb not in _SKIA_CMD_TO_SVG_CMD:
+            raise ValueError(f'No mapping to svg for "{verb} {points}"')
+        for svg_cmd, svg_args in _SKIA_CMD_TO_SVG_CMD[verb](points):
+            yield (svg_cmd, svg_args)
+
+
+def _do_pathop(
+    op: str, svg_cmd_seqs: Sequence[SVGCommandSeq], fill_rules: Sequence[str]
+) -> SVGCommandGen:
+    if not svg_cmd_seqs:
+        return  # pytype: disable=bad-return-type
+    assert len(svg_cmd_seqs) == len(fill_rules)
+    sk_path = skia_path(svg_cmd_seqs[0], fill_rules[0])
+    for svg_cmds, fill_rule in zip(svg_cmd_seqs[1:], fill_rules[1:]):
+        sk_path2 = skia_path(svg_cmds, fill_rule)
+        sk_path = pathops.op(sk_path, sk_path2, op, fix_winding=True)
+    else:
+        sk_path.simplify(fix_winding=True)
+    return svg_commands(sk_path)
+
+
+def union(
+    svg_cmd_seqs: Sequence[SVGCommandSeq], fill_rules: Sequence[str]
+) -> SVGCommandGen:
+    return _do_pathop(pathops.PathOp.UNION, svg_cmd_seqs, fill_rules)
+
+
+def intersection(
+    svg_cmd_seqs: Sequence[SVGCommandSeq], fill_rules: Sequence[str]
+) -> SVGCommandGen:
+    return _do_pathop(pathops.PathOp.INTERSECTION, svg_cmd_seqs, fill_rules)
+
+
+def difference(
+    svg_cmd_seqs: Sequence[SVGCommandSeq], fill_rules: Sequence[str]
+) -> SVGCommandGen:
+    return _do_pathop(pathops.PathOp.DIFFERENCE, svg_cmd_seqs, fill_rules)
+
+
+def remove_overlaps(svg_cmds: SVGCommandSeq, fill_rule: str) -> SVGCommandGen:
+    """Create a simplified path filled using the "nonzero" winding rule.
+
+    This uses skia-pathops simplify method to create a new path containing
+    non-overlapping contours that describe the same area as the original path.
+    The fill_rule ("evenodd" or "nonzero") of the original path determines
+    what is inside or outside the path.
+    After simplification, the winding order of the sub-paths is such that the
+    path looks the same no matter what fill rule is used to render it.
+
+    References:
+        https://oreillymedia.github.io/Using_SVG/extras/ch06-fill-rule.html
+    """
+    sk_path = skia_path(svg_cmds, fill_rule=fill_rule)
+    sk_path.simplify(fix_winding=True)
+    assert sk_path.fillType == pathops.FillType.WINDING
+    return svg_commands(sk_path)
+
+
+def transform(svg_cmds: SVGCommandSeq, affine: Affine2D) -> SVGCommandGen:
+    sk_path = skia_path(svg_cmds, fill_rule="nonzero").transform(*affine)
+    return svg_commands(sk_path)
+
+
+def stroke(
+    svg_cmds: SVGCommandSeq,
+    svg_linecap: str,
+    svg_linejoin: str,
+    stroke_width: float,
+    stroke_miterlimit: float,
+    tolerance: float,
+    dash_array: Sequence[float] = (),
+    dash_offset: float = 0.0,
+) -> SVGCommandGen:
+    """Create a path that is a shape with its stroke applied.
+
+    The result may contain self-intersecting paths, thus it should be filled
+    using "nonzero" winding rule (otherwise with "evenodd" one may see gaps
+    where the sub-paths overlap).
+    """
+    cap = _SVG_TO_SKIA_LINE_CAP.get(svg_linecap, None)
+    if cap is None:
+        raise ValueError(f"Unsupported cap {svg_linecap}")
+    join = _SVG_TO_SKIA_LINE_JOIN.get(svg_linejoin, None)
+    if join is None:
+        raise ValueError(f"Unsupported join {svg_linejoin}")
+    # the input path's fill_rule doesn't affect the stroked result so for
+    # simplicity here we assume 'nonzero'
+    sk_path = skia_path(svg_cmds, fill_rule="nonzero")
+    sk_path.stroke(stroke_width, cap, join, stroke_miterlimit, dash_array, dash_offset)
+
+    # nuke any conics that snuck in (e.g. with stroke-linecap="round")
+    sk_path.convertConicsToQuads(tolerance)
+
+    backup = pathops.Path(sk_path)
+    try:
+        sk_path.simplify(fix_winding=True)
+    except pathops.PathOpsError:
+        # skip tricky paths that trigger PathOpsError
+        # https://github.com/googlefonts/picosvg/issues/192
+        sk_path = backup
+    return svg_commands(sk_path)
+
+
+def bounding_box(svg_cmds: SVGCommandSeq):
+    return skia_path(svg_cmds, fill_rule="nonzero").bounds
+
+
+def path_area(svg_cmds: SVGCommandSeq, fill_rule: str) -> float:
+    """Return the path's absolute area."""
+    sk_path = skia_path(svg_cmds, fill_rule=fill_rule)
+    sk_path.simplify(fix_winding=True)
+    return sk_path.area