CurveEditor API#

def __init__(
    self,
    points: Iterable[dict[str, Any]] | None = None,
    *,
    curve: str = "natural",
    x_bounds: tuple[float, float] = (0.0, 1.0),
    y_bounds: tuple[float, float] = (0.0, 1.0),
    width: int = 600,
    height: int = 360,
    tension: float = 0.0,
    alpha: float = 0.5,
    closed: bool = False,
    playing: bool = False,
    loop: bool = False,
    t: float = 0.0,
    interval_ms: int = 30,
    duration_ms: int = 12000,
    sync_throttle_ms: int = 250,
    selected_index: int = -1,
    show_axes: bool = False,
    n_samples: int = 100,
    **kwargs: Any,
) -> None:
    """Create a CurveEditor widget.

    Args:
        points: Initial knots as ``{"x": float, "y": float}`` dicts.
            Open curves store points sorted by x-coordinate. Closed curves
            preserve point order.
        curve: D3 curve name. One of ``linear``, ``step``,
            ``step_before``, ``step_after``, ``basis``, ``natural``,
            ``cardinal``, ``catmull_rom``, ``monotone_x``, or ``bump_x``.
        x_bounds: Data-coordinate x bounds.
        y_bounds: Data-coordinate y bounds.
        width: SVG width in pixels.
        height: SVG height in pixels.
        tension: Cardinal spline tension, clamped to ``[0, 1]``.
        alpha: Catmull-Rom alpha, clamped to ``[0, 1]``.
        closed: Whether to append the first point virtually when rendering.
        playing: Whether playback starts immediately.
        loop: Whether playback wraps from ``t=1`` back to ``t=0``.
        t: Initial path progress in ``[0, 1]``.
        interval_ms: Milliseconds between browser playback ticks.
        duration_ms: Milliseconds for one full ``t=0`` to ``t=1`` traversal.
        sync_throttle_ms: Minimum milliseconds between playback updates synced to Python.
        selected_index: Selected point index, or ``-1``.
        show_axes: Whether to render numeric tick marks and labels on the
            x and y axes.
        n_samples: Number of points emitted on the ``samples`` traitlet by
            the browser after each render. Must be at least 2.
        **kwargs: Forwarded to ``anywidget.AnyWidget``.
    """
    coerced_points = _coerce_points(points, sort_by_x=not closed)
    initial_t = _clamp01(t)
    initial_x, initial_y = _point_at_t(
        _effective_points(coerced_points, closed), initial_t
    )
    if int(n_samples) < 2:
        raise traitlets.TraitError("n_samples must be at least 2.")
    super().__init__(
        closed=closed,
        points=coerced_points,
        x=initial_x,
        y=initial_y,
        t=initial_t,
        curve=curve,
        x_bounds=x_bounds,
        y_bounds=y_bounds,
        width=width,
        height=height,
        tension=tension,
        alpha=alpha,
        playing=playing,
        loop=loop,
        interval_ms=interval_ms,
        duration_ms=duration_ms,
        sync_throttle_ms=sync_throttle_ms,
        selected_index=selected_index,
        show_axes=show_axes,
        n_samples=int(n_samples),
        **kwargs,
    )
    self.observe(self._refresh_current_point, names=["points", "t", "closed"])
    self.observe(self._sort_points_when_opened, names=["closed"])