@skillpet/circuit 0.5.0

package/dist/elements/lines-arc-labels.js

@@ -0,0 +1,822 @@
+/**
+ * Arcs and labels — aligned with Python `elements/lines.py` (`Arc2`–`EncircleBox`).
+ */
+import { Element } from "../element.js";
+import { linspace } from "../geometry/util.js";
+import { Point } from "../geometry/point.js";
+import { getParam } from "../params.js";
+import { pushElement } from "../drawing-stack.js";
+function xyTuple(p) {
+    return p instanceof Point ? [p.x, p.y] : [p[0], p[1]];
+}
+import { Segment, SegmentArc, SegmentBezier, SegmentPoly, } from "../segment.js";
+function isClose(a, b, tol = 0.01) {
+    return Math.abs(a - b) <= tol;
+}
+/** Python `ZLabel`/`CurrentLabelInline.at(Element)`: `xy.center` or local bbox center → drawing coords. */
+function elementCenterInDrawing(el) {
+    const c = el.absanchors.center;
+    if (c !== undefined) {
+        return c;
+    }
+    const bb = el.getBBox(false, false);
+    const mx = (bb.xmin + bb.xmax) / 2;
+    const my = (bb.ymin + bb.ymax) / 2;
+    return el.transform.transform([mx, my]);
+}
+/** Quadratic Bezier arc between `at` and `to` (or `delta`). */
+export class Arc2 extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { k: 0.5 });
+    }
+    to(target, dx = 0, dy = 0) {
+        const p = Point.fromXY(xyTuple(target));
+        this.userParams.to = [p.x + dx, p.y + dy];
+        return this;
+    }
+    delta(dx, dy) {
+        this.userParams.delta = [dx, dy];
+        return this;
+    }
+    k(k) {
+        this.userParams.k = k;
+        return this;
+    }
+    arrow(arrow) {
+        this.userParams.arrow = arrow;
+        return this;
+    }
+    _place(dwgxy, dwgtheta, dwgparams) {
+        this.dwgParams = { ...dwgparams };
+        if (!this._positioned) {
+            this._position();
+        }
+        this.segments = [];
+        this.elmParams.theta = 0;
+        const xy = this.params.at ?? dwgxy;
+        const to = this.params.to ?? [xy[0] + 3, xy[1]];
+        const delta = this.params.delta;
+        let dx;
+        let dy;
+        if (delta !== undefined) {
+            dx = delta[0];
+            dy = delta[1];
+        }
+        else {
+            dx = to[0] - xy[0];
+            dy = to[1] - xy[1];
+        }
+        const k = this.params.k ?? 0.5;
+        const pa = [dx / 2 - dy * k, dy / 2 + dx * k];
+        const mid = [dx / 2 - (dy * k) / 2, dy / 2 + (dx * k) / 2];
+        const arrow = this.params.arrow;
+        this.segments.push(new SegmentBezier([[0, 0], pa, [dx, dy]], { arrow }));
+        this.anchors.ctrl = pa;
+        this.anchors.mid = mid;
+        this.anchors.start = [0, 0];
+        this.anchors.end = [dx, dy];
+        this.elmParams.lblloc = "mid";
+        this.elmParams.drop = [dx, dy];
+        let valign = "bottom";
+        let halign = "left";
+        let vofst = 0.1;
+        let hofst = 0;
+        if (isClose(mid[1], pa[1])) {
+            valign = "center";
+            vofst = 0;
+        }
+        else if (mid[1] > pa[1]) {
+            valign = "top";
+            vofst = -0.1;
+        }
+        if (isClose(mid[0], pa[0])) {
+            halign = "center";
+        }
+        else if (mid[0] > pa[0]) {
+            halign = "right";
+            vofst = 0;
+            hofst = -0.1;
+        }
+        else {
+            hofst = 0.1;
+            vofst = 0;
+        }
+        this.elmParams.lblofst = [hofst, vofst];
+        this.elmParams.lblalign = [halign, valign];
+        this._positioned = true;
+        return super._place(dwgxy, dwgtheta, dwgparams);
+    }
+}
+/** Cubic Bezier arc (`th1`/`th2` in degrees). */
+export class Arc3 extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, {
+            k: 0.75,
+            th1: 0,
+            th2: 180,
+            to: [1, 0],
+            arrowlength: 0.25,
+            arrowwidth: 0.2,
+        });
+    }
+    to(target, dx = 0, dy = 0) {
+        const p = Point.fromXY(xyTuple(target));
+        this.userParams.to = [p.x + dx, p.y + dy];
+        return this;
+    }
+    delta(dx, dy) {
+        this.userParams.delta = [dx, dy];
+        return this;
+    }
+    k(k) {
+        this.userParams.k = k;
+        return this;
+    }
+    th1(deg) {
+        this.userParams.th1 = deg;
+        return this;
+    }
+    th2(deg) {
+        this.userParams.th2 = deg;
+        return this;
+    }
+    arrow(arrow) {
+        this.userParams.arrow = arrow;
+        return this;
+    }
+    arrowlength(len) {
+        this.userParams.arrowlength = len;
+        return this;
+    }
+    arrowwidth(w) {
+        this.userParams.arrowwidth = w;
+        return this;
+    }
+    setLabelAlign(dx, dy) {
+        this.elmParams.lblloc = "center";
+        let halign = "left";
+        let valign = "bottom";
+        if (dy > 0) {
+            valign = "top";
+            this.elmParams.lblofst = -0.1;
+        }
+        if (dx <= 0) {
+            halign = "right";
+        }
+        this.elmParams.lblalign = [halign, valign];
+    }
+    _place(dwgxy, dwgtheta, dwgparams) {
+        this.dwgParams = { ...dwgparams };
+        if (!this._positioned) {
+            this._position();
+        }
+        this.segments = [];
+        this.userParams.theta = 0;
+        const xy = this.params.at ?? dwgxy;
+        const to = this.params.to ?? dwgxy;
+        const delta = this.params.delta;
+        let dx;
+        let dy;
+        if (delta !== undefined) {
+            dx = delta[0];
+            dy = delta[1];
+        }
+        else {
+            dx = to[0] - xy[0];
+            dy = to[1] - xy[1];
+        }
+        const k = this.params.k ?? 0.75;
+        const th1 = (this.params.th1 ?? 0) * (Math.PI / 180);
+        const th2 = (this.params.th2 ?? 180) * (Math.PI / 180);
+        const pa1 = [dx * k * Math.cos(th1), dy * k * Math.sin(th1)];
+        const pa2 = [dx + dx * k * Math.cos(th2), dy + dy * k * Math.sin(th2)];
+        const arrow = this.params.arrow;
+        const arrowlength = this.params.arrowlength;
+        const arrowwidth = this.params.arrowwidth;
+        this.segments.push(new SegmentBezier([[0, 0], pa1, pa2, [dx, dy]], {
+            arrow,
+            arrowlength,
+            arrowwidth,
+        }));
+        this.anchors.center = [dx / 2, dy / 2];
+        this.anchors.start = [0, 0];
+        this.anchors.end = [dx, dy];
+        this.anchors.ctrl1 = pa1;
+        this.anchors.ctrl2 = pa2;
+        this.elmParams.drop = [dx, dy];
+        this.setLabelAlign(dx, dy);
+        this._positioned = true;
+        return super._place(dwgxy, dwgtheta, dwgparams);
+    }
+}
+/** Curved annotation arrow (label near tail). */
+export class Annotate extends Arc3 {
+    constructor(userParams = {}) {
+        super({
+            ...userParams,
+            to: userParams.to ?? [1, 1],
+            th1: userParams.th1 ?? 75,
+            th2: userParams.th2 ?? 180,
+            arrow: userParams.arrow ?? "<-",
+        });
+    }
+    setLabelAlign(_dx, dy) {
+        this.elmParams.lblloc = "end";
+        const p1 = this.anchors.ctrl2;
+        const p2 = this.anchors.end;
+        let th2;
+        if (p1[0] === p2[0] && p1[1] === p2[1]) {
+            th2 = dy < 0 ? -90 : 90;
+        }
+        else {
+            th2 = (Math.atan2(p2[1] - p1[1], p2[0] - p1[0]) * 180) / Math.PI;
+        }
+        while (th2 < 0) {
+            th2 += 360;
+        }
+        if (th2 < 45 || th2 > 315) {
+            this.elmParams.lblalign = ["left", "center"];
+            this.elmParams.lblofst = [0.1, 0];
+        }
+        else if (th2 >= 45 && th2 <= 135) {
+            this.elmParams.lblalign = ["center", "bottom"];
+            this.elmParams.lblofst = [0, 0.1];
+        }
+        else if (th2 > 135 && th2 <= 225) {
+            this.elmParams.lblalign = ["right", "center"];
+            this.elmParams.lblofst = [-0.1, 0];
+        }
+        else {
+            this.elmParams.lblalign = ["center", "top"];
+            this.elmParams.lblofst = [0, -0.1];
+        }
+    }
+}
+/** Arc3 with horizontal tangents at endpoints (Z-shaped). */
+export class ArcZ extends Arc3 {
+    constructor(userParams = {}) {
+        super({ ...userParams, th1: 0, th2: 180 });
+    }
+}
+/** Arc3 with vertical tangents at endpoints (N-shaped). */
+export class ArcN extends Arc3 {
+    constructor(userParams = {}) {
+        super({ ...userParams, th1: 90, th2: -90 });
+    }
+}
+/** Circular arc through `at` and `to`. */
+export class ArcLoop extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { radius: 0.6, arrowlength: 0.25, arrowwidth: 0.2 });
+    }
+    to(target, dx = 0, dy = 0) {
+        const p = Point.fromXY(xyTuple(target));
+        this.userParams.to = [p.x + dx, p.y + dy];
+        return this;
+    }
+    delta(dx, dy) {
+        this.userParams.delta = [dx, dy];
+        return this;
+    }
+    radius(r) {
+        this.userParams.radius = r;
+        return this;
+    }
+    arrow(arrow) {
+        this.userParams.arrow = arrow;
+        return this;
+    }
+    arrowlength(len) {
+        this.userParams.arrowlength = len;
+        return this;
+    }
+    arrowwidth(w) {
+        this.userParams.arrowwidth = w;
+        return this;
+    }
+    _place(dwgxy, dwgtheta, dwgparams) {
+        this.dwgParams = { ...dwgparams };
+        if (!this._positioned) {
+            this._position();
+        }
+        this.segments = [];
+        this.elmParams.theta = 0;
+        const xy = this.params.at ?? dwgxy;
+        const to = this.params.to ?? dwgxy;
+        const delta = this.params.delta;
+        let dx;
+        let dy;
+        if (delta !== undefined) {
+            dx = delta[0];
+            dy = delta[1];
+        }
+        else {
+            dx = to[0] - xy[0];
+            dy = to[1] - xy[1];
+        }
+        const radius = this.params.radius ?? 0.6;
+        const xa = dx / 2;
+        const ya = dy / 2;
+        const q = Math.sqrt(dx * dx + dy * dy);
+        const inner = radius * radius - (q / 2) * (q / 2);
+        if (inner < 0) {
+            throw new Error(`ArcLoop: no solution for radius ${radius}`);
+        }
+        const s = Math.sqrt(inner);
+        const center = [
+            xa + s * (-dy / q),
+            ya + s * (dx / q),
+        ];
+        const da = Math.sqrt(xa * xa + ya * ya);
+        const thetaa = Math.atan2(ya, xa);
+        const thda = Math.acos(da / radius);
+        const t1 = thetaa - thda;
+        const t2 = thetaa + thda;
+        const tAng = linspace(Math.PI + t2, t1, 50);
+        const x = [];
+        const y = [];
+        for (const ti of tAng) {
+            x.push(center[0] + radius * Math.cos(ti));
+            y.push(center[1] + radius * Math.sin(ti));
+        }
+        const pts = x.map((xi, i) => [xi, y[i]]);
+        const arrow = this.params.arrow;
+        const arrowlength = this.params.arrowlength;
+        const arrowwidth = this.params.arrowwidth;
+        this.segments.push(new Segment(pts, { arrow, arrowlength, arrowwidth }));
+        const mid = Math.floor(x.length / 2);
+        this.anchors.start = [0, 0];
+        this.anchors.end = [x[x.length - 1], y[y.length - 1]];
+        this.anchors.mid = [x[mid], y[mid]];
+        this.anchors.BL = [Math.min(...x), Math.min(...y)];
+        this.anchors.BR = [Math.max(...x), Math.min(...y)];
+        this.anchors.TL = [Math.min(...x), Math.max(...y)];
+        this.anchors.TR = [Math.max(...x), Math.max(...y)];
+        this.elmParams.lblloc = "mid";
+        this.elmParams.drop = [to[0] - xy[0], to[1] - xy[1]];
+        this.elmParams.lblofst = [0, 0.2];
+        if (y[mid] < y[0]) {
+            this.elmParams.lblofst = [0, -0.25];
+        }
+        this._positioned = true;
+        return super._place(dwgxy, dwgtheta, dwgparams);
+    }
+}
+/** Current arrow above/below a line (use `overElement` to mimic Python `.at(el)`). */
+export class CurrentLabel extends Element {
+    _side = "top";
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, {
+            ofst: 0.15,
+            length: 2,
+            top: true,
+            reverse: false,
+            headlength: 0.3,
+            headwidth: 0.2,
+            anchor: "center",
+            drop: null,
+        });
+        this.anchors.center = [0, 0];
+    }
+    /**
+     * When `xy` is an {@link Element}, behave like Python `CurrentLabel.at(el)`:
+     * inherit placement from that element (stored as `overElement`).
+     */
+    at(xy, dx = 0, dy = 0) {
+        if (xy instanceof Element) {
+            this.userParams.overElement = xy;
+            return this;
+        }
+        return super.at(xy, dx, dy);
+    }
+    /** Alias for `at(otherElement)` (Python-style name). */
+    over(el) {
+        this.userParams.overElement = el;
+        return this;
+    }
+    placeArrowSegment(_loc) {
+        let ofst = this.params.ofst ?? 0.15;
+        const length = this.params.length ?? 2;
+        if (this._side === "bottom") {
+            ofst = -ofst;
+        }
+        const a = [-length / 2, ofst];
+        const b = [length / 2, ofst];
+        const headwidth = this.params.headwidth ?? 0.2;
+        const headlength = this.params.headlength ?? 0.3;
+        this.segments.push(new Segment([a, b], {
+            arrow: "->",
+            arrowwidth: headwidth,
+            arrowlength: headlength,
+        }));
+    }
+    /**
+     * Python `CurrentLabel.at(Element)` — `ilabel`, host `flip`/`reverse`, bbox in **local** coords then `transform`.
+     */
+    placeFromOverElement(over) {
+        let side = String(getParam(over.params, "ilabel", "top")).toLowerCase();
+        if (side === "bot") {
+            side = "bottom";
+        }
+        const clTop = this.params.top !== false;
+        if (!clTop) {
+            const m = {
+                top: "bottom",
+                bottom: "top",
+                left: "right",
+                right: "left",
+            };
+            side = m[side] ?? side;
+        }
+        let rev = this.userParams.reverse === true;
+        if (over.userParams.reverse === true) {
+            const sw = { left: "right", right: "left" };
+            if (sw[side] !== undefined) {
+                side = sw[side];
+            }
+            else {
+                rev = !rev;
+            }
+        }
+        if (over.userParams.flip === true && (side === "left" || side === "right")) {
+            rev = !rev;
+        }
+        if (side === "left") {
+            rev = !rev;
+        }
+        this.userParams.reverse = rev;
+        let theta = over.transform.theta;
+        const bb = over.getBBox(false, false);
+        let pos;
+        let lblloc;
+        if (side === "top") {
+            pos = new Point((bb.xmin + bb.xmax) / 2, bb.ymax);
+            lblloc = "top";
+        }
+        else if (side === "bottom") {
+            pos = new Point((bb.xmin + bb.xmax) / 2, bb.ymin);
+            lblloc = "bot";
+        }
+        else if (side === "right") {
+            pos = new Point(bb.xmax, (bb.ymin + bb.ymax) / 2);
+            lblloc = "bot";
+            theta -= 90;
+        }
+        else if (side === "left") {
+            pos = new Point(bb.xmin, (bb.ymin + bb.ymax) / 2);
+            lblloc = "top";
+            theta += 90;
+        }
+        else {
+            pos = new Point((bb.xmin + bb.xmax) / 2, bb.ymax);
+            lblloc = "top";
+        }
+        const abs = over.transform.transform(pos.toTuple());
+        this.userParams.at = [abs.x, abs.y];
+        this.userParams.theta = theta;
+        this.elmParams.lblloc = lblloc;
+        this._side = (side === "bottom" ? "bottom" : side === "top" ? "top" : side === "left" ? "left" : "right");
+        const c = over.userParams.color;
+        if (c !== undefined) {
+            this.userParams.color = c;
+        }
+    }
+    _place(dwgxy, dwgtheta, dwgparams) {
+        this.dwgParams = { ...dwgparams };
+        const over = this.params.overElement;
+        if (over !== undefined) {
+            this.placeFromOverElement(over);
+        }
+        this.segments = [];
+        const theta = ((((this.params.theta ?? 0) % 360) + 360) % 360);
+        let loc = this.params.lblloc ?? "top";
+        const side = this._side;
+        if (side === "right" && (theta <= 90 || theta > 270)) {
+            const l0 = this.elmParams.lblloc ?? "top";
+            this.elmParams.lblloc = l0 === "bot" ? "top" : "bot";
+            loc = this.elmParams.lblloc;
+        }
+        else if ((side === "top" || side === "left" || side === "bottom") &&
+            theta > 90 &&
+            theta <= 270) {
+            const l0 = this.elmParams.lblloc ?? "top";
+            this.elmParams.lblloc = l0 === "bot" ? "top" : "bot";
+            loc = this.elmParams.lblloc;
+        }
+        this.placeArrowSegment(loc);
+        return super._place(dwgxy, dwgtheta, dwgparams);
+    }
+}
+/** Voltage label as a quadratic arc. */
+export class VoltageLabelArc extends CurrentLabel {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { length: 1.75, ofst: 0.075, bend: 0.6 });
+    }
+    placeArrowSegment(_loc) {
+        let ofst = this.params.ofst ?? 0.075;
+        let bend = this.params.bend ?? 0.6;
+        const length = this.params.length ?? 1.75;
+        if (this._side === "bottom") {
+            ofst = -ofst;
+            bend = -bend;
+        }
+        const headwidth = this.params.headwidth ?? 0.2;
+        const headlength = this.params.headlength ?? 0.3;
+        const arrow = this.params.reverse === true ? "<-" : "->";
+        const p1 = [-length / 2, ofst];
+        const p2 = [length / 2, ofst];
+        const pa = [0, bend];
+        this.segments.push(new SegmentBezier([p1, pa, p2], {
+            arrow,
+            arrowlength: headlength,
+            arrowwidth: headwidth,
+        }));
+    }
+}
+/** Inline current arrow on a lead (`overElement` mimics `.at(el)`). */
+export class CurrentLabelInline extends Element {
+    constructor(direction = "in", ofst = 0.8, start = true, userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { headlength: 0.3, headwidth: 0.3 });
+        this.elmParams.lblofst = 0;
+        this.elmParams.drop = null;
+        this.elmParams.zorder = 4;
+        let x = ofst;
+        let dx = this.params.headlength ?? 0.3;
+        if (direction === "in") {
+            x += this.params.headlength ?? 0.3;
+            dx = -dx;
+        }
+        if (start) {
+            x = -x;
+            dx = -dx;
+        }
+        const hw = this.params.headwidth ?? 0.3;
+        const hl = this.params.headlength ?? 0.3;
+        this.segments.push(new Segment([
+            [x, 0],
+            [x + dx, 0],
+        ], { arrow: "->", arrowwidth: hw, arrowlength: hl }));
+    }
+    at(xy, dx = 0, dy = 0) {
+        if (xy instanceof Element) {
+            this.userParams.overElement = xy;
+            return this;
+        }
+        return super.at(xy, dx, dy);
+    }
+    over(el) {
+        this.userParams.overElement = el;
+        return this;
+    }
+    _place(dwgxy, dwgtheta, dwgparams) {
+        this.dwgParams = { ...dwgparams };
+        if (!this._positioned) {
+            this._position();
+        }
+        const over = this.params.overElement;
+        if (over !== undefined) {
+            const pos = elementCenterInDrawing(over);
+            this.userParams.at = [pos.x, pos.y];
+            this.userParams.theta = over.transform.theta;
+            const col = over.userParams.color;
+            if (col !== undefined) {
+                this.userParams.color = col;
+            }
+        }
+        this._positioned = true;
+        return super._place(dwgxy, dwgtheta, dwgparams);
+    }
+}
+/** Right-angle impedance-style arrow. */
+export class ZLabel extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, {
+            ofst: 0.5,
+            hofst: 0.4,
+            length: 1,
+            lengthtip: 0.5,
+            headlength: 0.25,
+            headwidth: 0.15,
+        });
+        this.userParams.anchor = "center";
+        this.anchors.center = [0, 0];
+    }
+    at(xy, dx = 0, dy = 0) {
+        if (xy instanceof Element) {
+            this.userParams.overElement = xy;
+            return this;
+        }
+        return super.at(xy, dx, dy);
+    }
+    over(el) {
+        this.userParams.overElement = el;
+        return this;
+    }
+    _place(dwgxy, dwgtheta, dwgparams) {
+        this.dwgParams = { ...dwgparams };
+        if (!this._positioned) {
+            this._position();
+        }
+        const over = this.params.overElement;
+        if (over !== undefined) {
+            const pos = elementCenterInDrawing(over);
+            this.userParams.at = [pos.x, pos.y];
+            let th = over.transform.theta;
+            if (((th % 360) + 360) % 360 > 90 && ((th % 360) + 360) % 360 <= 270) {
+                th += 180;
+            }
+            this.userParams.theta = th;
+            const col = over.userParams.color;
+            if (col !== undefined) {
+                this.userParams.color = col;
+            }
+        }
+        const hf = this.params.hofst ?? 0.4;
+        const os = this.params.ofst ?? 0.5;
+        const lt = this.params.lengthtip ?? 0.5;
+        const ln = this.params.length ?? 1;
+        const hw = this.params.headwidth ?? 0.15;
+        const hl = this.params.headlength ?? 0.25;
+        const a = [-hf, os];
+        const b = [-hf - lt, os];
+        const c = [-hf - lt, os - ln];
+        this.anchors.head = a;
+        this.anchors.tail = c;
+        this.segments = [];
+        this.segments.push(new Segment([c, b, a], {
+            arrow: "->",
+            arrowwidth: hw,
+            arrowlength: hl,
+        }));
+        this.elmParams.lblloc = "tail";
+        let th = this.params.theta ?? 0;
+        if (this.params.flip === true) {
+            th += 180;
+        }
+        th -= 90;
+        th = ((th % 360) + 360) % 360;
+        if (th < 45 || th > 315) {
+            this.elmParams.lblalign = ["left", "center"];
+            this.elmParams.lblofst = [0, -0.1];
+        }
+        else if (th >= 45 && th <= 135) {
+            this.elmParams.lblalign = ["center", "bottom"];
+            this.elmParams.lblofst = [0, 0.1];
+        }
+        else if (th > 135 && th <= 225) {
+            this.elmParams.lblalign = ["right", "center"];
+            this.elmParams.lblofst = [0, 0.1];
+        }
+        else {
+            this.elmParams.lblalign = ["center", "top"];
+            this.elmParams.lblofst = [0, -0.1];
+        }
+        this._positioned = true;
+        return super._place(dwgxy, dwgtheta, dwgparams);
+    }
+}
+/** Elliptical loop arrow (mesh notation). */
+export class LoopArrow extends Element {
+    constructor(userParams = {}) {
+        super(userParams);
+        Object.assign(this.defaults, { lblloc: "center", lblofst: 0, theta: 0 });
+        const direction = userParams.direction ?? "cw";
+        const theta1 = userParams.theta1 ?? 35;
+        const theta2 = userParams.theta2 ?? -35;
+        const width = userParams.width ?? 1;
+        const height = userParams.height ?? 1;
+        this.segments.push(new SegmentArc([0, 0], width, height, {
+            theta1,
+            theta2,
+            arrow: direction,
+        }));
+        this.anchors.center = [0, 0];
+    }
+}
+/** Loop current inside a quad of placed elements (order: top, right, bottom, left). */
+export class LoopCurrent extends LoopArrow {
+    constructor(userParams) {
+        pushElement(null);
+        const { elm_list, pad = 0.2, ...rest } = userParams;
+        const bbox1 = elm_list[0].getBBox(true, false);
+        const bbox2 = elm_list[1].getBBox(true, false);
+        const bbox3 = elm_list[2].getBBox(true, false);
+        const bbox4 = elm_list[3].getBBox(true, false);
+        const top = bbox1.ymin - pad;
+        const bot = bbox3.ymax + pad;
+        const left = bbox4.xmax + pad;
+        const rght = bbox2.xmin - pad;
+        const center = [(left + rght) / 2, (top + bot) / 2];
+        const width = rght - left;
+        const height = top - bot;
+        super({ ...rest, width, height, at: center });
+    }
+}
+/** Ellipse around a list of elements. */
+export class Encircle extends Element {
+    constructor(userParams) {
+        pushElement(null);
+        const { elm_list, includelabels = true, ...rest } = userParams;
+        super(rest);
+        Object.assign(this.defaults, { padx: 0.2, pady: 0.2, theta: 0 });
+        let xmin = Infinity;
+        let xmax = -Infinity;
+        let ymin = Infinity;
+        let ymax = -Infinity;
+        for (const element of elm_list) {
+            const bb = element.getBBox(true, includelabels);
+            xmin = Math.min(xmin, bb.xmin);
+            xmax = Math.max(xmax, bb.xmax);
+            ymin = Math.min(ymin, bb.ymin);
+            ymax = Math.max(ymax, bb.ymax);
+        }
+        const padx = this.params.padx ?? 0.2;
+        const pady = this.params.pady ?? 0.2;
+        xmin -= padx;
+        xmax += padx;
+        ymin -= pady;
+        ymax += pady;
+        const w = xmax - xmin;
+        const h = ymax - ymin;
+        const center = [(xmax + xmin) / 2, (ymax + ymin) / 2];
+        this.userParams.at = center;
+        this.segments.push(new SegmentArc([0, 0], w, h, {
+            theta1: 0,
+            theta2: 360,
+        }));
+        const sinpi4 = Math.sin(Math.PI / 4);
+        const cospi4 = Math.cos(Math.PI / 4);
+        const sinpi8 = Math.sin(Math.PI / 8);
+        const cospi8 = Math.cos(Math.PI / 8);
+        this.anchors.N = [0, h / 2];
+        this.anchors.S = [0, -h / 2];
+        this.anchors.E = [w / 2, 0];
+        this.anchors.W = [-w / 2, 0];
+        this.anchors.SE = [(w / 2) * cospi4, (-h / 2) * sinpi4];
+        this.anchors.SW = [(-w / 2) * cospi4, (-h / 2) * sinpi4];
+        this.anchors.NW = [(-w / 2) * cospi4, (h / 2) * sinpi4];
+        this.anchors.NE = [(w / 2) * cospi4, (h / 2) * sinpi4];
+        this.anchors.ENE = [(w / 2) * cospi8, (h / 2) * sinpi8];
+        this.anchors.WNW = [(-w / 2) * cospi8, (h / 2) * sinpi8];
+        this.anchors.ESE = [(w / 2) * cospi8, (-h / 2) * sinpi8];
+        this.anchors.WSW = [(-w / 2) * cospi8, (-h / 2) * sinpi8];
+        this.anchors.NNE = [(w / 2) * sinpi8, (h / 2) * cospi8];
+        this.anchors.NNW = [(-w / 2) * sinpi8, (h / 2) * cospi8];
+        this.anchors.SSE = [(w / 2) * sinpi8, (-h / 2) * cospi8];
+        this.anchors.SSW = [(-w / 2) * sinpi8, (-h / 2) * cospi8];
+    }
+}
+/** Rounded rectangle around a list of elements. */
+export class EncircleBox extends Element {
+    constructor(userParams) {
+        pushElement(null);
+        const { elm_list, includelabels = true, ...rest } = userParams;
+        super(rest);
+        Object.assign(this.defaults, { cornerradius: 0.3, padx: 0.2, pady: 0.2, theta: 0 });
+        let xmin = Infinity;
+        let xmax = -Infinity;
+        let ymin = Infinity;
+        let ymax = -Infinity;
+        for (const element of elm_list) {
+            const bb = element.getBBox(true, includelabels);
+            xmin = Math.min(xmin, bb.xmin);
+            xmax = Math.max(xmax, bb.xmax);
+            ymin = Math.min(ymin, bb.ymin);
+            ymax = Math.max(ymax, bb.ymax);
+        }
+        const padx = this.params.padx ?? 0.2;
+        const pady = this.params.pady ?? 0.2;
+        xmin -= padx;
+        xmax += padx;
+        ymin -= pady;
+        ymax += pady;
+        const w = xmax - xmin;
+        const h = ymax - ymin;
+        const center = [(xmax + xmin) / 2, (ymax + ymin) / 2];
+        this.userParams.at = center;
+        const cr = this.params.cornerradius ?? 0.3;
+        this.segments.push(new SegmentPoly([
+            [-w / 2, h / 2],
+            [w / 2, h / 2],
+            [w / 2, -h / 2],
+            [-w / 2, -h / 2],
+        ], { closed: true, cornerradius: cr }));
+        const k = cr - (cr * Math.sqrt(2)) / 2;
+        this.anchors.NE = [w / 2 - k, h / 2 - k];
+        this.anchors.NW = [-w / 2 + k, h / 2 - k];
+        this.anchors.SE = [w / 2 - k, -h / 2 + k];
+        this.anchors.SW = [-w / 2 + k, -h / 2 + k];
+        this.anchors.N = [0, h / 2];
+        this.anchors.S = [0, -h / 2];
+        this.anchors.E = [w / 2, 0];
+        this.anchors.W = [-w / 2, 0];
+    }
+}
+//# sourceMappingURL=lines-arc-labels.js.map