Dach im Vertikalschnitt: analytischer TS-Schnitt inkl. Schicht-Bändern
toSection behandelte Dächer bislang gar nicht (der Rust-Extraktor kennt nur Wände + Decken). appendRoofSections schneidet die Schnittebene jetzt TS-seitig mit den Dachflächen: Grundriss-Spur der Ebene per Cyrus–Beck gegen jedes konvexe Aufsichts-Polygon der Dachflächen geclippt → u-Intervall; Oberkante v(u) linear aus der Ebenengleichung (Newell), Unterkante um lotrechte Dicke / cos(Neigung) tiefer. Mehrschichtige Dächer (roofLayers) werden wie beim Decken-Schnitt in Bänder aussen→innen zerlegt, jedes mit Bauteil-Schraffur (Papier-Neutralisierung wie resolveCeilingSectionStyle). SectionComponentRef um 'roof' erweitert; attachCutStyles reicht Dach-Bänder unverändert durch (Stile vorab aufgelöst, keine Boolean-Dominanz). Bewusst nur SCHNITT-Polygone — Ansichts-/Silhouettenkanten des Dachs sind eine eigene Phase. +4 analytische Tests. 689/689 grün.
This commit is contained in:
@@ -0,0 +1,144 @@
|
||||
// Dach im Vertikalschnitt: appendRoofSections schneidet die Schnittebene
|
||||
// analytisch mit den Dachflächen (der Rust-Extraktor kennt nur Wände/Decken).
|
||||
// Geprüft werden u-Intervalle, Oberkanten-Verlauf (linear je Fläche), die
|
||||
// vertikale Dicke (lotrechte Dicke / cos(Neigung)) und die Schicht-Bänder.
|
||||
|
||||
import { describe, it, expect } from "vitest";
|
||||
import { appendRoofSections } from "./toSection";
|
||||
import type { SectionOutput, SectionPlaneSpec } from "./toSection";
|
||||
import type { Project, Roof } from "../model/types";
|
||||
|
||||
const RECT: Roof["outline"] = [
|
||||
{ x: -3, y: 0 },
|
||||
{ x: 3, y: 0 },
|
||||
{ x: 3, y: 4 },
|
||||
{ x: -3, y: 4 },
|
||||
];
|
||||
|
||||
function roof(over: Partial<Roof> = {}): Roof {
|
||||
return {
|
||||
id: "R1",
|
||||
type: "roof",
|
||||
floorId: "eg",
|
||||
categoryCode: "35",
|
||||
outline: RECT,
|
||||
shape: "sattel",
|
||||
pitchDeg: 30,
|
||||
overhang: 0,
|
||||
ridgeAxis: "x",
|
||||
baseElevation: 5, // explizit — kein Geschoss-Lookup nötig
|
||||
thickness: 0.3,
|
||||
...over,
|
||||
};
|
||||
}
|
||||
|
||||
function project(r: Roof, extra: Partial<Project> = {}): Project {
|
||||
return {
|
||||
id: "t",
|
||||
name: "T",
|
||||
lineStyles: [],
|
||||
hatches: [],
|
||||
components: [],
|
||||
wallTypes: [],
|
||||
drawingLevels: [],
|
||||
layers: [],
|
||||
walls: [],
|
||||
doors: [],
|
||||
roofs: [r],
|
||||
...extra,
|
||||
} as unknown as Project;
|
||||
}
|
||||
|
||||
/** Schnittebene: Blick entlang +x, Spur = Modell-Gerade x=0 (u wächst mit y). */
|
||||
const PLANE: SectionPlaneSpec = { point: [0, 0, 0], normal: [1, 0, 0] };
|
||||
|
||||
const emptyOutput = (): SectionOutput => ({ cutPolygons: [], visibleEdges: [], hiddenEdges: [] });
|
||||
|
||||
describe("appendRoofSections", () => {
|
||||
it("Flachdach: EIN Rechteck-Band, Oberkante = Traufhöhe, Höhe = Dicke", () => {
|
||||
const out = emptyOutput();
|
||||
appendRoofSections(out, project(roof({ shape: "flach", pitchDeg: 0 })), PLANE);
|
||||
expect(out.cutPolygons.length).toBe(1);
|
||||
const cp = out.cutPolygons[0];
|
||||
expect(cp.component).toEqual({ kind: "roof", index: 0 });
|
||||
// u-Intervall = Tiefe 0..4; Oberkante 5, Unterkante 5 − 0.3 (cosθ = 1).
|
||||
const us = cp.pts.map((p) => p[0]).sort((a, b) => a - b);
|
||||
expect(us[0]).toBeCloseTo(0, 6);
|
||||
expect(us[3]).toBeCloseTo(4, 6);
|
||||
const vs = cp.pts.map((p) => p[1]).sort((a, b) => a - b);
|
||||
expect(vs[3]).toBeCloseTo(5, 6);
|
||||
expect(vs[0]).toBeCloseTo(5 - 0.3, 6);
|
||||
});
|
||||
|
||||
it("Satteldach quer zum First: zwei Bänder (steigend/fallend) mit Neigungs-Dicke", () => {
|
||||
const out = emptyOutput();
|
||||
appendRoofSections(out, project(roof()), PLANE);
|
||||
expect(out.cutPolygons.length).toBe(2);
|
||||
const tan30 = Math.tan((30 * Math.PI) / 180);
|
||||
const cos30 = Math.cos((30 * Math.PI) / 180);
|
||||
const ridgeZ = 5 + 2 * tan30; // First bei halber Tiefe (y=2)
|
||||
// Alle Oberkanten-Werte je Band: an u=0/4 Traufe (5), an u=2 First.
|
||||
const topAt = (cp: (typeof out.cutPolygons)[number], u: number): number =>
|
||||
Math.max(...cp.pts.filter((p) => Math.abs(p[0] - u) < 1e-6).map((p) => p[1]));
|
||||
const bands = out.cutPolygons;
|
||||
const front = bands.find((b) => b.pts.some((p) => Math.abs(p[0]) < 1e-6));
|
||||
const back = bands.find((b) => b.pts.some((p) => Math.abs(p[0] - 4) < 1e-6));
|
||||
expect(front).toBeDefined();
|
||||
expect(back).toBeDefined();
|
||||
expect(topAt(front!, 0)).toBeCloseTo(5, 5);
|
||||
expect(topAt(front!, 2)).toBeCloseTo(ridgeZ, 5);
|
||||
expect(topAt(back!, 4)).toBeCloseTo(5, 5);
|
||||
expect(topAt(back!, 2)).toBeCloseTo(ridgeZ, 5);
|
||||
// Vertikale Banddicke = lotrechte Dicke / cos(Neigung).
|
||||
const vAt = (cp: (typeof out.cutPolygons)[number], u: number): number[] =>
|
||||
cp.pts.filter((p) => Math.abs(p[0] - u) < 1e-6).map((p) => p[1]);
|
||||
const [hi, lo] = vAt(front!, 0).sort((a, b) => b - a);
|
||||
expect(hi - lo).toBeCloseTo(0.3 / cos30, 5);
|
||||
});
|
||||
|
||||
it("Schnittspur ausserhalb des Dachs: keine Bänder", () => {
|
||||
const out = emptyOutput();
|
||||
// Spur x=0 — Dach komplett rechts davon (x 10..16).
|
||||
const far = roof({
|
||||
outline: [
|
||||
{ x: 10, y: 0 },
|
||||
{ x: 16, y: 0 },
|
||||
{ x: 16, y: 4 },
|
||||
{ x: 10, y: 4 },
|
||||
],
|
||||
});
|
||||
appendRoofSections(out, project(far), PLANE);
|
||||
expect(out.cutPolygons.length).toBe(0);
|
||||
});
|
||||
|
||||
it("mehrschichtiges Dach (roofTypeId): je Schicht ein Band pro Fläche, aussen oben", () => {
|
||||
const p = project(roof({ shape: "flach", pitchDeg: 0, roofTypeId: "rt1" }), {
|
||||
hatches: [
|
||||
{ id: "h1", name: "H", pattern: "diagonal", scale: 1, angle: 45, color: "#111111" },
|
||||
],
|
||||
components: [
|
||||
{ id: "tile", name: "Ziegel", color: "#a03a2a", hatchId: "h1", joinPriority: 1 },
|
||||
{ id: "ins", name: "Dämmung", color: "#ffffff", hatchId: "h1", joinPriority: 2 },
|
||||
],
|
||||
roofTypes: [
|
||||
{
|
||||
id: "rt1",
|
||||
name: "Aufbau",
|
||||
layers: [
|
||||
{ componentId: "tile", thickness: 0.05 },
|
||||
{ componentId: "ins", thickness: 0.25 },
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
const out = emptyOutput();
|
||||
appendRoofSections(out, p, PLANE);
|
||||
expect(out.cutPolygons.length).toBe(2); // 1 Fläche × 2 Schichten
|
||||
const tops = out.cutPolygons.map((cp) => Math.max(...cp.pts.map((q) => q[1])));
|
||||
// Eindeckung oben (OK 5), Dämmung darunter (OK 5 − 0.05).
|
||||
expect(Math.max(...tops)).toBeCloseTo(5, 6);
|
||||
expect(Math.min(...tops)).toBeCloseTo(4.95, 6);
|
||||
// Schicht-Stile sind aufgelöst (Schraffur des Bauteils).
|
||||
expect(out.cutPolygons.every((cp) => cp.hatch?.pattern === "diagonal")).toBe(true);
|
||||
});
|
||||
});
|
||||
+166
-2
@@ -18,10 +18,11 @@
|
||||
// v = absolute Höhe (world.y). Siehe src-tauri/render3d/src/section.rs.
|
||||
|
||||
import type { Ceiling, DrawingLevel, Project, Vec2, Wall } from "../model/types";
|
||||
import { getCeilingType, getComponent, getWallType, openingsOfWall } from "../model/types";
|
||||
import { getCeilingType, getComponent, getWallType, openingsOfWall, roofLayers } from "../model/types";
|
||||
import { ceilingVerticalExtent, wallVerticalExtent } from "../model/wall";
|
||||
import { dot, leftNormal, normalize, sub } from "../model/geometry";
|
||||
import { openingInterval, openingVerticalExtent } from "../geometry/opening";
|
||||
import { roofBaseElevation, roofGeometry } from "../geometry/roof";
|
||||
import { projectToModel3d } from "./toWalls3d";
|
||||
import { loadEngine3d } from "../engine/engine3d";
|
||||
import {
|
||||
@@ -36,7 +37,7 @@ import type { HatchRender } from "./generatePlan";
|
||||
|
||||
/** Bauteil-Referenz eines Cut-Polygons/einer Kante (Art + Eingabe-Index). */
|
||||
export interface SectionComponentRef {
|
||||
kind: "wall" | "slab";
|
||||
kind: "wall" | "slab" | "roof";
|
||||
index: number;
|
||||
}
|
||||
|
||||
@@ -289,6 +290,13 @@ function attachCutStyles(output: SectionOutput, project: Project, plane: Section
|
||||
const bands: SectionCutPolygon[] = [];
|
||||
for (const cp of output.cutPolygons) {
|
||||
const ref = cp.component;
|
||||
// Dach: Füllung/Schraffur sind bereits je Schicht in `appendRoofSections`
|
||||
// aufgelöst; keine Boolean-Dominanz (joinPriority undefined) — unverändert
|
||||
// übernehmen. WICHTIG vor dem Slab-Zweig (sonst falscher owner-Lookup).
|
||||
if (ref.kind === "roof") {
|
||||
bands.push(cp);
|
||||
continue;
|
||||
}
|
||||
if (ref.kind === "wall") {
|
||||
const owner = walls[ref.index];
|
||||
// Wand: bei mehrschichtigem Wandtyp wird das EINE geschnittene Rechteck in
|
||||
@@ -767,6 +775,160 @@ export function splitWallLayers(
|
||||
* und blendet einen Fallback ein (pkg3d muss dann über `npm run build:engine3d`
|
||||
* neu gebaut werden, damit `cut_section_json` verfügbar ist).
|
||||
*/
|
||||
/** Hex "#rrggbb" → RGB 0..1 (Fallback bei ungültigem Hex). */
|
||||
function hexToRgb01(hex: string, fallback: [number, number, number]): [number, number, number] {
|
||||
const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
|
||||
if (!m) return fallback;
|
||||
const v = parseInt(m[1], 16);
|
||||
return [((v >> 16) & 0xff) / 255, ((v >> 8) & 0xff) / 255, (v & 0xff) / 255];
|
||||
}
|
||||
|
||||
/** Default-Albedo geschnittener Dächer (wie ROOF_RGB im 3D). */
|
||||
const ROOF_CUT_RGB: [number, number, number] = [0.72, 0.45, 0.36];
|
||||
|
||||
/**
|
||||
* Schneidet die vertikale Schnittebene analytisch mit den DÄCHERN des Projekts
|
||||
* und hängt die Schnitt-Polygone an `output.cutPolygons` an — der Rust-Extraktor
|
||||
* (`cut_section_json`) kennt nur Wände + Decken, Dächer werden TS-seitig ergänzt.
|
||||
*
|
||||
* Vorgehen je Dach: die Grundriss-Spur der Schnittebene (Gerade durch
|
||||
* `plane.point`, Richtung u-Achse) wird gegen jede DACHFLÄCHE (konvexes Polygon
|
||||
* der Aufsicht, s. roofGeometry.planes) geclippt (Cyrus–Beck) → u-Intervall.
|
||||
* Die Oberkante v(u) ist auf dem Intervall LINEAR (Ebenengleichung); die
|
||||
* Unterkante liegt um die LOTRECHTE Dicke / cos(Flächenneigung) tiefer
|
||||
* (vertikale Dicke). Mehrschichtige Dächer (roofLayers) werden wie beim
|
||||
* Decken-Schnitt in Bänder von aussen (Eindeckung, oben) nach innen zerlegt,
|
||||
* jedes mit Füllung/Schraffur seines Bauteils (Neutralisierung wie
|
||||
* `resolveCeilingSectionStyle`: Papier-Hintergrund, solid → Tinte).
|
||||
*
|
||||
* Bewusst NUR Schnitt-Polygone (keine Ansichts-/Silhouettenkanten des Dachs
|
||||
* hinter der Ebene) — Ansicht/Elevation des Dachs bleibt eine eigene Phase.
|
||||
* Giebel (vertikale Endflächen) schneiden die vertikale Ebene nur in einer
|
||||
* Linie (keine Fläche) und entfallen.
|
||||
*/
|
||||
export function appendRoofSections(
|
||||
output: SectionOutput,
|
||||
project: Project,
|
||||
plane: SectionPlaneSpec,
|
||||
): void {
|
||||
const roofs = project.roofs ?? [];
|
||||
if (roofs.length === 0) return;
|
||||
// Grundriss-Spur: Basispunkt + u-Richtung (Modell-2D). world=[x,H,y] ⇒
|
||||
// plane.point[0]=x, plane.point[2]=y; u-Achse = (−nz, nx) (s. section.rs).
|
||||
const base: Vec2 = { x: plane.point[0], y: plane.point[2] };
|
||||
const uDir = sectionUAxisModel(plane);
|
||||
const EPS_U = 1e-6;
|
||||
|
||||
roofs.forEach((roof, index) => {
|
||||
const eavesZ = roofBaseElevation(project, roof);
|
||||
const geo = roofGeometry(roof, eavesZ);
|
||||
const layers = roofLayers(project, roof);
|
||||
const totalT = layers.reduce((s, l) => s + Math.max(0, l.thickness), 0);
|
||||
if (totalT <= 1e-9) return;
|
||||
|
||||
for (const pl of geo.planes) {
|
||||
const pts = pl.pts;
|
||||
if (pts.length < 3) continue;
|
||||
// Ebenengleichung z = z0 − (A(x−x0)+B(y−y0))/C über die Newell-Normale.
|
||||
let A = 0;
|
||||
let B = 0;
|
||||
let C = 0;
|
||||
for (let i = 0; i < pts.length; i++) {
|
||||
const c = pts[i];
|
||||
const d = pts[(i + 1) % pts.length];
|
||||
A += (c[1] - d[1]) * (c[2] + d[2]);
|
||||
B += (c[2] - d[2]) * (c[0] + d[0]);
|
||||
C += (c[0] - d[0]) * (c[1] + d[1]);
|
||||
}
|
||||
if (Math.abs(C) < 1e-9) continue; // (nahezu) vertikale Fläche — kein Flächenschnitt
|
||||
const nLen = Math.hypot(A, B, C);
|
||||
const cosTheta = Math.abs(C) / (nLen || 1);
|
||||
const zAt = (x: number, y: number): number =>
|
||||
pts[0][2] - (A * (x - pts[0][0]) + B * (y - pts[0][1])) / C;
|
||||
|
||||
// Cyrus–Beck: Gerade base + t·uDir gegen das konvexe Aufsichts-Polygon.
|
||||
// Orientierungsunabhängig: Innenseite je Kante über den Polygon-Schwerpunkt.
|
||||
let cx = 0;
|
||||
let cy = 0;
|
||||
for (const p of pts) {
|
||||
cx += p[0];
|
||||
cy += p[1];
|
||||
}
|
||||
cx /= pts.length;
|
||||
cy /= pts.length;
|
||||
let tLo = -Infinity;
|
||||
let tHi = Infinity;
|
||||
let outside = false;
|
||||
for (let i = 0; i < pts.length && !outside; i++) {
|
||||
const a = pts[i];
|
||||
const b = pts[(i + 1) % pts.length];
|
||||
// Kanten-Normale, zum Schwerpunkt orientiert (Innenseite).
|
||||
let ex = -(b[1] - a[1]);
|
||||
let ey = b[0] - a[0];
|
||||
if (ex * (cx - a[0]) + ey * (cy - a[1]) < 0) {
|
||||
ex = -ex;
|
||||
ey = -ey;
|
||||
}
|
||||
const denom = ex * uDir.x + ey * uDir.y;
|
||||
const dist = ex * (base.x - a[0]) + ey * (base.y - a[1]);
|
||||
if (Math.abs(denom) < 1e-12) {
|
||||
if (dist < -1e-9) outside = true; // parallel ausserhalb
|
||||
continue;
|
||||
}
|
||||
const t = -dist / denom;
|
||||
if (denom > 0) tLo = Math.max(tLo, t);
|
||||
else tHi = Math.min(tHi, t);
|
||||
}
|
||||
if (outside || tHi - tLo <= EPS_U) continue;
|
||||
|
||||
const q = (t: number): Vec2 => ({ x: base.x + t * uDir.x, y: base.y + t * uDir.y });
|
||||
const p0 = q(tLo);
|
||||
const p1 = q(tHi);
|
||||
const zTop0 = zAt(p0.x, p0.y);
|
||||
const zTop1 = zAt(p1.x, p1.y);
|
||||
|
||||
// Schicht-Bänder von aussen (oben) nach innen, vertikale Dicke je Schicht.
|
||||
let prefixV = 0;
|
||||
for (const layer of layers) {
|
||||
const t = Math.max(0, layer.thickness);
|
||||
if (t <= 1e-9) continue;
|
||||
const vT = t / Math.max(cosTheta, 1e-6);
|
||||
const top0 = zTop0 - prefixV;
|
||||
const top1 = zTop1 - prefixV;
|
||||
prefixV += vT;
|
||||
|
||||
let fill: string | undefined;
|
||||
let hatch: HatchRender | undefined;
|
||||
let color = ROOF_CUT_RGB;
|
||||
if (layer.componentId) {
|
||||
try {
|
||||
const comp = getComponent(project, layer.componentId);
|
||||
const h = resolveHatch(project, comp.hatchId);
|
||||
fill = h.pattern === "solid" ? HATCH_INK : HATCH_PAPER;
|
||||
hatch = h;
|
||||
color = hexToRgb01(comp.color, ROOF_CUT_RGB);
|
||||
} catch {
|
||||
fill = undefined;
|
||||
hatch = undefined;
|
||||
}
|
||||
}
|
||||
output.cutPolygons.push({
|
||||
component: { kind: "roof", index },
|
||||
color,
|
||||
pts: [
|
||||
[tLo, top0],
|
||||
[tHi, top1],
|
||||
[tHi, top1 - vT],
|
||||
[tLo, top0 - vT],
|
||||
],
|
||||
...(fill ? { fill } : {}),
|
||||
...(hatch ? { hatch } : {}),
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
export async function computeSection(
|
||||
project: Project,
|
||||
level: DrawingLevel,
|
||||
@@ -794,6 +956,8 @@ export async function computeSection(
|
||||
plane.normal[2],
|
||||
);
|
||||
const output = JSON.parse(json) as SectionOutput;
|
||||
// Dächer TS-seitig ergänzen (der Rust-Extraktor kennt nur Wände + Decken).
|
||||
appendRoofSections(output, project, plane);
|
||||
attachCutStyles(output, project, plane);
|
||||
return output;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user