strokeoutline 0.1.0__py3-none-any.whl

strokeoutline/__init__.py

@@ -0,0 +1,69 @@
+"""Deterministic variable-width stroke outlining for planar centerlines."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from planarcurve import CubicBezier, CubicPath, Point2D, QuadraticBezier
+
+from .core import (
+    DEFAULT_OUTLINE_CONFIG,
+    CapStyle,
+    Contour,
+    DegeneratePathError,
+    InvalidWidthError,
+    OutlineConfig,
+    OutlineError,
+    OutlineResult,
+    SubdivisionLimitError,
+    WidthProfile,
+    combine_outlines,
+    expand_tap,
+    outline,
+    outline_disc,
+    signed_area,
+    winding,
+)
+from .model import (
+    Line,
+    Path2D,
+    Segment,
+    Subpath,
+    path_from_cubic_path,
+    path_from_polyline,
+)
+
+try:
+    __version__ = version("strokeoutline")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    "DEFAULT_OUTLINE_CONFIG",
+    "CapStyle",
+    "Contour",
+    "CubicBezier",
+    "CubicPath",
+    "DegeneratePathError",
+    "InvalidWidthError",
+    "Line",
+    "OutlineConfig",
+    "OutlineError",
+    "OutlineResult",
+    "Path2D",
+    "Point2D",
+    "QuadraticBezier",
+    "Segment",
+    "Subpath",
+    "SubdivisionLimitError",
+    "WidthProfile",
+    "__version__",
+    "combine_outlines",
+    "expand_tap",
+    "outline",
+    "outline_disc",
+    "path_from_cubic_path",
+    "path_from_polyline",
+    "signed_area",
+    "winding",
+]

strokeoutline/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = 'g72d8e8d28'

strokeoutline/core.py

@@ -0,0 +1,563 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass
+from math import acos, atan2, ceil, cos, degrees, hypot, isfinite, pi, sin
+from typing import Literal, TypeAlias
+
+from planarcurve import CubicPath, Point2D, QuadraticBezier
+
+from .model import Line, Path2D, Segment, Subpath, path_from_cubic_path
+
+WidthProfile: TypeAlias = float | Sequence[tuple[float, float]] | Callable[[float], float]
+Contour: TypeAlias = tuple[Point2D, ...]
+CapStyle: TypeAlias = Literal["round", "square"]
+
+
+class OutlineError(ValueError):
+    """Base class for geometric outlining failures."""
+
+
+class InvalidWidthError(OutlineError):
+    """Raised when a width profile is malformed or non-positive."""
+
+
+class DegeneratePathError(OutlineError):
+    """Raised when a centerline contains degenerate geometry."""
+
+
+class SubdivisionLimitError(OutlineError):
+    """Raised when adaptive sampling cannot satisfy configured tolerances."""
+
+
+@dataclass(frozen=True)
+class OutlineConfig:
+    """Controls adaptive sampling and cap behavior for open paths.
+
+    Parameters
+    ----------
+    max_centerline_error : float
+        Maximum centerline deviation from a straight chord, in input coordinate
+        units. Smaller values generally produce more samples.
+    max_width_error : float
+        Maximum width-profile deviation from linear interpolation, in width
+        units. Smaller values sample changing widths more closely.
+    max_normal_angle_degrees : float
+        Maximum tangent direction change over a sampling interval, in degrees.
+        The value must be positive and less than 180.
+    cap : CapStyle
+        Cap style for open paths: ``"round"`` or ``"square"``. Ignored for
+        closed centerlines.
+    max_subdivision_depth : int
+        Maximum recursive subdivision depth. If sampling cannot meet the
+        tolerances by this depth, outlining raises ``SubdivisionLimitError``.
+
+    Notes
+    -----
+    Decreasing tolerances generally increases contour vertices and work. Keep
+    the defaults unless the application has a reason to tune them.
+    """
+
+    max_centerline_error: float = 0.25
+    max_width_error: float = 0.25
+    max_normal_angle_degrees: float = 3.0
+    cap: CapStyle = "round"
+    max_subdivision_depth: int = 18
+
+    def __post_init__(self) -> None:
+        tolerances = (
+            self.max_centerline_error,
+            self.max_width_error,
+            self.max_normal_angle_degrees,
+        )
+        if any(
+            isinstance(value, bool) or not isfinite(value) or value <= 0 for value in tolerances
+        ):
+            raise ValueError("outline tolerances must be positive and finite")
+        if self.max_normal_angle_degrees >= 180:
+            raise ValueError("normal angle tolerance must be less than 180 degrees")
+        if self.cap not in {"round", "square"}:
+            raise ValueError("cap must be 'round' or 'square'")
+        if (
+            isinstance(self.max_subdivision_depth, bool)
+            or not isinstance(self.max_subdivision_depth, int)
+            or self.max_subdivision_depth < 1
+        ):
+            raise ValueError("maximum subdivision depth must be a positive integer")
+
+
+DEFAULT_OUTLINE_CONFIG = OutlineConfig()
+
+
+@dataclass(frozen=True)
+class OutlineResult:
+    """Result of a centerline expansion.
+
+    Parameters
+    ----------
+    contours : tuple[Contour, ...]
+        Output contours. Each non-empty contour is closed by repeating its
+        first point as its final point. The tuple may be empty.
+    bounds : tuple[float, float, float, float] or None
+        Aggregate ``(min_x, min_y, max_x, max_y)`` bounds, or ``None`` when
+        there are no contours, for example in ``combine_outlines(())``.
+    """
+
+    contours: tuple[Contour, ...]
+    bounds: tuple[float, float, float, float] | None
+
+
+def _lerp(a: Point2D, b: Point2D, t: float) -> Point2D:
+    return (a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t)
+
+
+def _point_on(segment: Segment, t: float) -> Point2D:
+    if isinstance(segment, Line):
+        return _lerp(segment.p0, segment.p1, t)
+    if isinstance(segment, QuadraticBezier):
+        return _lerp(_lerp(segment.p0, segment.p1, t), _lerp(segment.p1, segment.p2, t), t)
+    a = _lerp(segment.p0, segment.p1, t)
+    b = _lerp(segment.p1, segment.p2, t)
+    c = _lerp(segment.p2, segment.p3, t)
+    return _lerp(_lerp(a, b, t), _lerp(b, c, t), t)
+
+
+def _tangent(segment: Segment, t: float) -> Point2D:
+    if isinstance(segment, Line):
+        return (segment.p1[0] - segment.p0[0], segment.p1[1] - segment.p0[1])
+    if isinstance(segment, QuadraticBezier):
+        return (
+            2 * ((1 - t) * (segment.p1[0] - segment.p0[0]) + t * (segment.p2[0] - segment.p1[0])),
+            2 * ((1 - t) * (segment.p1[1] - segment.p0[1]) + t * (segment.p2[1] - segment.p1[1])),
+        )
+    u = 1 - t
+    return (
+        3
+        * (
+            u * u * (segment.p1[0] - segment.p0[0])
+            + 2 * u * t * (segment.p2[0] - segment.p1[0])
+            + t * t * (segment.p3[0] - segment.p2[0])
+        ),
+        3
+        * (
+            u * u * (segment.p1[1] - segment.p0[1])
+            + 2 * u * t * (segment.p2[1] - segment.p1[1])
+            + t * t * (segment.p3[1] - segment.p2[1])
+        ),
+    )
+
+
+def _width_function(profile: WidthProfile) -> Callable[[float], float]:
+    if callable(profile):
+        raw = profile
+    elif isinstance(profile, (int, float)) and not isinstance(profile, bool):
+        constant = float(profile)
+
+        def raw(_u: float) -> float:
+            return constant
+
+    else:
+        try:
+            knots = tuple((float(position), float(width)) for position, width in profile)
+        except (TypeError, ValueError, OverflowError) as exc:
+            raise InvalidWidthError(
+                "width must be a positive number, knot sequence, or callable"
+            ) from exc
+        if any(
+            not isfinite(position) or not isfinite(width) or width <= 0 for position, width in knots
+        ):
+            raise InvalidWidthError("width profile knots must be finite with positive widths")
+        if len(knots) < 2:
+            raise InvalidWidthError("width profile requires at least two knots")
+        if knots[0][0] != 0 or knots[-1][0] != 1:
+            raise InvalidWidthError("width profile must span parameter values 0 through 1")
+        if any(b[0] <= a[0] for a, b in zip(knots, knots[1:], strict=False)):
+            raise InvalidWidthError("width profile parameters must increase")
+
+        def raw(u: float) -> float:
+            for (u0, w0), (u1, w1) in zip(knots, knots[1:], strict=False):
+                if u <= u1:
+                    return w0 + (w1 - w0) * (u - u0) / (u1 - u0)
+            return knots[-1][1]
+
+    def width_at(u: float) -> float:
+        raw_value = raw(float(u))
+        if isinstance(raw_value, bool):
+            raise InvalidWidthError("outline widths must be finite and positive")
+        try:
+            value = float(raw_value)
+        except (TypeError, ValueError, OverflowError) as exc:
+            raise InvalidWidthError("width callable must return numeric values") from exc
+        if not isfinite(value) or value <= 0:
+            raise InvalidWidthError("outline widths must be finite and positive")
+        return value
+
+    return width_at
+
+
+def _unit(vector: Point2D) -> Point2D:
+    length = hypot(*vector)
+    if length <= 1e-12:
+        raise DegeneratePathError("outline contains a zero-length tangent")
+    return (vector[0] / length, vector[1] / length)
+
+
+def _shift(point: Point2D, direction: Point2D, distance: float) -> Point2D:
+    return (point[0] + direction[0] * distance, point[1] + direction[1] * distance)
+
+
+def _distance_to_chord(point: Point2D, start: Point2D, end: Point2D) -> float:
+    dx, dy = end[0] - start[0], end[1] - start[1]
+    length2 = dx * dx + dy * dy
+    if length2 <= 1e-24:
+        return hypot(point[0] - start[0], point[1] - start[1])
+    u = max(0.0, min(1.0, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / length2))
+    projection = (start[0] + u * dx, start[1] + u * dy)
+    return hypot(point[0] - projection[0], point[1] - projection[1])
+
+
+def _angle_between(left: Point2D, right: Point2D) -> float:
+    a, b = _unit(left), _unit(right)
+    return degrees(acos(max(-1.0, min(1.0, a[0] * b[0] + a[1] * b[1]))))
+
+
+def _flatten_segment(
+    segment: Segment,
+    segment_index: int,
+    segment_count: int,
+    width_at: Callable[[float], float],
+    config: OutlineConfig,
+) -> list[tuple[float, Point2D]]:
+    def subdivide(t0: float, t1: float, depth: int) -> list[tuple[float, Point2D]]:
+        p0, p1 = _point_on(segment, t0), _point_on(segment, t1)
+        span = t1 - t0
+        probes = [_point_on(segment, t0 + span * fraction) for fraction in (0.25, 0.5, 0.75)]
+        chord_error = max(_distance_to_chord(point, p0, p1) for point in probes)
+        tangent0 = _tangent(segment, t0)
+        tangent1 = _tangent(segment, t1)
+        tangent_mid = _tangent(segment, (t0 + t1) / 2)
+        chord = (p1[0] - p0[0], p1[1] - p0[1])
+        if hypot(*tangent0) <= 1e-12:
+            tangent0 = chord
+        if hypot(*tangent1) <= 1e-12:
+            tangent1 = chord
+        if hypot(*tangent_mid) <= 1e-12:
+            tangent_mid = chord
+        normal_change = max(
+            _angle_between(tangent0, tangent_mid),
+            _angle_between(tangent_mid, tangent1),
+        )
+        u0 = (segment_index + t0) / segment_count
+        u1 = (segment_index + t1) / segment_count
+        widths = (width_at(u0), width_at(u1))
+        width_error = max(
+            abs(
+                width_at(u0 + fraction * (u1 - u0))
+                - (widths[0] + fraction * (widths[1] - widths[0]))
+            )
+            for fraction in (0.25, 0.5, 0.75)
+        )
+        acceptable = (
+            chord_error <= config.max_centerline_error
+            and normal_change <= config.max_normal_angle_degrees
+            and width_error <= config.max_width_error
+        )
+        if acceptable:
+            return [(t0, p0), (t1, p1)]
+        if depth >= config.max_subdivision_depth:
+            raise SubdivisionLimitError("adaptive outline subdivision exceeded its depth limit")
+        middle = (t0 + t1) / 2
+        left = subdivide(t0, middle, depth + 1)
+        right = subdivide(middle, t1, depth + 1)
+        return left[:-1] + right
+
+    return subdivide(0.0, 1.0, 0)
+
+
+def _profile_points(
+    segments: Sequence[Segment], width_at: Callable[[float], float], config: OutlineConfig
+) -> tuple[list[Point2D], list[float]]:
+    sampled: list[Point2D] = []
+    widths: list[float] = []
+    count = len(segments)
+    for index, segment in enumerate(segments):
+        samples = _flatten_segment(segment, index, count, width_at, config)
+        for sample_index, (t, point) in enumerate(samples):
+            if index and sample_index == 0:
+                continue
+            u = (index + t) / count
+            current_width = float(width_at(u))
+            if not isfinite(current_width) or current_width <= 0:
+                raise InvalidWidthError("outline widths must be finite and positive")
+            sampled.append(point)
+            widths.append(current_width)
+    return sampled, widths
+
+
+def _normals(points: list[Point2D], closed: bool) -> list[Point2D]:
+    result = []
+    count = len(points)
+    for index, point in enumerate(points):
+        if closed:
+            previous = points[(index - 1) % count]
+            following = points[(index + 1) % count]
+        else:
+            previous = points[max(0, index - 1)]
+            following = points[min(count - 1, index + 1)]
+        tangent = (following[0] - previous[0], following[1] - previous[1])
+        if hypot(*tangent) <= 1e-12:
+            following = points[min(index + 1, count - 1)]
+            tangent = (following[0] - point[0], following[1] - point[1])
+        tx, ty = _unit(tangent)
+        result.append((-ty, tx))
+    return result
+
+
+def _offset(points: list[Point2D], widths: list[float], closed: bool, side: float) -> list[Point2D]:
+    normals = _normals(points, closed)
+    offsets = []
+    count = len(points)
+    for index, (point, normal) in enumerate(zip(points, normals, strict=True)):
+        radius = widths[index] / 2
+        if closed or 0 < index < count - 1:
+            before = normals[(index - 1) % count]
+            after = normals[(index + 1) % count]
+            bisector = (before[0] + after[0], before[1] + after[1])
+            if hypot(*bisector) > 1e-12:
+                bisector = _unit(bisector)
+                denominator = bisector[0] * normal[0] + bisector[1] * normal[1]
+                scale = min(widths[index] / 2 / max(denominator, 0.25), widths[index] * 2)
+                normal = (bisector[0] * scale / radius, bisector[1] * scale / radius)
+        offsets.append((point[0] + side * radius * normal[0], point[1] + side * radius * normal[1]))
+    return offsets
+
+
+def _arc_points(
+    center: Point2D, radius: float, start_angle: float, sweep: float, tolerance: float
+) -> list[Point2D]:
+    if radius <= 0:
+        return [center]
+    ratio = max(-1.0, min(1.0, 1 - tolerance / radius))
+    max_angle = 2 * acos(ratio)
+    steps = max(2, ceil(abs(sweep) / max(max_angle, 1e-6)))
+    if steps % 2:
+        steps += 1
+    return [
+        (
+            center[0] + radius * cos(start_angle + sweep * index / steps),
+            center[1] + radius * sin(start_angle + sweep * index / steps),
+        )
+        for index in range(steps + 1)
+    ]
+
+
+def signed_area(points: Sequence[Point2D]) -> float:
+    """Return signed polygon area; the repeated closing point is optional."""
+    if len(points) < 3:
+        return 0.0
+    return (
+        sum(
+            first[0] * second[1] - second[0] * first[1]
+            for first, second in zip(points, (*points[1:], points[0]), strict=False)
+        )
+        / 2
+    )
+
+
+def winding(points: Sequence[Point2D]) -> Literal["ccw", "cw", "degenerate"]:
+    """Return contour winding from signed area."""
+    area = signed_area(points)
+    if area > 0:
+        return "ccw"
+    if area < 0:
+        return "cw"
+    return "degenerate"
+
+
+def _close(points: list[Point2D]) -> Contour:
+    if not points:
+        return ()
+    if points[-1] != points[0]:
+        points.append(points[0])
+    if not all(isfinite(value) for point in points for value in point):
+        raise OutlineError("outline produced non-finite coordinates")
+    return tuple(points)
+
+
+def _expand_subpath(
+    subpath: Subpath,
+    width_at: Callable[[float], float],
+    config: OutlineConfig,
+) -> tuple[Contour, ...]:
+    segments = subpath.outlining_segments()
+    points, widths = _profile_points(segments, width_at, config)
+    if len(points) < 2 or any(
+        hypot(b[0] - a[0], b[1] - a[1]) <= 1e-12 for a, b in zip(points, points[1:], strict=False)
+    ):
+        raise DegeneratePathError("outline path contains a zero-length segment")
+    if subpath.closed and points[-1] == points[0]:
+        points.pop()
+        widths.pop()
+    left = _offset(points, widths, subpath.closed, 1.0)
+    right = _offset(points, widths, subpath.closed, -1.0)
+    if subpath.closed:
+        left_contour = list(left)
+        right_contour = list(right)
+        if signed_area(left_contour) * signed_area(right_contour) > 0:
+            right_contour.reverse()
+        return (_close(left_contour), _close(right_contour))
+    if config.cap == "round":
+        start_tangent = _unit((points[1][0] - points[0][0], points[1][1] - points[0][1]))
+        end_tangent = _unit((points[-1][0] - points[-2][0], points[-1][1] - points[-2][1]))
+        end_angle = atan2(end_tangent[1], end_tangent[0])
+        start_angle = atan2(start_tangent[1], start_tangent[0])
+        end_cap = _arc_points(
+            points[-1], widths[-1] / 2, end_angle + pi / 2, -pi, config.max_centerline_error
+        )
+        start_cap = _arc_points(
+            points[0], widths[0] / 2, start_angle - pi / 2, -pi, config.max_centerline_error
+        )
+        contour = left + end_cap[1:] + list(reversed(right))[1:] + start_cap[1:]
+    else:
+        start_tangent = _unit((points[1][0] - points[0][0], points[1][1] - points[0][1]))
+        end_tangent = _unit((points[-1][0] - points[-2][0], points[-1][1] - points[-2][1]))
+        start_extension, end_extension = widths[0] / 2, widths[-1] / 2
+        left[0] = _shift(left[0], start_tangent, -start_extension)
+        right[0] = _shift(right[0], start_tangent, -start_extension)
+        left[-1] = _shift(left[-1], end_tangent, end_extension)
+        right[-1] = _shift(right[-1], end_tangent, end_extension)
+        contour = left + list(reversed(right))
+    return (_close(contour),)
+
+
+def _result(contours: Sequence[Contour]) -> OutlineResult:
+    nonempty = tuple(contour for contour in contours if contour)
+    if not nonempty:
+        return OutlineResult((), None)
+    points = [point for contour in nonempty for point in contour]
+    return OutlineResult(
+        nonempty,
+        (
+            min(point[0] for point in points),
+            min(point[1] for point in points),
+            max(point[0] for point in points),
+            max(point[1] for point in points),
+        ),
+    )
+
+
+def combine_outlines(outlines: Iterable[OutlineResult]) -> OutlineResult:
+    """Aggregate outline contours in order without performing a Boolean union."""
+    contours = tuple(contour for result in outlines for contour in result.contours)
+    return _result(contours)
+
+
+def outline(
+    path: Path2D | CubicPath,
+    width: WidthProfile,
+    *,
+    config: OutlineConfig = DEFAULT_OUTLINE_CONFIG,
+) -> OutlineResult:
+    """Expand centerlines into deterministic sampled closed contours.
+
+    Parameters
+    ----------
+    path : Path2D or planarcurve.CubicPath
+        One or more centerline subpaths, or a cubic path accepted directly.
+    width : WidthProfile
+        A positive full diameter, a piecewise-linear knot sequence spanning
+        normalized progress from 0 to 1, or a callable from progress to width.
+    config : OutlineConfig, optional
+        Adaptive sampling tolerances and open-path cap choice.
+
+    Returns
+    -------
+    OutlineResult
+        Closed contour tuples and aggregate bounds in
+        ``(min_x, min_y, max_x, max_y)`` order.
+
+    Raises
+    ------
+    InvalidWidthError
+        If the width profile or an evaluated width is invalid.
+    DegeneratePathError
+        If the centerline contains a zero-length segment or tangent.
+    SubdivisionLimitError
+        If adaptive sampling cannot meet the configured tolerances within the
+        subdivision depth limit.
+    TypeError
+        If ``path`` is not a ``Path2D`` or ``planarcurve.CubicPath``.
+
+    Notes
+    -----
+    Width is the full stroke diameter, not the radius. Normalized width
+    progress is segment-index based:
+    ``u = (segment_index + local_segment_parameter) / segment_count``.
+    It is not physical arc length, and it restarts from zero for every
+    independent ``Subpath``. The configured cap applies only to open paths.
+    """
+    if isinstance(path, CubicPath):
+        path = path_from_cubic_path(path)
+    if not isinstance(path, Path2D):
+        raise TypeError("path must be Path2D or planarcurve.CubicPath")
+    width_at = _width_function(width)
+    contours = [
+        contour
+        for subpath in path.subpaths
+        for contour in _expand_subpath(subpath, width_at, config)
+    ]
+    return _result(contours)
+
+
+def outline_disc(
+    center: Point2D,
+    diameter: WidthProfile,
+    *,
+    config: OutlineConfig = DEFAULT_OUTLINE_CONFIG,
+) -> OutlineResult:
+    """Create a sampled circular contour from a center and width profile.
+
+    Parameters
+    ----------
+    center : Point2D
+        Center of the disc in the input coordinate system.
+    diameter : WidthProfile
+        Positive full diameter, width knots, or callable width profile.
+    config : OutlineConfig, optional
+        Sampling tolerance used to choose the circular contour resolution.
+
+    Returns
+    -------
+    OutlineResult
+        One explicitly closed circular contour and its bounds.
+
+    Raises
+    ------
+    InvalidWidthError
+        If the width profile or its evaluated value is invalid.
+
+    Notes
+    -----
+    Since a point has no path progression, a width profile is evaluated at
+    normalized progress ``u == 0.5``.
+    """
+    width_at = _width_function(diameter)
+    diameter_value = width_at(0.5)
+    radius = diameter_value / 2
+    max_angle = 2 * acos(max(-1.0, 1 - config.max_centerline_error / radius))
+    steps = max(8, ceil(2 * pi / max(max_angle, 1e-6)))
+    steps = ceil(steps / 4) * 4
+    contour = _close(
+        [
+            (
+                center[0] + radius * cos(2 * pi * index / steps),
+                center[1] + radius * sin(2 * pi * index / steps),
+            )
+            for index in range(steps)
+        ]
+    )
+    return _result((contour,))
+
+
+# Migration-friendly alias for InkGrammar terminology.
+expand_tap = outline_disc

strokeoutline/model.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from math import isfinite
+from typing import TypeAlias
+
+from planarcurve import CubicBezier, CubicPath, Point2D, QuadraticBezier
+
+
+def _point(value: Sequence[float], *, name: str) -> Point2D:
+    if len(value) != 2:
+        raise ValueError(f"{name} must have exactly two coordinates")
+    point = (float(value[0]), float(value[1]))
+    if not all(isfinite(component) for component in point):
+        raise ValueError(f"{name} must contain finite coordinates")
+    return point
+
+
+@dataclass(frozen=True)
+class Line:
+    """Finite straight segment between two 2D endpoints.
+
+    Parameters
+    ----------
+    p0 : Point2D
+        Start coordinate.
+    p1 : Point2D
+        End coordinate.
+
+    Both endpoints must contain exactly two finite coordinates. A zero-length
+    line can be constructed, but ``outline()`` rejects it as degenerate.
+    """
+
+    p0: Point2D
+    p1: Point2D
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "p0", _point(self.p0, name="p0"))
+        object.__setattr__(self, "p1", _point(self.p1, name="p1"))
+
+
+Segment: TypeAlias = Line | QuadraticBezier | CubicBezier
+
+
+def segment_start(segment: Segment) -> Point2D:
+    return segment.p0
+
+
+def segment_end(segment: Segment) -> Point2D:
+    if isinstance(segment, Line):
+        return segment.p1
+    if isinstance(segment, QuadraticBezier):
+        return segment.p2
+    return segment.p3
+
+
+@dataclass(frozen=True)
+class Subpath:
+    """One ordered, connected centerline subpath.
+
+    Parameters
+    ----------
+    segments : Sequence[Segment]
+        Non-empty ordered sequence of ``Line``, ``QuadraticBezier``, or
+        ``CubicBezier`` segments. Adjacent endpoints must compare exactly equal.
+    closed : bool, optional
+        If true, add an implicit closing ``Line`` during outlining when the
+        final endpoint differs from the first start point.
+
+    Raises
+    ------
+    ValueError
+        If no segments are provided or adjacent segments are disconnected.
+    TypeError
+        If a segment has an unsupported type.
+
+    Notes
+    -----
+    Repeating the start point with an explicit segment is not required for a
+    closed subpath. Outlining a zero-length segment raises
+    ``DegeneratePathError``.
+    """
+
+    segments: Sequence[Segment]
+    closed: bool = False
+
+    def __post_init__(self) -> None:
+        segments = tuple(self.segments)
+        if not segments:
+            raise ValueError("subpath requires at least one segment")
+        allowed = (Line, QuadraticBezier, CubicBezier)
+        if not all(isinstance(segment, allowed) for segment in segments):
+            raise TypeError("segments must contain Line, QuadraticBezier, or CubicBezier values")
+        for left, right in zip(segments, segments[1:], strict=False):
+            if segment_end(left) != segment_start(right):
+                raise ValueError("subpath segments must be connected in order")
+        object.__setattr__(self, "segments", segments)
+
+    def outlining_segments(self) -> tuple[Segment, ...]:
+        segments = tuple(self.segments)
+        if self.closed:
+            start = segment_start(segments[0])
+            end = segment_end(segments[-1])
+            if end != start:
+                segments = (*segments, Line(end, start))
+        return segments
+
+
+@dataclass(frozen=True)
+class Path2D:
+    """A path containing one or more independent centerline subpaths.
+
+    Parameters
+    ----------
+    subpaths : Sequence[Subpath]
+        Non-empty sequence of subpaths to outline independently.
+
+    Raises
+    ------
+    ValueError
+        If no subpaths are provided.
+    TypeError
+        If an element is not a ``Subpath``.
+
+    Notes
+    -----
+    Each subpath receives a separate outline, and normalized width progress
+    restarts at zero for each one.
+    """
+
+    subpaths: Sequence[Subpath]
+
+    def __post_init__(self) -> None:
+        subpaths = tuple(self.subpaths)
+        if not subpaths:
+            raise ValueError("path requires at least one subpath")
+        if not all(isinstance(subpath, Subpath) for subpath in subpaths):
+            raise TypeError("subpaths must contain Subpath values")
+        object.__setattr__(self, "subpaths", subpaths)
+
+
+def path_from_cubic_path(path: CubicPath, *, closed: bool = False) -> Path2D:
+    """Adapt a :class:`planarcurve.CubicPath` into a ``Path2D``.
+
+    Parameters
+    ----------
+    path : planarcurve.CubicPath
+        Cubic path to adapt.
+    closed : bool, optional
+        Whether the adapted subpath should be implicitly closed during outlining.
+
+    Returns
+    -------
+    Path2D
+        A path containing one subpath with the cubic path's Bézier segments.
+
+    Raises
+    ------
+    ValueError
+        If the cubic path contains no segments.
+    """
+    beziers = path.to_beziers()
+    if not beziers:
+        raise ValueError("cubic path requires at least one segment")
+    return Path2D((Subpath(beziers, closed=closed),))
+
+
+def path_from_polyline(points: Sequence[Sequence[float]], *, closed: bool = False) -> Path2D:
+    """Build a path from ordered finite 2D points.
+
+    Parameters
+    ----------
+    points : Sequence[Sequence[float]]
+        At least two finite ``(x, y)`` coordinates, in path order.
+    closed : bool, optional
+        If true, close the path implicitly during outlining; the first point
+        need not be repeated.
+
+    Returns
+    -------
+    Path2D
+        A path containing one subpath made from consecutive line segments.
+
+    Raises
+    ------
+    ValueError
+        If fewer than two points are supplied or a point is not a finite pair.
+    TypeError
+        If point coordinates cannot be interpreted as numeric values.
+
+    Notes
+    -----
+    Repeated adjacent points are retained. Outlining a resulting zero-length
+    segment raises ``DegeneratePathError``.
+    """
+    finite_points = tuple(
+        _point(point, name=f"points[{index}]") for index, point in enumerate(points)
+    )
+    if len(finite_points) < 2:
+        raise ValueError("polyline requires at least two points")
+    segments = tuple(
+        Line(start, end) for start, end in zip(finite_points, finite_points[1:], strict=False)
+    )
+    return Path2D((Subpath(segments, closed=closed),))

strokeoutline/svg.py

@@ -0,0 +1,144 @@
+"""Optional SVG path adapter based on FontTools.
+
+The core package does not require FontTools. This adapter intentionally owns
+only the compatibility bridge needed for the initial InkGrammar extraction.
+A future planarcurve public parsed-path API can replace this parser without
+changing the core outlining API.
+"""
+
+from __future__ import annotations
+
+try:
+    from fontTools.pens.recordingPen import RecordingPen
+    from fontTools.svgLib.path import parse_path
+except ImportError as exc:  # pragma: no cover
+    raise ImportError("strokeoutline.svg requires FontTools; install strokeoutline[svg]") from exc
+
+from planarcurve import CubicBezier, QuadraticBezier
+
+from .core import DEFAULT_OUTLINE_CONFIG, OutlineConfig, OutlineResult, WidthProfile, outline
+from .model import Line, Path2D, Subpath
+
+
+def path_from_svg(path: str) -> Path2D:
+    """Parse SVG path data into StrokeOutline's neutral path model.
+
+    Parameters
+    ----------
+    path : str
+        SVG path data to parse.
+
+    Returns
+    -------
+    Path2D
+        The parsed line, quadratic, and cubic subpaths.
+
+    Raises
+    ------
+    ValueError
+        If the data contains no drawable segments or an unsupported/invalid
+        path operation.
+
+    Notes
+    -----
+    This function requires FontTools from the optional ``svg`` extra. It parses
+    path geometry only; it does not render SVG/CSS strokes.
+    """
+    pen = RecordingPen()
+    parse_path(path, pen)
+    if not pen.value:
+        raise ValueError("path produced no operations")
+
+    subpaths: list[Subpath] = []
+    segments = []
+    current = None
+    start = None
+
+    def finish(*, closed: bool) -> None:
+        nonlocal segments
+        if segments:
+            subpaths.append(Subpath(tuple(segments), closed=closed))
+        segments = []
+
+    for operator, args in pen.value:
+        if operator == "moveTo":
+            finish(closed=False)
+            current = start = tuple(map(float, args[0]))
+        elif operator == "lineTo":
+            if current is None:
+                raise ValueError("outline path draws before moveTo")
+            end = tuple(map(float, args[0]))
+            segments.append(Line(current, end))
+            current = end
+        elif operator == "curveTo":
+            if current is None or len(args) != 3:
+                raise ValueError("outline path has an invalid cubic segment")
+            c1, c2, end = (tuple(map(float, value)) for value in args)
+            segments.append(CubicBezier(current, c1, c2, end))
+            current = end
+        elif operator == "qCurveTo":
+            if current is None or len(args) != 2 or args[-1] is None:
+                raise ValueError("outline path has an invalid quadratic segment")
+            control, end = (tuple(map(float, value)) for value in args)
+            segments.append(QuadraticBezier(current, control, end))
+            current = end
+        elif operator == "closePath":
+            if current is None or start is None:
+                raise ValueError("outline path closes before moveTo")
+            finish(closed=True)
+            current = start = None
+        elif operator == "endPath":
+            finish(closed=False)
+            current = start = None
+        else:
+            raise ValueError(f"unsupported outline path operation: {operator}")
+
+    finish(closed=False)
+    if not subpaths:
+        raise ValueError("outline path has no drawable segments")
+    return Path2D(tuple(subpaths))
+
+
+def outline_svg_path(
+    path: str,
+    width: WidthProfile,
+    *,
+    config: OutlineConfig = DEFAULT_OUTLINE_CONFIG,
+) -> OutlineResult:
+    """Parse and expand SVG path data into closed sampled contours.
+
+    Parameters
+    ----------
+    path : str
+        SVG path data to parse.
+    width : WidthProfile
+        Constant, piecewise-linear, or callable full-diameter width profile.
+    config : OutlineConfig, optional
+        Adaptive sampling tolerances and open-path cap selection.
+
+    Returns
+    -------
+    OutlineResult
+        Closed contour tuples and aggregate bounds.
+
+    Raises
+    ------
+    ValueError
+        If SVG path data cannot be converted to the supported neutral model.
+    InvalidWidthError
+        If the width profile is invalid.
+    DegeneratePathError
+        If the parsed centerline contains degenerate geometry.
+    SubdivisionLimitError
+        If adaptive sampling cannot meet the configured tolerances.
+
+    Notes
+    -----
+    Importing this module requires FontTools from the optional ``svg`` extra.
+    The adapter parses path geometry; it is not a complete SVG/CSS stroker.
+    """
+    return outline(path_from_svg(path), width, config=config)
+
+
+# Compatibility name matching InkGrammar's previous generic entry point.
+expand_path = outline_svg_path

strokeoutline-0.1.0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: strokeoutline
+Version: 0.1.0
+Summary: Deterministic variable-width stroke expansion from 2D centerlines to filled contours.
+Author: Holger Nahrstaedt
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/schreibatlas/strokeoutline
+Project-URL: Repository, https://github.com/schreibatlas/strokeoutline
+Project-URL: Issues, https://github.com/schreibatlas/strokeoutline/issues
+Project-URL: Changelog, https://github.com/schreibatlas/strokeoutline/releases
+Keywords: geometry,stroke,outline,offset-curve,bezier,vector-graphics,svg
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: planarcurve<0.2,>=0.1
+Provides-Extra: svg
+Requires-Dist: fonttools>=4.55; extra == "svg"
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: fonttools>=4.55; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.8; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# strokeoutline
+
+`strokeoutline` converts 2D centerlines into deterministic filled contours with constant or variable width. It is reusable geometry extracted from InkGrammar's stroke outlining engine, without glyph, shaping, OCR, or handwriting-model responsibilities.
+
+Use it for vector brushes, pressure-like width profiles, centerline fonts, skeleton thickening, corridors, and other centerline-based applications. The MVP preserves current geometry behavior; see the documentation for its limitations and compatibility contracts.
+
+## Install
+
+```bash
+python -m pip install strokeoutline
+```
+
+For SVG path parsing, install the optional extra:
+
+```bash
+python -m pip install 'strokeoutline[svg]'
+```
+
+## Documentation
+
+The complete guides and deliberate API reference are in the [documentation source](docs/index.md):
+
+- [Getting started](docs/getting-started.md)
+- [Examples](docs/examples.md)
+- [API reference](docs/api/index.md)
+- [Limitations](docs/limitations.md)
+
+## Core example
+
+```python
+from strokeoutline import Line, Path2D, Subpath, outline
+
+path = Path2D((Subpath((Line((0, 0), (10, 0)),)),))
+
+result = outline(path, width=4.0)
+print(result.bounds)
+for contour in result.contours:
+    print(contour)
+```
+
+Width is the full stroke diameter, not radius. Width profiles may be a positive constant, a strictly increasing piecewise-linear knot sequence spanning `0..1`, or a callable.
+
+For compatibility, normalized width progress is based on segment index, not physical arc length:
+
+```text
+u = (segment_index + local_segment_parameter) / segment_count
+```
+
+Progress restarts at zero for each independent subpath. See [width profiles](docs/width-profiles.md) for details.
+
+## Integration boundary
+
+StrokeOutline owns centerline-to-contour geometry. Integrations such as InkGrammar own shaped-text traversal and domain-specific adaptation, and should call StrokeOutline rather than copy its outlining algorithm. The core package does not require FontTools; only the optional `strokeoutline.svg` adapter does.
+
+## Development
+
+```bash
+python -m pip install -e '.[dev]'
+ruff format --check .
+ruff check .
+pytest
+python docs/make.py html
+python docs/make.py doctest
+```
+
+## License
+
+Apache-2.0.

strokeoutline-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+strokeoutline/__init__.py,sha256=JAxSCVHcxruzD2bHWUoLY5_-WNaJfkx8V7NmYjW6dN4,1360
+strokeoutline/_version.py,sha256=lycdDSVOV74R332ezrzWfEthUQ4KGwAk2Z0XRudpMyY,528
+strokeoutline/core.py,sha256=ch0FqybTRSVEgnbndtMifUlu2qLIIAseOVXAjKc0jKY,20988
+strokeoutline/model.py,sha256=waujNObbiN31RFA0zgm8ShllG-rscPGm9uEQq16HI0c,6292
+strokeoutline/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+strokeoutline/svg.py,sha256=cRcECcc2drRwCoo2mdTTx8eOdwxVPTHnZ16Vd0aP6Ls,4748
+strokeoutline-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+strokeoutline-0.1.0.dist-info/METADATA,sha256=cFOwDlLodzZiBEYJVqYQhzXzCnZxXHHNvtR8J8eQKiM,3792
+strokeoutline-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+strokeoutline-0.1.0.dist-info/top_level.txt,sha256=JfubmOIq0vscSgw09jvRbOl3W3i8qT54TTxzBKbj4h4,14
+strokeoutline-0.1.0.dist-info/RECORD,,

strokeoutline-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

strokeoutline-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

strokeoutline-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+strokeoutline