@adnsistemas/pdf-lib 1.18.0 → 2.4.2

package/src/utils/elements/Arc.ts

@@ -0,0 +1,107 @@
+import { angleABC, distance, distanceCoords, rotate, vector } from '../maths';
+
+import Circle from './Circle';
+import GraphElement from './GraphElement';
+import Point from './Point';
+
+export default class Arc extends GraphElement {
+  O: Point;
+  A: Point;
+  B: Point;
+  /** Last sweep. Used to deduce the angle orientation */
+  lastSweep: number;
+
+  constructor(
+    O: Point = new Point(),
+    A: Point = new Point(),
+    B: Point = new Point(),
+    lastSweep = 0,
+  ) {
+    super();
+    this.O = O;
+    this.A = A;
+    this.B = B;
+    this.lastSweep = lastSweep;
+  }
+
+  center() {
+    return this.O;
+  }
+
+  origin() {
+    return this.A;
+  }
+
+  destination() {
+    return this.getCircle().orthoProjection(this.B);
+  }
+
+  sweep() {
+    this.lastSweep = angleABC(
+      this.origin(),
+      this.center(),
+      this.destination(),
+      this.lastSweep,
+    );
+    return this.lastSweep;
+  }
+
+  ray() {
+    return distance(this.center(), this.origin());
+  }
+
+  isEqual(element: GraphElement): boolean {
+    if (!(element instanceof Arc)) return false;
+    const dest = this.destination();
+    const o = this.origin();
+    const eDest = element.destination();
+    const eO = element.origin();
+    return (
+      this.getCircle().isEqual(element.getCircle()) &&
+      ((dest.isEqual(eDest) && o.isEqual(eO)) ||
+        (dest.isEqual(eO) && o.isEqual(eDest)))
+    );
+  }
+
+  getCircle() {
+    const circle = new Circle(this.center(), this.ray());
+    return circle;
+  }
+
+  originVect() {
+    return vector(this.center(), this.origin());
+  }
+
+  middle() {
+    const halfSweep = this.sweep() / 2;
+    const mid = this.center().plus(
+      rotate(vector(this.center(), this.origin()), halfSweep),
+    );
+    return mid;
+  }
+
+  includes(P: Point) {
+    // As angles are returned between -π and π, we need the middle of the arc
+    return (
+      this.getCircle().includes(P) &&
+      Math.abs(angleABC(this.middle(), this.center(), P)) <=
+        Math.abs(this.sweep() / 2)
+    );
+  }
+
+  orthoProjection(P: Point) {
+    const H = this.getCircle().orthoProjection(P);
+    if (this.includes(H)) return H;
+    else {
+      const origin = this.origin().toCoords();
+      const destination = this.destination().toCoords();
+      // Returns the closest between origin and destination
+      const coords =
+        distanceCoords(H.toCoords(), origin) <
+        distanceCoords(H.toCoords(), destination)
+          ? origin
+          : destination;
+      return new Point(coords);
+    }
+  }
+}

package/src/utils/elements/Circle.ts

@@ -0,0 +1,55 @@
+import {
+  distance,
+  distanceCoords,
+  isEqual,
+  minus,
+  plus,
+  times,
+  unitVector,
+} from '../maths';
+
+import GraphElement from './GraphElement';
+import Point from './Point';
+export default class Circle extends GraphElement {
+  O: Point;
+  r: number;
+
+  constructor(O: Point = new Point(), r = 1) {
+    super();
+    this.O = O;
+    this.r = r;
+  }
+
+  ray() {
+    return this.r;
+  }
+
+  center() {
+    return this.O;
+  }
+
+  /** This is used to standardize type Circle | Arc */
+  getCircle() {
+    return this;
+  }
+
+  isEqual(element: GraphElement): boolean {
+    return (
+      element instanceof Circle &&
+      this.center().isEqual(element.center()) &&
+      isEqual(this.ray(), element.ray())
+    );
+  }
+
+  includes(P: Point) {
+    return isEqual(distance(this.center(), P), this.ray());
+  }
+
+  orthoProjection(P: Point) {
+    const center = this.center().toCoords();
+    const coords = P.toCoords();
+    if (distanceCoords(coords, center) < this.ray()) return P;
+    const vect = times(unitVector(minus(coords, center)), this.ray());
+    return new Point(plus(center, vect));
+  }
+}

package/src/utils/elements/Ellipse.ts

@@ -0,0 +1,135 @@
+import { Size } from '../../types';
+import {
+  angle,
+  distance,
+  isEqual,
+  orientation,
+  orthogonal,
+  times,
+  unitVector,
+  vector,
+} from '../maths';
+
+import GraphElement from './GraphElement';
+import Point from './Point';
+import Segment from './Segment';
+
+export default class Ellipse extends GraphElement {
+  A: Point;
+  B: Point;
+  C: Point;
+
+  constructor(
+    A: Point = new Point(),
+    B: Point = new Point(),
+    C: Point = new Point(),
+  ) {
+    super();
+    this.A = A;
+    this.B = B;
+    this.C = C;
+  }
+
+  center(): Point {
+    const center = this.axis().middle();
+    return center;
+  }
+
+  axis(): Segment {
+    const axis = new Segment(this.A, this.B);
+    return axis;
+  }
+
+  a(): number {
+    const axis = this.axis();
+    return Math.max(axis.length() / 2, axis.distance(this.C));
+  }
+
+  b(): number {
+    const axis = this.axis();
+    return Math.min(axis.length() / 2, axis.distance(this.C));
+  }
+
+  rotation(): number {
+    const axis = this.axis();
+    return axis.length() / 2 > axis.distance(this.C)
+      ? orientation(axis.dirVect())
+      : orientation(orthogonal(axis.dirVect()));
+  }
+
+  getSize(): Size {
+    return { width: 2 * this.a(), height: 2 * this.b() };
+  }
+
+  isEqual(element: GraphElement): boolean {
+    if (!(element instanceof Ellipse)) return false;
+    const a = this.a();
+    const b = this.b();
+    const rotation = this.rotation();
+    const eltA = element.a();
+    const eltB = element.b();
+    const eltRotation = element.rotation();
+    // If the main axis is the same on both ellipse
+    if (eltA < eltB === a < b) {
+      // The rotation is equivalent module PI as the element is symetrical
+      return (
+        isEqual(eltA, a) &&
+        isEqual(eltB, b) &&
+        isEqual(
+          rotation + (Math.PI % Math.PI),
+          eltRotation + (Math.PI % Math.PI),
+        )
+      );
+    }
+    // If the small axis is different
+    else {
+      // We add a rotation of PI / 2 to emulate the fact that the main axis are actually orthogonal
+      return (
+        isEqual(eltA, b) &&
+        isEqual(eltB, a) &&
+        isEqual(
+          rotation + (Math.PI % Math.PI),
+          eltRotation + (((3 * Math.PI) / 2) % Math.PI),
+        )
+      );
+    }
+  }
+
+  includes(P: Point) {
+    const { x, y } = P.toCoords();
+    const { x: cx, y: cy } = this.center().toCoords();
+    const teta = this.rotation();
+    return isEqual(
+      Math.pow(
+        ((x - cx) * Math.cos(teta) + (y - cy) * Math.sin(teta)) / this.a(),
+        2,
+      ) +
+        Math.pow(
+          ((x - cx) * Math.sin(teta) - (y - cy) * Math.cos(teta)) / this.b(),
+          2,
+        ),
+      1,
+    );
+  }
+
+  orthoProjection(P: Point) {
+    // We will consider that the parametric projection is a correct approximation of the distance for the current case, even if it is not orthogonal
+    const C = this.center();
+    const axis = this.axis();
+    const CP = vector(C, P);
+    const teta = angle(axis.dirVect(), vector(C, P));
+    const ray = this.polarRay(teta);
+    if (distance(P, this.center()) < ray) return P;
+    const vect = times(unitVector(CP), ray);
+    return new Point(this.center().plus(vect).toCoords());
+  }
+
+  polarRay(teta: number) {
+    const a = this.a();
+    const b = this.b();
+    const excentricity = Math.sqrt(Math.abs(a * a - b * b)) / Math.max(a, b);
+    return (
+      Math.min(a, b) / Math.sqrt(1 - Math.pow(excentricity * Math.cos(teta), 2))
+    );
+  }
+}

package/src/utils/elements/GraphElement.ts

@@ -0,0 +1,14 @@
+import { distance } from '../maths';
+
+import Point from './Point';
+
+export default abstract class GraphElement {
+  abstract isEqual(element: GraphElement): boolean;
+
+  abstract orthoProjection(P: Point): Point;
+
+  distance(P: Point) {
+    const H = this.orthoProjection(P);
+    return distance(H, P);
+  }
+}

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';