@world-engines/authoring-ui 0.1.0-alpha.0

package/dist/ladybug/graph-placement.js

@@ -0,0 +1,253 @@
+export const NODE_DIAMETER = 48;
+export const NODE_RADIUS = NODE_DIAMETER / 2;
+export const NODE_SPACING_RADIUS_MULTIPLIER = 3;
+export const PLACEMENT_GAP = NODE_RADIUS * NODE_SPACING_RADIUS_MULTIPLIER;
+export const SAFE_DIST = NODE_DIAMETER + PLACEMENT_GAP;
+export const SAFE_ZONE_MULT = SAFE_DIST / NODE_DIAMETER;
+export const MIN_NODE_DIST = SAFE_DIST;
+const SPIRAL_MAX_RINGS = 20;
+const SPIRAL_ANGLE_SEGMENTS = 8;
+const FALLBACK_RING_FACTOR = SPIRAL_MAX_RINGS + 1;
+const TAU = Math.PI * 2;
+const finiteRadius = (radius) => typeof radius === "number" && Number.isFinite(radius) && radius > 0
+    ? radius
+    : NODE_RADIUS;
+/** 外框净空为较大节点半径的三倍。 */
+export const requiredNodeCenterDistance = (leftRadius, rightRadius) => {
+    const left = finiteRadius(leftRadius);
+    const right = finiteRadius(rightRadius);
+    return left + right + NODE_SPACING_RADIUS_MULTIPLIER * Math.max(left, right);
+};
+const collisionDistance = (left, right, legacyThreshold) => {
+    if (legacyThreshold !== undefined && Number.isFinite(legacyThreshold) && legacyThreshold >= 0) {
+        return legacyThreshold;
+    }
+    return requiredNodeCenterDistance(left.radius, right.radius);
+};
+const collidesWith = (point, others, distThreshold) => {
+    for (const other of others) {
+        const dx = point.x - other.x;
+        const dy = point.y - other.y;
+        const threshold = collisionDistance(point, other, distThreshold);
+        if (dx * dx + dy * dy < threshold * threshold)
+            return true;
+    }
+    return false;
+};
+const collectPositions = (existing, excludeId) => {
+    const out = [];
+    for (const [id, node] of Object.entries(existing)) {
+        if (excludeId !== undefined && id === excludeId)
+            continue;
+        out.push({
+            ...node.position,
+            radius: finiteRadius(node.radius ?? node.position.radius)
+        });
+    }
+    return out;
+};
+export const placeEntityWithoutOverlap = (existing, candidate, excludeId, distThreshold) => {
+    const others = collectPositions(existing, excludeId);
+    const candidateRadius = finiteRadius(candidate.radius);
+    const candidateFootprint = {
+        x: candidate.x,
+        y: candidate.y,
+        radius: candidateRadius
+    };
+    if (!collidesWith(candidateFootprint, others, distThreshold)) {
+        return { x: candidate.x, y: candidate.y };
+    }
+    const maxThreshold = others.reduce((largest, other) => Math.max(largest, collisionDistance(candidateFootprint, other, distThreshold)), distThreshold ?? 0);
+    const radiusStep = maxThreshold / 2;
+    for (let ring = 1; ring <= SPIRAL_MAX_RINGS; ring += 1) {
+        const radius = maxThreshold + (ring - 1) * radiusStep;
+        for (let segment = 0; segment < SPIRAL_ANGLE_SEGMENTS; segment += 1) {
+            const angle = (segment / SPIRAL_ANGLE_SEGMENTS) * TAU;
+            const probe = {
+                x: Math.round(candidate.x + Math.cos(angle) * radius),
+                y: Math.round(candidate.y + Math.sin(angle) * radius),
+                radius: candidateRadius
+            };
+            if (!collidesWith(probe, others, distThreshold)) {
+                return { x: probe.x, y: probe.y };
+            }
+        }
+    }
+    const fallback = maxThreshold * FALLBACK_RING_FACTOR;
+    return {
+        x: Math.round(candidate.x + fallback),
+        y: Math.round(candidate.y + fallback)
+    };
+};
+export const resolveOverlaps = (nodes, distThreshold) => {
+    if (nodes.length === 0)
+        return [];
+    const maxRadius = nodes.reduce((largest, node) => Math.max(largest, finiteRadius(node.radius ?? node.position.radius)), NODE_RADIUS);
+    const cellSize = distThreshold === undefined
+        ? requiredNodeCenterDistance(maxRadius, maxRadius)
+        : Math.max(1, distThreshold);
+    let rightmostX = nodes.reduce((largest, node) => Math.max(largest, node.position.x), Number.NEGATIVE_INFINITY);
+    const grid = new Map();
+    const nearby = (point) => {
+        const out = [];
+        const cellX = Math.floor(point.x / cellSize);
+        const cellY = Math.floor(point.y / cellSize);
+        for (let offsetX = -1; offsetX <= 1; offsetX += 1) {
+            const row = grid.get(cellX + offsetX);
+            if (row === undefined)
+                continue;
+            for (let offsetY = -1; offsetY <= 1; offsetY += 1) {
+                const cell = row.get(cellY + offsetY);
+                if (cell !== undefined)
+                    out.push(...cell);
+            }
+        }
+        return out;
+    };
+    const insert = (point) => {
+        rightmostX = Math.max(rightmostX, point.x);
+        const cellX = Math.floor(point.x / cellSize);
+        const cellY = Math.floor(point.y / cellSize);
+        let row = grid.get(cellX);
+        if (row === undefined) {
+            row = new Map();
+            grid.set(cellX, row);
+        }
+        const cell = row.get(cellY);
+        if (cell === undefined)
+            row.set(cellY, [point]);
+        else
+            cell.push(point);
+    };
+    return nodes.map((node) => {
+        const candidateRadius = finiteRadius(node.radius ?? node.position.radius);
+        const footprint = { ...node.position, radius: candidateRadius };
+        let next = { x: footprint.x, y: footprint.y };
+        if (collidesWith(footprint, nearby(footprint), distThreshold)) {
+            const maxThreshold = distThreshold ?? requiredNodeCenterDistance(candidateRadius, maxRadius);
+            const radiusStep = maxThreshold / 2;
+            let found = false;
+            for (let ring = 1; ring <= SPIRAL_MAX_RINGS && !found; ring += 1) {
+                const radius = maxThreshold + (ring - 1) * radiusStep;
+                for (let segment = 0; segment < SPIRAL_ANGLE_SEGMENTS; segment += 1) {
+                    const angle = (segment / SPIRAL_ANGLE_SEGMENTS) * TAU;
+                    const probe = {
+                        x: Math.round(footprint.x + Math.cos(angle) * radius),
+                        y: Math.round(footprint.y + Math.sin(angle) * radius),
+                        radius: candidateRadius
+                    };
+                    if (!collidesWith(probe, nearby(probe), distThreshold)) {
+                        next = { x: probe.x, y: probe.y };
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found) {
+                next = {
+                    x: Math.round(rightmostX + cellSize),
+                    y: Math.round(footprint.y)
+                };
+            }
+        }
+        insert({ ...next, radius: candidateRadius });
+        if (next.x === node.position.x && next.y === node.position.y)
+            return node;
+        return { ...node, position: { x: next.x, y: next.y } };
+    });
+};
+const FORCE_ITERATIONS = 120;
+const FORCE_REPULSION = MIN_NODE_DIST * MIN_NODE_DIST * 6;
+const FORCE_CENTER_PULL = 0.012;
+const FORCE_MAX_STEP = NODE_DIAMETER;
+const FORCE_EPSILON = 0.01;
+const CLAMP_MAX_ITERATIONS = 32;
+const CLAMP_EPSILON = 0.01;
+const CLAMP_MARGIN = 1;
+const CLAMP_ANGLE_GOLDEN = 2.399963;
+export const clampToSafeDistance = (target, others, distThreshold) => {
+    let x = target.x;
+    let y = target.y;
+    for (let iteration = 0; iteration < CLAMP_MAX_ITERATIONS; iteration += 1) {
+        let moved = false;
+        for (const other of others) {
+            const dx = x - other.x;
+            const dy = y - other.y;
+            const distSq = dx * dx + dy * dy;
+            const threshold = collisionDistance(target, other, distThreshold);
+            if (distSq >= threshold * threshold)
+                continue;
+            const distance = Math.sqrt(distSq);
+            if (distance < CLAMP_EPSILON) {
+                const angle = (iteration * CLAMP_ANGLE_GOLDEN) % TAU;
+                x += Math.cos(angle) * threshold;
+                y += Math.sin(angle) * threshold;
+            }
+            else {
+                const push = threshold - distance + CLAMP_MARGIN;
+                x += (dx / distance) * push;
+                y += (dy / distance) * push;
+            }
+            moved = true;
+        }
+        if (!moved)
+            break;
+    }
+    return { x: Math.round(x), y: Math.round(y) };
+};
+/** 保留 editor 既有的静态 force API；共享 Canvas 的按钮布局使用 graph-physics。 */
+export const forcePlacement = (nodes) => {
+    if (nodes.length <= 1)
+        return nodes.map((node) => ({ ...node }));
+    let centerX = 0;
+    let centerY = 0;
+    for (const node of nodes) {
+        centerX += node.position.x;
+        centerY += node.position.y;
+    }
+    centerX /= nodes.length;
+    centerY /= nodes.length;
+    const points = nodes.map((node) => ({
+        id: node.id,
+        x: node.position.x,
+        y: node.position.y,
+        radius: finiteRadius(node.radius ?? node.position.radius)
+    }));
+    for (let iteration = 0; iteration < FORCE_ITERATIONS; iteration += 1) {
+        const forceX = new Array(points.length).fill(0);
+        const forceY = new Array(points.length).fill(0);
+        for (let left = 0; left < points.length; left += 1) {
+            for (let right = left + 1; right < points.length; right += 1) {
+                let dx = points[left].x - points[right].x;
+                let dy = points[left].y - points[right].y;
+                let distSq = dx * dx + dy * dy;
+                if (distSq < FORCE_EPSILON) {
+                    const angle = (left * 2.399963 + right) % TAU;
+                    dx = Math.cos(angle) * FORCE_EPSILON;
+                    dy = Math.sin(angle) * FORCE_EPSILON;
+                    distSq = FORCE_EPSILON;
+                }
+                const pairMinDistance = requiredNodeCenterDistance(points[left].radius, points[right].radius);
+                const radiusScale = pairMinDistance / MIN_NODE_DIST;
+                const force = (FORCE_REPULSION * radiusScale * radiusScale) / distSq;
+                const distance = Math.sqrt(distSq);
+                const unitX = dx / distance;
+                const unitY = dy / distance;
+                forceX[left] += unitX * force;
+                forceY[left] += unitY * force;
+                forceX[right] -= unitX * force;
+                forceY[right] -= unitY * force;
+            }
+        }
+        for (let index = 0; index < points.length; index += 1) {
+            forceX[index] += (centerX - points[index].x) * FORCE_CENTER_PULL;
+            forceY[index] += (centerY - points[index].y) * FORCE_CENTER_PULL;
+            points[index].x += Math.max(-FORCE_MAX_STEP, Math.min(FORCE_MAX_STEP, forceX[index]));
+            points[index].y += Math.max(-FORCE_MAX_STEP, Math.min(FORCE_MAX_STEP, forceY[index]));
+        }
+    }
+    return points.map((point, index) => ({
+        ...nodes[index],
+        position: { x: Math.round(point.x), y: Math.round(point.y) }
+    }));
+};