py-visactor-vchart 0.1.1__py3-none-any.whl

py_vchart/__init__.py

@@ -0,0 +1,9 @@
+"""Python implementation of VisActor VChart."""
+
+from importlib.metadata import version
+
+__version__ = version("py-visactor-vchart")
+
+from .core import VChart, supported_types
+
+__all__ = ["VChart", "supported_types", "__version__"]

py_vchart/_deps/vdataset/__init__.py

@@ -0,0 +1,26 @@
+"""The single inline data view needed by the first Cartesian series."""
+
+from math import isfinite
+
+
+def inline_values(data, path):
+    views = data if isinstance(data, list) else [data]
+    if len(views) != 1 or not isinstance(views[0], dict):
+        raise ValueError(f"{path} requires one inline data view")
+    view = views[0]
+    if set(view) - {"id", "values"} or not isinstance(view.get("values"), list):
+        raise ValueError(f"{path}[0] requires inline values")
+    return view["values"]
+
+
+def read_records(data, category_field, value_field, *, path="bar.data", allow_missing=False):
+    rows = []
+    for i, row in enumerate(inline_values(data, path)):
+        if not isinstance(row, dict) or category_field not in row or (value_field not in row and not allow_missing):
+            raise ValueError(f"{path}.values[{i}] is missing a required field")
+        category, value = row[category_field], row.get(value_field)
+        valid_number = type(value) in (int, float) and isfinite(value)
+        if type(category) not in (str, int, float) or not (valid_number or (allow_missing and value is None)):
+            raise ValueError(f"{path}.values[{i}] requires a scalar category and finite numeric value")
+        rows.append((category, value))
+    return rows

py_vchart/_deps/vdataset/correlation.py

@@ -0,0 +1,56 @@
+"""Map records to correlation symbols in region-local coordinates."""
+
+from math import ceil, cos, pi, sin
+
+
+def angle_sequence(start, end):
+    slots = max(2, ceil(2*(end-start)/pi))
+    step = (end-start)/slots
+    origin, offset, direction = start, step/2, 1
+    generation = 0
+    while True:
+        for i in range(slots):
+            index = i//2 + (slots//2 if i % 2 else 0)
+            yield origin + index*step*direction
+        generation += 1
+        direction = -direction
+        origin = end-offset if direction < 0 else start+offset
+        offset /= 2
+        if generation >= 2:
+            slots *= 2
+            step /= 2
+
+
+def map_values(values, limits, constant):
+    low, high = min(values), max(values)
+    if low == high:
+        return [constant]*len(values)
+    a, b = limits
+    return [a + (b-a)*(v-low)/(high-low) for v in values]
+
+
+def positions(values, sizes, radii, size_range, angles, center, bounds, obstacles):
+    if not values:
+        return []
+    distances = map_values(values, radii, sum(radii)/2)
+    diameters = map_values(sizes, size_range, size_range[1])
+    start, end = sorted(angles)
+    cx, cy = center
+    width, height = bounds
+    step = (end-start)/60
+    result = []
+    blockers = []
+    for angle, distance, size, obstacle in zip(angle_sequence(start, end), distances, diameters, obstacles):
+        for _ in range(60):
+            x, y = cx+distance*cos(angle), cy+distance*sin(angle)
+            inside = size <= x <= width-size and size <= y <= height-size
+            if inside and not any((x-ox)**2+(y-oy)**2 < (size+r)**2 for ox, oy, r in blockers):
+                break
+            angle += step
+            if angle > end:
+                angle = start
+        result.append((x, y, size))
+        # The upstream transform checks the original x/y/size fields on prior records.
+        if obstacle is not None:
+            blockers.append(obstacle)
+    return result

py_vchart/_deps/vlayouts/circle_packing.py

@@ -0,0 +1,197 @@
+"""Front-chain packing of weighted siblings in an enclosing disk."""
+
+from dataclasses import dataclass, field
+from itertools import combinations
+from math import hypot, sqrt
+from random import Random
+
+
+@dataclass
+class Disk:
+    radius: float
+    x: float = 0
+    y: float = 0
+    key: object = None
+    children: list = field(default_factory=list)
+
+
+def tangent(left, right, disk):
+    """Place disk on the clockwise side of the directed edge left -> right."""
+    dx, dy = right.x-left.x, right.y-left.y
+    squared = dx*dx + dy*dy
+    if not squared:
+        disk.x, disk.y = left.x + disk.radius, left.y
+        return
+    left_sq = (left.radius + disk.radius)**2
+    right_sq = (right.radius + disk.radius)**2
+    # Start from the smaller tangent distance for numerical stability.
+    if left_sq > right_sq:
+        along = (squared + right_sq - left_sq)/(2*squared)
+        across = sqrt(max(0, right_sq/squared - along*along))
+        disk.x = right.x - along*dx - across*dy
+        disk.y = right.y - along*dy + across*dx
+    else:
+        along = (squared + left_sq - right_sq)/(2*squared)
+        across = sqrt(max(0, left_sq/squared - along*along))
+        disk.x = left.x + along*dx - across*dy
+        disk.y = left.y + along*dy + across*dx
+
+
+def contains(outer, inner):
+    return hypot(outer.x-inner.x, outer.y-inner.y) + inner.radius <= outer.radius + 1e-9*max(outer.radius, 1)
+
+
+def pair_disk(a, b):
+    dx, dy = b.x-a.x, b.y-a.y
+    distance = hypot(dx, dy)
+    if distance <= abs(a.radius-b.radius):
+        return max((a, b), key=lambda d: d.radius)
+    radius = (distance+a.radius+b.radius)/2
+    ratio = (radius-a.radius)/distance
+    return Disk(radius, a.x+ratio*dx, a.y+ratio*dy)
+
+
+def triple_disks(a, b, c):
+    # Subtract the first tangency equation from the other two. The center
+    # becomes an affine function of the enclosing radius, leaving one quadratic.
+    bx, by, cx, cy = b.x-a.x, b.y-a.y, c.x-a.x, c.y-a.y
+    determinant = bx*cy-by*cx
+    if not determinant:
+        return
+    def solve(p, q):
+        return (cy*p-by*q)/determinant, (bx*q-cx*p)/determinant
+    ux, uy = solve((bx*bx+by*by+a.radius**2-b.radius**2)/2,
+                   (cx*cx+cy*cy+a.radius**2-c.radius**2)/2)
+    vx, vy = solve(b.radius-a.radius, c.radius-a.radius)
+    qa = vx*vx+vy*vy-1
+    qb = 2*(ux*vx+uy*vy+a.radius)
+    qc = ux*ux+uy*uy-a.radius**2
+    if abs(qa) < 1e-14:
+        radii = [-qc/qb] if qb else []
+    else:
+        disc = qb*qb-4*qa*qc
+        radii = [] if disc < 0 else [(-qb+sign*sqrt(disc))/(2*qa) for sign in (-1, 1)]
+    for radius in radii:
+        if radius >= max(a.radius, b.radius, c.radius):
+            yield Disk(radius, a.x+ux+radius*vx, a.y+uy+radius*vy)
+
+
+def enclosing_disk(chain):
+    # A minimal enclosure is supported by at most three disks. When a disk
+    # falls outside, update the support and revisit the already seen disks.
+    disks = list(chain)
+    Random(0).shuffle(disks)
+    support = []
+    enclosure = None
+    index = 0
+    while index < len(disks):
+        disk = disks[index]
+        if enclosure is not None and contains(enclosure, disk):
+            index += 1
+            continue
+        previous = support + [disk]
+        options = [(disk, [disk])]
+        for a in support:
+            options.append((pair_disk(a, disk), [a, disk]))
+        for a, b in combinations(support, 2):
+            options.extend((circle, [a, b, disk]) for circle in triple_disks(a, b, disk))
+        enclosure, support = min(((circle, basis) for circle, basis in options
+                                  if all(contains(circle, p) for p in previous)), key=lambda item: item[0].radius)
+        index = 0
+    return enclosure
+
+
+def edge_score(a, b):
+    weight = a.radius+b.radius
+    if not weight:
+        return a.x*a.x+a.y*a.y
+    x = (a.x*b.radius+b.x*a.radius)/weight
+    y = (a.y*b.radius+b.y*a.radius)/weight
+    return x*x+y*y
+
+
+def pack(disks):
+    first = disks[0]
+    first.x = first.y = 0
+    if len(disks) == 1:
+        return first.radius
+    second = disks[1]
+    first.x, second.x, second.y = -second.radius, first.radius, 0
+    if len(disks) == 2:
+        return first.radius+second.radius
+    tangent(first, second, disks[2])
+    chain = disks[:3]
+    for disk in disks[3:]:
+        while True:
+            a, b = chain[:2]
+            tangent(b, a, disk)
+            ahead, behind = 2, len(chain)-1
+            forward, backward = b.radius, a.radius
+            while ahead <= behind:
+                scan_forward = forward <= backward
+                i = ahead if scan_forward else behind
+                other = chain[i]
+                if hypot(other.x-disk.x, other.y-disk.y) < other.radius+disk.radius-1e-6:
+                    chain = [a]+chain[i:] if scan_forward else [other]+chain[1:i]
+                    break
+                if scan_forward:
+                    ahead += 1
+                    forward += other.radius
+                else:
+                    behind -= 1
+                    backward += other.radius
+            else:
+                chain.insert(1, disk)
+                candidates = [0, *range(2, len(chain))]
+                start = min(candidates, key=lambda j: edge_score(chain[j], chain[(j+1) % len(chain)]))
+                chain = chain[start:]+chain[:start]
+                break
+    enclosure = enclosing_disk(chain)
+    for disk in disks:
+        disk.x -= enclosure.x
+        disk.y -= enclosure.y
+    return enclosure.radius
+
+
+def packed_circles(nodes, plot, padding):
+    if not nodes:
+        return
+
+    def build(node, key):
+        children = [build(n, key) for n in sorted(node.children, key=lambda n: -n.weight)]
+        return Disk(sqrt(node.weight), key=key, children=children)
+
+    root = Disk(0, children=[build(n, n.key) for n in sorted(nodes, key=lambda n: -n.weight)])
+
+    def layout(node, level, scale):
+        if not node.children:
+            return
+        gap = padding(level)*scale
+        for child in node.children:
+            layout(child, level+1, scale)
+            child.radius += gap
+        node.radius = pack(node.children)+gap
+        for child in node.children:
+            child.radius -= gap
+
+    x, y, w, h = plot
+    size = min(w, h)
+    layout(root, 0, 0)
+    if not root.radius:
+        # VChart retains the marks but has no finite scale for an all-zero tree.
+        pending = list(reversed(root.children))
+        while pending:
+            node = pending.pop()
+            yield node.key, None, None, None
+            pending.extend(reversed(node.children))
+        return
+    layout(root, 0, root.radius/size)
+    scale = size/(2*root.radius)
+
+    def emit(parent, x, y):
+        for child in parent.children:
+            cx, cy = x+child.x*scale, y+child.y*scale
+            yield child.key, cx, cy, child.radius*scale
+            yield from emit(child, cx, cy)
+
+    yield from emit(root, x+w/2, y+h/2)

py_vchart/_deps/vlayouts/geo.py

@@ -0,0 +1,97 @@
+"""Local-region Mercator paths for clockwise GeoJSON polygons."""
+
+from math import asin, cos, hypot, isfinite, log, pi, radians, sin, tan, atan2
+
+
+
+def _ring(raw, exterior):
+    if not isinstance(raw, list) or len(raw) < 4 or raw[0] != raw[-1]:
+        raise ValueError("map polygons require closed rings with at least three vertices")
+    points = []
+    for coord in raw[:-1]:
+        if not isinstance(coord, (list, tuple)) or len(coord) < 2:
+            raise ValueError("map requires longitude/latitude positions")
+        lon, lat = coord[:2]
+        if not all(type(n) in (int, float) and isfinite(n) for n in (lon, lat)):
+            raise ValueError("map requires finite coordinates")
+        if abs(lon) > 180 or abs(lat) >= 85:
+            raise ValueError("map supports local Mercator regions below 85 degrees latitude")
+        points.append((radians(lon), radians(lat)))
+    area = sum(a*d-b*c for (a,b),(c,d) in zip(points, points[1:] + points[:1]))
+    if (area >= 0 if exterior else area <= 0):
+        raise ValueError("map requires clockwise exterior rings and counterclockwise holes")
+    return points
+
+
+def read_features(source):
+    if not isinstance(source, dict) or source.get("type") != "FeatureCollection" or not source.get("features"):
+        raise ValueError("map requires a nonempty GeoJSON FeatureCollection")
+    features = []
+    for f in source["features"]:
+        if not isinstance(f, dict) or f.get("type") != "Feature" or not isinstance(f.get("geometry"), dict):
+            raise ValueError("map requires Feature geometries")
+        geometry = f["geometry"]
+        polygons = geometry.get("coordinates")
+        if geometry.get("type") == "Polygon":
+            polygons = [polygons]
+        elif geometry.get("type") != "MultiPolygon":
+            raise ValueError("map supports Polygon and MultiPolygon")
+        if not isinstance(polygons, list) or not polygons or any(not isinstance(p, list) or not p for p in polygons):
+            raise ValueError("map requires nonempty polygons")
+        rings = [_ring(r, i == 0) for polygon in polygons for i, r in enumerate(polygon)]
+        properties = f.get("properties") or {}
+        if not isinstance(properties, dict):
+            raise ValueError("map requires object properties")
+        features.append((properties.copy(), rings))
+    return features
+
+
+def _mercator(point):
+    lon, lat = point
+    return lon, -log(tan(pi / 4 + lat / 2))
+
+
+def _sample(ring, scale):
+    # Subdivide a great-circle edge until its projected chord meets the
+    # native half-square-pixel tolerance. The closing edge participates too.
+    out = []
+    def edge(a, b, depth):
+        x, y = _mercator(a)
+        u, v = _mercator(b)
+        dx, dy = u-x, v-y
+        length2 = dx*dx + dy*dy
+        if depth == 0 or length2 * scale**2 <= 2:
+            return
+        ax, ay, az = cos(a[1])*cos(a[0]), cos(a[1])*sin(a[0]), sin(a[1])
+        bx, by, bz = cos(b[1])*cos(b[0]), cos(b[1])*sin(b[0]), sin(b[1])
+        sx, sy, sz = ax+bx, ay+by, az+bz
+        mid = atan2(sy, sx), asin(sz/hypot(sx, sy, sz))
+        mx, my = _mercator(mid)
+        rx, ry = mx-x, my-y
+        if ((dy*rx-dx*ry)**2 * scale**2 > 0.5*length2
+                or abs((dx*rx+dy*ry)/length2 - 0.5) > 0.3
+                or ax*bx+ay*by+az*bz < cos(pi/6)):
+            edge(a, mid, depth-1)
+            out.append((mx, my))
+            edge(mid, b, depth-1)
+
+    for i, a in enumerate(ring):
+        out.append(_mercator(a))
+        edge(a, ring[(i+1) % len(ring)], 16)
+    return out
+
+
+def fit_paths(features, plot):
+    px, py, width, height = plot
+    rings = [ring for _, feature in features for ring in feature]
+    longitudes = [lon for ring in rings for lon, _ in ring]
+    if max(longitudes)-min(longitudes) >= pi:
+        raise ValueError("map requires a region spanning less than 180 degrees longitude")
+    points = [p for ring in rings for p in _sample(ring, 150)]
+    xs, ys = zip(*points)
+    left, right, top, bottom = min(xs), max(xs), min(ys), max(ys)
+    scale = min(width/(right-left), height/(bottom-top))
+    tx = px + (width-scale*(right+left))/2
+    ty = py + (height-scale*(bottom+top))/2
+    return [[[[tx+x*scale, ty+y*scale] for x,y in _sample(ring, scale)] for ring in rings]
+            for _, rings in features]

py_vchart/_deps/vlayouts/hierarchy.py

@@ -0,0 +1,102 @@
+"""Weighted hierarchy, rectangular partitions and concentric rings."""
+
+from bisect import bisect_left
+from dataclasses import dataclass
+from itertools import accumulate
+from math import isfinite
+
+
+@dataclass
+class Node:
+    key: object
+    weight: float
+    children: list
+    levels: int
+
+
+def hierarchy(rows, key, value):
+    nodes = []
+    for row in rows:
+        if not isinstance(row, dict) or not isinstance(row.get(key), (int, float, str)):
+            raise ValueError("Hierarchy nodes require a scalar category")
+        children = row.get("children", [])
+        if not isinstance(children, list):
+            raise ValueError("Hierarchy children must be an array")
+        descendants = hierarchy(children, key, value)
+        weight = row.get(value, 0)
+        if type(weight) not in (int, float) or not isfinite(weight) or weight < 0:
+            raise ValueError("Hierarchy weights must be finite and nonnegative")
+        nodes.append(Node(row[key], max(weight, sum(n.weight for n in descendants)), descendants,
+                          1 + max((n.levels for n in descendants), default=0)))
+    return nodes
+
+
+def binary_tiles(nodes, weight, box):
+    """Split the longer edge at the sibling boundary nearest half the weight."""
+    sums = list(accumulate((n.weight for n in nodes), initial=0))
+    pending = [(0, len(nodes), weight, box)] if nodes else []
+    while pending:
+        first, stop, total, bounds = pending.pop()
+        if stop == first + 1:
+            yield nodes[first], bounds
+            continue
+        target = sums[first] + total/2
+        cut = min(bisect_left(sums, target, first+1, stop), stop-1)
+        if cut > first+1 and target-sums[cut-1] < sums[cut]-target:
+            cut -= 1
+        part = sums[cut] - sums[first]
+        x, y, right, bottom = bounds
+        fraction = part / total if total else 1
+        if right-x > bottom-y:
+            split = x + (right-x)*fraction
+            left_box, right_box = (x,y,split,bottom), (split,y,right,bottom)
+        else:
+            split = y + (bottom-y)*fraction
+            left_box, right_box = (x,y,right,split), (x,split,right,bottom)
+        pending.append((cut, stop, total-part, right_box))
+        pending.append((first, cut, part, left_box))
+
+
+def inset(box, amount):
+    x, y, right, bottom = box
+    dx = min(amount, (right-x)/2)
+    dy = min(amount, (bottom-y)/2)
+    return [x+dx, y+dy, right-dx, bottom-dy]
+
+
+def treemap_tiles(roots, box, gap, padding):
+    total = sum(node.weight for node in roots)
+    area = (box[2]-box[0])*(box[3]-box[1])
+
+    def visible(node):
+        return total > 0 and node.weight*area/total >= 10
+
+    def visit(node, bounds, depth, key):
+        children = [child for child in node.children if visible(child)]
+        if not children:
+            yield key, bounds
+            return
+        space = padding(depth)
+        if 2*space < min(bounds[2]-bounds[0], bounds[3]-bounds[1]):
+            bounds = inset(bounds, space)
+        for child, tile in binary_tiles(children, node.weight, inset(bounds, -gap/2)):
+            yield from visit(child, inset(tile, gap/2), depth+1, key)
+
+    for node, tile in binary_tiles([n for n in roots if visible(n)], total, inset(box, -gap/2)):
+        yield from visit(node, inset(tile, gap/2), 0, node.key)
+
+
+def sunburst_arcs(roots, angles, radii):
+    levels = max((node.levels for node in roots), default=1)
+    step = (radii[1]-radii[0])/levels
+
+    def visit(nodes, total, start, end, depth, root=None):
+        scale = (end-start)/total if total else 0
+        for node in nodes:
+            key = node.key if root is None else root
+            stop = start + node.weight*scale
+            yield key, (radii[0]+depth*step, radii[0]+(depth+1)*step, start, stop)
+            yield from visit(node.children, node.weight, start, stop, depth+1, key)
+            start = stop
+
+    yield from visit(roots, sum(n.weight for n in roots), *angles, 0)

py_vchart/_deps/vlayouts/sankey.py

@@ -0,0 +1,122 @@
+"""Layer and size an acyclic, weighted node-link graph in logical pixels."""
+
+from collections import deque
+from dataclasses import dataclass, field
+
+
+@dataclass(eq=False)
+class Node:
+    key: object
+    category: object
+    value: float
+    incoming: list = field(default_factory=list)
+    outgoing: list = field(default_factory=list)
+    depth: int = 0
+    tail: int = 0
+    x: float = 0
+    y: float = 0
+    height: float = 0
+
+
+@dataclass(eq=False)
+class Link:
+    source: Node
+    target: Node
+    value: float
+    thickness: float = 0
+    start: float = 0
+    end: float = 0
+
+    def __post_init__(self):
+        self.source.outgoing.append(self)
+        self.target.incoming.append(self)
+
+
+def layers(nodes, align):
+    pending = {n: len(n.incoming) for n in nodes}
+    queue = deque(n for n in nodes if not pending[n])
+    ordered = []
+    while queue:
+        node = queue.popleft()
+        ordered.append(node)
+        for edge in node.outgoing:
+            child = edge.target
+            child.depth = max(child.depth, node.depth+1)
+            pending[child] -= 1
+            if not pending[child]:
+                queue.append(child)
+    if len(ordered) != len(nodes):
+        raise ValueError("sankey requires an acyclic graph")
+    last = max(n.depth for n in nodes)
+    for n in reversed(ordered):
+        n.tail = max((link.target.tail+1 for link in n.outgoing), default=0)
+    columns = [[] for _ in range(last+1)]
+    for n in nodes:
+        index = n.depth
+        if align in ("right", "end"):
+            index = last-n.tail
+        elif align == "justify" and not n.outgoing:
+            index = last
+        elif align == "center" and not n.incoming and n.outgoing:
+            index = min(link.target.depth for link in n.outgoing)-1
+        columns[index].append(n)
+    return columns
+
+
+def assign_ports(nodes):
+    for node in nodes:
+        # Incoming bands follow the vertical order of their source nodes.
+        node.incoming.sort(key=lambda link: link.source.y)
+        for links, attr in [(node.outgoing, "start"), (node.incoming, "end")]:
+            offset = 0
+            for link in links:
+                offset = min(offset + link.thickness, node.height)
+                setattr(link, attr, node.y + offset-link.thickness/2)
+
+
+def sankey_layout(nodes, length, breadth, width, gap, minimum, align, cross):
+    if not nodes:
+        return 0
+    columns = layers(nodes, align)
+    steps = len(columns)-1
+    if isinstance(width, str):
+        ratio = float(width[:-1])/100
+        step = length/(steps+ratio) if steps+ratio else 0
+        width = step*ratio
+    else:
+        step = (length-width)/steps if steps else float("inf")
+    for n in nodes:
+        n.value = max(n.value, sum(edge.value for edge in n.incoming), sum(edge.value for edge in n.outgoing))
+    max_step = breadth/max(map(len, columns))
+    gap = min(gap, max_step)
+    if minimum+gap > max_step:
+        gap = max_step/2 if minimum >= max_step else (max_step-minimum)/2
+        minimum = min(max_step-gap, minimum)
+    scales = []
+    for column in columns:
+        value = sum(n.value for n in column)
+        if value:
+            available = breadth-(len(column)-1)*max(gap, minimum)-minimum
+            scales.append(available/value)
+    scale = min(scales, default=float("inf"))
+    for i, column in enumerate(columns):
+        y = 0
+        for n in column:
+            n.x, n.y = i*step, y
+            raw_height = max(n.value*scale, 0)
+            n.height = max(raw_height, minimum)
+            for edge in n.outgoing:
+                edge.thickness = raw_height*(edge.value/n.value) if n.value else 0
+            y += n.height+gap
+        spare = breadth-y+gap
+        for j, n in enumerate(column):
+            if spare < 0 and len(column)>1:
+                correction = spare/(len(column)-1)
+                if gap+correction >= 0:
+                    n.y += j*correction
+            elif spare > 0 and cross == "end":
+                n.y += spare
+            elif spare > 0 and cross == "middle":
+                n.y += spare/(len(column)+1)*(j+1)
+    assign_ports(nodes)
+    return width