@foblex/2d
Version:
An Angular library for 2D geometric computations, providing classes and utilities for manipulating points, lines, vectors, rectangles, arcs, and transformations.
180 lines • 26.7 kB
JavaScript
import { PointExtensions } from './point';
import { Arc } from './arc';
import { Line } from './line';
import { ShapeParser } from './shape-parser';
import { VectorExtensions } from './vector';
/**
* The GetIntersections class is designed to find intersection points between
* line segments and various geometric shapes. Currently, it supports rectangles,
* circles, and ellipses. In the future, support for additional shapes will be added.
*/
export class GetIntersections {
/**
* Finds the guaranteed intersection points between a line segment and a rounded rectangle.
* @param from - Starting point of the line segment.
* @param to - Ending point of the line segment.
* @param rect - The rect to check for intersections.
* @returns An array of intersection points.
*/
static getRoundedRectIntersections(from, to, rect) {
const segments = ShapeParser.parseRoundedRect(rect);
for (const segment of segments) {
if (segment instanceof Arc) {
const intersections = this.intersectArcWithLine(segment, from, to);
if (intersections.length > 0) {
return intersections;
}
}
else if (segment instanceof Line) {
const intersection = this.intersectLineSegments(from, to, segment.point1, segment.point2);
if (intersection) {
return [intersection];
}
}
}
return [];
}
/**
* Finds the intersection points between a line segment and an SVG path.
* @param path - The SVG path to check for intersections.
* @param rect - The rect to check for intersections.
* @returns An array of intersection points.
*/
static getRoundedRectIntersectionsWithSVGPath(path, rect) {
const pathLength = path.getTotalLength();
const points = [];
for (let i = 0; i <= pathLength; i += 1) {
const point = path.getPointAtLength(i);
points.push({ x: point.x, y: point.y });
}
for (let i = 1; i < points.length; i++) {
const intersections = this.getRoundedRectIntersections(points[i - 1], points[i], rect);
if (intersections.length > 0) {
return intersections;
}
}
return [];
}
/**
* Finds the intersection points between an arc and a line segment.
* @param arc - The arc to check for intersections.
* @param from - Starting point of the line segment.
* @param to - Ending point of the line segment.
* @returns An array of intersection points.
*/
static intersectArcWithLine(arc, from, to) {
return this.filterPointsWithinArc(this.findEllipseLineIntersections(arc.center, arc.radiusX, arc.radiusY, from, to), arc);
}
/**
* Finds the intersection point between two line segments.
* @param p1 - Starting point of the first line segment.
* @param p2 - Ending point of the first line segment.
* @param p3 - Starting point of the second line segment.
* @param p4 - Ending point of the second line segment.
* @returns The intersection point or null if there is no intersection.
*/
static intersectLineSegments(p1, p2, p3, p4) {
const s1_x = p2.x - p1.x;
const s1_y = p2.y - p1.y;
const s2_x = p4.x - p3.x;
const s2_y = p4.y - p3.y;
const s = (-s1_y * (p1.x - p3.x) + s1_x * (p1.y - p3.y)) / (-s2_x * s1_y + s1_x * s2_y);
const t = (s2_x * (p1.y - p3.y) - s2_y * (p1.x - p3.x)) / (-s2_x * s1_y + s1_x * s2_y);
if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
return { x: p1.x + (t * s1_x), y: p1.y + (t * s1_y) };
}
return null;
}
/**
* Filters intersection points to retain only those within the given arc.
* @param points - The points to filter.
* @param arc - The arc to check against.
* @returns An array of points within the arc.
*/
static filterPointsWithinArc(points, arc) {
let { center, startAngle, endAngle } = arc;
if (points.length === 0) {
return points;
}
if (endAngle < startAngle) {
[startAngle, endAngle] = [endAngle, startAngle];
}
if (startAngle < 0 || endAngle < 0) {
startAngle += 2.0 * Math.PI;
endAngle += 2.0 * Math.PI;
}
const filteredPoints = [];
for (const point of points) {
let angle = this.normalizeAngle(VectorExtensions.angle(VectorExtensions.initialize(1, 0), VectorExtensions.initialize(point.x - center.x, point.y - center.y)));
if (angle < startAngle) {
angle += 2.0 * Math.PI;
}
if (startAngle <= angle && angle <= endAngle) {
filteredPoints.push(point);
}
}
return filteredPoints;
}
/**
* Normalizes an angle to be within the range 0 to 2π.
* @param radians - The angle in radians.
* @returns The normalized angle.
*/
static normalizeAngle(radians) {
const normal = radians % (2.0 * Math.PI);
return normal < 0.0 ? (normal + (2.0 * Math.PI)) : normal;
}
/**
* Finds the intersection points between an ellipse and a line segment.
* @param center - Center of the ellipse.
* @param radiusX - X radius of the ellipse.
* @param radiusY - Y radius of the ellipse.
* @param pointA - Starting point of the line segment.
* @param pointB - Ending point of the line segment.
* @returns An array of intersection points.
*/
static findEllipseLineIntersections(center, radiusX, radiusY, pointA, pointB) {
const origin = VectorExtensions.initialize(pointA.x, pointA.y);
const direction = VectorExtensions.fromPoints(pointA, pointB);
const ellipseCenter = VectorExtensions.initialize(center.x, center.y);
const diff = VectorExtensions.subtract(origin, ellipseCenter);
const scaledDir = VectorExtensions.initialize(direction.x / (radiusX * radiusX), direction.y / (radiusY * radiusY));
const scaledDiff = VectorExtensions.initialize(diff.x / (radiusX * radiusX), diff.y / (radiusY * radiusY));
const a = VectorExtensions.dotProduct(direction, scaledDir);
const b = VectorExtensions.dotProduct(direction, scaledDiff);
const c = VectorExtensions.dotProduct(diff, scaledDiff) - 1.0;
const discriminant = b * b - a * c;
return discriminant < 0 ? [] : this.calculateIntersectionPoints(discriminant, a, b, pointA, pointB);
}
/**
* Calculates the intersection points based on the discriminant.
* @param discriminant - The discriminant value.
* @param a - Coefficient 'a' in the quadratic equation.
* @param b - Coefficient 'b' in the quadratic equation.
* @param pointA - Starting point of the line segment.
* @param pointB - Ending point of the line segment.
* @returns An array of intersection points.
*/
static calculateIntersectionPoints(discriminant, a, b, pointA, pointB) {
const points = [];
if (discriminant > 0) {
const root = Math.sqrt(discriminant);
const t1 = (-b - root) / a;
const t2 = (-b + root) / a;
if (t1 >= 0 && t1 <= 1) {
points.push(PointExtensions.interpolatePoints(pointA, pointB, t1));
}
if (t2 >= 0 && t2 <= 1) {
points.push(PointExtensions.interpolatePoints(pointA, pointB, t2));
}
}
else {
const t = -b / a;
if (t >= 0 && t <= 1) {
points.push(PointExtensions.interpolatePoints(pointA, pointB, t));
}
}
return points;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-intersections.js","sourceRoot":"","sources":["../../../projects/foblex2d/src/get-intersections.ts"],"names":[],"mappings":"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","sourcesContent":["import { IPoint, PointExtensions } from './point';\nimport { IRoundedRect } from './rounded-rect';\nimport { Arc, IArc } from './arc';\nimport { ILine, Line } from './line';\nimport { ShapeParser } from './shape-parser';\nimport { VectorExtensions } from './vector';\n\n\n/**\n * The GetIntersections class is designed to find intersection points between\n * line segments and various geometric shapes. Currently, it supports rectangles,\n * circles, and ellipses. In the future, support for additional shapes will be added.\n */\nexport class GetIntersections {\n\n  /**\n   * Finds the guaranteed intersection points between a line segment and a rounded rectangle.\n   * @param from - Starting point of the line segment.\n   * @param to - Ending point of the line segment.\n   * @param rect - The rect to check for intersections.\n   * @returns An array of intersection points.\n   */\n  public static getRoundedRectIntersections(from: IPoint, to: IPoint, rect: IRoundedRect): IPoint[] {\n    const segments: (Arc | Line)[] = ShapeParser.parseRoundedRect(rect);\n\n    for (const segment of segments) {\n      if (segment instanceof Arc) {\n        const intersections = this.intersectArcWithLine(segment, from, to);\n        if (intersections.length > 0) {\n          return intersections;\n        }\n      } else if (segment instanceof Line) {\n        const intersection = this.intersectLineSegments(from, to, segment.point1, segment.point2);\n        if (intersection) {\n          return [ intersection ];\n        }\n      }\n    }\n\n    return [];\n  }\n\n  /**\n   * Finds the intersection points between a line segment and an SVG path.\n   * @param path - The SVG path to check for intersections.\n   * @param rect - The rect to check for intersections.\n   * @returns An array of intersection points.\n   */\n\n  public static getRoundedRectIntersectionsWithSVGPath(path: SVGPathElement, rect: IRoundedRect): IPoint[] {\n    const pathLength = path.getTotalLength();\n    const points = [];\n\n    for (let i = 0; i <= pathLength; i += 1) {\n      const point = path.getPointAtLength(i);\n      points.push({ x: point.x, y: point.y });\n    }\n\n    for (let i = 1; i < points.length; i++) {\n      const intersections = this.getRoundedRectIntersections(points[i - 1], points[i], rect);\n      if (intersections.length > 0) {\n        return intersections;\n      }\n    }\n    return [];\n  }\n\n  /**\n   * Finds the intersection points between an arc and a line segment.\n   * @param arc - The arc to check for intersections.\n   * @param from - Starting point of the line segment.\n   * @param to - Ending point of the line segment.\n   * @returns An array of intersection points.\n   */\n  private static intersectArcWithLine(arc: IArc, from: IPoint, to: IPoint): IPoint[] {\n    return this.filterPointsWithinArc(\n      this.findEllipseLineIntersections(arc.center, arc.radiusX, arc.radiusY, from, to),\n      arc\n    );\n  }\n\n  /**\n   * Finds the intersection point between two line segments.\n   * @param p1 - Starting point of the first line segment.\n   * @param p2 - Ending point of the first line segment.\n   * @param p3 - Starting point of the second line segment.\n   * @param p4 - Ending point of the second line segment.\n   * @returns The intersection point or null if there is no intersection.\n   */\n  private static intersectLineSegments(p1: IPoint, p2: IPoint, p3: IPoint, p4: IPoint): IPoint | null {\n    const s1_x = p2.x - p1.x;\n    const s1_y = p2.y - p1.y;\n    const s2_x = p4.x - p3.x;\n    const s2_y = p4.y - p3.y;\n\n    const s = (-s1_y * (p1.x - p3.x) + s1_x * (p1.y - p3.y)) / (-s2_x * s1_y + s1_x * s2_y);\n    const t = (s2_x * (p1.y - p3.y) - s2_y * (p1.x - p3.x)) / (-s2_x * s1_y + s1_x * s2_y);\n\n    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {\n      return { x: p1.x + (t * s1_x), y: p1.y + (t * s1_y) };\n    }\n\n    return null;\n  }\n\n  /**\n   * Filters intersection points to retain only those within the given arc.\n   * @param points - The points to filter.\n   * @param arc - The arc to check against.\n   * @returns An array of points within the arc.\n   */\n  private static filterPointsWithinArc(points: IPoint[], arc: IArc): IPoint[] {\n    let { center, startAngle, endAngle } = arc;\n\n    if (points.length === 0) {\n      return points;\n    }\n\n    if (endAngle < startAngle) {\n      [ startAngle, endAngle ] = [ endAngle, startAngle ];\n    }\n\n    if (startAngle < 0 || endAngle < 0) {\n      startAngle += 2.0 * Math.PI;\n      endAngle += 2.0 * Math.PI;\n    }\n\n    const filteredPoints: IPoint[] = [];\n\n    for (const point of points) {\n      let angle = this.normalizeAngle(\n        VectorExtensions.angle(\n          VectorExtensions.initialize(1, 0),\n          VectorExtensions.initialize(point.x - center.x, point.y - center.y)\n        )\n      );\n\n      if (angle < startAngle) {\n        angle += 2.0 * Math.PI;\n      }\n\n      if (startAngle <= angle && angle <= endAngle) {\n        filteredPoints.push(point);\n      }\n    }\n\n    return filteredPoints;\n  }\n\n  /**\n   * Normalizes an angle to be within the range 0 to 2π.\n   * @param radians - The angle in radians.\n   * @returns The normalized angle.\n   */\n  private static normalizeAngle(radians: number): number {\n    const normal = radians % (2.0 * Math.PI);\n    return normal < 0.0 ? (normal + (2.0 * Math.PI)) : normal;\n  }\n\n  /**\n   * Finds the intersection points between an ellipse and a line segment.\n   * @param center - Center of the ellipse.\n   * @param radiusX - X radius of the ellipse.\n   * @param radiusY - Y radius of the ellipse.\n   * @param pointA - Starting point of the line segment.\n   * @param pointB - Ending point of the line segment.\n   * @returns An array of intersection points.\n   */\n  private static findEllipseLineIntersections(center: IPoint, radiusX: number, radiusY: number, pointA: IPoint, pointB: IPoint): IPoint[] {\n    const origin = VectorExtensions.initialize(pointA.x, pointA.y);\n    const direction = VectorExtensions.fromPoints(pointA, pointB);\n    const ellipseCenter = VectorExtensions.initialize(center.x, center.y);\n    const diff = VectorExtensions.subtract(origin, ellipseCenter);\n    const scaledDir = VectorExtensions.initialize(direction.x / (radiusX * radiusX), direction.y / (radiusY * radiusY));\n    const scaledDiff = VectorExtensions.initialize(diff.x / (radiusX * radiusX), diff.y / (radiusY * radiusY));\n\n    const a = VectorExtensions.dotProduct(direction, scaledDir);\n    const b = VectorExtensions.dotProduct(direction, scaledDiff);\n    const c = VectorExtensions.dotProduct(diff, scaledDiff) - 1.0;\n    const discriminant = b * b - a * c;\n\n    return discriminant < 0 ? [] : this.calculateIntersectionPoints(discriminant, a, b, pointA, pointB);\n  }\n\n  /**\n   * Calculates the intersection points based on the discriminant.\n   * @param discriminant - The discriminant value.\n   * @param a - Coefficient 'a' in the quadratic equation.\n   * @param b - Coefficient 'b' in the quadratic equation.\n   * @param pointA - Starting point of the line segment.\n   * @param pointB - Ending point of the line segment.\n   * @returns An array of intersection points.\n   */\n  private static calculateIntersectionPoints(discriminant: number, a: number, b: number, pointA: IPoint, pointB: IPoint): IPoint[] {\n    const points: IPoint[] = [];\n\n    if (discriminant > 0) {\n      const root = Math.sqrt(discriminant);\n      const t1 = (-b - root) / a;\n      const t2 = (-b + root) / a;\n\n      if (t1 >= 0 && t1 <= 1) {\n        points.push(PointExtensions.interpolatePoints(pointA, pointB, t1));\n      }\n      if (t2 >= 0 && t2 <= 1) {\n        points.push(PointExtensions.interpolatePoints(pointA, pointB, t2));\n      }\n    } else {\n      const t = -b / a;\n      if (t >= 0 && t <= 1) {\n        points.push(PointExtensions.interpolatePoints(pointA, pointB, t));\n      }\n    }\n\n    return points;\n  }\n}\n"]}