@knowvah/dot-engine 0.1.0

package/src/common/poly-shapes-util.ts

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// Shared helpers for the special node-shape renderers (poly-shapes-cases.ts),
+// ported from C's round_corners support code (lib/common/shapes.c). The case
+// functions build a `D[]` vertex array from the box vertices `AF[]` and the
+// bevel polygon `B[]`, then render through the coord-add + transform adapters.
+
+import type { Point } from '../model/geom.js';
+import type { RenderJob } from '../gvc/job.js';
+import type { RendererPlugin } from '../gvc/context.js';
+import { transformPoint } from '../gvc/device.js';
+import { BOX3D, COMPONENT, DOGEAR } from './shapeData.js';
+
+/** Minimal render context for a special shape (subset of RingCtx). */
+export interface ShapeCtx {
+  renderer: RendererPlugin;
+  job: RenderJob;
+}
+
+/** @see lib/common/shapes.c:30 RBCONST */
+const RBCONST = 12;
+/** @see lib/common/shapes.c:31 RBCURVE (rounded-corner curve offset) */
+const RBCURVE = 0.5;
+
+/** @see lib/common/geomprocs.h interpolate_pointf: p + t*(q-p) */
+export function interpolatePoint(t: number, p: Point, q: Point): Point {
+  return { x: p.x + t * (q.x - p.x), y: p.y + t * (q.y - p.y) };
+}
+
+/** Componentwise point add / subtract (C does these inline). */
+export function vadd(a: Point, b: Point): Point {
+  return { x: a.x + b.x, y: a.y + b.y };
+}
+export function vsub(a: Point, b: Point): Point {
+  return { x: a.x - b.x, y: a.y - b.y };
+}
+
+/** mid_x(AF): X midpoint of the AF[0]-AF[1] edge. @see shapes.c:687 */
+export function midX(af: Point[]): number {
+  return (af[0]!.x + af[1]!.x) / 2;
+}
+
+/** mid_y(&AF[1]): Y midpoint of the AF[1]-AF[2] edge. @see shapes.c:696 */
+export function midY1(af: Point[]): number {
+  return (af[1]!.y + af[2]!.y) / 2;
+}
+
+/**
+ * The recurring "dsDNA" centre line shared by the SBOLv shapes:
+ * from (AF[1].x, midY) to (AF[0].x, AF[2].y + (AF[0].y-AF[3].y)/2).
+ * @see lib/common/shapes.c (e.g. :949-953, :1026-1030)
+ */
+export function dsDnaLine(af: Point[]): [Point, Point] {
+  return [
+    { x: af[1]!.x, y: midY1(af) },
+    { x: af[0]!.x, y: af[2]!.y + (af[0]!.y - af[3]!.y) / 2 },
+  ];
+}
+
+/** Axis-aligned rectangle [TL→TR→BR→BL] from a corner + width/height. */
+export function rect(x: number, y: number, w: number, h: number): Point[] {
+  return [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }];
+}
+
+/** dsDNA-line Y on the right end: AF[2].y + (AF[0].y-AF[3].y)/2. */
+export function dnaY(af: Point[]): number {
+  return af[2]!.y + (af[0]!.y - af[3]!.y) / 2;
+}
+
+/** Next vertex (wrapping to index 0 on the last side). */
+function nextV(af: Point[], seg: number, sides: number): Point {
+  return seg + 1 < sides ? af[seg + 1]! : af[0]!;
+}
+
+/**
+ * Build the bevel/inset polygon B[]: per side, the corner (or, when `rounded`,
+ * an inset curve start) plus the interpolated points at t and 1-t (and, when
+ * rounded, a trailing 1-RBCURVE*t point); then the first three points are
+ * repeated as a wrap. Non-rounded → 3*sides+3 points; rounded → 4*sides+3.
+ * @see lib/common/shapes.c:566 alloc_interpolation_points
+ */
+export function interpolationPoints(
+  af: Point[], sides: number, shape: number, rounded = false,
+): Point[] {
+  let rbconst = RBCONST;
+  for (let seg = 0; seg < sides; seg++) {
+    const p0 = af[seg]!;
+    const p1 = nextV(af, seg, sides);
+    rbconst = Math.min(rbconst, Math.hypot(p1.x - p0.x, p1.y - p0.y) / 3);
+  }
+  const b: Point[] = [];
+  for (let seg = 0; seg < sides; seg++) {
+    const p0 = af[seg]!;
+    const p1 = nextV(af, seg, sides);
+    let t = rbconst / Math.hypot(p1.x - p0.x, p1.y - p0.y);
+    if (shape === BOX3D || shape === COMPONENT) t /= 3;
+    else if (shape === DOGEAR) t /= 2;
+    b.push(rounded ? interpolatePoint(RBCURVE * t, p0, p1) : p0);
+    b.push(interpolatePoint(t, p0, p1), interpolatePoint(1 - t, p0, p1));
+    if (rounded) b.push(interpolatePoint(1 - RBCURVE * t, p0, p1));
+  }
+  b.push(b[0]!, b[1]!, b[2]!);
+  return b;
+}
+
+/** Render a custom polygon (node-relative pts → coord-add + device transform). */
+export function renderShapePolygon(
+  pts: Point[], coord: Point, ctx: ShapeCtx, filled: boolean,
+): void {
+  const dev = pts.map((v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job));
+  ctx.renderer.polygon(dev, filled, ctx.job);
+}
+
+/** Render a custom polyline (node-relative pts → coord-add + device transform). */
+export function renderShapePolyline(pts: Point[], coord: Point, ctx: ShapeCtx): void {
+  const dev = pts.map((v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job));
+  ctx.renderer.polyline(dev, ctx.job);
+}
+
+/** Render a Bézier curve (node-relative control pts → coord-add + transform). */
+export function renderShapeBezier(pts: Point[], coord: Point, ctx: ShapeCtx, filled: boolean): void {
+  const dev = pts.map((v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job));
+  ctx.renderer.bezier(dev, filled, ctx.job);
+}

package/src/common/poly-shapes.ts

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// Special node-shape rendering — a faithful port of C's round_corners shape
+// switch (lib/common/shapes.c:709), which draws the SBOLv synthetic-biology
+// shapes, the box family, the arrows, and cylinder as custom polygons. Without
+// this the port drew every special shape as a plain box.
+//
+// This module is the dispatcher; the bevel/helper machinery lives in
+// poly-shapes-util.ts and the per-shape vertex generators in
+// poly-shapes-cases.ts.
+
+import type { Point } from '../model/geom.js';
+import {
+  type ShapeCtx, interpolationPoints, renderShapeBezier,
+  renderShapePolygon, renderShapePolyline,
+} from './poly-shapes-util.js';
+import {
+  BOX3D, COMPONENT, DOGEAR, CDS, TAB, FOLDER, PROMOTER, TERMINATOR, UTR,
+  INSULATOR, RIBOSITE, RNASTAB, PROTEASESITE, PROTEINSTAB,
+  PRIMERSITE, RESTRICTIONSITE, FIVEPOVERHANG, THREEPOVERHANG, NOVERHANG,
+  ASSEMBLY, SIGNATURE, RPROMOTER, RARROW, LARROW, LPROMOTER, CYLINDER, STAR,
+} from './shapeData.js';
+import * as C from './poly-shapes-cases.js';
+import * as C2 from './poly-shapes-cases2.js';
+
+export type { ShapeCtx } from './poly-shapes-util.js';
+
+/** One shape-case renderer: (af, b, coord, filled, ctx) → void. */
+type Case = (af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx) => void;
+
+/** option.shape → renderer. A shape absent here is not yet ported. */
+const CASES: ReadonlyMap<number, Case> = new Map<number, Case>([
+  [CDS, C.drawCds],
+  [DOGEAR, C.drawDogear],
+  [TAB, C.drawTab],
+  [FOLDER, C.drawFolder],
+  [BOX3D, C.drawBox3d],
+  [COMPONENT, C.drawComponent],
+  [PROMOTER, C.drawPromoter],
+  [TERMINATOR, C.drawTerminator],
+  [UTR, C.drawUtr],
+  [INSULATOR, C.drawInsulator],
+  [RIBOSITE, C.drawRibosite],
+  [RNASTAB, C.drawRnastab],
+  [PROTEASESITE, C.drawProteasesite],
+  [PROTEINSTAB, C.drawProteinstab],
+  [PRIMERSITE, C2.drawPrimersite],
+  [RESTRICTIONSITE, C2.drawRestrictionsite],
+  [FIVEPOVERHANG, C2.drawFivepoverhang],
+  [THREEPOVERHANG, C2.drawThreepoverhang],
+  [NOVERHANG, C2.drawNoverhang],
+  [ASSEMBLY, C2.drawAssembly],
+  [SIGNATURE, C2.drawSignature],
+  [RPROMOTER, C2.drawRpromoter],
+  [RARROW, C2.drawRarrow],
+  [LARROW, C2.drawLarrow],
+  [LPROMOTER, C2.drawLpromoter],
+]);
+
+/**
+ * Draw one periphery ring of a special-shape node, mirroring round_corners.
+ * A shape that is not yet ported throws (loud) — never a silent plain box.
+ * @see lib/common/shapes.c:709 round_corners; :739 switch
+ */
+export function drawSpecialShape(
+  shape: number, ring: Point[], coord: Point, filled: boolean, ctx: ShapeCtx,
+): void {
+  // C handles cylinder before allocating B[] (round_corners:734); it is a
+  // bezier outline + an unfilled top arc, not a B[]-derived polygon.
+  if (shape === CYLINDER) {
+    drawCylinder(ring, coord, filled, ctx);
+    return;
+  }
+  const draw = CASES.get(shape);
+  if (draw === undefined) {
+    throw new Error('special shape ' + String(shape) + ' not yet ported');
+  }
+  const b = interpolationPoints(ring, ring.length, shape);
+  draw(ring, b, coord, filled, ctx);
+}
+
+/**
+ * CYLINDER: the 19-point control polygon as a (filled) bezier outline, plus a
+ * 7-point unfilled top arc mirrored across AF[0].y.
+ * @see lib/common/shapes.c:4199 cylinder_draw
+ */
+function drawCylinder(ring: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  renderShapeBezier(ring, coord, ctx, filled);
+  const y02 = 2 * ring[0]!.y;
+  const top: Point[] = [ring[0]!];
+  for (let i = 1; i <= 5; i++) top.push({ x: ring[i]!.x, y: y02 - ring[i]!.y });
+  top.push(ring[6]!);
+  renderShapeBezier(top, coord, ctx, false);
+}
+
+/** Render context for the round_corners dispatcher (shape + style flags). */
+export interface RoundCtx extends ShapeCtx {
+  shape: number;
+  diagonals: boolean;
+  rounded: boolean;
+}
+
+/**
+ * Dispatch one periphery ring of a node with special corners, mirroring
+ * round_corners: diagonals → shape switch → rounded.
+ * @see lib/common/shapes.c:709 round_corners (:722 diagonals, :725 shape, :727 rounded)
+ */
+export function drawRoundCorners(ring: Point[], coord: Point, filled: boolean, ctx: RoundCtx): void {
+  // STAR is a port-internal marker on option.shape selecting the star vertex
+  // generator (poly-vertices.ts); C's p_star has option.shape=0, so it is NOT a
+  // round_corners special shape. Exclude it here so a style=rounded/diagonals
+  // star falls through to rounded_draw/diagonals_draw over its star vertices,
+  // matching C. Mirrors the identical guard in poly-gencode renderPolygonRing.
+  // @see lib/common/shapes.c:p_star (no option.shape) / round_corners
+  if (ctx.diagonals) diagonalsDraw(ring, coord, filled, ctx);
+  else if (ctx.shape !== 0 && ctx.shape !== STAR) drawSpecialShape(ctx.shape, ring, coord, filled, ctx);
+  else if (ctx.rounded) roundedDraw(ring, coord, filled, ctx);
+}
+
+/** diagonals: the plain polygon plus a corner-cutoff polyline per side.
+ * @see lib/common/shapes.c:619 diagonals_draw */
+function diagonalsDraw(ring: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const sides = ring.length;
+  const b = interpolationPoints(ring, sides, 0);
+  renderShapePolygon(ring, coord, ctx, filled);
+  for (let seg = 0; seg < sides; seg++) {
+    renderShapePolyline([b[3 * seg + 2]!, b[3 * seg + 4]!], coord, ctx);
+  }
+}
+
+/** rounded: a Bézier outline through the per-corner inset curve points.
+ * @see lib/common/shapes.c rounded_draw */
+function roundedDraw(ring: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  emitRoundedBezier(ring, coord, filled, ctx);
+}
+
+/**
+ * Emit one rounded boundary as a single Bézier `<path>`, the reusable core of
+ * C's `rounded_draw` (the rounded branch of `round_corners`). `ring` is the
+ * periphery corner polygon in the same frame `renderShapeBezier` expects — i.e.
+ * relative to `coord`; cluster and record sites pass absolute corners with
+ * `coord = {0,0}`. Shared by poly nodes (`roundedDraw`), rounded clusters
+ * (`renderOneCluster`), and rounded records/Mrecord (`recordGencode`), matching
+ * C's single `round_corners` call from poly_gencode/record_gencode/emit_clusters.
+ * @see lib/common/shapes.c:643 rounded_draw
+ */
+export function emitRoundedBezier(
+  ring: Point[], coord: Point, filled: boolean, ctx: ShapeCtx,
+): void {
+  const sides = ring.length;
+  const b = interpolationPoints(ring, sides, 0, true);
+  const pts: Point[] = [];
+  for (let seg = 0; seg < sides; seg++) {
+    pts.push(b[4 * seg]!, b[4 * seg + 1]!, b[4 * seg + 1]!, b[4 * seg + 2]!, b[4 * seg + 2]!, b[4 * seg + 3]!);
+  }
+  pts.push(pts[0]!, pts[1]!);
+  renderShapeBezier(pts.slice(1), coord, ctx, filled);
+}
+
+/** Mcircle: two horizontal chords on an ellipse (style=diagonals, sides<=2).
+ * @see lib/common/shapes.c:547 Mcircle_hack */
+export function mcircleHack(ring: Point[], coord: Point, ctx: ShapeCtx): void {
+  const px = ring[1]!.x * 0.6614;
+  const py = (0.75 * (ring[1]!.y - ring[0]!.y)) / 2;
+  renderShapePolyline([{ x: px, y: py }, { x: -px, y: py }], coord, ctx);
+  renderShapePolyline([{ x: px, y: -py }, { x: -px, y: -py }], coord, ctx);
+}
+
+/** underline: borderless fill, then only the bottom edge (AF[2]→AF[3]) stroked.
+ * @see lib/common/shapes.c:3044 poly_gencode underline branch */
+export function underlineDraw(ring: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const obj = ctx.job.obj;
+  const saved = obj?.penColor;
+  if (obj) obj.penColor = { type: 'none' };
+  try {
+    renderShapePolygon(ring, coord, ctx, filled);
+  } finally {
+    if (obj && saved !== undefined) obj.penColor = saved;
+  }
+  renderShapePolyline([ring[2]!, ring[3]!], coord, ctx);
+}