@equinor/esv-intersection 3.0.0-beta.4 → 3.0.0-beta.6

package/src/utils/text.ts

@@ -0,0 +1,88 @@
+import { clamp } from '@equinor/videx-math';
+
+import { BoundingBox } from '../interfaces';
+import { ScaleLinear } from 'd3-scale';
+
+const DEFAULT_HORIZONTAL_PADDING = 4;
+const DEFAULT_VERTICAL_PADDING = 2;
+
+export function pixelsPerUnit(x: ScaleLinear<number, number>): number {
+  const [min] = x.domain();
+  return Math.abs(x(min + 1));
+}
+
+export function calcSize(factor: number, min: number, max: number, x: ScaleLinear<number, number>): number {
+  return clamp(pixelsPerUnit(x) * factor, min, max);
+}
+
+export function isOverlappingHorizontally(r1: BoundingBox, r2: BoundingBox): boolean {
+  const r1x2 = r1.x + r1.width;
+  const r2x2 = r2.x + r2.width;
+
+  if (r2.x > r1x2 || r2x2 < r1.x) {
+    return false;
+  }
+  return true;
+}
+
+export function isOverlapping(
+  r1: BoundingBox,
+  r2: BoundingBox,
+  horizontalPadding: number = DEFAULT_HORIZONTAL_PADDING,
+  verticalPadding: number = DEFAULT_VERTICAL_PADDING,
+): boolean {
+  const r1x2 = r1.x + r1.width + horizontalPadding;
+  const r2x2 = r2.x + r2.width + horizontalPadding;
+  const r1y2 = r1.y + r1.height + verticalPadding;
+  const r2y2 = r2.y + r2.height + verticalPadding;
+
+  if (r2.x - horizontalPadding > r1x2 || r2.y - verticalPadding > r1y2 || r2x2 + horizontalPadding < r1.x || r2y2 + verticalPadding < r1.y) {
+    return false;
+  }
+  return true;
+}
+
+export function getOverlap(r1: BoundingBox, r2: BoundingBox): { dx: number; dy: number } {
+  const r1x2 = r1.x + r1.width;
+  const r2x2 = r2.x + r2.width;
+  const r1y2 = r1.y + r1.height;
+  const r2y2 = r2.y + r2.height;
+
+  if (r2.x > r1x2 || r2.y > r1y2 || r2x2 < r1.x || r2y2 < r1.y) {
+    return null;
+  }
+
+  const dx = Math.max(0, Math.min(r1.x + r1.width, r2.x + r2.width) - Math.max(r1.x, r2.x));
+  const dy = Math.max(0, Math.min(r1.y + r1.height, r2.y + r2.height) - Math.max(r1.y, r2.y));
+
+  const newPoints = {
+    dx,
+    dy,
+  };
+  return newPoints;
+}
+
+export function getOverlapOffset(
+  r1: BoundingBox,
+  r2: BoundingBox,
+  horizontalPadding = DEFAULT_HORIZONTAL_PADDING,
+  verticalPadding = DEFAULT_VERTICAL_PADDING,
+): { dx: number; dy: number } {
+  const r1x2 = r1.x + r1.width;
+  const r2x2 = r2.x + r2.width;
+  const r1y2 = r1.y + r1.height;
+  const r2y2 = r2.y + r2.height;
+
+  if (r2.x - horizontalPadding > r1x2 || r2.y - verticalPadding > r1y2 || r2x2 + horizontalPadding < r1.x || r2y2 + verticalPadding < r1.y) {
+    return null;
+  }
+
+  const dx = r1.x + r1.width - r2.x + horizontalPadding;
+  const dy = r1.y + r1.height - r2.y + verticalPadding;
+
+  const newPoints = {
+    dx,
+    dy,
+  };
+  return newPoints;
+}

package/src/utils/vectorUtils.ts

@@ -0,0 +1,67 @@
+import { IPoint, Point } from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+
+export const pointToVector = (p: IPoint): Vector2 => new Vector2(p.x, p.y);
+export const pointToArray = (p: IPoint): [number, number] => [p.x, p.y];
+export const vectorToPoint = (v: Vector2): Point => new Point(v[0], v[1]);
+export const vectorToArray = (v: Vector2): [number, number] => [v[0], v[1]];
+export const arrayToPoint = (a: number[]): Point => new Point(a[0], a[1]);
+export const arrayToVector = (a: number[]): Vector2 => new Vector2(a[0], a[1]);
+
+export const calcDist = (prev: [number, number], point: [number, number]): number => {
+  return arrayToVector(point).sub(prev).magnitude;
+};
+
+export const calcDistPoint = (prev: Point, point: Point): number => {
+  return pointToVector(point).sub(prev.x, prev.y).magnitude;
+};
+
+export const calcNormal = (p1: Point, p2: Point): Point => {
+  const d = pointToVector(p2).sub(p1.x, p1.y);
+  d.x = d.y === 0 ? 1 : d.x;
+  d.y = d.x === 0 ? 1 : d.y;
+  return vectorToPoint(d.rotate90()); //TODO: normalize
+};
+
+export const convertToUnitVector = (p: Point): Point => {
+  return vectorToPoint(pointToVector(p).normalize());
+};
+
+export const createNormals = (points: IPoint[]): Vector2[] => {
+  if (points.length < 2) {
+    return [new Vector2(0)];
+  }
+
+  let n: Vector2;
+
+  return points.map((_coord, i, list) => {
+    if (i < list.length - 1) {
+      const p = pointToVector(list[i]);
+      const q = pointToVector(list[i + 1]);
+      const np = q.sub(p);
+      const rotate = np.rotate90();
+      n = rotate.normalized();
+      return n;
+    }
+
+    // reuse previous normal for last coord
+    return n;
+  });
+};
+
+// TODO check if this can be simplified and return Vector/number[]
+export const offsetPoint = (point: IPoint, vector: Vector2, offset: number): Point => {
+  const p = pointToVector(point);
+  return vectorToPoint(p.add(vector.scale(offset)));
+};
+
+export const offsetPoints = (points: IPoint[], vectors: Vector2[], offset: number): Point[] => {
+  if (points.length !== vectors.length) {
+    throw new Error('Number of vectors does not match number of points');
+  }
+
+  return points.map((point, index) => {
+    const vector = vectors[index];
+    return offsetPoint(point, vector, offset);
+  });
+};