charts.shape

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from typing import List, Sequence, Tuple

from .charts_shape_types import Point
from .text_format_decimal import format_decimal  ← from text.format-decimal ^1.0.0 · built alongside by fune


def line_path(points: Sequence[Point]) -> str:
    """A polyline as SVG path data, in d3.line's format ("M10,20L30,40").

    A null y ends the current subpath; a run of one point is "Mx,yZ", as d3
    closes it so a round line cap still shows a dot.
    """
    out = ""
    for run in point_runs(points):
        for i, (x, y) in enumerate(run):
            out += ("M" if i == 0 else "L") + svg_pair(x, y)
        if len(run) == 1:
            out += "Z"
    return out


# Shared with the other path functions of this group.


def svg_pair(x: float, y: float) -> str:
    """"x,y" with each number rounded to 2 places, trailing zeros dropped."""
    return format_decimal(x, 2, True, "") + "," + format_decimal(y, 2, True, "")


def point_runs(points: Sequence[Point]) -> List[List[Tuple[float, float]]]:
    """The unbroken runs of a series: a point with a null y separates them."""
    runs: List[List[Tuple[float, float]]] = []
    current: List[Tuple[float, float]] = []
    for p in points:
        if p.y is None:
            if current:
                runs.append(current)
            current = []
        else:
            # float() so integer inputs take the same binary64 path as the
            # other languages.
            current.append((float(p.x), float(p.y)))
    if current:
        runs.append(current)
    return runs

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from typing import List, Sequence

from .charts_shape_line_path import svg_pair  ← linePath, another function of this group · built into the same file, even by a slim install
from .charts_shape_types import AreaPoint


def area_path(points: Sequence[AreaPoint]) -> str:
    """A filled area as SVG path data, in d3.area's format: along the top edge
    (y1) left to right, back along the baseline (y0) right to left, closed.
    A null y1 ends one area and starts the next."""
    out = ""
    runs: List[List[AreaPoint]] = []
    run: List[AreaPoint] = []
    for p in points:
        if p.y1 is None:
            if run:
                runs.append(run)
            run = []
        else:
            run.append(p)
    if run:
        runs.append(run)
    for run in runs:
        for i, p in enumerate(run):
            out += ("M" if i == 0 else "L") + svg_pair(float(p.x), float(p.y1))
        for p in reversed(run):
            out += "L" + svg_pair(float(p.x), float(p.y0))
        out += "Z"
    return out

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from typing import Sequence

from .charts_shape_line_path import point_runs, svg_pair  ← linePath, another function of this group · built into the same file, even by a slim install
from .charts_shape_types import Point, StepPosition


def step_path(points: Sequence[Point], position: StepPosition) -> str:
    """A step line as SVG path data, as d3.curveStepBefore, d3.curveStep and
    d3.curveStepAfter draw it: horizontal then vertical moves only."""
    if position == "before":
        t = 0.0
    elif position == "middle":
        t = 0.5
    elif position == "after":
        t = 1.0
    else:
        raise ValueError("step position must be before, middle or after, received %r" % (position,))
    out = ""
    for run in point_runs(points):
        out += "M" + svg_pair(run[0][0], run[0][1])
        for i in range(1, len(run)):
            px, py = run[i - 1]
            x, y = run[i]
            if t <= 0:
                out += "L" + svg_pair(px, y) + "L" + svg_pair(x, y)
            else:
                # d3's own expression, so the midpoint rounds as d3's does.
                x1 = px * (1 - t) + x * t
                out += "L" + svg_pair(x1, py) + "L" + svg_pair(x1, y)
        if 0 < t < 1 and len(run) >= 2:
            lx, ly = run[-1]
            out += "L" + svg_pair(lx, ly)
        if len(run) == 1:
            out += "Z"
    return out

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from typing import Sequence

from .charts_shape_line_path import point_runs, svg_pair  ← linePath, another function of this group · built into the same file, even by a slim install
from .charts_shape_types import Point


def _sign(x: float) -> float:
    return -1.0 if x < 0 else 1.0


def _slope3(x0: float, y0: float, x1: float, y1: float, x2: float, y2: float) -> float:
    # Fritsch–Carlson: the tangent at the middle point, limited so the curve
    # cannot overshoot either neighbouring value. d3's slope3.
    h0 = x1 - x0
    h1 = x2 - x1
    s0 = (y1 - y0) / h0
    s1 = (y2 - y1) / h1
    p = (s0 * h1 + s1 * h0) / (h0 + h1)
    t = (_sign(s0) + _sign(s1)) * min(abs(s0), abs(s1), 0.5 * abs(p))
    return t if t != 0 else 0.0


def _slope2(x0: float, y0: float, x1: float, y1: float, t: float) -> float:
    return (3 * (y1 - y0) / (x1 - x0) - t) / 2


def _bezier(x0: float, y0: float, x1: float, y1: float, t0: float, t1: float) -> str:
    dx = (x1 - x0) / 3
    return "C" + svg_pair(x0 + dx, y0 + dx * t0) + "," + svg_pair(x1 - dx, y1 - dx * t1) + "," + svg_pair(x1, y1)


def monotone_curve(points: Sequence[Point]) -> str:
    """A smooth line that stays monotone wherever the data is: d3.curveMonotoneX,
    Hermite segments with Fritsch–Carlson tangents, as cubic Béziers."""
    out = ""
    for run in point_runs(points):
        for i in range(1, len(run)):
            if not run[i][0] > run[i - 1][0]:
                raise ValueError(
                    "monotone curve needs x strictly increasing, but %r follows %r" % (run[i][0], run[i - 1][0])
                )
        out += "M" + svg_pair(run[0][0], run[0][1])
        n = len(run)
        if n == 1:
            out += "Z"
            continue
        if n == 2:
            out += "L" + svg_pair(run[1][0], run[1][1])
            continue
        t0 = 0.0
        for i in range(2, n):
            ax, ay = run[i - 2]
            bx, by = run[i - 1]
            cx, cy = run[i]
            t1 = _slope3(ax, ay, bx, by, cx, cy)
            start = _slope2(ax, ay, bx, by, t1) if i == 2 else t0
            out += _bezier(ax, ay, bx, by, start, t1)
            t0 = t1
        ax, ay = run[n - 2]
        bx, by = run[n - 1]
        out += _bezier(ax, ay, bx, by, t0, _slope2(ax, ay, bx, by, t0))
    return out

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from typing import List, Sequence

from .charts_shape_types import BarSpec, Orientation, Rect
from .math_round_float import round_float  ← from math.round-float ^1.0.0 · built alongside by fune


def bar_rects(bars: Sequence[BarSpec], orientation: Orientation) -> List[Rect]:
    """Rectangles for bars. Edges are rounded to 2 places and sizes are the
    differences of the rounded edges, so bars that share an edge share it
    exactly, and a negative bar's height is still positive."""
    if orientation not in ("vertical", "horizontal"):
        raise ValueError("orientation must be vertical or horizontal, received %r" % (orientation,))
    out: List[Rect] = []
    for bar in bars:
        if not bar.thickness >= 0:
            raise ValueError("bar thickness must not be negative, received %r" % (bar.thickness,))
        band = float(bar.band)
        a0 = round_float(band, 2)
        a1 = round_float(band + float(bar.thickness), 2)
        v0 = round_float(min(float(bar.base), float(bar.value)), 2)
        v1 = round_float(max(float(bar.base), float(bar.value)), 2)
        across = round_float(a1 - a0, 2)
        along = round_float(v1 - v0, 2)
        if orientation == "vertical":
            out.append(Rect(x=a0, y=v0, width=across, height=along))
        else:
            out.append(Rect(x=v0, y=a0, width=along, height=across))
    return out

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from .charts_shape_line_path import svg_pair  ← linePath, another function of this group · built into the same file, even by a slim install
from .charts_shape_types import Arc
from .math_sin_cos import sin_cos  ← from math.sin-cos ^1.0.0 · built alongside by fune

PI = 3.141592653589793
TAU = 6.283185307179586


def _arc_point(arc: Arc, r: float, angle: float) -> str:
    sc = sin_cos(angle)
    return svg_pair(float(arc.cx) + r * sc.sin, float(arc.cy) - r * sc.cos)


def _arc_to(arc: Arc, r: float, large: int, sweep: int, angle: float) -> str:
    return "A" + svg_pair(r, r) + ",0," + str(large) + "," + str(sweep) + "," + _arc_point(arc, r, angle)


def arc_path(arc: Arc) -> str:
    """An annular sector as SVG path data. Angles are radians from 12 o'clock,
    clockwise, as in d3.arc. See the README for the exact path format."""
    ri = float(arc.inner_radius)
    ro = float(arc.outer_radius)
    a0 = float(arc.start_angle)
    a1 = float(arc.end_angle)
    if not ri >= 0 or not ro >= ri:
        raise ValueError(
            "arc radii must satisfy 0 <= innerRadius <= outerRadius, received %r and %r" % (arc.inner_radius, arc.outer_radius)
        )
    span = a1 - a0
    if span == 0 or ro == 0:
        return ""
    sweep = 1 if span > 0 else 0
    back = 1 - sweep
    direction = 1.0 if span > 0 else -1.0
    if abs(span) >= TAU:
        # One SVG arc cannot start and end at the same point, so a full turn is
        # two half turns; the hole is drawn the other way so it stays empty.
        half = a0 + direction * PI
        out = "M" + _arc_point(arc, ro, a0) + _arc_to(arc, ro, 1, sweep, half) + _arc_to(arc, ro, 1, sweep, a0) + "Z"
        if ri > 0:
            other = a0 - direction * PI
            out += "M" + _arc_point(arc, ri, a0) + _arc_to(arc, ri, 1, back, other) + _arc_to(arc, ri, 1, back, a0) + "Z"
        return out
    large = 1 if abs(span) > PI else 0
    out = "M" + _arc_point(arc, ro, a0) + _arc_to(arc, ro, large, sweep, a1)
    if ri > 0:
        out += "L" + _arc_point(arc, ri, a1) + _arc_to(arc, ri, large, back, a0)
    else:
        out += "L" + svg_pair(float(arc.cx), float(arc.cy))
    return out + "Z"

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

from typing import List, Sequence

from .charts_shape_types import PieSlice
from .math_round_float import round_float  ← from math.round-float ^1.0.0 · built alongside by fune

TAU = 6.283185307179586


def pie_angles(values: Sequence[float], start_angle: float, end_angle: float, pad_angle: float) -> List[PieSlice]:
    """Start and end angles of pie slices in input order: d3.pie with
    sort(null), then half the pad trimmed from each side, so the angles go
    straight into arc_path and neighbouring slices show a gap of pad_angle."""
    if not pad_angle >= 0:
        raise ValueError("padAngle must not be negative, received %r" % (pad_angle,))
    n = len(values)
    total = 0.0
    for v in values:
        if not v >= 0:
            raise ValueError("pie values must be zero or more, received %r" % (v,))
        total += float(v)
    a0 = float(start_angle)
    da = min(TAU, max(-TAU, float(end_angle) - a0))
    p = min(abs(da) / n, float(pad_angle)) if n > 0 else 0.0
    pa = p * (-1.0 if da < 0 else 1.0)
    k = (da - n * pa) / total if total > 0 else 0.0
    out: List[PieSlice] = []
    for v in values:
        v = float(v)
        a1 = a0 + (v * k if v > 0 else 0.0) + pa
        out.append(PieSlice(value=v, start_angle=round_float(a0 + pa / 2, 6), end_angle=round_float(a1 - pa / 2, 6)))
        a0 = a1
    return out