@equinor/esv-intersection 3.0.1 → 3.0.4

package/dist/utils/root-finder.d.ts

@@ -1,34 +0,0 @@
-type fx = (n: number) => number;
-export declare class RootFinder {
-    /**
-     * Find root using newthons method
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static newton(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-    /**
-     * Find root using bisect method
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static bisect(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-    /**
-     * Find root by trying available methods
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static findRoot(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-}
-export {};

package/dist/utils/text.d.ts

@@ -1,14 +0,0 @@
-import { BoundingBox } from '../interfaces';
-import { ScaleLinear } from 'd3-scale';
-export declare function pixelsPerUnit(x: ScaleLinear<number, number>): number;
-export declare function calcSize(factor: number, min: number, max: number, x: ScaleLinear<number, number>): number;
-export declare function isOverlappingHorizontally(r1: BoundingBox, r2: BoundingBox): boolean;
-export declare function isOverlapping(r1: BoundingBox, r2: BoundingBox, horizontalPadding?: number, verticalPadding?: number): boolean;
-export declare function getOverlap(r1: BoundingBox, r2: BoundingBox): {
-    dx: number;
-    dy: number;
-};
-export declare function getOverlapOffset(r1: BoundingBox, r2: BoundingBox, horizontalPadding?: number, verticalPadding?: number): {
-    dx: number;
-    dy: number;
-};

package/dist/utils/vectorUtils.d.ts

@@ -1,15 +0,0 @@
-import { IPoint, Point } from 'pixi.js';
-import Vector2 from '@equinor/videx-vector2';
-export declare const pointToVector: (p: IPoint) => Vector2;
-export declare const pointToArray: (p: IPoint) => [number, number];
-export declare const vectorToPoint: (v: Vector2) => Point;
-export declare const vectorToArray: (v: Vector2) => [number, number];
-export declare const arrayToPoint: (a: number[]) => Point;
-export declare const arrayToVector: (a: number[]) => Vector2;
-export declare const calcDist: (prev: [number, number], point: [number, number]) => number;
-export declare const calcDistPoint: (prev: Point, point: Point) => number;
-export declare const calcNormal: (p1: Point, p2: Point) => Point;
-export declare const convertToUnitVector: (p: Point) => Point;
-export declare const createNormals: (points: IPoint[]) => Vector2[];
-export declare const offsetPoint: (point: IPoint, vector: Vector2, offset: number) => Point;
-export declare const offsetPoints: (points: IPoint[], vectors: Vector2[], offset: number) => Point[];

package/dist/vendor/pixi-dashed-line/index.d.ts

@@ -1,57 +0,0 @@
-import * as PIXI from 'pixi.js';
-/** Define the dash: [dash length, gap size, dash size, gap size, ...] */
-export type Dashes = number[];
-export interface DashLineOptions {
-    dash?: Dashes;
-    width?: number;
-    color?: number;
-    alpha?: number;
-    scale?: number;
-    useTexture?: boolean;
-    useDots?: boolean;
-    cap?: PIXI.LINE_CAP;
-    join?: PIXI.LINE_JOIN;
-    alignment?: number;
-}
-export declare class DashLine {
-    graphics: PIXI.Graphics;
-    /** current length of the line */
-    lineLength: number;
-    /** cursor location */
-    cursor: PIXI.Point;
-    /** desired scale of line */
-    scale: number;
-    private activeTexture;
-    private start;
-    private dashSize;
-    private dash;
-    private useTexture;
-    private options;
-    static dashTextureCache: Record<string, PIXI.Texture>;
-    /**
-     * Create a DashLine
-     * @param graphics
-     * @param [options]
-     * @param [options.useTexture=false] - use the texture based render (useful for very large or very small dashed lines)
-     * @param [options.dashes=[10,5] - an array holding the dash and gap (eg, [10, 5, 20, 5, ...])
-     * @param [options.width=1] - width of the dashed line
-     * @param [options.alpha=1] - alpha of the dashed line
-     * @param [options.color=0xffffff] - color of the dashed line
-     * @param [options.cap] - add a PIXI.LINE_CAP style to dashed lines (only works for useTexture: false)
-     * @param [options.join] - add a PIXI.LINE_JOIN style to the dashed lines (only works for useTexture: false)
-     * @param [options.alignment] - The alignment of any lines drawn (0.5 = middle, 1 = outer, 0 = inner)
-     */
-    constructor(graphics: PIXI.Graphics, options?: DashLineOptions);
-    /** resets line style to enable dashed line (useful if lineStyle was changed on graphics element) */
-    setLineStyle(): void;
-    private static distance;
-    moveTo(x: number, y: number): this;
-    lineTo(x: number, y: number, closePath?: boolean): this;
-    closePath(): void;
-    drawCircle(x: number, y: number, radius: number, points?: number, matrix?: PIXI.Matrix): this;
-    drawEllipse(x: number, y: number, radiusX: number, radiusY: number, points?: number, matrix?: PIXI.Matrix): this;
-    drawPolygon(points: PIXI.Point[] | number[], matrix?: PIXI.Matrix): this;
-    drawRect(x: number, y: number, width: number, height: number, matrix?: PIXI.Matrix): this;
-    private adjustLineStyle;
-    private static getTexture;
-}

package/src/components/axis.ts

@@ -1,247 +0,0 @@
-import { axisRight, axisBottom } from 'd3-axis';
-import { BaseType, Selection } from 'd3-selection';
-import { ScaleLinear, scaleLinear } from 'd3-scale';
-import { OnResizeEvent, OnRescaleEvent } from '../interfaces';
-
-export type Options = {
-  offsetX: number;
-  offsetY: number;
-  visible: boolean;
-};
-
-export class Axis {
-  private mainGroup: Selection<SVGElement, unknown, null, undefined>;
-  private _scaleX: ScaleLinear<number, number>;
-  private _scaleY: ScaleLinear<number, number>;
-  private _showLabels = true;
-  private _labelXDesc: string;
-  private _labelYDesc: string;
-  private _unitOfMeasure: string;
-  private _offsetX: number = 0;
-  private _offsetY: number = 0;
-  private _flipX = false;
-  private _flipY = false;
-  private visible: boolean = true;
-
-  constructor(
-    mainGroup: Selection<SVGElement, unknown, null, undefined>,
-    showLabels = true,
-    labelXDesc: string,
-    labelYDesc: string,
-    unitOfMeasure: string,
-    options?: Options,
-  ) {
-    this.mainGroup = mainGroup;
-    this._showLabels = showLabels;
-    this._labelXDesc = labelXDesc;
-    this._labelYDesc = labelYDesc;
-    this._unitOfMeasure = unitOfMeasure;
-    if (options && options.offsetX) {
-      this._offsetX = options.offsetX;
-    }
-    if (options && options.offsetX) {
-      this._offsetY = options.offsetY;
-    }
-    if (options && options.visible) {
-      this.visible = options.visible;
-    }
-    this.mainGroup.style('pointer-events', 'none');
-
-    this._scaleX = scaleLinear().domain([0, 1]).range([0, 1]);
-    this._scaleY = scaleLinear().domain([0, 1]).range([0, 1]);
-  }
-
-  private renderLabelx(): Selection<BaseType, unknown, null, undefined> {
-    const { _labelXDesc: labelXDesc, _unitOfMeasure: unitOfMeasure, _showLabels, _scaleX: scaleX } = this;
-    const [, width] = scaleX.range();
-    const gx = this.renderGx();
-
-    let labelx = gx.select('text.axis-labelx');
-    if (_showLabels) {
-      if (labelx.empty()) {
-        labelx = gx
-          .append('text')
-          .attr('class', 'axis-labelx')
-          .attr('fill', 'rgba(0,0,0,0.3)')
-          .style('text-anchor', 'middle')
-          .style('font-weight', '800')
-          .style('font-size', '10px')
-          .text(`${labelXDesc} (${unitOfMeasure})`);
-      }
-    } else {
-      labelx.remove();
-    }
-    labelx.attr('transform', `translate(${width / 2},-4)`);
-    return labelx;
-  }
-
-  private renderLabely(): Selection<BaseType, unknown, null, undefined> {
-    const { _labelYDesc: labelYDesc, _unitOfMeasure: unitOfMeasure, _showLabels, _scaleY } = this;
-    const [, height] = _scaleY.range();
-    const gy = this.renderGy();
-
-    let labely = gy.select('text.axis-labely');
-    if (_showLabels) {
-      if (labely.empty()) {
-        labely = gy
-          .append('text')
-          .attr('class', 'axis-labely')
-          .attr('fill', 'rgba(0,0,0,0.3)')
-          .style('text-anchor', 'middle')
-          .style('font-weight', '800')
-          .style('font-size', '10px')
-          .text(`${labelYDesc} (${unitOfMeasure})`);
-      }
-      labely.attr('transform', `translate(-10,${height / 2})rotate(90)`);
-    } else {
-      labely.remove();
-    }
-    return labely;
-  }
-
-  private renderGy(): Selection<BaseType, unknown, null, undefined> {
-    const { _scaleX, _scaleY } = this;
-    const yAxis = axisRight(_scaleY) as (selection: Selection<SVGSVGElement, unknown, null, undefined>) => void;
-    const [, width] = _scaleX.range();
-    const gy = this.createOrGet('y-axis');
-    gy.call(yAxis);
-    gy.attr('transform', `translate(${width},0)`);
-
-    return gy;
-  }
-
-  private renderGx(): Selection<BaseType, unknown, null, undefined> {
-    const { _scaleX, _scaleY } = this;
-    const xAxis = axisBottom(_scaleX) as (selection: Selection<SVGSVGElement, unknown, null, undefined>) => void;
-    const [, height] = _scaleY.range();
-
-    const gx = this.createOrGet('x-axis');
-    gx.attr('transform', `translate(0 ${height})`);
-    gx.call(xAxis);
-    return gx;
-  }
-
-  private createOrGet = (name: string): Selection<BaseType, unknown, null, undefined> => {
-    const { mainGroup } = this;
-    let res = mainGroup.select(`g.${name}`);
-    if (res.empty()) {
-      res = mainGroup.append('g').attr('class', name);
-    }
-    return res;
-  };
-
-  render(): void {
-    this.renderLabelx();
-    this.renderLabely();
-  }
-
-  onResize(event: OnResizeEvent): void {
-    this.mainGroup.attr('height', `${event.height}px`).attr('width', `${event.width}px`);
-  }
-
-  onRescale(event: OnRescaleEvent): void {
-    const { _scaleX, _scaleY, offsetX, offsetY } = this;
-    const { xScale, yScale } = event;
-    const xBounds = xScale.domain();
-    const yBounds = yScale.domain();
-
-    const xRange = xScale.range();
-    const yRange = yScale.range();
-
-    _scaleX.domain([xBounds[0] - offsetX, xBounds[1] - offsetX]).range(xRange);
-    _scaleY.domain([yBounds[0] - offsetY, yBounds[1] - offsetY]).range(yRange);
-    this.flipX(this._flipX);
-    this.flipY(this._flipY);
-
-    if (this.visible) {
-      this.render();
-    }
-  }
-
-  show(): Axis {
-    this.visible = true;
-    this.mainGroup.attr('visibility', 'visible');
-    this.render();
-    return this;
-  }
-
-  hide(): Axis {
-    this.visible = false;
-    this.mainGroup.attr('visibility', 'hidden');
-    return this;
-  }
-
-  flipX(flipX: boolean): Axis {
-    this._flipX = flipX;
-    const domain = this._scaleX.domain();
-    const flip = flipX ? -1 : 1;
-    this._scaleX.domain([flip * domain[0], flip * domain[1]]);
-    return this;
-  }
-
-  flipY(flipY: boolean): Axis {
-    this._flipY = flipY;
-    const domain = this._scaleY.domain();
-    const flip = flipY ? -1 : 1;
-    this._scaleY.domain([flip * domain[0], flip * domain[1]]);
-    return this;
-  }
-
-  showLabels(): Axis {
-    this._showLabels = true;
-    this.render();
-    return this;
-  }
-
-  hideLabels(): Axis {
-    this._showLabels = false;
-    this.render();
-    return this;
-  }
-
-  setLabelX(label: string): Axis {
-    this._labelXDesc = label;
-    return this;
-  }
-
-  setLabelY(label: string): Axis {
-    this._labelYDesc = label;
-    return this;
-  }
-
-  setUnitOfMeasure(uom: string): Axis {
-    this._unitOfMeasure = uom;
-    return this;
-  }
-
-  setLabels(labelX: string, labelY: string, unitOfMeasure: string): Axis {
-    this._labelXDesc = labelX;
-    this._labelYDesc = labelY;
-    this._unitOfMeasure = unitOfMeasure;
-    return this;
-  }
-
-  get offsetX(): number {
-    return this._offsetX;
-  }
-
-  set offsetX(offset: number) {
-    this._offsetX = offset;
-  }
-
-  get offsetY(): number {
-    return this._offsetY;
-  }
-
-  set offsetY(offset: number) {
-    this._offsetY = offset;
-  }
-
-  get scaleX(): ScaleLinear<number, number> {
-    return this._scaleX.copy();
-  }
-
-  get scaleY(): ScaleLinear<number, number> {
-    return this._scaleY.copy();
-  }
-}

package/src/components/index.ts

@@ -1 +0,0 @@
-export * from './axis';

package/src/control/ExtendedCurveInterpolator.ts

@@ -1,155 +0,0 @@
-import Vector2 from '@equinor/videx-vector2';
-import { clamp } from '@equinor/videx-math';
-import { CurveInterpolator } from 'curve-interpolator';
-import { Vector } from 'curve-interpolator/dist/src/interfaces';
-import { CurveInterpolatorOptions } from 'curve-interpolator/dist/src/curve-interpolator';
-
-import { RootFinder } from '../utils/root-finder';
-import { ArcLength } from '../utils/arc-length';
-import { BinarySearch } from '../utils/binary-search';
-
-export class ExtendedCurveInterpolator extends CurveInterpolator {
-  arcLengthLookup: number[] = [];
-
-  constructor(points: Vector[], options?: CurveInterpolatorOptions) {
-    super(points, options);
-    this.findTForArcLength = this.findTForArcLength.bind(this);
-    this.findTByRootForArcLength = this.findTByRootForArcLength.bind(this);
-    this.findApproxTForArcLength = this.findApproxTForArcLength.bind(this);
-    this.findTQuickForArcLength = this.findTQuickForArcLength.bind(this);
-    this.generateArcLengthLookup = this.generateArcLengthLookup.bind(this);
-    this.getArcLength = this.getArcLength.bind(this);
-    this.getQuickArcLength = this.getQuickArcLength.bind(this);
-    this.getPointAtArcLength = this.getPointAtArcLength.bind(this);
-    this.getPointAt = this.getPointAt.bind(this);
-  }
-
-  /**
-   * Function which finds t value for arc length
-   * @param {Number} arcLength Target arc length
-   * @param {Number} tolerance Tolerance for result
-   * @param {Number} iterations Max number of iterations to use
-   */
-  findTForArcLength(arcLength: number, options?: { approxT?: boolean; quickT?: boolean; normalizedLength?: number }): number {
-    // TODO: Ideally the CurveInterpolator should be able to provide t for curve length
-    let t;
-    if (options?.approxT) {
-      t = this.findApproxTForArcLength(arcLength, options?.normalizedLength);
-    } else if (options?.quickT) {
-      t = this.findTQuickForArcLength(arcLength);
-    } else {
-      t = this.findTByRootForArcLength(arcLength);
-    }
-    return t;
-  }
-
-  /**
-   * Function which finds t value for arc length by finding root
-   * @param {Number} arcLength Target arc length
-   * @param {Number} tolerance Tolerance for result
-   * @param {Number} iterations Max number of iterations to use
-   */
-  findTByRootForArcLength(arcLength: number, tolerance = 0.01, iterations = 100): number {
-    if (arcLength <= 0) {
-      return 0.0;
-    }
-    if (arcLength >= this.length) {
-      return 1.0;
-    }
-    const t = RootFinder.findRoot((x) => arcLength - this.getQuickArcLength(0, x), tolerance, iterations, arcLength / this.length);
-    return t;
-  }
-
-  /**
-   * Function which finds t value for arc length by simple approximation
-   * @param {Number} arcLength Target arclength
-   */
-  findApproxTForArcLength(arcLength: number, normalizedLength?: number): number {
-    const t = arcLength / (normalizedLength || this.length);
-    return t;
-  }
-
-  /**
-   * Function which finds t value for arc length using lookup table
-   * @param {Number} arcLength Target arclength
-   */
-  findTQuickForArcLength(arcLength: number): number {
-    if (this.arcLengthLookup.length === 0) {
-      this.generateArcLengthLookup();
-    }
-    const index = BinarySearch.search(this.arcLengthLookup, arcLength);
-    const v1 = this.arcLengthLookup[index];
-    const v2 = this.arcLengthLookup[index + 1];
-    const t = (index + (arcLength - v1) / (v2 - v1)) / this.arcLengthLookup.length;
-    return t;
-  }
-
-  generateArcLengthLookup(segments: number = 1000): void {
-    let lastPos = this.getPointAt(0);
-    let length = 0;
-    for (let i = 0; i < segments; i++) {
-      const pos = this.getPointAt(i / (segments - 1));
-      const delta = Vector2.distance(lastPos as number[], pos as number[]);
-      length += delta;
-      this.arcLengthLookup.push(length);
-      lastPos = pos;
-    }
-  }
-
-  /**
-   * Function calculating length along curve using interpolator.
-   * @param {Number} from t at start (default = 0)
-   * @param {Number} to t at end (default = 1)
-   */
-  getArcLength(from = 0, to = 1): number {
-    if (from === 0 && to === 1) {
-      return this.length;
-    }
-    const tolerance = 0.002;
-    return ArcLength.bisect((t: number) => this.getPointAt(t), from, to, tolerance);
-  }
-
-  /**
-   * Function calculating length along curve using interpolator.
-   * @param {Number} from t at start (default = 0)
-   * @param {Number} to t at end (default = 1)
-   */
-  getQuickArcLength(from = 0, to = 1): number {
-    let fromLength = 0;
-    let toLength = this.length;
-    if (this.arcLengthLookup.length === 0) {
-      this.generateArcLengthLookup();
-    }
-
-    if (from !== 0) {
-      const fromIndex = Math.floor(from * this.arcLengthLookup.length);
-      const fromLl = this.arcLengthLookup[fromIndex];
-      const fromLh = this.arcLengthLookup[fromIndex + 1];
-      fromLength = fromLl + ((from * this.arcLengthLookup.length) % this.arcLengthLookup.length) * (fromLh - fromLl);
-    }
-
-    if (to !== 1) {
-      const toIndex = Math.floor(to * this.arcLengthLookup.length);
-      const toLl = this.arcLengthLookup[toIndex];
-      const toLh = this.arcLengthLookup[toIndex + 1];
-      toLength = toLl + ((from * this.arcLengthLookup.length) % this.arcLengthLookup.length) * (toLh - toLl);
-    }
-
-    const totalLength = toLength - fromLength;
-    return totalLength;
-  }
-
-  /**
-   * Function getting a point at curve length.
-   * @param {Number} arcLength
-   */
-  getPointAtArcLength(arcLength: number, options?: { approxT?: boolean; quickT?: boolean; normalizedLength?: number }): Vector {
-    const t = this.findTForArcLength(arcLength, options);
-    return this.getPointAt(t);
-  }
-
-  getPointAt(t: number): Vector {
-    const tl = clamp(t, 0, 1);
-    return super.getPointAt(tl);
-  }
-}