Aislo/B07_DesignDetail/openwebcad/src/helpers/geometry/sample-entity.ts

/**
 * 엔티티를 점렬(폴리라인)로 펴는 순수 함수들.
 * 등분(DIVIDE)·길이분할(MEASURE)·경계(BOUNDARY)·해치가 모두 이 표현을 공유한다.
 */
import { Arc, Circle, Point, Polygon, Segment } from '@flatten-js/core';
import type { Entity } from '../../entities/Entity';
import { EntityName } from '../../entities/Entity';
import type { PolyLineEntity } from '../../entities/PolyLineEntity';
import { polygonToSegments } from '../polygon-to-segments';

const CURVE_SEGMENTS = 64;

/** 두 점이 사실상 같은 위치인지 (좌표 오차 허용) */
const samePoint = (a: Point, b: Point, tolerance = 1e-6): boolean =>
	Math.abs(a.x - b.x) <= tolerance && Math.abs(a.y - b.y) <= tolerance;

function sampleArc(arc: Arc, segments: number): Point[] {
	const points: Point[] = [];
	const sweep = arc.sweep * (arc.counterClockwise ? 1 : -1);
	// flatten-js 타입 선언이 반지름을 Number 객체로 잡아 두어 숫자로 되돌린다
	const radius = Number(arc.r);
	for (let index = 0; index <= segments; index++) {
		const angle = arc.startAngle + (sweep * index) / segments;
		points.push(
			new Point(arc.center.x + radius * Math.cos(angle), arc.center.y + radius * Math.sin(angle))
		);
	}
	return points;
}

function sampleCircle(circle: Circle, segments: number): Point[] {
	const points: Point[] = [];
	for (let index = 0; index <= segments; index++) {
		const angle = (2 * Math.PI * index) / segments;
		points.push(
			new Point(
				circle.center.x + circle.r * Math.cos(angle),
				circle.center.y + circle.r * Math.sin(angle)
			)
		);
	}
	return points;
}

/** 이어지는 중복점을 제거한다 (폴리선 이음매에서 생긴다) */
export function dedupeConsecutive(points: Point[]): Point[] {
	return points.filter((point, index) => index === 0 || !samePoint(point, points[index - 1]));
}

/** 엔티티 하나를 점렬로 편다. 곡선은 curveSegments 등분해 근사한다. */
export function sampleEntityPoints(entity: Entity, curveSegments = CURVE_SEGMENTS): Point[] {
	if (entity.getType() === EntityName.PolyLine) {
		const children = (entity as PolyLineEntity).getEntities();
		return dedupeConsecutive(children.flatMap((child) => sampleEntityPoints(child, curveSegments)));
	}

	const shape = entity.getShape();
	if (shape instanceof Segment) return [shape.start, shape.end];
	if (shape instanceof Arc) return sampleArc(shape, curveSegments);
	if (shape instanceof Circle) return sampleCircle(shape, curveSegments);
	if (shape instanceof Polygon) {
		const segments = polygonToSegments(shape);
		return dedupeConsecutive([
			...segments.map((segment) => segment.start),
			...(segments.length ? [segments[segments.length - 1].end] : []),
		]);
	}
	if (shape instanceof Point) return [shape];
	return [];
}

/** 점렬의 누적 길이 */
export function polylineLengths(points: Point[]): number[] {
	const lengths = [0];
	for (let index = 1; index < points.length; index++) {
		lengths.push(lengths[index - 1] + points[index - 1].distanceTo(points[index])[0]);
	}
	return lengths;
}

export const polylineLength = (points: Point[]): number => {
	const lengths = polylineLengths(points);
	return lengths[lengths.length - 1] ?? 0;
};

/** 시작점에서 distance만큼 진행한 위치 (길이를 넘으면 null) */
export function pointAtDistance(points: Point[], distance: number): Point | null {
	if (points.length < 2) return null;
	const lengths = polylineLengths(points);
	const total = lengths[lengths.length - 1];
	if (distance < 0 || distance > total) return null;
	for (let index = 1; index < points.length; index++) {
		if (lengths[index] >= distance) {
			const segmentLength = lengths[index] - lengths[index - 1];
			const ratio = segmentLength === 0 ? 0 : (distance - lengths[index - 1]) / segmentLength;
			const start = points[index - 1];
			const end = points[index];
			return new Point(start.x + (end.x - start.x) * ratio, start.y + (end.y - start.y) * ratio);
		}
	}
	return points[points.length - 1];
}

/** DIVIDE — 객체를 count 등분하는 내부 점 (count-1개) */
export function dividePoints(points: Point[], count: number): Point[] {
	if (count < 2) return [];
	const total = polylineLength(points);
	const result: Point[] = [];
	for (let index = 1; index < count; index++) {
		const point = pointAtDistance(points, (total * index) / count);
		if (point) result.push(point);
	}
	return result;
}

/** MEASURE — 시작점에서 spacing 간격마다 찍는 점 */
export function measurePoints(points: Point[], spacing: number): Point[] {
	if (spacing <= 0) return [];
	const total = polylineLength(points);
	const result: Point[] = [];
	for (let distance = spacing; distance <= total + 1e-9; distance += spacing) {
		const point = pointAtDistance(points, Math.min(distance, total));
		if (point) result.push(point);
	}
	return result;
}