Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
/**
* Wie weit die Kamera stehen muss, damit ein Rechteck ganz ins Bild passt.
*
* Reine Trigonometrie, ohne three und ohne DOM, damit die eine Zahl, an der die
* Lesbarkeit der Hierarchie haengt, ohne Browser pruefbar ist.
*
* **Warum ueberhaupt eine eigene Rechnung.** `computeCameraTarget` der
* Uebernahme rahmt eine Punktwolke: es nimmt den Schwerpunkt, misst den
* groessten Abstand dazu und multipliziert ihn mit drei, mit einer Untergrenze
* von 300 Einheiten. Fuer eine Wolke aus tausend Sternen ist das richtig. Fuer
* einen Walk aus vier Symbolen ist es das nicht: der groesste Abstand ist dort
* klein, die Untergrenze greift, und die vier Punkte stehen als Briefmarke in
* der Mitte eines leeren Panels (Nutzerfeedback 2026-08-29, Screenshots). Diese
* Datei rechnet stattdessen aus dem Oeffnungswinkel und dem Seitenverhaeltnis
* die Entfernung, bei der das Rechteck genau hineinpasst, und legt einen Rand
* darum.
*
* **Warum frontal.** Die Uebernahme stellt die Kamera schraeg ueber die Wolke,
* und in drei Dimensionen ist das die bessere Ansicht. Die Hierarchie ist eine
* flache Zeichnung in der Ebene z=0; schraeg darauf zu sehen hiesse, ein Raster
* aus Spalten und Zeilen perspektivisch zu verziehen, damit es raeumlich
* aussieht. Also steht die Kamera frontal davor.
*
* **Seit W10 gibt es hier zwei Rahmungen.** {@link frameDistance} rahmt fuer die
* perspektivische Kamera, {@link orthographicZoom} fuer die flache Ansicht des
* Einstellungen-Panels. Sie stehen nebeneinander und nicht ineinander, weil die
* beiden Kameras nach verschiedenen Groessen fragen: die eine nach einer
* Entfernung, die andere nach Pixeln je Welteinheit. Eine gemeinsame Funktion
* haette einen Parameter, der entscheidet, welche Haelfte gilt.
*
* **Seit W10b kommt die Ausrichtung dazu.** Beide Rahmungen oben setzen voraus,
* dass die Kamera schon in die richtige Richtung sieht: sie rechnen eine
* Entfernung fuer ein Rechteck in der Ebene z=0. Das Layout des Servers ist
* aber dreidimensional und in den drei Richtungen verschieden weit, und eine
* Kamera, die die duenne Richtung entlangsieht, zeigt von einer Wolke einen
* Strich (Nutzerbefund 2026-08-30: "mich nervt, dass die Galaxy manchmal
* einfach flach ist"). {@link principalFrame} rechnet darum aus den Positionen
* selbst, wo die groesste Flaeche der Wolke liegt, und {@link fitCamera} stellt
* die Kamera senkrecht davor, weit genug weg, dass alles hineinpasst.
*/
/** Ein achsenparalleles Rechteck in Weltkoordinaten. */
export interface FrameBox {
centerX: number;
centerY: number;
width: number;
height: number;
}
/**
* Der Rand um das Gerahmte.
*
* Zwoelf Prozent: genug, dass die aeussersten Beschriftungen nicht am Rand
* kleben, und wenig genug, dass ein kleiner Walk das Panel wirklich fuellt.
*/
export const FRAME_MARGIN = 1.12;
/** Unter diese Entfernung faehrt die Kamera nie, egal wie klein das Bild ist. */
export const FRAME_MIN_DISTANCE = 40;
/**
* Die Entfernung, bei der `box` vollstaendig im Bild steht.
*
* `fovDegrees` ist der SENKRECHTE Oeffnungswinkel, so wie three ihn fuehrt, und
* `aspect` ist Breite durch Hoehe der Zeichenflaeche. Die waagerechte Bedingung
* teilt darum durch das Seitenverhaeltnis: ein breites Panel braucht fuer
* dieselbe Breite weniger Abstand als ein schmales.
*
* Total: ein Rechteck ohne Ausdehnung, ein Seitenverhaeltnis von null und ein
* unsinniger Winkel ergeben die Untergrenze statt NaN.
*/
export function frameDistance(
box: FrameBox,
fovDegrees: number,
aspect: number,
margin: number = FRAME_MARGIN,
): number {
const fov = (Math.max(1, Math.min(179, fovDegrees)) * Math.PI) / 180;
const half = Math.tan(fov / 2);
const safeAspect = Number.isFinite(aspect) && aspect > 0 ? aspect : 1;
const scale = Number.isFinite(margin) && margin > 0 ? margin : 1;
const height = Math.max(0, box.height) * scale;
const width = Math.max(0, box.width) * scale;
const vertical = height / 2 / half;
const horizontal = width / 2 / (half * safeAspect);
const distance = Math.max(vertical, horizontal);
return Number.isFinite(distance) ? Math.max(FRAME_MIN_DISTANCE, distance) : FRAME_MIN_DISTANCE;
}
/**
* Wie viel des Bildes das Gerahmte danach einnimmt, in beiden Richtungen.
*
* Der Beweislauf liest daran, dass ein kleiner Walk das Panel wirklich fuellt,
* statt als Briefmarke darin zu stehen. Ein Wert von 1 heisst "genau
* formatfuellend", darunter bleibt Rand.
*/
/**
* Das umschliessende Rechteck einer Punktmenge in der Ebene.
*
* Nur x und y: die Rahmung der flachen Ansicht laesst z fallen, und ein
* Rechteck, das eine dritte Achse mittelte, waere ein Rechteck ueber etwas
* anderem als dem, was zu sehen ist. Ohne Punkte ergibt sich ein Rechteck ohne
* Ausdehnung, und die Rechnungen darunter fangen den Fall selbst ab.
*/
export function flatBounds(points: readonly { x: number; y: number }[]): FrameBox {
if (points.length === 0) {
return { centerX: 0, centerY: 0, width: 0, height: 0 };
}
let minX = Number.POSITIVE_INFINITY;
let maxX = Number.NEGATIVE_INFINITY;
let minY = Number.POSITIVE_INFINITY;
let maxY = Number.NEGATIVE_INFINITY;
for (const point of points) {
if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
continue;
}
minX = Math.min(minX, point.x);
maxX = Math.max(maxX, point.x);
minY = Math.min(minY, point.y);
maxY = Math.max(maxY, point.y);
}
if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
return { centerX: 0, centerY: 0, width: 0, height: 0 };
}
return {
centerX: (minX + maxX) / 2,
centerY: (minY + maxY) / 2,
width: maxX - minX,
height: maxY - minY,
};
}
/**
* Der Zoom, mit dem eine orthografische Kamera dieses Rechteck ganz zeigt.
*
* Hier steht ausdruecklich KEINE Trigonometrie, und das ist der Unterschied
* zwischen den beiden Kameras: eine perspektivische braucht den
* Oeffnungswinkel, weil ihr Ausschnitt mit der Entfernung waechst. Eine
* orthografische hat keinen Ausschnittkegel; three rechnet ihre Ebenen aus der
* Groesse der Zeichenflaeche und teilt durch `zoom`. Der Ausschnitt ergibt sich
* damit direkt aus Pixeln je Welteinheit, und die Entfernung der Kamera aendert
* daran nichts.
*
* Genommen wird die kleinere der beiden Richtungen, damit das Rechteck in beide
* hineinpasst. Total: ein Rechteck ohne Ausdehnung und eine Zeichenflaeche ohne
* Pixel ergeben {@link FLAT_MIN_ZOOM} statt einer Division durch null.
*/
export const FLAT_MIN_ZOOM = 0.01;
export function orthographicZoom(
box: FrameBox,
pixelWidth: number,
pixelHeight: number,
margin: number = FRAME_MARGIN,
): number {
const scale = Number.isFinite(margin) && margin > 0 ? margin : 1;
const width = Math.max(0, box.width) * scale;
const height = Math.max(0, box.height) * scale;
if (!(pixelWidth > 0) || !(pixelHeight > 0) || width <= 0 || height <= 0) {
return FLAT_MIN_ZOOM;
}
const zoom = Math.min(pixelWidth / width, pixelHeight / height);
return Number.isFinite(zoom) && zoom > FLAT_MIN_ZOOM ? zoom : FLAT_MIN_ZOOM;
}
export function frameFill(
box: FrameBox,
distance: number,
fovDegrees: number,
aspect: number,
): { vertical: number; horizontal: number } {
const fov = (Math.max(1, Math.min(179, fovDegrees)) * Math.PI) / 180;
const safeAspect = Number.isFinite(aspect) && aspect > 0 ? aspect : 1;
const visibleHeight = 2 * Math.max(FRAME_MIN_DISTANCE, distance) * Math.tan(fov / 2);
const visibleWidth = visibleHeight * safeAspect;
return {
vertical: visibleHeight === 0 ? 0 : Math.max(0, box.height) / visibleHeight,
horizontal: visibleWidth === 0 ? 0 : Math.max(0, box.width) / visibleWidth,
};
}
/* ------------------------------------------- die Ausrichtung (W10b, AC5) --- */
/** Ein Punkt im Raum. Absichtlich ohne three: diese Datei rechnet ohne Szene. */
export interface Vector3Like {
x: number;
y: number;
z: number;
}
/**
* Die drei Hauptachsen einer Punktwolke, nach ihrer Ausdehnung geordnet.
*
* `axes[0]` ist die weiteste Richtung, `axes[2]` die duennste; zusammen mit
* `extents` ist das die Antwort auf die Frage, wo die groesste Flaeche der Wolke
* liegt. Das Dreibein ist rechtshaendig (`axes[2]` ist das Kreuzprodukt der
* beiden anderen), weil die Kamera es genau so als Basis benutzt: Blick entlang
* `axes[2]`, `axes[1]` nach oben, `axes[0]` nach rechts.
*/
export interface PrincipalFrame {
/** Der Mittelpunkt des umschliessenden Kastens IN diesen Achsen. */
center: Vector3Like;
axes: [Vector3Like, Vector3Like, Vector3Like];
/** Ausdehnung entlang jeder Achse, in derselben Reihenfolge. */
extents: [number, number, number];
/** Wie viele Punkte wirklich in die Rechnung eingegangen sind. */
counted: number;
}
const ZERO: Vector3Like = { x: 0, y: 0, z: 0 };
const IDENTITY: [Vector3Like, Vector3Like, Vector3Like] = [
{ x: 1, y: 0, z: 0 },
{ x: 0, y: 1, z: 0 },
{ x: 0, y: 0, z: 1 },
];
const dot = (a: Vector3Like, b: Vector3Like): number => a.x * b.x + a.y * b.y + a.z * b.z;
const cross = (a: Vector3Like, b: Vector3Like): Vector3Like => ({
x: a.y * b.z - a.z * b.y,
y: a.z * b.x - a.x * b.z,
z: a.x * b.y - a.y * b.x,
});
const norm = (a: Vector3Like): Vector3Like => {
const length = Math.sqrt(dot(a, a));
return length > 0 ? { x: a.x / length, y: a.y / length, z: a.z / length } : { x: 0, y: 0, z: 1 };
};
/**
* Das Vorzeichen einer Achse festnageln.
*
* Ein Eigenvektor ist nur bis auf sein Vorzeichen bestimmt, und ohne diese Regel
* stuende die Kamera bei derselben Wolke mal vor und mal hinter ihr, je nachdem
* wie die Rechnung gerade ausgeht. Genommen wird die groesste Komponente; ist
* sie negativ, wird die ganze Achse umgedreht. Das ist willkuerlich, aber
* WIEDERHOLBAR, und darauf kommt es an.
*/
function orient(a: Vector3Like): Vector3Like {
const entries: [number, number][] = [[Math.abs(a.x), a.x], [Math.abs(a.y), a.y], [Math.abs(a.z), a.z]];
let best = 0;
for (let i = 1; i < entries.length; i += 1) {
if ((entries[i] as [number, number])[0] > (entries[best] as [number, number])[0] + 1e-12) {
best = i;
}
}
return (entries[best] as [number, number])[1] < 0 ? { x: -a.x, y: -a.y, z: -a.z } : a;
}
/**
* Eigenwerte und Eigenvektoren einer symmetrischen 3x3-Matrix, nach Jacobi.
*
* Zyklisch und mit fester Rundenzahl, also ohne Abbruch nach Gefuehl: dieselbe
* Eingabe gibt dieselbe Ausgabe, und mehr braucht diese Datei nicht. Die Matrix
* ist eine Kovarianz, also symmetrisch und reell, und damit ist Jacobi der
* kuerzeste Weg, der ohne Bibliothek auskommt.
*/
function jacobiEigen(input: number[][]): { values: number[]; vectors: number[][] } {
const a = input.map((row) => [...row]);
const v = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
for (let sweep = 0; sweep < 24; sweep += 1) {
let off = 0;
for (const [p, q] of [[0, 1], [0, 2], [1, 2]] as [number, number][]) {
off += Math.abs((a[p] as number[])[q] as number);
}
if (off < 1e-12) {
break;
}
for (const [p, q] of [[0, 1], [0, 2], [1, 2]] as [number, number][]) {
const apq = (a[p] as number[])[q] as number;
if (Math.abs(apq) < 1e-15) {
continue;
}
const app = (a[p] as number[])[p] as number;
const aqq = (a[q] as number[])[q] as number;
const theta = (aqq - app) / (2 * apq);
const t = Math.sign(theta || 1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
const c = 1 / Math.sqrt(t * t + 1);
const s = t * c;
for (let k = 0; k < 3; k += 1) {
const akp = (a[k] as number[])[p] as number;
const akq = (a[k] as number[])[q] as number;
(a[k] as number[])[p] = c * akp - s * akq;
(a[k] as number[])[q] = s * akp + c * akq;
}
for (let k = 0; k < 3; k += 1) {
const apk = (a[p] as number[])[k] as number;
const aqk = (a[q] as number[])[k] as number;
(a[p] as number[])[k] = c * apk - s * aqk;
(a[q] as number[])[k] = s * apk + c * aqk;
}
for (let k = 0; k < 3; k += 1) {
const vkp = (v[k] as number[])[p] as number;
const vkq = (v[k] as number[])[q] as number;
(v[k] as number[])[p] = c * vkp - s * vkq;
(v[k] as number[])[q] = s * vkp + c * vkq;
}
}
}
return {
values: [(a[0] as number[])[0] as number, (a[1] as number[])[1] as number, (a[2] as number[])[2] as number],
vectors: v,
};
}
/**
* Wo die groesste Flaeche einer Punktwolke liegt.
*
* Die Achsen kommen aus der Kovarianz der Positionen (also aus der Streuung),
* die Ausdehnungen aus dem umschliessenden Kasten IN diesen Achsen (also aus
* den aeussersten Punkten). Beides zusammen und nicht eines von beiden allein:
* die Streuung sagt, WIE die Wolke liegt, und die aeussersten Punkte sagen, wie
* viel Bild sie braucht. Sortiert wird nach der Ausdehnung und nicht nach dem
* Eigenwert, denn gerahmt wird der Kasten und nicht die Varianz.
*
* Total: keine Punkte, ein Punkt oder lauter unbrauchbare Zahlen ergeben die
* Weltachsen und ein Dreibein ohne Ausdehnung. Ein Sonderfall, der still ein
* NaN in die Kamera schreibt, waere ein schwarzes Bild ohne Meldung.
*/
export function principalFrame(points: readonly Vector3Like[]): PrincipalFrame {
const usable: Vector3Like[] = [];
for (const point of points) {
if (Number.isFinite(point.x) && Number.isFinite(point.y) && Number.isFinite(point.z)) {
usable.push(point);
}
}
if (usable.length === 0) {
return { center: ZERO, axes: IDENTITY, extents: [0, 0, 0], counted: 0 };
}
let mx = 0;
let my = 0;
let mz = 0;
for (const point of usable) {
mx += point.x;
my += point.y;
mz += point.z;
}
mx /= usable.length;
my /= usable.length;
mz /= usable.length;
const covariance = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
for (const point of usable) {
const d = [point.x - mx, point.y - my, point.z - mz];
for (let i = 0; i < 3; i += 1) {
for (let j = 0; j < 3; j += 1) {
(covariance[i] as number[])[j] =
((covariance[i] as number[])[j] as number) + (d[i] as number) * (d[j] as number);
}
}
}
for (let i = 0; i < 3; i += 1) {
for (let j = 0; j < 3; j += 1) {
(covariance[i] as number[])[j] = ((covariance[i] as number[])[j] as number) / usable.length;
}
}
const { vectors } = jacobiEigen(covariance);
const candidates: Vector3Like[] = [0, 1, 2].map((column) => orient(norm({
x: (vectors[0] as number[])[column] as number,
y: (vectors[1] as number[])[column] as number,
z: (vectors[2] as number[])[column] as number,
})));
/*
* Gemessen wird die Ausdehnung, danach wird sortiert.
*
* Der Eigenwert waere die Varianz, und die kann bei einer Wolke mit einem
* dichten Kern und wenigen Ausreissern eine andere Reihenfolge ergeben als
* der Kasten. Ins Bild muss der Kasten.
*/
const measured = candidates.map((axis) => {
let min = Number.POSITIVE_INFINITY;
let max = Number.NEGATIVE_INFINITY;
for (const point of usable) {
const value = dot(point, axis);
min = Math.min(min, value);
max = Math.max(max, value);
}
return { axis, min, max, extent: max - min, middle: (min + max) / 2 };
});
measured.sort((a, b) => b.extent - a.extent);
const first = orient((measured[0] as { axis: Vector3Like }).axis);
const second = orient((measured[1] as { axis: Vector3Like }).axis);
// Rechtshaendig, damit die dritte Achse wirklich die Blickrichtung ist und
// das Bild nicht spiegelverkehrt steht.
const third = norm(cross(first, second));
const along = (axis: Vector3Like): { extent: number; middle: number } => {
let min = Number.POSITIVE_INFINITY;
let max = Number.NEGATIVE_INFINITY;
for (const point of usable) {
const value = dot(point, axis);
min = Math.min(min, value);
max = Math.max(max, value);
}
return { extent: max - min, middle: (min + max) / 2 };
};
const a0 = along(first);
const a1 = along(second);
const a2 = along(third);
return {
center: {
x: first.x * a0.middle + second.x * a1.middle + third.x * a2.middle,
y: first.y * a0.middle + second.y * a1.middle + third.y * a2.middle,
z: first.z * a0.middle + second.z * a1.middle + third.z * a2.middle,
},
axes: [first, second, third],
extents: [a0.extent, a1.extent, a2.extent],
counted: usable.length,
};
}
/**
* Wie weit eine Kamera entlang ihrer Blickrichtung treten muss, damit jeder
* Punkt mit Rand im Bild liegt und der aeusserste genau am Rand steht.
*
* Die Punkte stehen im Blickraum der Kamera (vor ihr ist z negativ). Ein
* Schritt entlang der Blickrichtung aendert ihr x und y nicht, nur ihre Tiefe,
* also ist die Antwort fuer jeden Punkt geschlossen ausrechenbar: die Tiefe,
* bei der er genau am Rand steht, weniger der Tiefe, die er hat. Positiv heisst
* zurueck, negativ heisst vor; ohne brauchbare Punkte bleibt sie stehen.
*/
export function containShift(
points: readonly Vector3Like[],
fovDegrees: number,
aspect: number,
margin: number = FRAME_MARGIN,
): number {
const fov = (Math.max(1, Math.min(179, fovDegrees)) * Math.PI) / 180;
const scale = Number.isFinite(margin) && margin > 0 ? margin : 1;
const vertical = Math.tan(fov / 2) / scale;
const horizontal = vertical * (Number.isFinite(aspect) && aspect > 0 ? aspect : 1);
let shift = Number.NEGATIVE_INFINITY;
for (const point of points) {
if (!Number.isFinite(point.x) || !Number.isFinite(point.y) || !Number.isFinite(point.z)) {
continue;
}
const needed = Math.max(Math.abs(point.x) / horizontal, Math.abs(point.y) / vertical);
shift = Math.max(shift, needed + point.z);
}
return Number.isFinite(shift) ? shift : 0;
}
/** Wo die Kamera steht, damit die ganze Wolke im Bild ist. */
export interface CameraFit {
/** Der Punkt, auf den die Kamera sieht. */
center: Vector3Like;
/** Wo sie dafuer steht. */
eye: Vector3Like;
/** Ihre Oben-Richtung: die zweitweiteste Achse der Wolke. */
up: Vector3Like;
/** Die Richtung, aus der sie sieht: die duennste Achse der Wolke. */
normal: Vector3Like;
/** Die Ausdehnungen der Wolke in genau diesen drei Richtungen. */
width: number;
height: number;
depth: number;
/** Wie weit die Kamera vom Mittelpunkt weg steht. */
distance: number;
counted: number;
}
/**
* Die Kamera senkrecht auf die groesste Flaeche stellen, mit Rand.
*
* Zwei Zutaten, und beide sind Nutzerbefunde vom 2026-08-30:
*
* 1. **Die Richtung.** Sie kommt aus {@link principalFrame}: die Kamera sieht
* die duennste Richtung entlang, also auf die groesste Flaeche. Sonst zeigt
* eine flache Wolke ihre Kante.
* 2. **Der Abstand.** Er rahmt das Rechteck aus den beiden weiten Achsen UND
* legt die halbe Tiefe drauf. Ohne diesen Zuschlag waere die Rahmung fuer
* die Ebene durch den Mittelpunkt richtig und fuer alles, was naeher an der
* Kamera liegt, zu eng: ein Punkt auf der vorderen Haelfte steht naeher und
* erscheint damit weiter aussen, als das Rechteck erlaubt. Mit dem Zuschlag
* liegt die vordere Ebene der Wolke genau auf der gerahmten Entfernung, und
* jeder Punkt dahinter ist nur noch kleiner.
*
* Der Rand ist derselbe wie bei jeder anderen Rahmung dieser Datei
* ({@link FRAME_MARGIN}), damit "eingepasst" ueberall dasselbe heisst.
*
* Mit `center` (Review-Befund G4) steht die Kamera auf diesen Punkt und nicht
* auf die Mitte der Wolke: die Wurzel eines Scopes bleibt in der Bildmitte.
* Die Ausdehnungen werden dann symmetrisch um ihn gemessen, also ist der
* Rahmen so gross, dass auch der fernste Knoten auf der anderen Seite passt.
*/
export function fitCamera(
points: readonly Vector3Like[],
fovDegrees: number,
aspect: number,
margin: number = FRAME_MARGIN,
center?: Vector3Like,
): CameraFit | null {
const frame = principalFrame(points);
if (frame.counted === 0) {
return null;
}
let [width, height, depth] = frame.extents;
const pinned = center !== undefined && [center.x, center.y, center.z].every(Number.isFinite) ? center : undefined;
if (pinned !== undefined) {
[width, height, depth] = frame.axes.map((axis) => {
const offset = dot(pinned, axis);
let reach = 0;
for (const point of points) {
if (Number.isFinite(point.x) && Number.isFinite(point.y) && Number.isFinite(point.z)) {
reach = Math.max(reach, Math.abs(dot(point, axis) - offset));
}
}
return reach * 2;
}) as [number, number, number];
}
const middle = pinned ?? frame.center;
const planar = frameDistance(
{ centerX: 0, centerY: 0, width, height },
fovDegrees,
aspect,
margin,
);
const distance = planar + depth / 2;
const normal = (frame.axes[2] as Vector3Like);
return {
center: middle,
eye: {
x: middle.x + normal.x * distance,
y: middle.y + normal.y * distance,
z: middle.z + normal.z * distance,
},
up: frame.axes[1] as Vector3Like,
normal,
width,
height,
depth,
distance,
counted: frame.counted,
};
}