369 lines
15 KiB
TypeScript
369 lines
15 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
|
import ClipperLib from 'clipper-lib';
|
|
import { planFlooring } from '../src/lib/flooring';
|
|
import { buildGeometry, insetPolygon, signedArea } from '../src/lib/geometry';
|
|
import { fireplace, rectangle } from '../src/lib/defaults';
|
|
import { flooringCuts } from '../src/lib/cut-list';
|
|
import type { FlooringPlan, FlooringSettings, Point, Room } from '../src/lib/types';
|
|
|
|
const settings: FlooringSettings = {
|
|
length: 1200,
|
|
width: 200,
|
|
gap: 10,
|
|
pattern: 'brick',
|
|
minOffset: 300,
|
|
maxOffset: 600,
|
|
minLength: 200,
|
|
minWidth: 60,
|
|
kerf: 3,
|
|
};
|
|
function room(width = 4020, height = 2220, id = '1'): Room {
|
|
const result = rectangle(id, `Room ${id}`, width, height);
|
|
result.walls.forEach((wall) => {
|
|
wall.doors = [];
|
|
});
|
|
return result;
|
|
}
|
|
function errors(plan: FlooringPlan) {
|
|
return plan.issues.filter((issue) => issue.severity === 'error');
|
|
}
|
|
function overlap(a: Point[], b: Point[]): number {
|
|
const clipper = new ClipperLib.Clipper();
|
|
const path = (points: Point[]) =>
|
|
points.map((p) => ({ X: Math.round(p.x * 1000), Y: Math.round(p.y * 1000) }));
|
|
clipper.AddPath(path(a), ClipperLib.PolyType.ptSubject, true);
|
|
clipper.AddPath(path(b), ClipperLib.PolyType.ptClip, true);
|
|
const result: ClipperLib.Paths = [];
|
|
clipper.Execute(ClipperLib.ClipType.ctIntersection, result);
|
|
return result.reduce((sum, polygon) => sum + Math.abs(ClipperLib.Clipper.Area(polygon)) / 1e6, 0);
|
|
}
|
|
function expectCoverage(plan: FlooringPlan, r: Room, gap: number) {
|
|
const inset = insetPolygon(buildGeometry(r, 1).vertices, gap);
|
|
const expectedArea = inset.reduce((sum, p) => sum + Math.abs(signedArea(p)), 0);
|
|
const pieces = plan.pieces.filter((p) => p.roomId === r.id);
|
|
// Clipping rounds intersections to 0.001 mm; permit less than 1 mm² area drift.
|
|
expect(
|
|
Math.abs(pieces.reduce((sum, p) => sum + Math.abs(signedArea(p.polygon)), 0) - expectedArea),
|
|
).toBeLessThan(1);
|
|
for (let i = 0; i < pieces.length; i++) {
|
|
expect(
|
|
Math.abs(
|
|
inset.reduce((sum, p) => sum + overlap(pieces[i].polygon, p), 0) -
|
|
Math.abs(signedArea(pieces[i].polygon)),
|
|
),
|
|
).toBeLessThan(1);
|
|
for (let j = i + 1; j < pieces.length; j++)
|
|
expect(overlap(pieces[i].polygon, pieces[j].polygon)).toBeLessThan(0.01);
|
|
}
|
|
}
|
|
function expectStockFits(plan: FlooringPlan, s: FlooringSettings) {
|
|
const ids = plan.pieces.map((piece) => piece.id);
|
|
expect(new Set(ids).size).toBe(ids.length);
|
|
expect(plan.stocks.flatMap((stock) => stock.pieceIds).sort()).toEqual([...ids].sort());
|
|
for (const stock of plan.stocks) {
|
|
const pieces = stock.pieceIds.map((id) => plan.pieces.find((piece) => piece.id === id)!);
|
|
const used = pieces.reduce((sum, piece) => sum + piece.length, 0);
|
|
expect(used + Math.max(0, pieces.length - 1) * s.kerf).toBeLessThanOrEqual(s.length + 0.02);
|
|
expect(stock.remaining).toBeGreaterThanOrEqual(0);
|
|
expect(used + stock.remaining).toBeLessThanOrEqual(s.length + 0.02);
|
|
}
|
|
}
|
|
function expectOffsets(plan: FlooringPlan, s: FlooringSettings) {
|
|
for (let i = 1; i < plan.rows.length; i++) {
|
|
const a = plan.rows[i - 1],
|
|
b = plan.rows[i];
|
|
if (a.roomId !== b.roomId) continue;
|
|
const difference = Math.abs(a.offset - b.offset);
|
|
const distance = Math.min(difference, s.length - difference);
|
|
expect(distance).toBeGreaterThanOrEqual(s.minOffset - 0.01);
|
|
expect(distance).toBeLessThanOrEqual(s.maxOffset + 0.01);
|
|
}
|
|
}
|
|
|
|
describe('laminate planning', () => {
|
|
it('covers a rectangle exactly, without overlap, and stays inside its expansion gap', () => {
|
|
const r = room();
|
|
const plan = planFlooring([r], settings, 1);
|
|
expect(errors(plan)).toEqual([]);
|
|
expect(plan.coveredArea).toBe(4000 * 2200);
|
|
expectCoverage(plan, r, settings.gap);
|
|
expect(
|
|
plan.pieces.every((p) => p.length >= settings.minLength && p.width >= settings.minWidth),
|
|
).toBe(true);
|
|
expectOffsets(plan, settings);
|
|
expectStockFits(plan, settings);
|
|
});
|
|
|
|
it('splits a narrow remainder between first and last rows', () => {
|
|
const plan = planFlooring([room(4020, 2040)], settings, 1);
|
|
expect(errors(plan)).toEqual([]);
|
|
expect(plan.rows).toHaveLength(11);
|
|
expect(plan.rows[0].width).toBe(110);
|
|
expect(plan.rows.at(-1)?.width).toBe(110);
|
|
expect(plan.rows.slice(1, -1).every((row) => row.width === 200)).toBe(true);
|
|
expect(
|
|
plan.pieces.filter((piece) => piece.row === 1).every((piece) => piece.ripEdge === 'top'),
|
|
).toBe(true);
|
|
expect(
|
|
plan.pieces.filter((piece) => piece.row === 11).every((piece) => piece.ripEdge === 'bottom'),
|
|
).toBe(true);
|
|
});
|
|
|
|
it('rejects impossible edge widths instead of ripping factory joints off middle rows', () => {
|
|
const plan = planFlooring([room(4020, 450)], { ...settings, minWidth: 120 }, 1);
|
|
expect(plan.boardCount).toBe(0);
|
|
expect(errors(plan)[0].message).toContain('minimum row width');
|
|
});
|
|
|
|
it('reuses offcuts without double counting stock or ignoring saw kerf', () => {
|
|
const r = room(4020, 2020);
|
|
const plan = planFlooring([r], settings, 1);
|
|
expect(errors(plan)).toEqual([]);
|
|
expect(plan.reusedCount).toBeGreaterThan(0);
|
|
expectStockFits(plan, settings);
|
|
// A 600 mm starter and 600 mm finisher cannot share a 1200 mm board with a 3 mm kerf.
|
|
for (const stock of plan.stocks) {
|
|
const lengths = stock.pieceIds.map((id) => plan.pieces.find((p) => p.id === id)!.length);
|
|
expect(lengths.filter((length) => Math.abs(length - 600) < 0.01).length).toBeLessThan(2);
|
|
}
|
|
expect(plan.boardCount).toBeGreaterThanOrEqual(
|
|
Math.ceil(plan.coveredArea / (settings.length * settings.width)),
|
|
);
|
|
expect(plan.wasteArea).toBeCloseTo(
|
|
plan.boardCount * settings.length * settings.width - plan.coveredArea,
|
|
2,
|
|
);
|
|
});
|
|
|
|
it('does not reuse a cut end where an interior board needs two factory ends', () => {
|
|
const plan = planFlooring([room()], settings, 1);
|
|
for (const row of plan.rows) {
|
|
const pieces = row.pieceIds
|
|
.map((id) => plan.pieces.find((piece) => piece.id === id)!)
|
|
.sort((a, b) => a.column - b.column);
|
|
for (const interior of pieces.slice(1, -1)) {
|
|
expect(interior.length).toBe(settings.length);
|
|
expect(interior.reused).toBe(false);
|
|
expect(interior.factoryLeft).toBe(true);
|
|
expect(interior.factoryRight).toBe(true);
|
|
}
|
|
}
|
|
});
|
|
|
|
it('produces exact concave fireplace templates and keeps the gap at its external corners', () => {
|
|
const r = fireplace('fire', 'Fireplace room');
|
|
const plan = planFlooring([r], { ...settings, width: 190 }, 1);
|
|
expect(errors(plan)).toEqual([]);
|
|
expectCoverage(plan, r, settings.gap);
|
|
expect(plan.pieces.some((piece) => piece.shaped)).toBe(true);
|
|
for (const piece of plan.pieces) {
|
|
expect(
|
|
piece.template.every(
|
|
(p) =>
|
|
p.x >= -0.01 && p.y >= -0.01 && p.x <= piece.length + 0.01 && p.y <= piece.width + 0.01,
|
|
),
|
|
).toBe(true);
|
|
}
|
|
expectStockFits(plan, { ...settings, width: 190 });
|
|
});
|
|
|
|
it('clips an angled wall exactly and provides shaped cut coordinates', () => {
|
|
const points = [
|
|
{ x: 0, y: 0 },
|
|
{ x: 4000, y: 0 },
|
|
{ x: 4200, y: 2200 },
|
|
{ x: 0, y: 2200 },
|
|
];
|
|
const headings = points.map(
|
|
(p, i) =>
|
|
(Math.atan2(
|
|
points[(i + 1) % points.length].y - p.y,
|
|
points[(i + 1) % points.length].x - p.x,
|
|
) *
|
|
180) /
|
|
Math.PI,
|
|
);
|
|
const r: Room = {
|
|
id: 'angled',
|
|
name: 'Angled room',
|
|
direction: 0,
|
|
walls: points.map((p, i) => ({
|
|
id: `w${i}`,
|
|
length: Math.hypot(
|
|
points[(i + 1) % points.length].x - p.x,
|
|
points[(i + 1) % points.length].y - p.y,
|
|
),
|
|
turn: ((headings[(i + 1) % points.length] - headings[i] + 540) % 360) - 180,
|
|
doors: [],
|
|
})),
|
|
};
|
|
const plan = planFlooring([r], settings, 1);
|
|
expect(errors(plan)).toEqual([]);
|
|
expectCoverage(plan, r, settings.gap);
|
|
expect(plan.pieces.filter((piece) => piece.shaped).length).toBeGreaterThan(2);
|
|
expectStockFits(plan, settings);
|
|
});
|
|
|
|
it('gives identical random plans for identical input and respects both stagger limits', () => {
|
|
const s = { ...settings, pattern: 'random' as const, minOffset: 250, maxOffset: 450 };
|
|
const a = planFlooring([room()], s, 1);
|
|
expect(errors(a)).toEqual([]);
|
|
expect(a).toEqual(planFlooring([room()], s, 1));
|
|
expect(new Set(a.rows.map((row) => row.offset)).size).toBeGreaterThan(2);
|
|
expectOffsets(a, s);
|
|
expectStockFits(a, s);
|
|
expectCoverage(a, room(), s.gap);
|
|
});
|
|
|
|
it.each([
|
|
['rectangle', room(4800, 3600, 'room-1'), 76, 42],
|
|
['fireplace', fireplace('room-2', 'Fireplace room'), 74, 48],
|
|
] as const)(
|
|
'breaks random staircases and near-brick repeats in a common %s',
|
|
(_, r, boardBudget, cutBudget) => {
|
|
const s = { ...settings, width: 190, pattern: 'random' as const };
|
|
const plan = planFlooring([r], s, 1);
|
|
expect(errors(plan)).toEqual([]);
|
|
expect(plan).toEqual(planFlooring([r], s, 1));
|
|
const phases = plan.rows.map((row) => row.offset);
|
|
const signedDistance = (a: number, b: number) => {
|
|
let difference = b - a;
|
|
if (difference >= s.length / 2) difference -= s.length;
|
|
if (difference < -s.length / 2) difference += s.length;
|
|
return difference;
|
|
};
|
|
const steps = phases.slice(1).map((phase, i) => signedDistance(phases[i], phase));
|
|
// This case actually crosses the board boundary, so checking raw differences would miss steps.
|
|
expect(
|
|
phases.some((phase, i) => i > 0 && Math.abs(phase - phases[i - 1]) > s.length / 2),
|
|
).toBe(true);
|
|
for (let i = 1; i < steps.length; i++) {
|
|
// Similar signed steps across three rows produce a visible staircase, even with small kerf drift.
|
|
expect(Math.abs(steps[i] - steps[i - 1])).toBeGreaterThan(36);
|
|
// Returning to almost the same joint line two rows later produces an H/brick repeat.
|
|
expect(Math.abs(signedDistance(phases[i - 1], phases[i + 1]))).toBeGreaterThan(36);
|
|
}
|
|
for (let i = 2; i < steps.length; i++) {
|
|
expect(
|
|
steps.slice(i - 2, i + 1).every((step) => step > 0) ||
|
|
steps.slice(i - 2, i + 1).every((step) => step < 0),
|
|
).toBe(false);
|
|
}
|
|
// Breaking the old regular pattern must not increase the stock requirement for these rooms.
|
|
expect(plan.boardCount).toBeLessThanOrEqual(boardBudget);
|
|
expect(plan.cuts).toBeLessThanOrEqual(cutBudget);
|
|
expect(plan.reusedCount).toBeGreaterThan(0);
|
|
expect(
|
|
plan.pieces.every((piece) => piece.length >= s.minLength && piece.width >= s.minWidth),
|
|
).toBe(true);
|
|
expectOffsets(plan, s);
|
|
expectStockFits(plan, s);
|
|
expectCoverage(plan, r, s.gap);
|
|
},
|
|
);
|
|
|
|
it('keeps a constrained random layout valid when only alternating starts can fit', () => {
|
|
const r = room(2420, 1620);
|
|
const s = { ...settings, pattern: 'random' as const, minLength: 600 };
|
|
const plan = planFlooring([r], s, 1);
|
|
expect(errors(plan)).toEqual([]);
|
|
expect(plan.rows).toHaveLength(8);
|
|
expect(new Set(plan.rows.map((row) => row.offset))).toEqual(new Set([0, 600]));
|
|
expect(plan.rows[0].offset).toBe(plan.rows[2].offset);
|
|
expectOffsets(plan, s);
|
|
expectStockFits(plan, s);
|
|
expectCoverage(plan, r, s.gap);
|
|
});
|
|
|
|
it.each([400, 600])(
|
|
'respects an exact %i mm random offset even when repetition is unavoidable',
|
|
(offset) => {
|
|
const s = { ...settings, pattern: 'random' as const, minOffset: offset, maxOffset: offset };
|
|
const plan = planFlooring([room()], s, 1);
|
|
expect(errors(plan)).toEqual([]);
|
|
expect(plan).toEqual(planFlooring([room()], s, 1));
|
|
expectOffsets(plan, s);
|
|
expectStockFits(plan, s);
|
|
},
|
|
);
|
|
|
|
it('rejects impossible brick stagger constraints', () => {
|
|
const plan = planFlooring([room()], { ...settings, maxOffset: 400 }, 1);
|
|
expect(plan.boardCount).toBe(0);
|
|
expect(errors(plan)[0].message).toContain('half-board');
|
|
});
|
|
|
|
it('plans each room independently and can reuse compatible end offcuts across directions', () => {
|
|
const a = room(1820, 1220, '1');
|
|
const b = room(1220, 1820, '2');
|
|
b.direction = 90;
|
|
const combined = planFlooring([a, b], settings, 1);
|
|
const separately =
|
|
planFlooring([a], settings, 1).boardCount + planFlooring([b], settings, 1).boardCount;
|
|
expect(errors(combined)).toEqual([]);
|
|
expect(combined.boardCount).toBeLessThanOrEqual(separately);
|
|
expect(
|
|
combined.stocks.some(
|
|
(stock) =>
|
|
new Set(stock.pieceIds.map((id) => combined.pieces.find((p) => p.id === id)!.roomId))
|
|
.size > 1,
|
|
),
|
|
).toBe(true);
|
|
expectCoverage(combined, a, settings.gap);
|
|
expectCoverage(combined, b, settings.gap);
|
|
expectStockFits(combined, settings);
|
|
expectOffsets(combined, settings);
|
|
});
|
|
|
|
it('reports an unclosed room and never counts a partial floor', () => {
|
|
const r = room();
|
|
r.walls[0].length += 100;
|
|
const plan = planFlooring([r], settings, 1);
|
|
expect(plan.boardCount).toBe(0);
|
|
expect(plan.pieces).toEqual([]);
|
|
expect(errors(plan)[0].message).toContain('closed outline');
|
|
});
|
|
|
|
it('rejects zero and nonfinite settings without unbounded loops', () => {
|
|
expect(errors(planFlooring([room()], { ...settings, width: 0 }, 1))).toHaveLength(1);
|
|
const nonfinite = planFlooring([room()], { ...settings, length: NaN }, 1);
|
|
expect(errors(nonfinite)).toHaveLength(1);
|
|
expect(nonfinite.wasteArea).toBe(0);
|
|
expect(errors(planFlooring([room()], { ...settings, length: 1e308 }, 1))).toHaveLength(1);
|
|
expect(
|
|
errors(planFlooring([room()], { ...settings, width: 0.001, minWidth: 0.001 }, 1)),
|
|
).toHaveLength(1);
|
|
});
|
|
|
|
it('numbers cuts and ready offcuts continuously while preserving all row and stock references', () => {
|
|
const s = { ...settings, pattern: 'random' as const, minOffset: 250, maxOffset: 450 };
|
|
const plan = planFlooring([room()], s, 1);
|
|
const cuts = flooringCuts(plan);
|
|
expect(plan.pieces.length).toBeGreaterThan(cuts.length);
|
|
expect(cuts.some((piece) => piece.reused && !piece.cut)).toBe(true);
|
|
expect(cuts.map((piece) => piece.id)).toEqual(cuts.map((_, index) => `F${index + 1}`));
|
|
expect(
|
|
plan.pieces
|
|
.filter((piece) => !piece.cut && !piece.reused)
|
|
.every((piece) => piece.id.startsWith('FU')),
|
|
).toBe(true);
|
|
const ids = plan.pieces.map((piece) => piece.id);
|
|
expect(plan.rows.flatMap((row) => row.pieceIds).sort()).toEqual([...ids].sort());
|
|
expectStockFits(plan, s);
|
|
});
|
|
|
|
it('scopes room failures and shape warnings without scoping global material errors', () => {
|
|
const valid = room(4020, 2220, 'valid');
|
|
const open = room(4020, 2220, 'open');
|
|
open.walls[0].length += 100;
|
|
const shaped = fireplace('shaped', 'Fireplace room');
|
|
const plan = planFlooring([valid, open, shaped], { ...settings, width: 190 }, 1);
|
|
expect(plan.pieces.some((piece) => piece.roomId === valid.id)).toBe(true);
|
|
expect(plan.pieces.some((piece) => piece.roomId === open.id)).toBe(false);
|
|
expect(errors(plan).map((issue) => issue.roomId)).toEqual(['open']);
|
|
expect(
|
|
plan.issues.filter((issue) => issue.severity === 'warning').map((issue) => issue.roomId),
|
|
).toEqual(['shaped']);
|
|
expect(errors(planFlooring([valid], { ...settings, width: 0 }, 1))[0].roomId).toBeUndefined();
|
|
});
|
|
});
|