plotboilerplate 1.21.0 → 1.22.0

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

@@ -0,0 +1,121 @@
+/**
+ * A DataGrid2d implementation on a linear array of triplets/Vector3.
+ *
+ * @author   Ikaros Kappler
+ * @date     2023-10-28
+ * @modified 2023-11-04 Converted to a Typescript class.
+ * @version  1.0.0
+ **/
+
+import { DataGridFace4, IDataGrid2d } from "./DataGrid2d";
+
+type Triplet<T> = {
+  x: T;
+  y: T;
+  z: T;
+};
+
+type RasterPosition = {
+  xIndex: number;
+  yIndex: number;
+  xRel?: number;
+  yRel?: number;
+};
+
+export class DataGrid2dListAdapter<T> implements IDataGrid2d<T> {
+  /**
+   * @override
+   */
+  readonly xSegmentCount: number;
+
+  /**
+   * @override
+   */
+  readonly ySegmentCount: number;
+
+  minDataValue: T;
+  maxDataValue: T;
+  minXValue: T;
+  maxXValue: T;
+  minYValue: T;
+  maxYValue: T;
+  private _dataList: Array<Triplet<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(list: Array<Triplet<T>>, xSegmentCount: number, ySegmentCount: number) {
+    if (xSegmentCount * ySegmentCount > list.length) {
+      throw `Cannot create DataGrid2dListAdapter, the list (length ${list.length}) does not provide enough items for ${xSegmentCount}x${ySegmentCount} required entries.`;
+    }
+
+    // this.canvas = document.getElementById(canvasId);
+    this.xSegmentCount = xSegmentCount;
+    this.ySegmentCount = ySegmentCount;
+
+    this._dataList = list;
+  }
+
+  getIndicesFromBufferIndex(bufferIndex: number): RasterPosition {
+    return { xIndex: Math.floor(bufferIndex % this.xSegmentCount), yIndex: Math.floor(bufferIndex / this.xSegmentCount) };
+  }
+
+  getCoordsFromBufferIndex(bufferIndex: number): RasterPosition {
+    var index = this.getIndicesFromBufferIndex(bufferIndex);
+    // Note that the xSegmentCount and ySegmentCount counts plane squares, each consisting of four vertices
+    index.xRel = index.xIndex / (this.xSegmentCount - 1);
+    index.yRel = index.yIndex / (this.ySegmentCount - 1);
+    return index;
+  }
+
+  coordinateIndicesToBufferIndex(xIndex: number, yIndex: number): number {
+    return yIndex * this.xSegmentCount + xIndex;
+  }
+
+  /**
+   * @override
+   */
+  getMinDataValue(): T {
+    return this.minDataValue;
+  }
+
+  /**
+   * @override
+   */
+  getMaxDataValue(): T {
+    return this.maxDataValue;
+  }
+
+  /**
+   * @override
+   */
+  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 (bufferIndex > this._dataList.length) {
+      console.error("ERR buffer index is out of bounds! xIndex", xIndex, "yIndex", yIndex, "bufferIndex", bufferIndex);
+    }
+    if (!this._dataList[bufferIndex]) {
+      console.error("ERR buffer element is null! xIndex", xIndex, "yIndex", yIndex, "bufferIndex", bufferIndex);
+    }
+    return this._dataList && bufferIndex < this._dataList.length ? this._dataList[bufferIndex].z : null;
+  }
+
+  /**
+   * @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);
+  }
+}

package/src/ts/utils/datastructures/GenericPath.ts

@@ -1,7 +1,8 @@
 /**
- * @author  Ikaros Kappler
- * @version 1.0.0
- * @date    2022-10-17
+ * @author   Ikaros Kappler
+ * @version  1.1.0
+ * @date     2022-10-17
+ * @modified 2023-11-27 Added the `GenericPath.getAllStartEndPoints()` function.
  */
 
 import { Path, PathSegment } from "../../interfaces/additionals";
@@ -110,4 +111,21 @@ export class GenericPath implements Path {
   getEndTangent(): Vertex {
     return this.segments[this.segments.length - 1].getEndTangent();
   }
+
+  /**
+   * Get the sequence of all start/end points of this path.
+   * Assumption is: each path segment's end point is located on the next segment's start point
+   * to shape a full connected path.
+   *
+   * No arcs are considered here, just plain linear segments.
+   *
+   * @returns {Array<Vertex>}
+   */
+  getAllStartEndPoints(): Array<Vertex> {
+    const verts: Array<Vertex> = [this.segments[0].getStartPoint()];
+    this.segments.forEach((segment: PathSegment) => {
+      verts.push(segment.getEndPoint());
+    });
+    return verts;
+  }
 }