plotboilerplate 1.25.0 → 1.26.0

package/src/ts/utils/algorithms/pixelCornersToRoundPaths.ts

@@ -0,0 +1,379 @@
+/**
+ * A script to convert any boolean matrix to rounded paths.
+ *
+ * @author  Ikaros Kappler
+ * @date    2025-10-17 (ported to Typescript from a demo-script)
+ * @version 1.0.0
+ */
+
+import { Bounds } from "../../Bounds";
+import { SVGPathParams, XYCoords } from "../../interfaces";
+import { RasterPosition } from "../datastructures/DataGrid2d";
+import { DataGrid2dArrayMatrix } from "../datastructures/DataGrid2dArrayMatrix";
+
+const LEFT_BORDER: number = 0;
+const TOP_BORDER: number = 1;
+const RIGHT_BORDER: number = 2;
+const BOTTOM_BORDER: number = 3;
+
+export type PixelCornerPathOptions = {
+  origin?: XYCoords;
+  squareSize?: number;
+  gapSize?: number;
+  curveFactor?: number;
+};
+
+/**
+ * Computes an array of paths from the given boolean matrix.
+ *
+ * @param {DataGrid2dArrayMatrix<boolean>} matrix
+ * @param {PixelCornerPathOptions} options
+ * @returns
+ */
+export const pixelCornersToRoundPaths = (
+  matrix: DataGrid2dArrayMatrix<boolean>,
+  options: PixelCornerPathOptions
+): Array<SVGPathParams> => {
+  const paths: Array<SVGPathParams> = [];
+  const visitedLeftBorderMatrix = new DataGrid2dArrayMatrix(matrix.xSegmentCount, matrix.ySegmentCount, false);
+
+  const origin: XYCoords = options && options.origin ? options.origin : { x: 0, y: 0 };
+  const squareSize: number = options && typeof options.squareSize === "number" ? options.squareSize : 10;
+  const gapSize: number = options && typeof options.gapSize === "number" ? options.gapSize : 2;
+  const curveFactor: number = options && typeof options.curveFactor === "number" ? options.curveFactor : 0.666;
+
+  // Find an unvisited pixel with a free left neighbour
+  const condition = (value: boolean, x: number, y: number, _matrix: DataGrid2dArrayMatrix<boolean>) => {
+    return (
+      value === true &&
+      visitedLeftBorderMatrix.get(x, y) === false &&
+      // is left neighbour free?
+      (x - 1 < 0 || _matrix.get(x - 1, y) === false)
+    );
+  };
+
+  // Just to be sure the while loop terminates after a maximum number of iterations.
+  const safetyLimit: number = matrix.xSegmentCount * matrix.ySegmentCount + 1;
+
+  // The next unvisited pixel position.
+  var nonVisitedPosition: RasterPosition;
+
+  var i: number = 0;
+  while ((nonVisitedPosition = matrix.find(condition)) && i++ < safetyLimit) {
+    // console.log("nonVisitedPosition", nonVisitedPosition);
+    // Condition: if a point was found then its left neighbour is empty.
+    //            So by this the current pixel's left bound is definitely a path start.
+    const squareBox: Bounds = getSquareBox(origin, squareSize, gapSize, nonVisitedPosition.xIndex, nonVisitedPosition.yIndex);
+    const west: XYCoords = squareBox.getWestPoint();
+    // A starting point was found: Initialize the next path.
+    var pathData: SVGPathParams = [
+      // Start point
+      "M",
+      west.x,
+      west.y
+    ];
+    // Now from this point starting (left pixel corner) construct the next sequence of path commands.
+    __constructPath(
+      pathData,
+      matrix,
+      visitedLeftBorderMatrix,
+      nonVisitedPosition,
+      LEFT_BORDER,
+      origin,
+      squareSize,
+      gapSize,
+      curveFactor
+    );
+    paths.push(pathData);
+    // console.log("pathData", pathData);
+  }
+
+  return paths;
+};
+
+/**
+ * Construct a bounding box representing the visual square bounds for the given pixel.
+ *
+ * @param {XYCoords} origin - The origin to build the paths from (upper left corner of the graphics).
+ * @param {number} squareSize - The number of pixels to use to represent a pixel square.
+ * @param {number} gapSize - The number of pixels to use for gaps between squares.
+ * @param {number} x - The x position inside the data grid (matrix offset).
+ * @param {number} y - They  position inside the data grid (matrix offset).
+ * @returns
+ */
+const getSquareBox = (origin: XYCoords, squareSize: number, gapSize: number, x: number, y: number): Bounds => {
+  return new Bounds(
+    {
+      x: origin.x + x * (squareSize + gapSize),
+      y: origin.y + y * (squareSize + gapSize)
+    },
+    {
+      x: origin.x + x * (squareSize + gapSize) + squareSize,
+      y: origin.y + y * (squareSize + gapSize) + squareSize
+    }
+  );
+};
+
+/**
+ * Lerp between these two numbers using the passed lerp amount (usually a value in 0.0-1.0).
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} lerpFactor
+ * @returns {number}
+ */
+const lerp = (a: number, b: number, lerpFactor): number => {
+  return a + (b - a) * lerpFactor;
+};
+
+/**
+ * Construct a path command for a cubic Bézier curve.
+ *
+ * @param {SVGPathParams} pathData
+ * @param {XYCoords} start
+ * @param {XYCoords} controlA
+ * @param {XYCoords} controlB
+ * @param {XYCoords} end
+ * @param {number} curveFactor
+ */
+const addRoundCorner = (
+  pathData: SVGPathParams,
+  start: XYCoords,
+  controlA: XYCoords,
+  controlB: XYCoords,
+  end: XYCoords,
+  curveFactor: number
+) => {
+  pathData.push(
+    "C",
+    lerp(start.x, controlA.x, curveFactor),
+    lerp(start.y, controlA.y, curveFactor),
+    lerp(end.x, controlB.x, curveFactor),
+    lerp(end.y, controlB.y, curveFactor),
+    end.x,
+    end.y
+  );
+};
+
+/**
+ * Construct a new path command for a straight line.
+ *
+ * @param {SVGPathParams} pathData
+ * @param {XYCoords} target
+ */
+const addStraightLine = (pathData: SVGPathParams, target: XYCoords) => {
+  pathData.push("L", target.x, target.y);
+};
+
+/**
+ * A helper function for constructing the next path, beginning at the passed matrix position.
+ *
+ * Note the path will be created at the left border of the given 'pixel', constructe
+ * in clockwise order.
+ *
+ * @param {SVGPathParams} pathData
+ * @param {DataGrid2dArrayMatrix<boolean>} matrix - The data matrix to use.
+ * @param {DataGrid2dArrayMatrix<boolean>} visitedLeftBordersMatrix - A helper matrix to keep track of visited pixels.
+ * @param {RasterPosition} startingPosition
+ * @param {number} startingBorderDirection
+ * @param {XYCoords} origin
+ * @param {number} squareSize
+ * @param {number} gapSize
+ * @param {number} curveFactor
+ */
+const __constructPath = (
+  pathData: SVGPathParams,
+  matrix: DataGrid2dArrayMatrix<boolean>,
+  visitedLeftBordersMatrix: DataGrid2dArrayMatrix<boolean>,
+  startingPosition: RasterPosition,
+  startingBorderDirection: number,
+  origin: XYCoords,
+  squareSize: number,
+  gapSize: number,
+  curveFactor: number
+) => {
+  // Pre: position's neighbour pixel at ehe given border direction is unset.
+  var isPathComplete: boolean = false;
+  const maxInterations = matrix.xSegmentCount * matrix.ySegmentCount * 4 + 1;
+  var i = 0;
+  var position = startingPosition;
+  var borderDirection = startingBorderDirection;
+
+  while (!isPathComplete && i++ < maxInterations) {
+    var x = position.xIndex;
+    var y = position.yIndex;
+    // console.log("x", x, "y", y, "borderDirection", borderDirection);
+    // Get the pixel's box bounds.
+    const squareBox: Bounds = getSquareBox(origin, squareSize, gapSize, x, y);
+    // Find next step when walking 'clockwise'
+    if (borderDirection === LEFT_BORDER) {
+      // Only track visits on left borders. By this we can detect non-visited holes :)
+      visitedLeftBordersMatrix.set(x, y, true);
+      // We want to expand the left border
+      const west: XYCoords = squareBox.getWestPoint();
+      // Pixel in the north?
+      if (y - 1 < 0 || matrix.get(x, y - 1) === false) {
+        // Northwise pixel is empty
+        //  -> construct round corner to right
+        addRoundCorner(
+          pathData,
+          west,
+          squareBox.getNorthWestPoint(),
+          squareBox.getNorthWestPoint(),
+          squareBox.getNorthPoint(),
+          curveFactor
+        );
+        borderDirection = TOP_BORDER;
+        // Keep pixel position unchanged
+      } else if (x - 1 >= 0 && matrix.get(x - 1, y - 1) === true) {
+        // Top neighbour pixel is set AND top-left pixel is set too.
+        // -> construct rounded edge to top-left.
+        const squareBoxNW: Bounds = getSquareBox(origin, squareSize, gapSize, x - 1, y - 1);
+        addRoundCorner(
+          pathData,
+          west,
+          squareBox.getNorthWestPoint(),
+          squareBoxNW.getSouthEastPoint(),
+          squareBoxNW.getSouthPoint(),
+          curveFactor
+        );
+        borderDirection = BOTTOM_BORDER;
+        position = { xIndex: x - 1, yIndex: y - 1 };
+      } else {
+        // Straight to top
+        const squareBoxN: Bounds = getSquareBox(origin, squareSize, gapSize, x, y - 1);
+        addStraightLine(pathData, squareBoxN.getWestPoint());
+        position = { xIndex: x, yIndex: y - 1 };
+        // Keep borderDirection: LEFT_BORDER
+        // isPathComplete = true; // TODO
+      }
+    } else if (borderDirection === TOP_BORDER) {
+      // North pixel is definitely empty.
+      const north: XYCoords = squareBox.getNorthPoint();
+      if (x + 1 >= matrix.xSegmentCount || matrix.get(x + 1, y) === false) {
+        // Top border and right pixel is empty
+        //  --> create rounded corner to right south
+        addRoundCorner(
+          pathData,
+          north,
+          squareBox.getNorthEastPoint(),
+          squareBox.getNorthEastPoint(),
+          squareBox.getEastPoint(),
+          curveFactor
+        );
+        borderDirection = RIGHT_BORDER;
+        // Keep pixel position unchanged
+      } else if (y - 1 < 0 || matrix.get(x + 1, y - 1) === false) {
+        // Top border and right pixel is set, and north-east pixel is clear.
+        // -> linear path to right
+        const squareBoxE: Bounds = getSquareBox(origin, squareSize, gapSize, x + 1, y);
+        addStraightLine(pathData, squareBoxE.getNorthPoint());
+        position = { xIndex: x + 1, yIndex: y };
+        // Keep borderDirection TOP
+      } else {
+        // Last case: right neighbour is set and north-east pixel is set
+        //-> construct a rounded corner to east-north.
+        const squareBoxNE: Bounds = getSquareBox(origin, squareSize, gapSize, x + 1, y - 1);
+        addRoundCorner(
+          pathData,
+          north,
+          squareBox.getNorthEastPoint(),
+          squareBoxNE.getSouthWestPoint(),
+          squareBoxNE.getWestPoint(),
+          curveFactor
+        );
+        borderDirection = LEFT_BORDER;
+        position = { xIndex: x + 1, yIndex: y - 1 };
+        // isPathComplete = true; // TODO!!!
+      }
+    } else if (borderDirection === RIGHT_BORDER) {
+      // East pixel is definitely empty.
+      var east = squareBox.getEastPoint();
+      if (y + 1 >= matrix.ySegmentCount || matrix.get(x, y + 1) === false) {
+        // South pixel is empty.
+        // -> construct rounded corner to south-east
+        addRoundCorner(
+          pathData,
+          east,
+          squareBox.getSouthEastPoint(),
+          squareBox.getSouthEastPoint(),
+          squareBox.getSouthPoint(),
+          curveFactor
+        );
+        borderDirection = BOTTOM_BORDER;
+        // Keep pixel position unchanged
+      } else if (x + 1 < matrix.xSegmentCount && y + 1 < matrix.ySegmentCount && matrix.get(x + 1, y + 1) === true) {
+        // South pixel is set AND right lower pixel is set, too.
+        // -> construct round corner to south-east.
+        const squareBoxSE: Bounds = getSquareBox(origin, squareSize, gapSize, x + 1, y + 1);
+        addRoundCorner(
+          pathData,
+          east,
+          squareBox.getSouthEastPoint(),
+          squareBoxSE.getNorthWestPoint(),
+          squareBoxSE.getNorthPoint(),
+          curveFactor
+        );
+        borderDirection = TOP_BORDER;
+        position = { xIndex: x + 1, yIndex: y + 1 };
+      } else {
+        // South pixel is set and south-east pixel is clear.
+        // -> construct linear connection to south
+        const squareBoxS: Bounds = getSquareBox(origin, squareSize, gapSize, x, y + 1);
+        addStraightLine(pathData, squareBoxS.getEastPoint());
+        position = { xIndex: x, yIndex: y + 1 };
+        // Keep borderDirection RIGHT
+      }
+    } else if (borderDirection === BOTTOM_BORDER) {
+      // Pre: south pixel is definitely empty
+      const south: XYCoords = squareBox.getSouthPoint();
+      if (x - 1 < 0 || matrix.get(x - 1, y) === false) {
+        // Left pixel is empty
+        // -> construct round corner to west-north
+        addRoundCorner(
+          pathData,
+          south,
+          squareBox.getSouthWestPoint(),
+          squareBox.getSouthWestPoint(),
+          squareBox.getWestPoint(),
+          curveFactor
+        );
+        borderDirection = LEFT_BORDER;
+      } else if (x - 1 >= 0 && y + 1 < matrix.ySegmentCount && matrix.get(x - 1, y + 1) === true) {
+        // Left pixel AND left lower pixel are set
+        // -> construct rounded edge to south-west
+        const squareBoxSW: Bounds = getSquareBox(origin, squareSize, gapSize, x - 1, y + 1);
+        addRoundCorner(
+          pathData,
+          south,
+          squareBox.getSouthWestPoint(),
+          squareBoxSW.getNorthEastPoint(),
+          squareBoxSW.getEastPoint(),
+          curveFactor
+        );
+        borderDirection = RIGHT_BORDER;
+        position = { xIndex: x - 1, yIndex: y + 1 };
+      } else {
+        // Left pixel is set AND south pixel is empty
+        // -> construct linear edge to left neighbour.
+        const squareBoxW: Bounds = getSquareBox(origin, squareSize, gapSize, x - 1, y);
+        addStraightLine(pathData, squareBoxW.getSouthPoint());
+        position = { xIndex: x - 1, yIndex: y };
+        // Keep borderDirection BOTTOM
+      }
+    } else {
+      console.warn(`[Error] Cannot construct full rounded path; 'borderDirection' has wrong value (${borderDirection}).`);
+      isPathComplete = true;
+    }
+
+    // End condition reached?
+    if (
+      startingPosition.xIndex === position.xIndex &&
+      startingPosition.yIndex === position.yIndex &&
+      startingBorderDirection === borderDirection
+    ) {
+      pathData.push("Z");
+      isPathComplete = true;
+    }
+  }
+};

package/src/ts/utils/datastructures/DataGrid2d.ts

@@ -18,6 +18,13 @@
 
 export type DataGridFace4<T> = [[T | null, T | null], [T | null, T | null]];
 
+export type RasterPosition = {
+  xIndex: number;
+  yIndex: number;
+  xRel?: number;
+  yRel?: number;
+};
+
 export interface IDataGrid2d<T> {
   readonly xSegmentCount: number;
 

package/src/ts/utils/datastructures/DataGrid2dArrayMatrix.ts

@@ -0,0 +1,182 @@
+/**
+ * A DataGrid2d implementation on 2 dimensional arrays.
+ *
+ * @author   Ikaros Kappler
+ * @date     2025-10-16
+ * @modified 2025-10-28 Added `DataGrid2dArrayMatrix.setAll(function)`.
+ * @modified 2025-10-28 Fixed a bug in the `DataGrid2dArrayMatrix.toString()` method.
+ * @version  1.0.0
+ **/
+
+import { arrayFill } from "../algorithms/arrayFill";
+import { DataGridFace4, IDataGrid2d, RasterPosition } from "./DataGrid2d";
+
+export class DataGrid2dArrayMatrix<T> implements IDataGrid2d<T> {
+  /**
+   * @override
+   */
+  readonly xSegmentCount: number;
+
+  /**
+   * @override
+   */
+  readonly ySegmentCount: number;
+
+  // This is not really useful here ...
+  minDataValue: T;
+  maxDataValue: T;
+
+  private _matrix: Array<Array<T>>;
+
+  /**
+   * Create a new DataGrid2d from the given
+   * @throws Error if xSegmentCount*ySegmentCount is larger than the capacity of the array/list.
+   * @param list
+   * @param xSegmentCount
+   * @param ySegmentCount
+   */
+  constructor(xSegmentCount: number, ySegmentCount: number, initialValue: T) {
+    if (xSegmentCount <= 0) {
+      throw `Cannot create DataGrid2dArray, xSegmentCount (${xSegmentCount}) must be > 0.`;
+    }
+    if (ySegmentCount <= 0) {
+      throw `Cannot create DataGrid2dArray, ySegmentCount (${ySegmentCount}) must be > 0.`;
+    }
+
+    // this.canvas = document.getElementById(canvasId);
+    this.xSegmentCount = xSegmentCount;
+    this.ySegmentCount = ySegmentCount;
+
+    this._matrix = [];
+    for (var i = 0; i < ySegmentCount; i++) {
+      this._matrix.push(arrayFill(xSegmentCount, initialValue));
+    }
+  }
+
+  /**
+   * Set the matrix value at the given (x,y) position to a new value.
+   *
+   * @param {number} xIndex - The horizontal matrix position to set.
+   * @param {number} yIndex - The vertical matrix position to set.
+   * @param {T} value - The new value.
+   */
+  public set(xIndex: number, yIndex: number, value: T) {
+    this._matrix[yIndex][xIndex] = value;
+  }
+
+  /**
+   * Getthe matrix value at the given (x,y) position.
+   *
+   * @param {number} xIndex - The horizontal matrix position to set.
+   * @param {number} yIndex - The vertical matrix position to set.
+   * @return {T} value - The new value.
+   */
+  public get(xIndex: number, yIndex: number): T {
+    return this.getDataValueAt(xIndex, yIndex);
+  }
+
+  /**
+   * Set all matrix values. The passed factory function must accept respective (x,y) positions.
+   *
+   * @param {Function} factory - The factory function to determine the new values to set.
+   * @return {DataGrid2dArrayMatrix<T>} this - for chaning.
+   */
+  public setAll(factory: (xIndex: number, yIndex: number) => T): DataGrid2dArrayMatrix<T> {
+    for (var x = 0; x < this.xSegmentCount; x++) {
+      for (var y = 0; y < this.ySegmentCount; y++) {
+        this.set(x, y, factory(x, y));
+      }
+    }
+    return this;
+  }
+
+  public find(
+    condition: (value: T, xIndex: number, yIndex: number, sourceMatrix: DataGrid2dArrayMatrix<T>) => boolean
+  ): RasterPosition {
+    for (var x = 0; x < this.xSegmentCount; x++) {
+      for (var y = 0; y < this.ySegmentCount; y++) {
+        if (condition(this.get(x, y), x, y, this)) {
+          return {
+            xIndex: x,
+            yIndex: y,
+            xRel: x / this.xSegmentCount,
+            yRel: y / this.ySegmentCount
+          };
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @override
+   */
+  getMinDataValue(): T {
+    return this.minDataValue;
+  }
+
+  /**
+   * @override
+   */
+  getMaxDataValue(): T {
+    return this.maxDataValue;
+  }
+
+  /**
+   * @override
+   */
+  getDataValueAt(xIndex: number, yIndex: number, isDebug?: boolean): T | null {
+    return this._matrix[yIndex][xIndex];
+  }
+
+  /**
+   * @override
+   */
+  getDataFace4At(xIndex: number, yIndex: number, buffer: DataGridFace4<T>) {
+    // buffer: array[2][2]
+    buffer[0][0] = this.getDataValueAt(xIndex, yIndex);
+    buffer[1][0] = this.getDataValueAt(xIndex + 1, yIndex);
+    buffer[1][1] = this.getDataValueAt(xIndex + 1, yIndex + 1);
+    buffer[0][1] = this.getDataValueAt(xIndex, yIndex + 1);
+  }
+
+  /**
+   * A helper method to convert a boolean matrix to a parsable string.
+   *
+   * @param {DataGrid2dArrayMatrix<boolean>} matrix
+   * @returns {string}
+   */
+  static toString(matrix: DataGrid2dArrayMatrix<boolean>): string {
+    const buffer: Array<string> = [];
+    for (var y = 0; y < matrix.ySegmentCount; y++) {
+      for (var x = 0; x < matrix.xSegmentCount; x++) {
+        buffer.push(matrix.get(x, y) ? "X" : ".");
+      }
+      buffer.push("\n");
+    }
+    return buffer.join("");
+  }
+
+  /**
+   * Simple way to parse a data matrix from a string. `false` should be coded as '.' character,
+   * `true` must be coded as 'X' character.
+   *
+   * @param {string} str - The input string.
+   * @param {number} width - The desired width of the matrix (xSegmentCount).
+   * @param {number} height - The desired height of the matrix (ySegmentCount).
+   * @returns {DataGrid2dArrayMatrix<boolean>}
+   */
+  static parseBooleanMatrix(str: string, width: number, height: number): DataGrid2dArrayMatrix<boolean> {
+    const matrix = new DataGrid2dArrayMatrix<boolean>(width, height, false);
+    const lines: String[] = str.trim().split("\n");
+    for (var y = 0; y < lines.length && y < height; y++) {
+      lines[y] = lines[y].trim();
+      for (var x = 0; x < lines[y].length && x < width; x++) {
+        if (y < height && x < width && lines[y].charAt(x) === "X") {
+          matrix.set(x, y, true);
+        }
+      }
+    }
+    return matrix;
+  }
+}

package/src/ts/utils/datastructures/DataGrid2dListAdapter.ts

@@ -7,7 +7,7 @@
  * @version  1.0.0
  **/
 
-import { DataGridFace4, IDataGrid2d } from "./DataGrid2d";
+import { DataGridFace4, IDataGrid2d, RasterPosition } from "./DataGrid2d";
 
 type Triplet<T> = {
   x: T;
@@ -15,13 +15,6 @@ type Triplet<T> = {
   z: T;
 };
 
-type RasterPosition = {
-  xIndex: number;
-  yIndex: number;
-  xRel?: number;
-  yRel?: number;
-};
-
 export class DataGrid2dListAdapter<T> implements IDataGrid2d<T> {
   /**
    * @override
@@ -96,9 +89,9 @@ export class DataGrid2dListAdapter<T> implements IDataGrid2d<T> {
   getDataValueAt(xIndex: number, yIndex: number, isDebug?: boolean): T | null {
     // var bufferIndex = yIndex * this.xSegmentCount + xIndex;
     var bufferIndex = this.coordinateIndicesToBufferIndex(xIndex, yIndex);
-    if (isDebug) {
-      console.log("xIndex", xIndex, "yIndex", yIndex, "bufferIndex", bufferIndex);
-    }
+    // if (isDebug) {
+    //   console.log("xIndex", xIndex, "yIndex", yIndex, "bufferIndex", bufferIndex);
+    // }
     if (bufferIndex > this._dataList.length) {
       console.error("ERR buffer index is out of bounds! xIndex", xIndex, "yIndex", yIndex, "bufferIndex", bufferIndex);
     }

package/src/ts/utils/datastructures/GeometryMesh.ts

@@ -0,0 +1,79 @@
+/**
+ * Adapted from the 3D geometry datastuctured from demo-33 (depth mesh).
+ *
+ * Refactored the strucure into a class.
+ *
+ * @author   Ikaros Kappler
+ * @date     2025-11-14
+ * @modified 2025-11-17 Moved `getBounds` and `normalizeGeometry` from helper functions to this class.
+ * @version  1.0.0
+ */
+
+export type Vertex2 = { x: number; y: number };
+export type Vertex3 = { x: number; y: number; z: number };
+
+export class GeometryMesh<T extends Vertex2 | Vertex3> {
+  /**
+   * A set (array) of vertices (points) used in this mesh. Can be 2d or 3d.
+   *
+   * @member {Array<T>}
+   * @memberof GeometryMesh
+   * @type {Array<T>}
+   * @instance
+   */
+  vertices: Array<T>;
+
+  /**
+   * A set (array) of edges used in this mesh.
+   * Each edge consist of two indices indicating the vertex position.
+   *
+   * @member {Array<T>}
+   * @memberof GeometryMesh
+   * @type {Array<T>}
+   * @instance
+   */
+  edges: Array<[number, number]>;
+
+  constructor(vertices?: Array<T>, edges?: Array<[number, number]>) {
+    this.vertices = vertices || [];
+    this.edges = edges || [];
+  }
+
+  normalize() {
+    // Desired bounds is a max bounding box. The object will be scaled keeping aspect ratio
+    // in that way that the largest axis size touches the desired bounds.
+    var desiredBounds = { min: { x: -1, y: -1, z: -1 }, max: { x: 1, y: 1, z: 1 } };
+    var bounds = this.getGeometryBounds();
+    var sizeX = bounds.max.x - bounds.min.x;
+    var sizeY = bounds.max.y - bounds.min.y;
+    var sizeZ = bounds.max.z - bounds.min.z;
+    // Scale uniform so the dimension with the max expansion fits into [-1,1]
+    var maxDimension = Math.max(sizeX, sizeY, sizeZ);
+    var desiredSizeX = (desiredBounds.max.x - desiredBounds.min.x) / maxDimension;
+    var desiredSizeY = (desiredBounds.max.y - desiredBounds.min.y) / maxDimension;
+    var desiredSizeZ = (desiredBounds.max.z - desiredBounds.min.z) / maxDimension;
+    for (var i in this.vertices) {
+      var vert = this.vertices[i] as Vertex3; // TODO: Check if this is safe
+      vert.x = desiredBounds.min.x + (bounds.max.x - vert.x) * desiredSizeX;
+      vert.y = desiredBounds.min.y + (bounds.max.y - vert.y) * desiredSizeY;
+      vert.z = desiredBounds.min.z + (bounds.max.z - vert.z) * desiredSizeZ;
+    }
+  }
+
+  getGeometryBounds(): { min: Vertex3; max: Vertex3; width: number; height: number; depth: number } {
+    // var min = new Vert3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+    // var max = new Vert3(Number.MIN_VALUE, Number.MIN_VALUE, Number.MIN_VALUE);
+    var min = { x: Number.MAX_VALUE, y: Number.MAX_VALUE, z: Number.MAX_VALUE };
+    var max = { x: Number.MIN_VALUE, y: Number.MIN_VALUE, z: Number.MIN_VALUE };
+    for (var i in this.vertices) {
+      var vert = this.vertices[i] as Vertex3;
+      min.x = Math.min(vert.x, min.x);
+      min.y = Math.min(vert.y, min.y);
+      min.z = Math.min(vert.z, min.z);
+      max.x = Math.max(vert.x, max.x);
+      max.y = Math.max(vert.y, max.y);
+      max.z = Math.max(vert.z, max.z);
+    }
+    return { min: min, max: max, width: max.x - min.x, height: max.y - min.y, depth: max.z - min.z };
+  }
+}