@pdfme/pdf-lib 1.17.3 → 1.18.3

package/src/utils/elements/Line.ts

@@ -0,0 +1,85 @@
+import { Coordinates } from '../../types';
+import { intersectionLine } from '../intersections';
+import { isColinear, isEqual, orthogonal, vector } from '../maths';
+
+import GraphElement from './GraphElement';
+import Point from './Point';
+
+export default class Line extends GraphElement {
+  origin(): Point {
+    return this.A;
+  }
+
+  dirVect(): Coordinates {
+    return vector(this.A, this.B);
+  }
+
+  A: Point;
+  B: Point;
+
+  constructor(A: Point = new Point(), B: Point = new Point()) {
+    super();
+    this.A = A;
+    this.B = B;
+  }
+
+  /** Line equation */
+  y(x: number) {
+    const a = this.a();
+    const b = this.b();
+    return a * x + b;
+  }
+
+  /** The slope */
+  a() {
+    const dirVect = this.dirVect();
+    return dirVect.y / dirVect.x;
+  }
+
+  /** Origin y coordinate */
+  b() {
+    const O = this.origin().toCoords();
+    const a = this.a();
+    return O.y - a * O.x;
+  }
+
+  isEqual(element: GraphElement): boolean {
+    const vect = this.dirVect();
+    return (
+      element instanceof Line &&
+      isColinear(vect, element.dirVect()) &&
+      (isEqual(vect.x, 0)
+        ? // We need to take care of the case of the vertical line
+          isEqual(this.origin().toCoords().x, element.origin().toCoords().x)
+        : isEqual(this.b(), element.b()))
+    );
+  }
+
+  /** Reversed line equation */
+  x(y: number) {
+    const dirVect = this.dirVect();
+    return ((y - this.b()) * dirVect.x) / dirVect.y;
+  }
+
+  includes(P: Point) {
+    const { x, y } = P.toCoords();
+    const vect = this.dirVect();
+    return isEqual(vect.x, 0)
+      ? isEqual(this.origin().toCoords().x, x)
+      : isEqual(this.y(x), y);
+  }
+
+  /** This is used to standarsize type Segment | HalfLine | Line */
+  getLine() {
+    const line = new Line(this.origin(), this.B);
+    return line;
+  }
+
+  orthoProjection(P: Point): Point {
+    const vectOrtho = orthogonal(this.dirVect());
+    const A = new Point(P.toCoords());
+    const ortho = new Line(A, A.plus(vectOrtho));
+    const H = intersectionLine(this, ortho)[0];
+    return new Point(H);
+  }
+}

package/src/utils/elements/Plot.ts

@@ -0,0 +1,50 @@
+import { Coordinates } from '../../types';
+import { plus } from '../maths';
+
+import GraphElement from './GraphElement';
+import Point from './Point';
+import Segment from './Segment';
+export default class Plot extends GraphElement {
+  points: Coordinates[];
+
+  constructor(points: Coordinates[] = []) {
+    super();
+    this.points = points;
+  }
+
+  getPoints() {
+    return [...this.points];
+  }
+
+  translate(translationVector: Coordinates) {
+    this.points = this.points.map((point) => plus(point, translationVector));
+  }
+
+  isEqual(element: GraphElement): boolean {
+    if (!(element instanceof Plot)) return false;
+    const points = this.getPoints().map((coord) => new Point(coord));
+    const points2 = element.getPoints().map((coord) => new Point(coord));
+    return (
+      points.every((point, i) => point.isEqual(points2[i])) ||
+      points.reverse().every((point, i) => point.isEqual(points2[i]))
+    );
+  }
+
+  orthoProjection(P: Point) {
+    const points = this.getPoints();
+    const orthos = points
+      .slice(0, -1)
+      .map((pt, i) => new Segment(new Point(pt), new Point(points[i + 1])))
+      .map((seg) => seg.orthoProjection(P));
+    let min = Number.POSITIVE_INFINITY;
+    let closest: Point = new Point(points[0]);
+    orthos.forEach((ortho) => {
+      const d = ortho.distance(P);
+      if (d < min) {
+        min = d;
+        closest = ortho;
+      }
+    });
+    return closest;
+  }
+}

package/src/utils/elements/Point.ts

@@ -0,0 +1,37 @@
+import type { Coordinates } from '../../types';
+
+import { isEqual, plus } from '../maths';
+import GraphElement from './GraphElement';
+
+export default class Point extends GraphElement {
+  static type = 'PointFixed';
+
+  x: number;
+  y: number;
+
+  constructor(coords = { x: 0, y: 0 }) {
+    super();
+    this.x = coords.x;
+    this.y = coords.y;
+  }
+
+  toCoords() {
+    return { x: this.x, y: this.y };
+  }
+
+  isEqual(element: GraphElement): boolean {
+    if (!(element instanceof Point)) return false;
+    const A = this.toCoords();
+    const B = element.toCoords();
+    return isEqual(A.x, B.x) && isEqual(A.y, B.y);
+  }
+
+  orthoProjection() {
+    return new Point(this.toCoords());
+  }
+
+  plus(vect: Coordinates) {
+    const P = new Point(plus(this.toCoords(), vect));
+    return P;
+  }
+}

package/src/utils/elements/Rectangle.ts

@@ -0,0 +1,65 @@
+import GraphElement from './GraphElement';
+import Point from './Point';
+import Segment from './Segment';
+
+export default class Rectangle extends GraphElement {
+  static type = 'Rectangle';
+  start: Point;
+  end: Point;
+  constructor(start: Point = new Point(), end: Point = new Point()) {
+    super();
+    this.start = start;
+    this.end = end;
+  }
+
+  getSize() {
+    const start = this.start.toCoords();
+    const end = this.end.toCoords();
+    return {
+      width: Math.abs(start.x - end.x),
+      height: Math.abs(start.y - end.y),
+    };
+  }
+
+  getCoords() {
+    const start = this.start.toCoords();
+    const end = this.end.toCoords();
+    return {
+      x: Math.min(start.x, end.x),
+      y: Math.max(start.y, end.y),
+    };
+  }
+
+  getStart() {
+    const start = new Point(this.getCoords());
+    return start;
+  }
+
+  getEnd() {
+    const { width, height } = this.getSize();
+    const end = new Point(this.getStart()).plus({ x: width, y: -height });
+    return end;
+  }
+
+  center() {
+    const center = new Segment(this.getStart(), this.getEnd()).middle();
+    return center;
+  }
+
+  isEqual(element: GraphElement): boolean {
+    return (
+      element instanceof Rectangle &&
+      this.getStart().isEqual(element.getStart()) &&
+      this.getEnd().isEqual(element.getEnd())
+    );
+  }
+
+  orthoProjection(P: Point) {
+    const { x, y } = this.getCoords();
+    const end = this.getEnd().toCoords();
+    const { x: Px, y: Py } = P.toCoords();
+    const Hx = Px < x ? x : Px > end.x ? end.x : Px;
+    const Hy = Py > y ? y : Py < end.y ? end.y : Py;
+    return new Point({ x: Hx, y: Hy });
+  }
+}

package/src/utils/elements/Segment.ts

@@ -0,0 +1,92 @@
+import {
+  distance,
+  isColinear,
+  norm,
+  scalar,
+  vector,
+  plus,
+  times,
+} from '../maths';
+
+import GraphElement from './GraphElement';
+import Line from './Line';
+import Point from './Point';
+
+export default class Segment extends GraphElement {
+  static type = 'Segment';
+  A: Point;
+  B: Point;
+  constructor(A: Point = new Point(), B: Point = new Point()) {
+    super();
+    this.A = A;
+    this.B = B;
+  }
+
+  origin(): Point {
+    return this.A;
+  }
+
+  destination(): Point {
+    return this.B;
+  }
+
+  dirVect() {
+    return vector(this.origin(), this.destination());
+  }
+
+  length() {
+    return distance(this.destination(), this.origin());
+  }
+
+  isEqual(element: GraphElement): boolean {
+    if (!(element instanceof Segment)) return false;
+    const o = this.origin();
+    const dest = this.destination();
+    const oE = element.origin();
+    const destE = element.destination();
+    return (
+      element instanceof Segment &&
+      ((o.isEqual(oE) && dest.isEqual(destE)) ||
+        (o.isEqual(destE) && dest.isEqual(oE)))
+    );
+  }
+
+  /** Returns an equivalent line object */
+  getLine() {
+    const line = new Line(this.origin(), this.destination());
+    return line;
+  }
+
+  includes(P: Point) {
+    const vect = this.dirVect();
+    const otherVect = vector(this.origin(), P);
+    // The vectors are not even colinear
+    if (!isColinear(vect, otherVect)) return false;
+    // The point is behind the origin
+    else if (scalar(vect, otherVect) < 0) return false;
+    // The point is after the destination
+    else if (norm(vect) < norm(otherVect)) return false;
+    else return true;
+  }
+
+  middle() {
+    const mid = new Point(
+      plus(this.origin().toCoords(), times(this.dirVect(), 0.5)),
+    );
+    return mid;
+  }
+
+  orthoProjection(P: Point) {
+    const H = this.getLine().orthoProjection(P);
+    const vect = this.dirVect();
+    const origin = this.origin().toCoords();
+    const destination = this.destination().toCoords();
+    const otherVect = vector(this.origin(), H);
+    // The point is before the origin
+    if (scalar(vect, otherVect) < 0) return new Point(origin);
+    // The point is after the destination
+    else if (norm(vect) < norm(otherVect)) return new Point(destination);
+    // The point is within the segment
+    else return H;
+  }
+}

package/src/utils/elements/index.ts

@@ -0,0 +1,9 @@
+export { default as Arc } from './Arc';
+export { default as Circle } from './Circle';
+export { default as GraphElement } from './GraphElement';
+export { default as Ellipse } from './Ellipse';
+export { default as Line } from './Line';
+export { default as SegmePlotnt } from './Plot';
+export { default as Point } from './Point';
+export { default as Rectangle } from './Rectangle';
+export { default as Segment } from './Segment';

package/src/utils/index.ts

@@ -1,11 +1,11 @@
-export * from 'src/utils/arrays';
-export * from 'src/utils/async';
-export * from 'src/utils/strings';
-export * from 'src/utils/unicode';
-export * from 'src/utils/numbers';
-export * from 'src/utils/errors';
-export * from 'src/utils/base64';
-export * from 'src/utils/objects';
-export * from 'src/utils/validators';
-export * from 'src/utils/pdfDocEncoding';
-export { default as Cache } from 'src/utils/Cache';
+export * from './arrays';
+export * from './async';
+export * from './strings';
+export * from './unicode';
+export * from './numbers';
+export * from './errors';
+export * from './base64';
+export * from './objects';
+export * from './validators';
+export * from './pdfDocEncoding';
+export { default as Cache } from './Cache';

package/src/utils/intersections.ts

@@ -0,0 +1,282 @@
+import Arc from './elements/Arc';
+import Circle from './elements/Circle';
+import Ellipse from './elements/Ellipse';
+import Line from './elements/Line';
+import Plot from './elements/Plot';
+import Point from './elements/Point';
+import Rectangle from './elements/Rectangle';
+import Segment from './elements/Segment';
+import { Coordinates, GraphicElement } from '../types';
+import {
+  distance,
+  isColinear,
+  isEqual,
+  norm,
+  orthogonal,
+  times,
+  unitVector,
+  vector,
+  rotate,
+} from './maths';
+
+export function intersections(
+  A: GraphicElement,
+  B: GraphicElement,
+): Coordinates[] {
+  if (A instanceof Point || B instanceof Point) return [];
+  else if (A instanceof Text || B instanceof Text) return [];
+  else if (A instanceof Image || B instanceof Image) return [];
+  // TODO: calculate the coords of the intersection: https://www.emathzone.com/tutorials/geometry/intersection-of-line-and-ellipse.html
+  else if (A instanceof Line) return intersectionsLine(A, B);
+  else if (A instanceof Segment) {
+    return intersectionsLine(A.getLine(), B).filter((P) =>
+      A.includes(new Point(P)),
+    );
+  } else if (A instanceof Circle) return intersectionsCircle(A, B);
+  else if (A instanceof Arc) {
+    return intersectionsCircle(A.getCircle(), B).filter((P) =>
+      A.includes(new Point(P)),
+    );
+  } else if (A instanceof Plot) return intersectionsPlot(A, B);
+  else if (A instanceof Rectangle) return intersectionsRectangle(A, B);
+  else if (A instanceof Ellipse) return intersectionsEllipse(A, B);
+  return A;
+}
+
+export function intersection(
+  A: GraphicElement,
+  B: GraphicElement,
+): Coordinates | undefined {
+  return intersections(A, B)[0];
+}
+
+function intersectionsLine(
+  A: Line,
+  B: Exclude<GraphicElement, Text | Point>,
+): Coordinates[] {
+  if (B instanceof Line) return intersectionLine(A, B);
+  else if (B instanceof Segment) {
+    return intersectionLine(A, B.getLine()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Circle) return intersectionCircleLine(B, A);
+  else if (B instanceof Arc) {
+    return intersectionsCircle(B.getCircle(), A).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Plot) return intersectionsPlot(B, A);
+  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
+  else if (B instanceof Ellipse) return intersectionsEllipse(B, A);
+  return B;
+}
+
+function intersectionsEllipse(
+  A: Ellipse,
+  B: Exclude<GraphicElement, Text | Point>,
+): Coordinates[] {
+  if (B instanceof Line) return intersectionsLineAndEllipse(A, B);
+  else if (B instanceof Segment) {
+    return intersectionsEllipse(A, B.getLine()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  }
+  // TODO:
+  // else if (B instanceof Circle) return intersectionEllipseCircle(B, A)
+  else if (B instanceof Circle) return [];
+  // TODO:
+  // else if (B instanceof Ellipse) return intersectionEllipseEllipse(B, A)
+  else if (B instanceof Ellipse) return [];
+  else if (B instanceof Arc) {
+    return intersectionsEllipse(A, B.getCircle()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Plot) return intersectionsPlot(B, A);
+  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
+  return B;
+}
+
+function intersectionsLineAndEllipse(A: Ellipse, B: Line): Coordinates[] {
+  const center = A.center().toCoords();
+  const a = A.a();
+  const b = A.b();
+  const rotation = A.rotation();
+  const isLineParallel2YAxis = isEqual(B.dirVect().x, 0);
+
+  // this is a dummy value to represent a point on the line
+  const p1Y = isLineParallel2YAxis ? 1 : B.y(1);
+  const p1X = isLineParallel2YAxis ? B.origin().toCoords().x : 1;
+  const p1 = { x: p1X, y: p1Y };
+
+  // this is a dummy value to represent a point on the line
+  const p2Y = isLineParallel2YAxis ? 2 : B.y(2);
+  const p2X = isLineParallel2YAxis ? B.origin().toCoords().x : 2;
+  const p2 = { x: p2X, y: p2Y };
+
+  const p1Normalized = rotate(
+    { x: p1.x - center.x, y: p1.y - center.y },
+    -rotation,
+  );
+  const p2Normalized = rotate(
+    { x: p2.x - center.x, y: p2.y - center.y },
+    -rotation,
+  );
+
+  const angular =
+    (p1Normalized.y - p2Normalized.y) / (p1Normalized.x - p2Normalized.x);
+  const linear = p1Normalized.y - angular * p1Normalized.x;
+
+  const lineY = (x: number) => angular * x + linear;
+  const denormalize = (coord: Coordinates) => {
+    const rotated = rotate(coord, rotation);
+    return {
+      x: rotated.x + center.x,
+      y: rotated.y + center.y,
+    };
+  };
+
+  // Intersection with vertical line
+  if (isEqual(p1Normalized.x - p2Normalized.x, 0)) {
+    const x = p1Normalized.x;
+    const delta = b ** 2 - (x ** 2 * b ** 2) / a ** 2;
+    if (delta < 0) return [];
+    else if (delta === 0) {
+      return [{ x, y: 0 }].map(denormalize);
+    } else {
+      const y1 = Math.sqrt((b ** 2 * (a ** 2 - x ** 2)) / a ** 2);
+      const y2 = -y1;
+      return [
+        { x, y: y1 },
+        { x, y: y2 },
+      ].map(denormalize);
+    }
+  }
+
+  // Intersection with any line
+
+  // the quadratic equation is:
+  // alpha * x ** 2 + beta * x + gamma = 0
+  const alpha = a ** 2 * angular ** 2 + b ** 2;
+  const beta = 2 * a ** 2 * (angular * linear);
+  const gamma = a ** 2 * (linear ** 2 - b ** 2);
+
+  const delta = beta ** 2 - 4 * alpha * gamma;
+  if (delta < 0) return [];
+  else if (delta === 0) {
+    const x = -(beta ** 2) / (2 * alpha);
+    const y = lineY(x);
+    return [{ x, y }].map(denormalize);
+  } else {
+    const x1 = (-beta + Math.sqrt(delta)) / (2 * alpha);
+    const y1 = lineY(x1);
+    const x2 = (-beta - Math.sqrt(delta)) / (2 * alpha);
+    const y2 = lineY(x2);
+    return [
+      { x: x1, y: y1 },
+      { x: x2, y: y2 },
+    ].map(denormalize);
+  }
+}
+
+export function intersectionLine(A: Line, B: Line): Coordinates[] {
+  if (isColinear(A.dirVect(), B.dirVect())) return [];
+  else {
+    const { x: ux, y: uy } = A.dirVect();
+    const { x: vx, y: vy } = B.dirVect();
+    const { x: xA, y: yA } = A.origin().toCoords();
+    const { x: xB, y: yB } = B.origin().toCoords();
+    const x =
+      (ux * (vx * (yA - yB) + vy * xB) - uy * vx * xA) / (ux * vy - uy * vx);
+    const y =
+      (uy * (vy * (xA - xB) + vx * yB) - ux * vy * yA) / (uy * vx - ux * vy);
+    return [{ x, y }];
+  }
+}
+
+function intersectionsPlot(A: Plot, B: GraphicElement): Coordinates[] {
+  const points = A.getPoints().map((pt) => new Point(pt));
+  const head = points.pop();
+  const segments = points.map(
+    (pt, i) => new Segment(pt, points[i + 1] || head),
+  );
+  // @ts-ignore
+  const inters = segments.map((s) => intersections(s, B)).flat();
+  return inters;
+}
+
+function intersectionsRectangle(
+  A: Rectangle,
+  B: GraphicElement,
+): Coordinates[] {
+  const P1 = A.getCoords();
+  const P3 = A.getEnd();
+  const P2 = { x: P1.x, y: P3.y };
+  const P4 = { x: P3.x, y: P1.y };
+  return intersections(new Plot([P1, P2, P3, P4, P1]), B);
+}
+
+export function intersectionCircleLine(A: Circle, B: Line): Coordinates[] {
+  const rA = A.ray();
+  const O = A.center();
+  const H = B.orthoProjection(O);
+  const OH = distance(O, H);
+  // The line is tangeant
+  if (isEqual(OH, rA)) return [H];
+  // The line is too far from the circle
+  else if (OH > A.ray()) return [];
+  // The line cut the circle in 2 points
+  else {
+    // Pythagore
+    const HP = Math.sqrt(rA * rA - OH * OH);
+    const vect = unitVector(B.dirVect());
+    return [H.plus(times(vect, HP)), H.plus(times(vect, -HP))];
+  }
+}
+
+export function intersectionCircle(A: Circle, B: Circle): Coordinates[] {
+  const oA = A.center();
+  const oB = B.center();
+  const rA = A.ray();
+  const rB = B.ray();
+  const axis = vector(oA, oB);
+  const CC = norm(axis);
+  // The circles are tangeant
+  if (isEqual(CC, rA + rB)) return [A.orthoProjection(oB).toCoords()];
+  // The circles are too far from eachother
+  else if (CC > rA + rB) return [];
+  // The intersections belong to an orthogonal axis
+  else {
+    const ratio = 1 / 2 + (rA * rA - rB * rB) / (CC * CC) / 2;
+    const H = oA.plus(times(axis, ratio));
+    return intersectionCircleLine(A, new Line(H, H.plus(orthogonal(axis))));
+  }
+}
+
+function intersectionsCircle(
+  A: Circle,
+  B: Exclude<GraphicElement, Text | Point>,
+): Coordinates[] {
+  if (B instanceof Circle) return intersectionCircle(A, B);
+  else if (B instanceof Line) return intersectionCircleLine(A, B);
+  else if (B instanceof Segment) {
+    return intersectionCircleLine(A, B.getLine()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Arc) {
+    return intersectionCircle(A, B.getCircle()).filter((P) =>
+      B.includes(new Point(P)),
+    );
+  } else if (B instanceof Plot) return intersectionsPlot(B, A);
+  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
+  else if (B instanceof Ellipse) return intersectionsEllipse(B, A);
+  return B;
+}
+
+export function getIntersections(elements: GraphicElement[]) {
+  const checked: GraphicElement[] = [];
+  const inters: Coordinates[] = [];
+  elements.forEach((elt) => {
+    checked.forEach((e) => inters.push(...intersections(e, elt)));
+    checked.push(elt);
+  });
+  return inters;
+}