import { VisQuill, Attach, Animate, EasingFunctions, Svg, Reactive, Circles, Rectangles } from "@visquill/visquill-gdk";
import { categories, points } from "./data";
import "./styles.css";
// Part 7: animated bar heights.
export function run(div: HTMLDivElement) {
const rvg = VisQuill.create(div, "lens-");
const canvas = rvg.canvas;
canvas.handles.defaultZIndex = 1;
const dots = canvas.layer();
for (const p of points) {
dots.visuals.point(`dot ${categories[p.category]}`, p);
}
const handle = canvas.handles.disk("handle", { x: 280, y: 170 });
const cover = canvas.layer();
cover.visuals.box("shade", [-2000, -2000], [3000, 3000]);
cover.mask.box("white", [-2000, -2000], [3000, 3000]);
const lens = canvas.layer();
Attach.pointToPoint(lens.anchor, handle);
const radius = lens.values.real(70);
const ring = lens.visuals.circle("ring");
Attach.circleRadiusToValue(ring, radius);
const hole = cover.mask.circle("black");
Reactive.do([handle, radius], () => {
Circles.circleAt(handle, radius, hole);
}, true);
const counts = categories.map(() => lens.values.real(0));
Reactive.do([handle, radius], () => {
const tally = categories.map(() => 0);
for (const p of points) {
const distance = Math.hypot(p.x - handle.x, p.y - handle.y);
if (distance < radius.value) tally[p.category] += 1;
}
tally.forEach((n, i) => (counts[i].value = n));
}, true);
// The baseline of the bars: a polyline with one segment per category,
// placed along the top of the ring, slightly outside.
const baseline = lens.visuals.polyline("baseline", categories.length + 1);
Attach.polylineToCircle(baseline, ring, Math.PI / 2, { angle: -Math.PI / 2, distance: 4 });
// The heights follow their target values with a short animation.
const heights = categories.map(() => lens.values.real(0));
Reactive.do(counts, () => {
const total = Math.max(1, counts.reduce((sum, count) => sum + count.value, 0));
counts.forEach((count, i) => Animate.real.follow(heights[i], (count.value / total) * 60));
}, true);
// Each bar is placed on its segment of the baseline, with a gap of 2 px at both ends.
categories.forEach((category, i) => {
const bar = lens.visuals.rectangle(`bar ${category}`);
Reactive.do([baseline, heights[i]], () => {
Rectangles.alongPaddedSegment(baseline.at(i), baseline.at(i + 1), heights[i], true, 0, 2, 2, bar);
}, true);
});
const sizes = [70, 100, 50];
let next = 0;
Svg.get(ring).addEventListener("click", () => {
next = (next + 1) % sizes.length;
Animate.real.eased(radius, sizes[next], 600, { easing: EasingFunctions.easeOutCubic });
});
}
// The data the lens explores: 240 points in four categories. Each category
// is distributed around its own center, so the mix differs across the canvas.
// The random numbers are seeded, so the points are the same on every load.
export const categories = ["red", "green", "blue", "orange"];
// A second property, used in part 9: each point also has a shape.
export const shapes = ["circle", "square", "triangle", "diamond"];
export interface DataPoint {
x: number;
y: number;
category: number; // index into categories
shape: number; // index into shapes
}
const centers = [
{ x: 170, y: 120 },
{ x: 390, y: 110 },
{ x: 210, y: 250 },
{ x: 400, y: 240 },
];
export const points: DataPoint[] = [];
const random = seededRandom(7);
centers.forEach((center, category) => {
for (let i = 0; i < 60; i++) {
// Normally distributed around the center (Box–Muller), kept on the canvas.
const length = 65 * Math.sqrt(-2 * Math.log(1 - random()));
const angle = 2 * Math.PI * random();
points.push({
x: clamp(center.x + length * Math.cos(angle), 12, 548),
y: clamp(center.y + length * Math.sin(angle), 12, 328),
category,
shape: 0,
});
}
});
// Each shape is most frequent near one corner.
const corners = [
{ x: 0, y: 0 },
{ x: 560, y: 0 },
{ x: 0, y: 340 },
{ x: 560, y: 340 },
];
const randomShape = seededRandom(11);
for (const p of points) {
const weights = corners.map((c) => Math.exp(-((p.x - c.x) ** 2 + (p.y - c.y) ** 2) / 90000));
let pick = randomShape() * weights.reduce((sum, w) => sum + w, 0);
p.shape = weights.findIndex((w) => (pick -= w) < 0);
if (p.shape < 0) p.shape = weights.length - 1;
}
function clamp(value: number, min: number, max: number): number {
return Math.min(max, Math.max(min, value));
}
// A small seeded generator (mulberry32): the same seed gives the same numbers.
function seededRandom(seed: number): () => number {
return () => {
seed = (seed + 0x6d2b79f5) | 0;
let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
};
}
/* Each class is the prefix "lens-" plus the name used in demo.ts. */
/* Data points: one class for all dots, one per category. */
.lens-dot { r: 4px; }
.lens-red { fill: #c0503f; }
.lens-green { fill: #3f7a5b; }
.lens-blue { fill: #3d6fa8; }
.lens-orange { fill: #d8913a; }
/* The handle is transparent and about as large as the lens. */
.lens-handle {
r: 45px;
fill: transparent;
cursor: grab;
}
.lens-handle:active { cursor: grabbing; }
.lens-ring {
fill: none;
stroke: #1c1a17;
stroke-width: 2px;
pointer-events: stroke;
cursor: pointer;
}
/* The cover darkens the canvas outside the lens. */
.lens-shade { fill: rgb(28 26 23 / 0.55); }
.lens-readout {
fill: #1c1a17;
font: 500 14px "JetBrains Mono", ui-monospace, monospace;
dominant-baseline: hanging;
}
.lens-baseline { fill: none; stroke: none; }
.lens-bar { stroke: #faf6ef; stroke-width: 1.5px; }
.lens-value {
fill: #faf6ef;
font: 600 12px "JetBrains Mono", ui-monospace, monospace;
text-anchor: middle;
dominant-baseline: middle;
}
/* Part 9: bars of the shape chart; the label shows the shape. */
.lens-shape { fill: #e7decb; }