570 lines
20 KiB
TypeScript
570 lines
20 KiB
TypeScript
// Parametrische Wand-Engine — löst ParametricWall-Regelwerke zu Wall[]-Arrays auf.
|
||
//
|
||
// Dieses Modul ist ABSICHTLICH frei von React-, Store- und App.tsx-Importen.
|
||
// Es ist eine reine Modell-Schicht: Eingabe ist ein ParametricWall-Regelwerk +
|
||
// Kontext (Geschoss, Grid-Achsen, bestehende Wände), Ausgabe sind neue Wall[]-
|
||
// Objekte, die direkt in project.walls eingefügt werden können.
|
||
//
|
||
// Bezeichner englisch, Kommentare deutsch (CONVENTIONS.md).
|
||
|
||
import type {
|
||
ConditionalThicknessRule,
|
||
DrawingLevel,
|
||
GridRule,
|
||
ModuleRule,
|
||
ParametricRule,
|
||
ParametricWall,
|
||
ReferenceLineRule,
|
||
SequenceRule,
|
||
Vec2,
|
||
Wall,
|
||
WallType,
|
||
} from "./types";
|
||
|
||
// ── Kontext-Typen ─────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Kontext, der dem Engine beim Auflösen übergeben wird.
|
||
* Enthält alle Informationen, die für die Generierung von Wänden benötigt werden.
|
||
*/
|
||
export interface ParametricContext {
|
||
/** Das Ziel-Geschoss. */
|
||
floor: DrawingLevel;
|
||
/**
|
||
* Optionale Rasterachsen (Phase 3: verlinkter Grid-Ressource). Fehlen sie,
|
||
* berechnet die Engine die Achsen aus `GridRule.spacing`.
|
||
*/
|
||
gridAxes?: { x: number[]; y: number[] };
|
||
/**
|
||
* Optionales Clipping-Polygon (Meter). Fehlt es, reicht das Raster über
|
||
* einen Standardbereich (0…spacing*count).
|
||
*/
|
||
boundaryGeometry?: { boundary: Vec2[] };
|
||
/**
|
||
* Bereits im Projekt vorhandene Wände des Geschosses. Werden von
|
||
* refinierenden Regeln (ConditionalThicknessRule, ReferenceLineRule) genutzt.
|
||
* Optional — fehlt er, wird mit leerem Array gearbeitet.
|
||
*/
|
||
existingWalls?: Wall[];
|
||
}
|
||
|
||
/** Interner Arbeitskontext, der durch den Rule-Dispatcher weitergereicht wird. */
|
||
interface RuleCtx {
|
||
floorId: string;
|
||
defaultWallType: WallType;
|
||
context: ParametricContext;
|
||
/** Wände, die bisher durch frühere Regeln erzeugt wurden (veränderbar). */
|
||
existingWalls: Wall[];
|
||
}
|
||
|
||
// ── ID-Hilfsfunktion ──────────────────────────────────────────────────────
|
||
|
||
/** Einfacher Zähler für generierte Wand-IDs (sessionlokal, nicht persistent). */
|
||
let _idCounter = 0;
|
||
|
||
/**
|
||
* Erzeugt eine eindeutige ID für eine parametrisch generierte Wand.
|
||
* Format: „pw-<parametricWallId>-<counter>".
|
||
*/
|
||
function makeWallId(prefix: string): string {
|
||
_idCounter += 1;
|
||
return `pw-${prefix}-${_idCounter}`;
|
||
}
|
||
|
||
// ── Öffentliche API ───────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Löst ein ParametricWall-Regelwerk zu einem Wall[]-Array für ein gegebenes
|
||
* Geschoss auf.
|
||
*
|
||
* Ablauf:
|
||
* 1. Regelwerk sequenziell ausführen; jede Regel erhält die Ausgabe der
|
||
* vorherigen als `existingWalls` (ermöglicht Verfeinerung).
|
||
* 2. Duplikate (gleicher Start-/Endpunkt innerhalb `tolerance`) entfernen.
|
||
* 3. Bereinigte Wall[]-Liste zurückgeben.
|
||
*
|
||
* Die Ausgabe ist sofort bereit zur Einfügung in `project.walls`. Es werden
|
||
* keine Seiteneffekte erzeugt — kein Store, kein Dispatch, kein React.
|
||
*
|
||
* @param parametricWall - Das Regelwerk (aus Project.parametricWalls[]).
|
||
* @param floorId - ID des Ziel-Geschosses.
|
||
* @param context - Kontext (Geschoss-Objekt, Grid-Achsen, Grenzen, …).
|
||
* @param defaultWallType - Fallback-Wandtyp, wenn eine Regel keinen nennt.
|
||
* @param tolerance - Näherungstoleranz für Duplikat-Erkennung (Meter, Default 0.01).
|
||
* @returns Wall[]-Array, bereit zur Einfügung.
|
||
*/
|
||
export function resolveParametricWall(
|
||
parametricWall: ParametricWall,
|
||
floorId: string,
|
||
context: ParametricContext,
|
||
defaultWallType: WallType,
|
||
tolerance = 0.01,
|
||
): Wall[] {
|
||
const ctx: RuleCtx = {
|
||
floorId,
|
||
defaultWallType,
|
||
context,
|
||
existingWalls: context.existingWalls ?? [],
|
||
};
|
||
|
||
const generated: Wall[] = [];
|
||
|
||
for (const rule of parametricWall.rules) {
|
||
const ruleWalls = applyRule(rule, {
|
||
...ctx,
|
||
existingWalls: [...ctx.existingWalls, ...generated],
|
||
});
|
||
generated.push(...ruleWalls);
|
||
}
|
||
|
||
return deduplicateWalls(generated, tolerance);
|
||
}
|
||
|
||
// ── Rule-Dispatcher ───────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Dispatcher: delegiert eine Regel an die passende Implementierung.
|
||
* Alle Branches sind exhaustiv — unbekannte Typen geben leer zurück.
|
||
*
|
||
* @param rule - Die auszuführende Regel.
|
||
* @param ctx - Interner Arbeitskontext.
|
||
* @returns Wall[]-Array, das diese Regel erzeugt oder verändert hat.
|
||
*/
|
||
export function applyRule(rule: ParametricRule, ctx: RuleCtx): Wall[] {
|
||
switch (rule.type) {
|
||
case "grid":
|
||
return applyGridRule(rule, ctx);
|
||
case "module":
|
||
return applyModuleRule(rule, ctx);
|
||
case "conditional-thickness":
|
||
return applyConditionalThicknessRule(rule, ctx);
|
||
case "reference-line":
|
||
return applyReferenceLineRule(rule, ctx);
|
||
case "sequence":
|
||
return applySequenceRule(rule, ctx);
|
||
default: {
|
||
// TypeScript exhaustiveness-Guard: niemals erreicht bei vollständiger Union.
|
||
const _exhaustive: never = rule;
|
||
void _exhaustive;
|
||
return [];
|
||
}
|
||
}
|
||
}
|
||
|
||
// ── Regel-Implementierungen ────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Raster-Regel: generiert Wände entlang gleichmäßiger X-/Y-Achsen.
|
||
*
|
||
* MVP-Verhalten:
|
||
* - Rasterachsen aus `context.gridAxes` ODER gleichmäßigem `spacing`.
|
||
* - Standardbereich: 0 … `defaultExtent` (10 Einheiten × Spacing), wenn keine
|
||
* Grenzgeometrie vorhanden.
|
||
* - Clipping durch `context.boundaryGeometry` (nur einfache Bounding-Box, MVP).
|
||
* - Je Achse eine Wand senkrecht zur Richtung.
|
||
*
|
||
* @param rule - GridRule-Parameter.
|
||
* @param ctx - Arbeitskontext (Geschoss, Wandtyp, …).
|
||
* @returns Wall[]-Array mit generierten Rasterwänden.
|
||
*/
|
||
export function applyGridRule(rule: GridRule, ctx: RuleCtx): Wall[] {
|
||
const walls: Wall[] = [];
|
||
const spacing = rule.spacing ?? 3.0;
|
||
const wallTypeId = rule.wallTypeId ?? ctx.defaultWallType.id;
|
||
const referenceLine = rule.referenceLine;
|
||
const height = rule.height ?? (ctx.context.floor.floorHeight ?? 2.6);
|
||
const floorId = ctx.floorId;
|
||
const categoryCode = "20";
|
||
|
||
// Bereich aus Grenzpolygon (Bounding-Box) oder Standardbereich ermitteln.
|
||
const { minX, maxX, minY, maxY } = computeBounds(ctx.context, spacing);
|
||
|
||
// X-Richtung: Wände parallel zur Y-Achse (also senkrecht zur X-Richtung).
|
||
if (rule.directions === "x" || rule.directions === "both") {
|
||
const axes = rule.gridId != null && ctx.context.gridAxes
|
||
? ctx.context.gridAxes.x
|
||
: generateAxisPositions(minX, maxX, spacing);
|
||
|
||
for (const axisX of axes) {
|
||
const wall: Wall = {
|
||
id: makeWallId(`${floorId}-gx`),
|
||
type: "wall",
|
||
floorId,
|
||
categoryCode,
|
||
start: { x: axisX, y: minY },
|
||
end: { x: axisX, y: maxY },
|
||
wallTypeId,
|
||
height,
|
||
...(referenceLine != null ? { referenceLine } : {}),
|
||
};
|
||
walls.push(wall);
|
||
}
|
||
}
|
||
|
||
// Y-Richtung: Wände parallel zur X-Achse (also senkrecht zur Y-Richtung).
|
||
if (rule.directions === "y" || rule.directions === "both") {
|
||
const axes = rule.gridId != null && ctx.context.gridAxes
|
||
? ctx.context.gridAxes.y
|
||
: generateAxisPositions(minY, maxY, spacing);
|
||
|
||
for (const axisY of axes) {
|
||
const wall: Wall = {
|
||
id: makeWallId(`${floorId}-gy`),
|
||
type: "wall",
|
||
floorId,
|
||
categoryCode,
|
||
start: { x: minX, y: axisY },
|
||
end: { x: maxX, y: axisY },
|
||
wallTypeId,
|
||
height,
|
||
...(referenceLine != null ? { referenceLine } : {}),
|
||
};
|
||
walls.push(wall);
|
||
}
|
||
}
|
||
|
||
return walls;
|
||
}
|
||
|
||
/**
|
||
* Modul-Regel: unterteilt eine Referenzspanne proportional in Felder.
|
||
*
|
||
* MVP-Verhalten:
|
||
* - Spanne aus Geschoss-Ausdehnung (Bounding-Box) oder Referenzwand.
|
||
* - Teilungspunkte im `moduleSize`-Abstand.
|
||
* - Querwände (senkrecht zur `direction`) an jedem Teilungspunkt.
|
||
*
|
||
* @param rule - ModuleRule-Parameter.
|
||
* @param ctx - Arbeitskontext.
|
||
* @returns Wall[]-Array mit Querwänden an Modul-Teilungspunkten.
|
||
*/
|
||
export function applyModuleRule(rule: ModuleRule, ctx: RuleCtx): Wall[] {
|
||
const walls: Wall[] = [];
|
||
const wallTypeId = rule.wallTypeId ?? ctx.defaultWallType.id;
|
||
const referenceLine = rule.referenceLine;
|
||
const height = rule.height ?? (ctx.context.floor.floorHeight ?? 2.6);
|
||
const floorId = ctx.floorId;
|
||
const categoryCode = "20";
|
||
|
||
const { minX, maxX, minY, maxY } = computeBounds(ctx.context, rule.moduleSize);
|
||
|
||
// Referenzwand: falls angegeben, Spanne aus dieser Wand ableiten.
|
||
let spanStart: number;
|
||
let spanEnd: number;
|
||
let perpStart: number;
|
||
let perpEnd: number;
|
||
|
||
if (rule.referenceWallId != null) {
|
||
const refWall = ctx.existingWalls.find((w) => w.id === rule.referenceWallId);
|
||
if (refWall != null) {
|
||
// Spanne entlang der Hauptachse der Referenzwand.
|
||
if (rule.direction === "x") {
|
||
spanStart = Math.min(refWall.start.x, refWall.end.x);
|
||
spanEnd = Math.max(refWall.start.x, refWall.end.x);
|
||
perpStart = minY;
|
||
perpEnd = maxY;
|
||
} else {
|
||
spanStart = Math.min(refWall.start.y, refWall.end.y);
|
||
spanEnd = Math.max(refWall.start.y, refWall.end.y);
|
||
perpStart = minX;
|
||
perpEnd = maxX;
|
||
}
|
||
} else {
|
||
// Referenzwand nicht gefunden: Fallback auf Bounding-Box.
|
||
spanStart = rule.direction === "x" ? minX : minY;
|
||
spanEnd = rule.direction === "x" ? maxX : maxY;
|
||
perpStart = rule.direction === "x" ? minY : minX;
|
||
perpEnd = rule.direction === "x" ? maxY : maxX;
|
||
}
|
||
} else {
|
||
spanStart = rule.direction === "x" ? minX : minY;
|
||
spanEnd = rule.direction === "x" ? maxX : maxY;
|
||
perpStart = rule.direction === "x" ? minY : minX;
|
||
perpEnd = rule.direction === "x" ? maxY : maxX;
|
||
}
|
||
|
||
// Modul-Teilungspunkte (ohne Start und Ende der Spanne selbst).
|
||
const positions = generateAxisPositions(spanStart, spanEnd, rule.moduleSize);
|
||
// Ersten und letzten Punkt herausfiltern, da das dort bereits Außenwände gibt.
|
||
const dividers = positions.filter((p) => p > spanStart + 1e-6 && p < spanEnd - 1e-6);
|
||
|
||
for (const pos of dividers) {
|
||
const wall: Wall = rule.direction === "x"
|
||
? {
|
||
id: makeWallId(`${floorId}-mx`),
|
||
type: "wall",
|
||
floorId,
|
||
categoryCode,
|
||
start: { x: pos, y: perpStart },
|
||
end: { x: pos, y: perpEnd },
|
||
wallTypeId,
|
||
height,
|
||
...(referenceLine != null ? { referenceLine } : {}),
|
||
}
|
||
: {
|
||
id: makeWallId(`${floorId}-my`),
|
||
type: "wall",
|
||
floorId,
|
||
categoryCode,
|
||
start: { x: perpStart, y: pos },
|
||
end: { x: perpEnd, y: pos },
|
||
wallTypeId,
|
||
height,
|
||
...(referenceLine != null ? { referenceLine } : {}),
|
||
};
|
||
walls.push(wall);
|
||
}
|
||
|
||
return walls;
|
||
}
|
||
|
||
/**
|
||
* Bedingte-Dicken-Regel: weist bestehenden Wänden einen neuen Wandtyp zu,
|
||
* wenn eine Bedingung erfüllt ist.
|
||
*
|
||
* Gibt MODIFIZIERTE KOPIEN der passenden Wände zurück (keine Mutation).
|
||
* Die Originalwände in `existingWalls` bleiben unverändert.
|
||
*
|
||
* @param rule - ConditionalThicknessRule-Parameter.
|
||
* @param ctx - Arbeitskontext (enthält die zu prüfenden Wände).
|
||
* @returns Wall[]-Array mit geändertem `wallTypeId` für passende Wände.
|
||
*/
|
||
export function applyConditionalThicknessRule(
|
||
rule: ConditionalThicknessRule,
|
||
ctx: RuleCtx,
|
||
): Wall[] {
|
||
return ctx.existingWalls
|
||
.filter((w) => matchesCondition(w, rule.condition, ctx))
|
||
.map((w) => ({ ...w, id: makeWallId(`${ctx.floorId}-ct`), wallTypeId: rule.wallTypeId }));
|
||
}
|
||
|
||
/**
|
||
* Referenzlinien-Regel: setzt `referenceLine` bei passenden Wänden einheitlich.
|
||
*
|
||
* Gibt MODIFIZIERTE KOPIEN der passenden Wände zurück.
|
||
*
|
||
* @param rule - ReferenceLineRule-Parameter.
|
||
* @param ctx - Arbeitskontext.
|
||
* @returns Wall[]-Array mit gesetzter `referenceLine`.
|
||
*/
|
||
export function applyReferenceLineRule(
|
||
rule: ReferenceLineRule,
|
||
ctx: RuleCtx,
|
||
): Wall[] {
|
||
return ctx.existingWalls
|
||
.filter((w) => matchesTarget(w, rule.target, ctx))
|
||
.map((w) => ({
|
||
...w,
|
||
id: makeWallId(`${ctx.floorId}-rl`),
|
||
referenceLine: rule.referenceLine,
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* Sequenz-Regel: führt Unterregeln in Reihenfolge aus.
|
||
*
|
||
* Jede Unterregel erhält das bisherige Ergebnis als `existingWalls`, sodass
|
||
* spätere Regeln die früheren verfeinern können (z. B. Raster → Dicke → Linie).
|
||
* Mit `stopOnMatch=true` bricht die Sequenz nach dem ersten produktiven Schritt ab.
|
||
*
|
||
* @param rule - SequenceRule-Parameter (enthält `rules[]`).
|
||
* @param ctx - Arbeitskontext.
|
||
* @returns Wall[]-Array (Summe aller Unterregel-Ausgaben, oder Abbruch bei stopOnMatch).
|
||
*/
|
||
export function applySequenceRule(rule: SequenceRule, ctx: RuleCtx): Wall[] {
|
||
let result: Wall[] = [];
|
||
|
||
for (const subrule of rule.rules) {
|
||
const subruleCtx: RuleCtx = {
|
||
...ctx,
|
||
existingWalls: [...ctx.existingWalls, ...result],
|
||
};
|
||
const subruleWalls = applyRule(subrule, subruleCtx);
|
||
result = [...result, ...subruleWalls];
|
||
|
||
if (rule.stopOnMatch === true && subruleWalls.length > 0) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// ── Hilfsfunktionen ───────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Entfernt doppelte Wände aus der generierten Liste.
|
||
*
|
||
* Zwei Wände gelten als Duplikat, wenn Start- und Endpunkt jeweils innerhalb
|
||
* `tolerance` (Meter) übereinstimmen — sowohl in der gleichen als auch in der
|
||
* umgekehrten Orientierung (A→B = B→A).
|
||
*
|
||
* Behält jeweils die ERSTE Instanz; spätere Duplikate werden verworfen.
|
||
*
|
||
* @param walls - Eingabe-Wall[]-Array (wird nicht mutiert).
|
||
* @param tolerance - Abstandsschwelle in Metern (Default 0.01 m = 1 cm).
|
||
* @returns Bereinigte Wall[]-Liste ohne Duplikate.
|
||
*/
|
||
export function deduplicateWalls(walls: Wall[], tolerance = 0.01): Wall[] {
|
||
const unique: Wall[] = [];
|
||
|
||
for (const candidate of walls) {
|
||
const isDuplicate = unique.some((existing) => {
|
||
const fwd =
|
||
dist2(candidate.start, existing.start) <= tolerance &&
|
||
dist2(candidate.end, existing.end) <= tolerance;
|
||
const rev =
|
||
dist2(candidate.start, existing.end) <= tolerance &&
|
||
dist2(candidate.end, existing.start) <= tolerance;
|
||
return fwd || rev;
|
||
});
|
||
|
||
if (!isDuplicate) {
|
||
unique.push(candidate);
|
||
}
|
||
}
|
||
|
||
return unique;
|
||
}
|
||
|
||
/**
|
||
* Prüft, ob eine Wand die Bedingung einer ConditionalThicknessRule erfüllt.
|
||
*
|
||
* MVP-Implementierung:
|
||
* • „exterior" — Wand liegt am Rand der Bounding-Box des Kontexts
|
||
* (innerhalb einer großzügigen Toleranz).
|
||
* • „interior" — Gegenteil von „exterior".
|
||
* • „bearing" — Wand ist in der Primärrichtung (X oder Y) ausgerichtet
|
||
* (einfaches Heuristikum für MVP).
|
||
* • Sonstige — immer `false` (Phase 3: Wall.tags[]).
|
||
*
|
||
* @param wall - Zu prüfende Wand.
|
||
* @param condition - Bedingungsstring aus der Regel.
|
||
* @param ctx - Arbeitskontext (enthält Grenzgeometrie).
|
||
* @returns `true`, wenn die Bedingung zutrifft.
|
||
*/
|
||
export function matchesCondition(
|
||
wall: Wall,
|
||
condition: string,
|
||
ctx: RuleCtx,
|
||
): boolean {
|
||
if (condition === "exterior") {
|
||
return isExteriorWall(wall, ctx);
|
||
}
|
||
if (condition === "interior") {
|
||
return !isExteriorWall(wall, ctx);
|
||
}
|
||
if (condition === "bearing") {
|
||
// Heuristikum: Wand ist „tragend", wenn sie in X- oder Y-Richtung läuft
|
||
// (nahezu horizontal/vertikal). Phase 3: strukturelle Klassifizierung.
|
||
const dx = Math.abs(wall.end.x - wall.start.x);
|
||
const dy = Math.abs(wall.end.y - wall.start.y);
|
||
const len = Math.sqrt(dx * dx + dy * dy);
|
||
if (len < 1e-6) return false;
|
||
const angleFromX = Math.atan2(dy, dx);
|
||
// Gilt als tragend, wenn Winkel innerhalb 10° von X- oder Y-Achse liegt.
|
||
const tenDeg = (10 * Math.PI) / 180;
|
||
return (
|
||
angleFromX <= tenDeg ||
|
||
angleFromX >= Math.PI / 2 - tenDeg
|
||
);
|
||
}
|
||
// Unbekannte Bedingung — Phase 3: Tag-Matching.
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Prüft, ob eine Wand dem Ziel einer ReferenceLineRule entspricht.
|
||
*
|
||
* @param wall - Zu prüfende Wand.
|
||
* @param target - Zielstring aus der Regel.
|
||
* @param ctx - Arbeitskontext.
|
||
* @returns `true`, wenn die Wand dem Ziel entspricht.
|
||
*/
|
||
export function matchesTarget(
|
||
wall: Wall,
|
||
target: string,
|
||
ctx: RuleCtx,
|
||
): boolean {
|
||
if (target === "all") return true;
|
||
if (target === "exterior") return isExteriorWall(wall, ctx);
|
||
// Unbekanntes Ziel — Phase 3: Tag-Matching.
|
||
return false;
|
||
}
|
||
|
||
// ── Interne Hilfsfunktionen ───────────────────────────────────────────────
|
||
|
||
/** Euklidischer Abstand zweier 2D-Punkte. */
|
||
function dist2(a: Vec2, b: Vec2): number {
|
||
const dx = a.x - b.x;
|
||
const dy = a.y - b.y;
|
||
return Math.sqrt(dx * dx + dy * dy);
|
||
}
|
||
|
||
/**
|
||
* Berechnet die Bounding-Box des Kontexts.
|
||
* Nutzt `boundaryGeometry`, falls vorhanden; sonst einen Standardbereich,
|
||
* der auf `spacing` basiert (0 … spacing × 10).
|
||
*/
|
||
function computeBounds(
|
||
context: ParametricContext,
|
||
spacing: number,
|
||
): { minX: number; maxX: number; minY: number; maxY: number } {
|
||
if (context.boundaryGeometry != null && context.boundaryGeometry.boundary.length >= 2) {
|
||
const pts = context.boundaryGeometry.boundary;
|
||
let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
|
||
for (const p of pts) {
|
||
if (p.x < minX) minX = p.x;
|
||
if (p.x > maxX) maxX = p.x;
|
||
if (p.y < minY) minY = p.y;
|
||
if (p.y > maxY) maxY = p.y;
|
||
}
|
||
return { minX, maxX, minY, maxY };
|
||
}
|
||
// Standardbereich: 10 Einheiten × Spacing.
|
||
const extent = spacing * 10;
|
||
return { minX: 0, maxX: extent, minY: 0, maxY: extent };
|
||
}
|
||
|
||
/**
|
||
* Generiert gleichmäßig verteilte Achspositionen im Intervall [min, max].
|
||
* Die erste Position liegt bei `min`, jede weitere `spacing` danach.
|
||
* Enthält `max`, wenn dieser exakt auf einem Rasterpunkt liegt (±1e-6).
|
||
*/
|
||
function generateAxisPositions(min: number, max: number, spacing: number): number[] {
|
||
if (spacing <= 0 || max <= min) return [];
|
||
const positions: number[] = [];
|
||
let pos = min;
|
||
while (pos <= max + 1e-6) {
|
||
positions.push(Math.round(pos * 1e6) / 1e6); // Rundungsfehler vermeiden
|
||
pos += spacing;
|
||
}
|
||
return positions;
|
||
}
|
||
|
||
/**
|
||
* Klassifiziert eine Wand als „außen" (Rand der Bounding-Box) oder „innen".
|
||
*
|
||
* MVP: Eine Wand gilt als außen, wenn BEIDE ihrer Endpunkte auf oder nahe
|
||
* am Rand der Bounding-Box des Kontexts liegen (±`edgeTolerance`).
|
||
*/
|
||
function isExteriorWall(wall: Wall, ctx: RuleCtx): boolean {
|
||
const { minX, maxX, minY, maxY } = computeBounds(ctx.context, 1.0);
|
||
const edgeTol = 0.1; // 10 cm Toleranz am Rand.
|
||
|
||
const isOnEdge = (p: Vec2): boolean =>
|
||
Math.abs(p.x - minX) <= edgeTol ||
|
||
Math.abs(p.x - maxX) <= edgeTol ||
|
||
Math.abs(p.y - minY) <= edgeTol ||
|
||
Math.abs(p.y - maxY) <= edgeTol;
|
||
|
||
return isOnEdge(wall.start) && isOnEdge(wall.end);
|
||
}
|
||
|
||
// ── Re-Export der Kontexttypen für Unit-Tests / Integration ──────────────
|
||
// (ermöglicht Import ohne Direktverweis auf interne RuleCtx)
|
||
export type { ParametricContext as ResolveContext };
|
||
|
||
// DrawingLevel-Re-Export für Konsumenten, die keinen eigenen types-Import wollen.
|
||
export type { DrawingLevel };
|