@kitware/vtk.js 32.3.1 → 32.4.0

package/IO/Misc/GCodeReader.d.ts

@@ -0,0 +1,128 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import HtmlDataAccessHelper from './../Core/DataAccessHelper/HtmlDataAccessHelper';
+import HttpDataAccessHelper from './../Core/DataAccessHelper/HttpDataAccessHelper';
+import JSZipDataAccessHelper from './../Core/DataAccessHelper/JSZipDataAccessHelper';
+import LiteHttpDataAccessHelper from './../Core/DataAccessHelper/LiteHttpDataAccessHelper';
+
+interface IGCodeReaderOptions {
+  binary?: boolean;
+  compression?: string;
+  progressCallback?: any;
+}
+
+/**
+ *
+ */
+export interface IGCodeReaderInitialValues {}
+
+type vtkGCodeReaderBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkGCodeReader extends vtkGCodeReaderBase {
+  /**
+   *
+   */
+  getBaseURL(): string;
+
+  /**
+   *
+   */
+  getDataAccessHelper():
+    | HtmlDataAccessHelper
+    | HttpDataAccessHelper
+    | JSZipDataAccessHelper
+    | LiteHttpDataAccessHelper;
+
+  /**
+   * Get the url of the object to load.
+   */
+  getUrl(): string;
+
+  /**
+   * Load the object data.
+   * @param {IGCodeReaderOptions} [options]
+   */
+  loadData(options?: IGCodeReaderOptions): Promise<any>;
+
+  /**
+   * Parse data.
+   * @param {String | ArrayBuffer} content The content to parse.
+   */
+  parse(content: string | ArrayBuffer): void;
+
+  /**
+   * Parse data as ArrayBuffer.
+   * @param {ArrayBuffer} content The content to parse.
+   */
+  parseAsArrayBuffer(content: ArrayBuffer): void;
+
+  /**
+   * Parse data as text.
+   * @param {String} content The content to parse.
+   */
+  parseAsText(content: string): void;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   *
+   * @param dataAccessHelper
+   */
+  setDataAccessHelper(
+    dataAccessHelper:
+      | HtmlDataAccessHelper
+      | HttpDataAccessHelper
+      | JSZipDataAccessHelper
+      | LiteHttpDataAccessHelper
+  ): boolean;
+
+  /**
+   * Set the url of the object to load.
+   * @param {String} url the url of the object to load.
+   * @param {IGCodeReaderOptions} [option] The PLY reader options.
+   */
+  setUrl(url: string, option?: IGCodeReaderOptions): Promise<string | any>;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkGCodeReader characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IGCodeReaderInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IGCodeReaderInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkGCodeReader
+ * @param {IGCodeReaderInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IGCodeReaderInitialValues
+): vtkGCodeReader;
+
+/**
+ * vtkGCodeReader is a source object that reads a GCODE file.
+ */
+export declare const vtkGCodeReader: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkGCodeReader;

package/IO/Misc/GCodeReader.js

@@ -0,0 +1,236 @@
+import { m as macro } from '../../macros2.js';
+import BinaryHelper from '../Core/BinaryHelper.js';
+import DataAccessHelper from '../Core/DataAccessHelper.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
+
+// import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + gz
+// import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
+// import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
+
+// ----------------------------------------------------------------------------
+// vtkGCodeReader methods
+// ----------------------------------------------------------------------------
+function vtkGCodeReader(publicAPI, model) {
+  const state = {
+    currentPosition: {
+      x: 0,
+      y: 0,
+      z: 0
+    },
+    offset: {
+      x: 0,
+      y: 0,
+      z: 0
+    },
+    currentLayer: 0,
+    layers: new Map(),
+    // Map to store layer data
+    isAbsolute: true,
+    // G90 is default
+    isMetric: true,
+    // G21 is default
+    lastZ: 0 // Track Z changes for layer detection
+  };
+
+  model.classHierarchy.push('vtkGCodeReader');
+  if (!model.dataAccessHelper) {
+    model.dataAccessHelper = DataAccessHelper.get('http');
+  }
+  function fetchData(url) {
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      compression,
+      progressCallback
+    } = model;
+    if (option.binary) {
+      return model.dataAccessHelper.fetchBinary(url, {
+        compression,
+        progressCallback
+      });
+    }
+    return model.dataAccessHelper.fetchText(publicAPI, url, {
+      compression,
+      progressCallback
+    });
+  }
+  function detectLayerChange(newZ) {
+    if (Math.abs(newZ - state.lastZ) > 0.001) {
+      state.currentLayer++;
+      state.lastZ = newZ;
+      return true;
+    }
+    return false;
+  }
+  function initializeLayer() {
+    if (!state.layers.has(state.currentLayer)) {
+      const points = vtkPoints.newInstance();
+      const lines = vtkCellArray.newInstance();
+      const polyData = vtkPolyData.newInstance();
+      polyData.setPoints(points);
+      polyData.setLines(lines);
+      state.layers.set(state.currentLayer, {
+        polyData,
+        points,
+        lines,
+        zHeight: state.lastZ
+      });
+    }
+  }
+  function addLineToLayer(startPoint, endPoint) {
+    initializeLayer();
+    const layer = state.layers.get(state.currentLayer);
+
+    // Add points and get their indices
+    const startIndex = layer.points.insertNextPoint(startPoint[0], startPoint[1], startPoint[2]);
+    const endIndex = layer.points.insertNextPoint(endPoint[0], endPoint[1], endPoint[2]);
+
+    // Add line cell
+    layer.lines.insertNextCell([startIndex, endIndex]);
+  }
+  function processMove(params) {
+    const newPosition = {
+      ...state.currentPosition
+    };
+    let positionChanged = false;
+    ['X', 'Y', 'Z'].forEach(axis => {
+      if (axis in params) {
+        const value = state.isMetric ? params[axis] : params[axis] * 25.4;
+        newPosition[axis.toLowerCase()] = state.isAbsolute ? value + state.offset[axis.toLowerCase()] : state.currentPosition[axis.toLowerCase()] + value;
+        positionChanged = true;
+      }
+    });
+    if (positionChanged) {
+      if ('Z' in params) {
+        detectLayerChange(newPosition.z);
+      }
+      const startPoint = [state.currentPosition.x, state.currentPosition.y, state.currentPosition.z];
+      const endPoint = [newPosition.x, newPosition.y, newPosition.z];
+      addLineToLayer(startPoint, endPoint);
+      state.currentPosition = newPosition;
+    }
+  }
+  function processG92(params) {
+    ['X', 'Y', 'Z'].forEach(axis => {
+      if (axis in params) {
+        state.offset[axis.toLowerCase()] = state.currentPosition[axis.toLowerCase()] - (state.isMetric ? params[axis] : params[axis] * 25.4);
+      }
+    });
+  }
+  function processCommand(command, params) {
+    switch (command) {
+      case 'G0': // Rapid move
+      case 'G1':
+        // Linear move
+        processMove(params);
+        break;
+      case 'G20':
+        // Imperial
+        state.isMetric = false;
+        break;
+      case 'G21':
+        // Metric
+        state.isMetric = true;
+        break;
+      case 'G90':
+        // Absolute positioning
+        state.isAbsolute = true;
+        break;
+      case 'G91':
+        // Relative positioning
+        state.isAbsolute = false;
+        break;
+      case 'G92':
+        // Set position
+        processG92(params);
+        break;
+    }
+  }
+  function parseGCode(gcodeText) {
+    const lines = gcodeText.split('\n');
+    lines.forEach(line => {
+      const sline = line.split(';')[0].trim();
+      if (!sline) return;
+      const tokens = sline.split(' ');
+      const command = tokens[0];
+      const params = {};
+      tokens.slice(1).forEach(token => {
+        const param = token[0];
+        const value = parseFloat(token.slice(1));
+        if (!Number.isNaN(value)) {
+          params[param] = value;
+        }
+      });
+      processCommand(command, params);
+    });
+  }
+
+  // Public methods
+  publicAPI.setUrl = function (url) {
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      binary: true
+    };
+    model.url = url;
+    const path = url.split('/');
+    path.pop();
+    model.baseURL = path.join('/');
+    model.compression = option.compression;
+    return publicAPI.loadData({
+      progressCallback: option.progressCallback,
+      binary: !!option.binary
+    });
+  };
+  publicAPI.loadData = function () {
+    let option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const promise = fetchData(model.url, option);
+    promise.then(publicAPI.parse);
+    return promise;
+  };
+  publicAPI.parseAsText = content => {
+    parseGCode(content);
+  };
+  publicAPI.parseAsArrayBuffer = content => {
+    const data = BinaryHelper.arrayBufferToString(content);
+    parseGCode(data);
+  };
+  publicAPI.parse = content => {
+    if (typeof content === 'string') {
+      publicAPI.parseAsText(content);
+    } else {
+      publicAPI.parseAsArrayBuffer(content);
+    }
+    state.layers.forEach((layer, i) => {
+      model.output[i] = layer.polyData;
+    });
+  };
+  publicAPI.requestData = (inData, outData) => {
+    publicAPI.parse(model.parseData);
+  };
+  publicAPI.getNumberOfOutputPorts = () => state.layers.size;
+}
+const DEFAULT_VALUES = {
+  // baseURL: null,
+  // dataAccessHelper: null,
+  // url: null,
+};
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.get(publicAPI, model, ['url', 'baseURL']);
+  macro.setGet(publicAPI, model, ['dataAccessHelper']);
+  macro.algo(publicAPI, model, 0, 1);
+  macro.event(publicAPI, model, 'ready');
+  vtkGCodeReader(publicAPI, model);
+}
+const newInstance = macro.newInstance(extend, 'vtkGCodeReader');
+var vtkGCodeReader$1 = {
+  extend,
+  newInstance
+};
+
+export { vtkGCodeReader$1 as default, extend, newInstance };

package/IO/Misc.js

@@ -7,6 +7,7 @@ import vtkMTLReader from './Misc/MTLReader.js';
 import vtkOBJReader from './Misc/OBJReader.js';
 import vtkPDBReader from './Misc/PDBReader.js';
 import vtkSkyboxReader from './Misc/SkyboxReader.js';
+import vtkGCodeReader from './Misc/GCodeReader.js';
 
 var Misc = {
   vtkElevationReader,
@@ -17,7 +18,8 @@ var Misc = {
   vtkMTLReader,
   vtkOBJReader,
   vtkPDBReader,
-  vtkSkyboxReader
+  vtkSkyboxReader,
+  vtkGCodeReader
 };
 
 export { Misc as default };

package/Rendering/Core/Mapper/CoincidentTopologyHelper.js

@@ -30,7 +30,10 @@ const staticOffsetModel = {
     offset: -2
   }
 };
-const staticOffsetAPI = {};
+const noOp = () => undefined;
+const staticOffsetAPI = {
+  modified: noOp
+};
 addCoincidentTopologyMethods(staticOffsetAPI, staticOffsetModel, CATEGORIES.map(key => ({
   key,
   method: `ResolveCoincidentTopology${key}OffsetParameters`
@@ -61,7 +64,8 @@ function implementCoincidentTopologyMethods(publicAPI, model) {
   Object.keys(otherStaticMethods).forEach(methodName => {
     publicAPI[methodName] = otherStaticMethods[methodName];
   });
-  Object.keys(staticOffsetAPI).forEach(methodName => {
+  Object.keys(staticOffsetAPI).filter(methodName => methodName !== 'modified') // don't override instance's modified
+  .forEach(methodName => {
     publicAPI[methodName] = staticOffsetAPI[methodName];
   });
   addCoincidentTopologyMethods(publicAPI, model.topologyOffset, CATEGORIES.map(key => ({

package/index.d.ts

@@ -97,6 +97,7 @@
 /// <reference path="./IO/Geometry/STLReader.d.ts" />
 /// <reference path="./IO/Geometry/STLWriter.d.ts" />
 /// <reference path="./IO/Misc/ElevationReader.d.ts" />
+/// <reference path="./IO/Misc/GCodeReader.d.ts" />
 /// <reference path="./IO/Misc/ITKImageReader.d.ts" />
 /// <reference path="./IO/Misc/ITKPolyDataReader.d.ts" />
 /// <reference path="./IO/Misc/JSONNucleoReader.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "32.3.1",
+  "version": "32.4.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",