EdgeLocator

Introduction

vtkEdgeLocator

Methods

initialize

Remove all the edges previously added.

newInstance

Method use to create a new instance of vtkEdgeLocator

Argument	Type	Required	Description
initialValues	IEdgeLocatorInitialValues	No	for pre-setting some of its content

Source

index.d.ts

import { Nullable } from '../../../types';

/**
 *
 */
export interface IEdgeLocatorInitialValues {
  oriented?: boolean;
}

export interface IEdge<T = unknown> {
  key: number;
  edgeId: number;
  value?: T;
}

export interface vtkEdgeLocator {
  /**
   * Remove all the edges previously added.
   */
  initialize(): void;

  /**
   * Returns the inserted edge or null if no edge was inserted.
   * @param {Number} pointId0 Edge first point id
   * @param {Number} pointId1 Edge last point id
   * @return {IEdge|null} an edge object ({ key, edgeId, value }) or null
   */
  isInsertedEdge<T = unknown>(
    pointId0: number,
    pointId1: number
  ): Nullable<IEdge<T>>;

  /**
   * Insert edge if it does not already exist.
   * Returns the existing or newly inserted edge.
   *
   * @param {Number} pointId0 Edge first point id
   * @param {Number} pointId1 Edge last point id
   * @param {unknown} value Optional value option
   * @return {IEdge|null} an edge object ({ key, edgeId, value }) or null
   * @see insertEdge()
   * @see isInsertedEdge()
   */
  insertUniqueEdge<T>(pointId0: number, pointId1: number, value?: T): IEdge<T>;

  /**
   * Insert edge. If the edge already exists, it is overwritten by this
   * new edge. You may verify that the edge did not previously exist with
   * `isInsertedEdge()`.
   * Returns the newly inserted edge.
   * @param {Number} pointId0 Edge first point id
   * @param {Number} pointId1 Edge last point id
   * @param {unknown} value Optional value option
   * @return {Edge|null} an edge object ({ key, edgeId, value }) or null
   * @see isInsertedEdge
   * @see insertUniqueEdge
   */
  insertEdge<T>(pointId0: number, pointId1: number, value?: T): IEdge<T>;
}

// ----------------------------------------------------------------------------
// Static API
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

/**
 * Method use to create a new instance of vtkEdgeLocator
 * @param {IEdgeLocatorInitialValues} [initialValues] for pre-setting some of its content
 */
export function newInstance(
  initialValues?: IEdgeLocatorInitialValues
): vtkEdgeLocator;

/**
 * vtkEdgeLocator
 */
export declare const vtkEdgeLocator: {
  newInstance: typeof newInstance;
};

export default vtkEdgeLocator;

index.js

class EdgeLocator {
  constructor(oriented = false) {
    this.oriented = oriented;
    this.edgeMap = new Map();
  }

  initialize() {
    this.edgeMap.clear();
  }

  computeEdgeKey(pointId0, pointId1) {
    return this.oriented || pointId0 < pointId1
      ? // Cantor pairing function:
        0.5 * (pointId0 * pointId1) * (pointId0 * pointId1 + 1) + pointId1
      : 0.5 * (pointId1 * pointId0) * (pointId1 * pointId0 + 1) + pointId0;
  }

  insertUniqueEdge(pointId0, pointId1, newEdgeValue) {
    // Generate a unique key
    const key = this.computeEdgeKey(pointId0, pointId1);
    let node = this.edgeMap.get(key);
    if (!node) {
      // Didn't find key, so add a new edge entry
      node = { key, edgeId: this.edgeMap.size, value: newEdgeValue };
      this.edgeMap.set(key, node);
    }
    return node;
  }

  insertEdge(pointId0, pointId1, newEdgeValue) {
    // Generate a unique key
    const key = this.computeEdgeKey(pointId0, pointId1);
    const node = { key, edgeId: this.edgeMap.size, value: newEdgeValue };
    this.edgeMap.set(key, node);
    return node;
  }

  isInsertedEdge(pointId0, pointId1) {
    const key = this.computeEdgeKey(pointId0, pointId1);
    return this.edgeMap.get(key);
  }

  static getEdgePointIds(node) {
    const n = 0.5 * (-1 + Math.sqrt(8 * node.key + 1));
    const pointId0 = node.key - 0.5 * (n + 1) * n;
    const pointId1 = n - pointId0;
    return [pointId0, pointId1];
  }
}

function newInstance(initialValues = {}) {
  return new EdgeLocator(initialValues.oriented);
}

export default { newInstance };