@knowvah/dot-engine 0.1.0

package/src/common/poly-inside.ts

@@ -0,0 +1,202 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Point-in-shape test for polygon nodes, used by edge clipping
+ * (bezier_clip via shape_clip0). Calculations use the unrotated node
+ * shape centered on the origin.
+ *
+ * The rankdir rotation (ccwrotatepf by 90*GD_rankdir) and the GD_flip extent
+ * swap ARE applied (mission-dot-splines T2 routes rankdir edges through this
+ * clip). The polygon segment walk uses the outline ring at the node's resolved
+ * penwidth (base + penwidth/2), matching C's outline periphery.
+ *
+ * @see lib/common/shapes.c:poly_inside
+ * @see lib/common/shapes.c:same_side
+ */
+
+import type { Point } from '../model/geom.js';
+import type { Node } from '../model/node.js';
+import type { PolygonT } from './types.js';
+import type { InsideContext } from './splines-geom.js';
+import { polygonOutlineRing } from './poly-sizing.js';
+import { ccwrotatepf } from '../model/geom.js';
+
+/** Test if p0 and p1 are on the same side of the line L0-L1. @see shapes.c:same_side */
+export function sameSide(p0: Point, p1: Point, L0: Point, L1: Point): boolean {
+  const a = -(L1.y - L0.y);
+  const b = L1.x - L0.x;
+  const c = a * L0.x + b * L0.y;
+  const s0 = a * p0.x + b * p0.y - c >= 0;
+  const s1 = a * p1.x + b * p1.y - c >= 0;
+  return s0 === s1;
+}
+
+/** Vertex-extent box of a fixedshape polygon. @see lib/common/shapes.c:polyBB */
+function fixedShapeSize(poly: PolygonT): { w: number; h: number } {
+  let xmax = 0;
+  let ymax = 0;
+  for (const v of poly.vertices ?? []) {
+    xmax = Math.max(xmax, Math.abs(v.x));
+    ymax = Math.max(ymax, Math.abs(v.y));
+  }
+  return { w: 2 * xmax, h: 2 * ymax };
+}
+
+/** Scale factors and outline half-extents for the inside test. */
+interface InsideScale {
+  scalex: number;
+  scaley: number;
+  boxURx: number;
+  boxURy: number;
+}
+
+/** Node size + outline extents (points) for the inside scale. */
+function insideDims(n: Node, poly: PolygonT, xsize: number, ysize: number):
+  { w: number; h: number; ow: number; oh: number } {
+  if (poly.option.fixedshape) {
+    const { w, h } = fixedShapeSize(poly);
+    return { w, h, ow: w, oh: h };
+  }
+  const w = 72 * (n.info.width || xsize / 72);
+  const h = 72 * (n.info.height || ysize / 72);
+  // Nodes that skipped poly_init (no measurer) have no outline dims.
+  return { w, h, ow: 72 * n.info.outline_width || w, oh: 72 * n.info.outline_height || h };
+}
+
+/** @see lib/common/shapes.c:poly_inside (scale setup) */
+function insideScale(n: Node, poly: PolygonT): InsideScale {
+  // C swaps the node extents for flipped (LR/RL) layouts. @see poly_inside (GD_flip)
+  const flip = n.root.info.flip === true;
+  const lwrw = n.info.lw + n.info.rw;
+  const xsize = flip ? n.info.ht : lwrw;
+  const ysize = flip ? lwrw : n.info.ht;
+  const { w, h, ow, oh } = insideDims(n, poly, xsize, ysize);
+  return {
+    scalex: xsize !== 0 ? w / xsize : w,
+    scaley: ysize !== 0 ? h / ysize : h,
+    boxURx: ow / 2,
+    boxURy: oh / 2,
+  };
+}
+
+/** Polygon segment walk over the vertex ring. @see shapes.c:poly_inside */
+function polygonWalk(P: Point, vertex: Point[], sides: number): boolean {
+  const O = { x: 0, y: 0 };
+  let i = 0;
+  let i1 = 1 % sides;
+  const Q = vertex[i]!;
+  const R = vertex[i1]!;
+  if (!sameSide(P, O, Q, R)) return false; // outside this segment's face
+  const s = sameSide(P, Q, R, O);
+  if (s && sameSide(P, R, O, Q)) return true; // between the segment's sides
+  for (let j = 1; j < sides; j++) {
+    if (s) {
+      i = i1;
+      i1 = (i + 1) % sides;
+    } else {
+      i1 = i;
+      i = (i + sides - 1) % sides;
+    }
+    if (!sameSide(P, O, vertex[i]!, vertex[i1]!)) return false;
+  }
+  return true;
+}
+
+/**
+ * True when point p (relative to the node center) lies inside the
+ * node's polygon shape.
+ * @see lib/common/shapes.c:poly_inside
+ */
+/** Scaled-point shape test once the polygon descriptor is resolved. */
+function insideShape(n: Node, poly: PolygonT, p: Point): boolean {
+  const sc = insideScale(n, poly);
+  const P = { x: p.x * sc.scalex, y: p.y * sc.scaley };
+  if (Math.abs(P.x) > sc.boxURx || Math.abs(P.y) > sc.boxURy) return false;
+  if (poly.sides <= 2) {
+    return Math.hypot(P.x / sc.boxURx, P.y / sc.boxURy) < 1;
+  }
+  // C walks the outline ring (outermost periphery + penwidth/2
+  // bisector offsets). @see shapes.c:poly_inside (outp selection)
+  const outerStart = (Math.max(poly.peripheries, 1) - 1) * poly.sides;
+  const outer = poly.vertices!.slice(outerStart, outerStart + poly.sides);
+  const ring = polygonOutlineRing(outer, poly.sides, poly.penwidth ?? 1);
+  return polygonWalk(P, ring, poly.sides);
+}
+
+export function polyInside(ctx: InsideContext, p: Point): boolean {
+  const n = ctx.node as Node | undefined;
+  if (n === undefined) return false;
+  // C rotates the test point by the rank direction before testing against the
+  // node's natural-frame polygon. @see shapes.c:poly_inside (ccwrotatepf)
+  const rankdir = (n.root.info.rankdir ?? 0) & 0x3;
+  const P = rankdir === 0 ? p : ccwrotatepf(p, rankdir * 90);
+  if (ctx.bp) {
+    const b = ctx.bp;
+    return P.x >= b.ll.x && P.x <= b.ur.x && P.y >= b.ll.y && P.y <= b.ur.y;
+  }
+  const poly = n.info.shape_info as PolygonT | undefined;
+  if (poly === undefined || poly.vertices === null) return false;
+  return insideShape(n, poly, P);
+}
+
+/**
+ * Point-in-star test. A star is concave, so the generic poly_inside decagon
+ * walk clips edges to the wrong (inner) boundary; C gives the star its own
+ * insidefn that tests the point against the OUTER-tip pentagram: step the
+ * outline vertices by 2 (the five tips) connecting tip i to tip (i+4)%sides,
+ * and count the pentagram edges the point is on the far side of from the
+ * centre — two or more means outside. The port's star vertices are already at
+ * final node scale (poly_inside's scalex/scaley collapse to 1), so P is tested
+ * directly, matching C. @see lib/common/shapes.c:star_inside (4089)
+ */
+export function starInside(ctx: InsideContext, p: Point): boolean {
+  const n = ctx.node as Node | undefined;
+  if (n === undefined) return false;
+  const rankdir = (n.root.info.rankdir ?? 0) & 0x3;
+  const P = rankdir === 0 ? p : ccwrotatepf(p, rankdir * 90);
+  if (ctx.bp) {
+    const b = ctx.bp;
+    return P.x >= b.ll.x && P.x <= b.ur.x && P.y >= b.ll.y && P.y <= b.ur.y;
+  }
+  const poly = n.info.shape_info as PolygonT | undefined;
+  if (poly === undefined || poly.vertices === null) return false;
+  const sides = poly.sides;
+  const outerStart = (Math.max(poly.peripheries, 1) - 1) * sides;
+  const outer = poly.vertices.slice(outerStart, outerStart + sides);
+  const ring = polygonOutlineRing(outer, sides, poly.penwidth ?? 1);
+  const O = { x: 0, y: 0 };
+  let outcnt = 0;
+  for (let i = 0; i < sides; i += 2) {
+    const Q = ring[i]!;
+    const R = ring[(i + 4) % sides]!;
+    if (!sameSide(P, O, Q, R)) outcnt++;
+    if (outcnt === 2) return false;
+  }
+  return true;
+}
+
+/**
+ * Point-in-record test: inside the field tree's bounding box, expanded
+ * by half the penwidth (the outline). penwidth attr is read as default
+ * 1 (no attr plumbing here; no test sets node penwidth).
+ * @see lib/common/shapes.c:record_inside
+ */
+export function recordInside(ctx: InsideContext, p: Point): boolean {
+  const n = ctx.node as Node | undefined;
+  if (n === undefined) return false;
+  // C converts the query point to the record's own (label) frame first:
+  // ccwrotatepf(p, 90 * GD_rankdir). @see lib/common/shapes.c:record_inside
+  const rankdir = (n.root.info.rankdir ?? 0) & 0x3;
+  const P = rankdir === 0 ? p : ccwrotatepf(p, rankdir * 90);
+  let bb: { ll: Point; ur: Point };
+  if (ctx.bp) {
+    bb = ctx.bp;
+  } else {
+    const fld = n.info.shape_info as { b?: { ll: Point; ur: Point } } | undefined;
+    if (!fld?.b) return false;
+    bb = fld.b;
+  }
+  const pw = 0.5; // DEFAULT_NODEPENWIDTH / 2
+  return P.x >= bb.ll.x - pw && P.x <= bb.ur.x + pw
+    && P.y >= bb.ll.y - pw && P.y <= bb.ur.y + pw;
+}

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

@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// Per-shape vertex generators, verbatim ports of the round_corners switch
+// cases (lib/common/shapes.c:740-1739). Each builds a D[] polygon (and any
+// inner polylines) from the box vertices AF[] (`af`) and bevel polygon B[]
+// (`b`), then renders via the adapters in poly-shapes-util.ts.
+
+import type { Point } from '../model/geom.js';
+import {
+  type ShapeCtx, renderShapePolygon, renderShapePolyline,
+  vadd, vsub, midX, midY1, dsDnaLine,
+} from './poly-shapes-util.js';
+
+// ---------------------------------------------------------------------------
+// Box family
+// ---------------------------------------------------------------------------
+
+/** CDS — arrow without protrusions (5-point polygon). @see shapes.c:959-989 */
+export function drawCds(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const w = b[3]!.y - b[4]!.y;
+  const D: Point[] = [
+    { x: b[1]!.x, y: b[1]!.y - w / 2 },
+    { x: b[3]!.x, y: b[3]!.y - w / 2 },
+    { x: af[2]!.x, y: af[2]!.y + w / 2 },
+    { x: b[1]!.x, y: af[2]!.y + w / 2 },
+    { x: af[0]!.x, y: af[0]!.y - (af[0]!.y - af[3]!.y) / 2 },
+  ];
+  renderShapePolygon(D, coord, ctx, filled);
+}
+
+/** DOGEAR (note): cutoff corner + inner fold lines. @see shapes.c:740-758 */
+export function drawDogear(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const sides = af.length;
+  const D: Point[] = new Array<Point>(sides + 1);
+  for (let seg = 1; seg < sides; seg++) D[seg] = af[seg]!;
+  D[0] = b[3 * (sides - 1) + 4]!;
+  D[sides] = b[3 * (sides - 1) + 2]!;
+  renderShapePolygon(D, coord, ctx, filled);
+  const s = sides - 1;
+  const c0 = b[3 * s + 2]!;
+  const c2 = vadd(b[3 * s + 4]!, vsub(c0, b[3 * s + 3]!));
+  renderShapePolyline([b[3 * s + 4]!, c2], coord, ctx);
+  renderShapePolyline([c0, c2], coord, ctx);
+}
+
+/** TAB: top-left tab protrusion. @see shapes.c:760-791 */
+export function drawTab(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const sides = af.length;
+  const w = { x: (b[3]!.x - b[4]!.x) / 3, y: (b[3]!.y - b[4]!.y) / 3 };
+  const D: Point[] = [af[0]!, b[2]!, vadd(b[2]!, w), vadd(b[3]!, w)];
+  for (let seg = 4; seg < sides + 2; seg++) D.push(af[seg - 2]!);
+  renderShapePolygon(D, coord, ctx, filled);
+  renderShapePolyline([b[3]!, b[2]!], coord, ctx);
+}
+
+/** FOLDER: top folder-tab outline. @see shapes.c:793-821 */
+export function drawFolder(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const sides = af.length;
+  const dx = af[0]!.x - b[1]!.x;
+  const wy = (b[3]!.y - b[4]!.y) / 3;
+  // C sets D[4]=B[3] then the seg=4 loop overwrites it with AF[1] (==B[3]).
+  const D: Point[] = [
+    af[0]!,
+    { x: af[0]!.x - dx / 4, y: af[0]!.y + wy },
+    { x: af[0]!.x - 2 * dx, y: af[0]!.y + wy },
+    { x: af[0]!.x - 2.25 * dx, y: b[3]!.y },
+  ];
+  for (let seg = 4; seg < sides + 3; seg++) D.push(af[seg - 3]!);
+  renderShapePolygon(D, coord, ctx, filled);
+}
+
+/** BOX3D: cutoff corners + three depth lines. @see shapes.c:823-844 (sides==4) */
+export function drawBox3d(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const D: Point[] = [af[0]!, b[2]!, b[4]!, af[2]!, b[8]!, b[10]!];
+  renderShapePolygon(D, coord, ctx, filled);
+  const c0 = vadd(b[1]!, vsub(b[11]!, b[0]!));
+  renderShapePolyline([c0, b[4]!], coord, ctx);
+  renderShapePolyline([c0, b[8]!], coord, ctx);
+  renderShapePolyline([c0, b[0]!], coord, ctx);
+}
+
+/** COMPONENT: two side bays + their inner lines. @see shapes.c:846-905 (sides==4) */
+export function drawComponent(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const u = vsub(b[4]!, b[3]!);
+  const v = vsub(b[3]!, b[2]!);
+  const D: Point[] = new Array<Point>(12);
+  D[0] = af[0]!; D[1] = af[1]!;
+  D[2] = vadd(b[3]!, u); D[3] = vadd(D[2], v); D[4] = vadd(D[3], u); D[5] = vadd(D[4], vsub(D[2], D[3]));
+  const u2 = vsub(b[5]!, b[6]!);
+  const v2 = vsub(b[6]!, b[7]!);
+  D[9] = vadd(b[6]!, u2); D[8] = vadd(D[9], v2); D[7] = vadd(D[8], u2); D[6] = vadd(D[7], vsub(D[9], D[8]));
+  D[10] = af[2]!; D[11] = af[3]!;
+  renderShapePolygon(D, coord, ctx, filled);
+  componentInnerLines(D, coord, ctx);
+}
+
+/** COMPONENT's two 4-point inner bay outlines. @see shapes.c:889-903 */
+function componentInnerLines(D: Point[], coord: Point, ctx: ShapeCtx): void {
+  const a1 = vsub(D[2]!, vsub(D[3]!, D[2]!));
+  const a2 = vadd(a1, vsub(D[4]!, D[3]!));
+  renderShapePolyline([D[2]!, a1, a2, D[5]!], coord, ctx);
+  const b1 = vsub(D[6]!, vsub(D[7]!, D[6]!));
+  const b2 = vadd(b1, vsub(D[8]!, D[7]!));
+  renderShapePolyline([D[6]!, b1, b2, D[9]!], coord, ctx);
+}
+
+// ---------------------------------------------------------------------------
+// Gene-expression SBOLv (filled polygon + dsDNA centre line)
+// ---------------------------------------------------------------------------
+
+/** PROMOTER: L-shaped arrow on the centre line. @see shapes.c:908-957 */
+export function drawPromoter(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const mx = midX(af), my = midY1(af);
+  const w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const D0 = { x: mx + (af[0]!.x - af[1]!.x) / 8, y: my + (w * 3) / 2 };
+  const D1 = { x: mx - (af[0]!.x - af[1]!.x) / 4, y: D0.y };
+  const D2 = { x: D1.x, y: my };
+  const D3 = { x: D2.x + wx / 2, y: my };
+  const D4 = { x: D3.x, y: my + w };
+  const D5 = { x: D0.x, y: D4.y };
+  const D6 = { x: D0.x, y: D4.y - w / 4 };
+  const D7 = { x: D6.x + wx, y: D6.y + w / 2 };
+  const D8 = { x: D0.x, y: D0.y + w / 4 };
+  renderShapePolygon([D0, D1, D2, D3, D4, D5, D6, D7, D8], coord, ctx, filled);
+  renderShapePolyline(dsDnaLine(af), coord, ctx);
+}
+
+/** TERMINATOR: centred T-shape. @see shapes.c:991-1033 */
+export function drawTerminator(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const mx = midX(af), my = midY1(af);
+  const w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const D0 = { x: mx + wx / 4, y: my };
+  const D1 = { x: D0.x, y: D0.y + w / 2 };
+  const D2 = { x: D1.x + wx / 2, y: D1.y };
+  const D3 = { x: D2.x, y: D2.y + w / 2 };
+  const D4 = { x: mx - (wx * 3) / 4, y: D3.y };
+  const D5 = { x: D4.x, y: D2.y };
+  const D6 = { x: mx - wx / 4, y: D1.y };
+  const D7 = { x: D6.x, y: D0.y };
+  renderShapePolygon([D0, D1, D2, D3, D4, D5, D6, D7], coord, ctx, filled);
+  renderShapePolyline(dsDnaLine(af), coord, ctx);
+}
+
+/** UTR: centred half-octagon. @see shapes.c:1036-1073 */
+export function drawUtr(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const mx = midX(af), my = midY1(af);
+  const w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const D0 = { x: mx + (wx * 3) / 4, y: my };
+  const D1 = { x: D0.x, y: D0.y + w / 4 };
+  const D2 = { x: mx + wx / 4, y: D1.y + w / 2 };
+  const D3 = { x: mx - wx / 4, y: D2.y };
+  const D4 = { x: mx - (wx * 3) / 4, y: D1.y };
+  const D5 = { x: D4.x, y: D0.y };
+  renderShapePolygon([D0, D1, D2, D3, D4, D5], coord, ctx, filled);
+  renderShapePolyline(dsDnaLine(af), coord, ctx);
+}
+
+/** INSULATOR: nested squares with split dsDNA. @see shapes.c:1455-1503 */
+export function drawInsulator(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const mx = midX(af), my = midY1(af);
+  const h = (b[2]!.x - b[3]!.x) / 2, q = ((b[2]!.x - b[3]!.x) * 3) / 4;
+  const dy = af[2]!.y + (af[0]!.y - af[3]!.y) / 2;
+  renderShapePolygon([
+    { x: mx + h, y: my + h }, { x: mx + h, y: my - h },
+    { x: mx - h, y: my - h }, { x: mx - h, y: my + h },
+  ], coord, ctx, filled);
+  renderShapePolyline([
+    { x: mx + q, y: my + q }, { x: mx + q, y: my - q },
+    { x: mx - q, y: my - q }, { x: mx - q, y: my + q }, { x: mx + q, y: my + q },
+  ], coord, ctx);
+  renderShapePolyline([{ x: mx + q, y: my }, { x: af[0]!.x, y: dy }], coord, ctx);
+  renderShapePolyline([{ x: af[1]!.x, y: my }, { x: mx - q, y: dy }], coord, ctx);
+}
+
+// ---------------------------------------------------------------------------
+// Shared geometry: 16-point X (ribosite/proteasesite), 8-point octagon
+// (rnastab/proteinstab). Both add a stem line + dsDNA.
+// ---------------------------------------------------------------------------
+
+/** The 16-point "X" body. @see shapes.c:1517-1548 (ribosite ≡ proteasesite) */
+function xShape(af: Point[], b: Point[]): Point[] {
+  const mx = midX(af), my = midY1(af);
+  const w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const D0 = { x: mx + wx / 4, y: my + w / 2 };
+  const D1 = { x: D0.x, y: D0.y + w / 8 };
+  const D2 = { x: D0.x - wx / 8, y: D1.y + w / 8 };
+  const D3 = { x: D0.x, y: D2.y + w / 8 };
+  const D4 = { x: D0.x, y: D3.y + w / 8 };
+  const D5 = { x: D2.x, y: D4.y };
+  const D6 = { x: mx, y: D3.y };
+  const D7 = { x: D6.x - wx / 8, y: D5.y };
+  const D8 = { x: D7.x - wx / 8, y: D7.y };
+  const D9 = { x: D8.x, y: D3.y };
+  const D10 = { x: D8.x + wx / 8, y: D2.y };
+  const D11 = { x: D8.x, y: D1.y };
+  const D12 = { x: D8.x, y: D0.y };
+  const D13 = { x: D10.x, y: D12.y };
+  const D14 = { x: D6.x, y: D1.y };
+  const D15 = { x: D2.x, y: D0.y };
+  return [D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15];
+}
+
+/** The 8-point octagon body. @see shapes.c:1588-1603 (rnastab ≡ proteinstab) */
+function octShape(af: Point[], b: Point[]): Point[] {
+  const mx = midX(af), my = midY1(af);
+  const w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const D0 = { x: mx + wx / 8, y: my + w / 2 };
+  const D1 = { x: D0.x + wx / 8, y: D0.y + w / 8 };
+  const D2 = { x: D1.x, y: D1.y + w / 4 };
+  const D3 = { x: D0.x, y: D2.y + w / 8 };
+  const D4 = { x: D3.x - wx / 4, y: D3.y };
+  const D5 = { x: D4.x - wx / 8, y: D2.y };
+  const D6 = { x: D5.x, y: D1.y };
+  const D7 = { x: D4.x, y: D0.y };
+  return [D0, D1, D2, D3, D4, D5, D6, D7];
+}
+
+/** RIBOSITE: X + 2-part dashed stem. @see shapes.c:1505-1573 */
+export function drawRibosite(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const D = xShape(af, b);
+  const my = midY1(af), w = b[3]!.y - b[4]!.y, cx = D[14]!.x;
+  renderShapePolygon(D, coord, ctx, filled);
+  renderShapePolyline([{ x: cx, y: my }, { x: cx, y: my + w / 8 }], coord, ctx);
+  renderShapePolyline([{ x: cx, y: my + w / 4 }, { x: cx, y: my + w / 4 + w / 8 }], coord, ctx);
+  renderShapePolyline(dsDnaLine(af), coord, ctx);
+}
+
+/** PROTEASESITE: X + solid stem. @see shapes.c:1633-1690 */
+export function drawProteasesite(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const D = xShape(af, b);
+  renderShapePolygon(D, coord, ctx, filled);
+  renderShapePolyline([D[14]!, { x: D[14]!.x, y: midY1(af) }], coord, ctx);
+  renderShapePolyline(dsDnaLine(af), coord, ctx);
+}
+
+/** RNASTAB: octagon + 2-part dashed stem. @see shapes.c:1576-1629 */
+export function drawRnastab(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const D = octShape(af, b);
+  const mx = midX(af), my = midY1(af), w = b[3]!.y - b[4]!.y;
+  renderShapePolygon(D, coord, ctx, filled);
+  renderShapePolyline([{ x: mx, y: my }, { x: mx, y: my + w / 8 }], coord, ctx);
+  renderShapePolyline([{ x: mx, y: my + w / 4 }, { x: mx, y: my + w / 4 + w / 8 }], coord, ctx);
+  renderShapePolyline(dsDnaLine(af), coord, ctx);
+}
+
+/** PROTEINSTAB: octagon + solid stem. @see shapes.c:1694-1736 */
+export function drawProteinstab(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const D = octShape(af, b);
+  const mx = midX(af);
+  renderShapePolygon(D, coord, ctx, filled);
+  renderShapePolyline([{ x: mx, y: D[0]!.y }, { x: mx, y: midY1(af) }], coord, ctx);
+  renderShapePolyline(dsDnaLine(af), coord, ctx);
+}

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

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// Per-shape vertex generators (part 2): DNA construction symbols and the
+// arrow/promoter family. Verbatim ports of the round_corners switch cases
+// (lib/common/shapes.c:1076-1454, 1741-1889). See poly-shapes-cases.ts for the
+// box and gene-expression families.
+
+import type { Point } from '../model/geom.js';
+import {
+  type ShapeCtx, renderShapePolygon, renderShapePolyline,
+  midX, midY1, dsDnaLine, rect, dnaY,
+} from './poly-shapes-util.js';
+
+// ---------------------------------------------------------------------------
+// DNA construction symbols
+// ---------------------------------------------------------------------------
+
+/** PRIMERSITE: half-arrow, scales in x. @see shapes.c:1076-1112 */
+export function drawPrimersite(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const mx = midX(af), my = midY1(af);
+  const w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const D0 = { x: mx + wx, y: my + w / 4 };
+  const D1 = { x: D0.x - wx, y: D0.y + w };
+  const D2 = { x: D1.x, y: D0.y + w / 2 };
+  const D3 = { x: mx - (af[0]!.x - af[1]!.x) / 4, y: D2.y };
+  const D4 = { x: D3.x, y: D0.y };
+  renderShapePolygon([D0, D1, D2, D3, D4], coord, ctx, filled);
+  renderShapePolyline(dsDnaLine(af), coord, ctx);
+}
+
+/** RESTRICTIONSITE: zigzag with split dsDNA. @see shapes.c:1115-1163 */
+export function drawRestrictionsite(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const mx = midX(af), my = midY1(af), sw = (af[0]!.x - af[1]!.x) / 8;
+  const w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const D0 = { x: mx + sw + wx / 2, y: my + w / 4 };
+  const D1 = { x: mx - sw, y: D0.y };
+  const D2 = { x: D1.x, y: D1.y + w / 2 };
+  const D3 = { x: D2.x - wx / 2, y: D2.y };
+  const D4 = { x: D3.x, y: my - w / 4 };
+  const D5 = { x: D0.x - wx / 2, y: D4.y };
+  const D6 = { x: D5.x, y: D5.y - w / 2 };
+  const D7 = { x: D0.x, y: D6.y };
+  renderShapePolygon([D0, D1, D2, D3, D4, D5, D6, D7], coord, ctx, filled);
+  renderShapePolyline([{ x: af[1]!.x, y: my }, { x: D4.x, y: dnaY(af) }], coord, ctx);
+  renderShapePolyline([{ x: D7.x, y: my }, { x: af[0]!.x, y: dnaY(af) }], coord, ctx);
+}
+
+/** FIVEPOVERHANG: two left rects + right dsDNA. @see shapes.c:1167-1213 */
+export function drawFivepoverhang(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const my = midY1(af), w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  renderShapePolygon(rect(af[1]!.x, my + w / 8, 2 * wx, w / 2), coord, ctx, filled);
+  const r2 = rect(af[1]!.x + wx, my - (w * 5) / 8, wx, w / 2);
+  renderShapePolygon(r2, coord, ctx, filled);
+  renderShapePolyline([{ x: r2[1]!.x, y: my }, { x: af[0]!.x, y: dnaY(af) }], coord, ctx);
+}
+
+/** THREEPOVERHANG: two right rects + left dsDNA. @see shapes.c:1217-1263 */
+export function drawThreepoverhang(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const my = midY1(af), w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const a0 = { x: af[0]!.x, y: my + w / 8 };
+  const a1 = { x: a0.x, y: a0.y + w / 2 };
+  renderShapePolygon([a0, a1, { x: a1.x - 2 * w, y: a1.y }, { x: a1.x - 2 * w, y: a0.y }], coord, ctx, filled);
+  const c0 = { x: af[0]!.x - wx, y: my - (w * 5) / 8 };
+  const c1 = { x: c0.x, y: c0.y + w / 2 };
+  const c2x = c1.x - w;
+  renderShapePolygon([c0, c1, { x: c2x, y: c1.y }, { x: c2x, y: c0.y }], coord, ctx, filled);
+  renderShapePolyline([{ x: af[1]!.x, y: my }, { x: c2x, y: dnaY(af) }], coord, ctx);
+}
+
+/** NOVERHANG: four rects + split dsDNA. @see shapes.c:1267-1348 */
+export function drawNoverhang(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const mx = midX(af), my = midY1(af), w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const lx = mx - (wx * 9) / 8, rx = mx + wx / 8;
+  const top = my + w / 8, bot = my - (w * 5) / 8;
+  for (const [x, y] of [[lx, top], [lx, bot], [rx, bot], [rx, top]] as const) {
+    renderShapePolygon(rect(x, y, wx, w / 2), coord, ctx, filled);
+  }
+  renderShapePolyline([{ x: rx + wx, y: my }, { x: af[0]!.x, y: dnaY(af) }], coord, ctx);
+  renderShapePolyline([{ x: lx, y: my }, { x: af[1]!.x, y: dnaY(af) }], coord, ctx);
+}
+
+/** ASSEMBLY: two centred rects + split dsDNA. @see shapes.c:1352-1404 */
+export function drawAssembly(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const mx = midX(af), my = midY1(af), w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  const x0 = mx - wx;
+  renderShapePolygon(rect(x0, my + w / 8, 2 * wx, w / 2), coord, ctx, filled);
+  renderShapePolygon(rect(x0, my - (w * 5) / 8, 2 * wx, w / 2), coord, ctx, filled);
+  renderShapePolyline([{ x: x0 + 2 * wx, y: my }, { x: af[0]!.x, y: dnaY(af) }], coord, ctx);
+  renderShapePolyline([{ x: af[1]!.x, y: my }, { x: x0, y: dnaY(af) }], coord, ctx);
+}
+
+/** SIGNATURE: box + "X" + bottom line. @see shapes.c:1408-1451 */
+export function drawSignature(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const my = midY1(af), w = b[3]!.y - b[4]!.y, wx = b[2]!.x - b[3]!.x;
+  renderShapePolygon([
+    { x: af[0]!.x, y: b[1]!.y - w / 2 },
+    { x: b[3]!.x, y: b[3]!.y - w / 2 },
+    { x: af[2]!.x, y: af[2]!.y + w / 2 },
+    { x: af[0]!.x, y: af[2]!.y + w / 2 },
+  ], coord, ctx, filled);
+  const xl = af[1]!.x + wx / 4;
+  renderShapePolyline([{ x: xl, y: my + w / 8 }, { x: xl + wx / 4, y: my + w / 8 - w / 4 }], coord, ctx);
+  renderShapePolyline([{ x: xl, y: my - w / 8 }, { x: xl + wx / 4, y: my - w / 8 + w / 4 }], coord, ctx);
+  const by = af[2]!.y + (w * 3) / 4;
+  renderShapePolyline([{ x: xl, y: by }, { x: af[0]!.x - wx / 4, y: by }], coord, ctx);
+}
+
+// ---------------------------------------------------------------------------
+// Arrow / promoter family (single filled polygon, triangle point on one end)
+// ---------------------------------------------------------------------------
+
+/** RPROMOTER: right-pointing arrow with a tab. @see shapes.c:1741-1777 */
+export function drawRpromoter(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const w = b[3]!.y - b[4]!.y, hw = (b[2]!.x - b[3]!.x) / 2;
+  const lx = b[1]!.x - hw, rx = b[2]!.x + hw;
+  renderShapePolygon([
+    { x: lx, y: b[1]!.y - w / 2 },
+    { x: b[3]!.x, y: b[3]!.y - w / 2 },
+    { x: af[2]!.x, y: af[2]!.y },
+    { x: rx, y: af[2]!.y },
+    { x: rx, y: af[2]!.y + w / 2 },
+    { x: lx, y: af[2]!.y + w / 2 },
+    { x: lx, y: af[3]!.y },
+    { x: af[0]!.x, y: af[0]!.y - (af[0]!.y - af[3]!.y) / 2 },
+    { x: lx, y: af[0]!.y },
+  ], coord, ctx, filled);
+}
+
+/** RARROW: right-pointing arrow. @see shapes.c:1781-1813 */
+export function drawRarrow(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const w = b[3]!.y - b[4]!.y, lx = b[1]!.x - (b[2]!.x - b[3]!.x) / 2;
+  renderShapePolygon([
+    { x: lx, y: b[1]!.y - w / 2 },
+    { x: b[3]!.x, y: b[3]!.y - w / 2 },
+    { x: af[2]!.x, y: af[2]!.y + w / 2 },
+    { x: lx, y: af[2]!.y + w / 2 },
+    { x: lx, y: af[3]!.y },
+    { x: af[0]!.x, y: af[0]!.y - (af[0]!.y - af[3]!.y) / 2 },
+    { x: lx, y: af[0]!.y },
+  ], coord, ctx, filled);
+}
+
+/** Shared head of LARROW / LPROMOTER (D[0..5], left-pointing arrow body). */
+function leftArrowHead(af: Point[], b: Point[]): Point[] {
+  const w = b[3]!.y - b[4]!.y, rx = b[2]!.x + (b[2]!.x - b[3]!.x) / 2;
+  return [
+    { x: af[0]!.x, y: af[0]!.y - w / 2 },
+    { x: rx, y: af[0]!.y - w / 2 },
+    { x: rx, y: b[2]!.y },
+    { x: af[1]!.x, y: af[1]!.y - (af[1]!.y - af[2]!.y) / 2 },
+    { x: rx, y: af[2]!.y },
+    { x: rx, y: af[2]!.y + w / 2 },
+  ];
+}
+
+/** LARROW: left-pointing arrow. @see shapes.c:1817-1847 */
+export function drawLarrow(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const w = b[3]!.y - b[4]!.y;
+  const D = leftArrowHead(af, b);
+  D.push({ x: af[0]!.x, y: af[3]!.y + w / 2 });
+  renderShapePolygon(D, coord, ctx, filled);
+}
+
+/** LPROMOTER: left-pointing arrow with a tab. @see shapes.c:1851-1887 */
+export function drawLpromoter(af: Point[], b: Point[], coord: Point, filled: boolean, ctx: ShapeCtx): void {
+  const w = b[3]!.y - b[4]!.y, lx = b[1]!.x - (b[2]!.x - b[3]!.x) / 2;
+  const D = leftArrowHead(af, b);
+  D.push({ x: lx, y: af[3]!.y + w / 2 }, { x: lx, y: af[3]!.y }, { x: af[3]!.x, y: af[3]!.y });
+  renderShapePolygon(D, coord, ctx, filled);
+}