@kitware/vtk.js 34.5.0 → 34.7.0

package/Filters/General/TransformPolyDataFilter.js

@@ -0,0 +1,194 @@
+import { m as macro } from '../../macros2.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// vtkTransformPolyDataFilter methods
+// ----------------------------------------------------------------------------
+
+function vtkTransformPolyDataFilter(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTransformPolyDataFilter');
+
+  // Internal method to handle the actual transformation
+  function transformPolyData(input, output) {
+    if (!model.transform) {
+      vtkErrorMacro('No transform defined!');
+      return false;
+    }
+    const inPts = input.getPoints();
+    const inPtData = input.getPointData();
+    const outPD = output.getPointData();
+    const inCellData = input.getCellData();
+    const outCD = output.getCellData();
+    if (!inPts) {
+      // Input polydata is empty. This is not an error, the output will be just empty, too.
+      return true;
+    }
+    const numPoints = inPts.getNumberOfPoints();
+
+    // Get input vectors and normals (points and cells)
+    const inVectors = inPtData.getVectors();
+    const inNormals = inPtData.getNormals();
+    const inCellVectors = inCellData.getVectors();
+    const inCellNormals = inCellData.getNormals();
+
+    // Set the desired precision for the points in the output
+    let pointType = inPts.getDataType();
+    if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
+      pointType = VtkDataTypes.FLOAT;
+    } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
+      pointType = VtkDataTypes.DOUBLE;
+    }
+
+    // Create output points with appropriate precision
+    const outPts = vtkPoints.newInstance({
+      dataType: pointType
+    });
+
+    // Transform points
+    const inPtsData = inPts.getData();
+    outPts.setNumberOfPoints(numPoints);
+    const outPtsData = outPts.getData();
+
+    // Transform vectors if present
+    let outVectors = null;
+    if (inVectors) {
+      outVectors = vtkDataArray.newInstance({
+        name: inVectors.getName(),
+        numberOfComponents: 3,
+        size: numPoints * 3
+      });
+    }
+
+    // Transform normals if present
+    let outNormals = null;
+    if (inNormals) {
+      outNormals = vtkDataArray.newInstance({
+        name: inNormals.getName(),
+        numberOfComponents: 3,
+        size: numPoints * 3
+      });
+    }
+    if (inVectors || inNormals) {
+      model.transform.transformPointsNormalsVectors(inPts, outPts, inNormals, outNormals, inVectors, outVectors);
+    } else {
+      model.transform.transformPoints(inPtsData, outPtsData);
+    }
+
+    // Transform cell vectors if present
+    let outCellVectors = null;
+    if (inCellVectors) {
+      const numCells = inCellVectors.getNumberOfTuples();
+      outCellVectors = vtkDataArray.newInstance({
+        name: inCellVectors.getName(),
+        numberOfComponents: 3,
+        size: numCells * 3
+      });
+      model.transform.transformVectors(inCellVectors, outCellVectors);
+    }
+
+    // Transform cell normals if present
+    let outCellNormals = null;
+    if (inCellNormals) {
+      const numCells = inCellNormals.getNumberOfTuples();
+      outCellNormals = vtkDataArray.newInstance({
+        name: inCellNormals.getName(),
+        numberOfComponents: 3,
+        size: numCells * 3
+      });
+      model.transform.transformNormals(inCellNormals, outCellNormals);
+    }
+
+    // Set output data
+    output.setPoints(outPts);
+
+    // Copy cell topology
+    output.setVerts(input.getVerts());
+    output.setLines(input.getLines());
+    output.setPolys(input.getPolys());
+    output.setStrips(input.getStrips());
+
+    // Set transformed point data
+    if (outNormals) {
+      outPD.setNormals(outNormals);
+      outPD.copyFieldOff(outNormals.getName());
+    }
+    if (outVectors) {
+      outPD.setVectors(outVectors);
+      outPD.copyFieldOff(outVectors.getName());
+    }
+
+    // Set transformed cell data
+    if (outCellNormals) {
+      outCD.setNormals(outCellNormals);
+      outCD.copyFieldOff(outCellNormals.getName());
+    }
+    if (outCellVectors) {
+      outCD.setVectors(outCellVectors);
+      outCD.copyFieldOff(outCellVectors.getName());
+    }
+
+    // Pass through other data
+    outPD.passData(inPtData);
+    outCD.passData(inCellData);
+    return true;
+  }
+  publicAPI.requestData = (inData, outData) => {
+    const input = inData[0];
+    const output = outData[0] || vtkPolyData.newInstance();
+    if (transformPolyData(input, output)) {
+      outData[0] = output;
+    } else {
+      vtkErrorMacro('TransformPolyDataFilter failed to transform input data.');
+    }
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  transform: null,
+  outputPointsPrecision: DesiredOutputPrecision.DEFAULT
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
+
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 1, 1);
+
+  // Set/Get methods
+  macro.setGet(publicAPI, model, ['transform', 'outputPointsPrecision']);
+
+  // Object specific methods
+  vtkTransformPolyDataFilter(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTransformPolyDataFilter');
+
+// ----------------------------------------------------------------------------
+
+var vtkTransformPolyDataFilter$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTransformPolyDataFilter$1 as default, extend, newInstance };

package/Filters/General.js

@@ -15,6 +15,7 @@ import vtkOBBTree from './General/OBBTree.js';
 import vtkOutlineFilter from './General/OutlineFilter.js';
 import vtkPaintFilter from './General/PaintFilter.js';
 import vtkScalarToRGBA from './General/ScalarToRGBA.js';
+import vtkTransformPolyDataFilter from './General/TransformPolyDataFilter.js';
 import vtkTriangleFilter from './General/TriangleFilter.js';
 import vtkTubeFilter from './General/TubeFilter.js';
 import vtkWarpScalar from './General/WarpScalar.js';
@@ -38,6 +39,7 @@ var General = {
   vtkOutlineFilter,
   vtkPaintFilter,
   vtkScalarToRGBA,
+  vtkTransformPolyDataFilter,
   vtkTriangleFilter,
   vtkTubeFilter,
   vtkWarpScalar,

package/Filters/Sources/CircleSource.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
-import { w as multiplyScalar } from '../../Common/Core/Math/index.js';
+import { x as multiplyScalar } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkCircleSource methods

package/Filters/Sources/PointSource.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { x as random } from '../../Common/Core/Math/index.js';
+import { y as random } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 // ----------------------------------------------------------------------------

package/Filters/Texture/TextureMapToPlane.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { l as normalize, d as dot, j as cross, e as distance2BetweenPoints, y as determinant3x3, z as rowsToMat3 } from '../../Common/Core/Math/index.js';
+import { l as normalize, d as dot, j as cross, e as distance2BetweenPoints, z as determinant3x3, A as rowsToMat3 } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
 const {

package/IO/Geometry/DracoReader.js

@@ -137,7 +137,7 @@ function getPolyDataFromDracoGeometry(decoder, dracoGeometry) {
   const indices = decodeIndices(decoder, dracoGeometry);
   const nCells = indices.length - 2;
   const cells = vtkCellArray.newInstance();
-  cells.resize(4 * indices.length / 3);
+  cells.allocate(4 * indices.length / 3);
   for (let cellId = 0; cellId < nCells; cellId += 3) {
     const cell = indices.slice(cellId, cellId + 3);
     cells.insertNextCell(cell);

package/IO/Geometry/GLTFImporter/Animations.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../../macros2.js';
-import { A as degreesFromRadians } from '../../../Common/Core/Math/index.js';
+import { B as degreesFromRadians } from '../../../Common/Core/Math/index.js';
 import { quat, vec3 } from 'gl-matrix';
 
 const {

package/IO/Geometry/GLTFImporter/Reader.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../../macros2.js';
-import { A as degreesFromRadians } from '../../../Common/Core/Math/index.js';
+import { B as degreesFromRadians } from '../../../Common/Core/Math/index.js';
 import vtkActor from '../../../Rendering/Core/Actor.js';
 import vtkCamera from '../../../Rendering/Core/Camera.js';
 import vtkDataArray from '../../../Common/Core/DataArray.js';
@@ -125,7 +125,7 @@ async function createPolyDataFromGLTFMesh(primitive) {
         vtkWarningMacro('GL_LINE_LOOP not implemented');
         break;
       default:
-        cells.resize(4 * indices.length / 3);
+        cells.allocate(4 * indices.length / 3);
         for (let cellId = 0; cellId < nCells; cellId += 3) {
           const cell = indices.slice(cellId, cellId + 3);
           cells.insertNextCell(cell);

package/IO/Image/HDRReader/Utils.js

@@ -1,4 +1,4 @@
-import { B as ldexp } from '../../../Common/Core/Math/index.js';
+import { C as ldexp } from '../../../Common/Core/Math/index.js';
 
 /**
  * Read a line from a Uint8Array

package/IO/Image/HDRReader.js

@@ -1,7 +1,7 @@
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 import { m as macro } from '../../macros2.js';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
-import { C as xyz2rgb } from '../../Common/Core/Math/index.js';
+import { D as xyz2rgb } from '../../Common/Core/Math/index.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { readLine, rgbe2float } from './HDRReader/Utils.js';

package/IO/Misc/OBJWriter.d.ts

@@ -0,0 +1,103 @@
+import vtkPolyData from './../../Common/DataModel/PolyData';
+import vtkTexture from './../../Rendering/Core/Texture';
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+
+/**
+ *
+ */
+export interface IOBJWriterInitialValues {
+  modelFilename?: string;
+  materialFilename?: string;
+  texture?: vtkTexture;
+  textureFileName?: string;
+}
+
+type vtkOBJWriterBase = vtkObject & vtkAlgorithm;
+
+export interface vtkOBJWriter extends vtkOBJWriterBase {
+  /**
+   * Get the zip file containing the OBJ and MTL files.
+   */
+  exportAsZip(): Promise<Uint8Array>;
+
+  /**
+   * Get the MTL file as a string.
+   */
+  getMtl(): string;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the material filename.
+   * @param materialFilename
+   * @returns {boolean} true if the material file name was set successfully
+   */
+  setMaterialFilename(materialFilename: string): boolean;
+
+  /**
+   * Set the model filename.
+   * @param modelFilename
+   */
+  setModelFilename(modelFilename: string): boolean;
+
+  /**
+   * Set the texture instance.
+   * @param {vtkTexture} texture
+   * @returns {boolean} true if the texture was set successfully
+   */
+  setTexture(texture: vtkTexture): boolean;
+
+  /**
+   * Set the texture file name.
+   * @param {string} textureFileName
+   * @returns {boolean} true if the texture file name was set successfully
+   */
+  setTextureFileName(textureFileName: string): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkOBJWriter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IOBJWriterInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IOBJWriterInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkOBJWriter
+ * @param {IOBJWriterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IOBJWriterInitialValues
+): vtkOBJWriter;
+
+/**
+ *
+ * @param {vktPolyData} polyData
+ */
+export function writeOBJ(polyData: vtkPolyData): vtkPolyData;
+
+/**
+ * vtkOBJWriter writes wavefront obj (.obj) files in ASCII form. OBJ files
+ * contain the geometry including lines, triangles and polygons. Normals and
+ * texture coordinates on points are also written if they exist.
+ *
+ * One can specify a texture passing a vtkTexture using `setTexture`. If a texture is
+ * set, additional .mtl and .png files are generated.
+ */
+export declare const vtkOBJWriter: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  writeOBJ: typeof writeOBJ;
+};
+export default vtkOBJWriter;

package/IO/Misc/OBJWriter.js

@@ -0,0 +1,235 @@
+import { strToU8, zipSync } from 'fflate';
+import { m as macro } from '../../macros2.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkTriangleStrip from '../../Common/DataModel/TriangleStrip.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+// vtkOBJWriter methods
+// ----------------------------------------------------------------------------
+
+const writeFaces = (faces, withNormals, withTCoords) => {
+  let outputData = '';
+  const fd = faces.getData();
+  let offset = 0;
+  while (offset < fd.length) {
+    const faceSize = fd[offset++];
+    outputData += 'f';
+    for (let i = 0; i < faceSize; i++) {
+      outputData += ` ${fd[offset + i] + 1}`;
+      if (withTCoords) {
+        outputData += `/${fd[offset + i] + 1}`;
+        if (withNormals) {
+          outputData += `//${fd[offset + i] + 1}`;
+        }
+      } else if (withNormals) {
+        outputData += `//${fd[offset + i] + 1}`;
+      }
+    }
+    offset += faceSize;
+    outputData += '\n';
+  }
+  return outputData;
+};
+const writeLines = lines => {
+  let outputData = '';
+  const ld = lines.getData();
+  let offset = 0;
+  while (offset < ld.length) {
+    const lineSize = ld[offset++];
+    outputData += 'l';
+    for (let i = 0; i < lineSize; i++) {
+      outputData += ` ${ld[offset + i] + 1}`;
+    }
+    offset += lineSize;
+    outputData += '\n';
+  }
+  return outputData;
+};
+const writePoints = (pts, normals, tcoords) => {
+  const outputData = [];
+  const nbPts = pts.getNumberOfPoints();
+  let p;
+
+  // Positions
+  for (let i = 0; i < nbPts; i++) {
+    p = pts.getPoint(i);
+    outputData.push(`v ${p[0]} ${p[1]} ${p[2]}`);
+  }
+
+  // Normals
+  if (normals) {
+    for (let i = 0; i < nbPts; i++) {
+      p = normals.getTuple(i);
+      outputData.push(`vn ${p[0]} ${p[1]} ${p[2]}`);
+    }
+  }
+
+  // Textures
+  if (tcoords) {
+    for (let i = 0; i < nbPts; i++) {
+      p = tcoords.getTuple(i);
+      if (p[0] !== -1.0) {
+        outputData.push(`vt ${p[0]} ${p[1]}`);
+      }
+    }
+  }
+  return `${outputData.join('\n')}\n`;
+};
+const writeMTL = (materialName, textureFileName) => {
+  const outputData = [];
+  outputData.push(`newmtl ${materialName}`);
+  outputData.push(`map_Kd ${textureFileName}`);
+  return outputData.join('\n');
+};
+const writeOBJ = (polyData, materialFilename, materialName) => {
+  let outputData = '# VTK.js generated OBJ File\n';
+  const pts = polyData.getPoints();
+  const polys = polyData.getPolys();
+  const strips = polyData.getStrips() ? polyData.getStrips().getData() : null;
+  const lines = polyData.getLines();
+  const normals = polyData.getPointData().getNormals();
+  const tcoords = polyData.getPointData().getTCoords();
+  const hasPtNormals = normals !== null;
+  const hasPtTCoords = tcoords !== null;
+  if (!pts) {
+    vtkErrorMacro('No data to write!');
+    return outputData;
+  }
+  if (materialFilename) {
+    // Write material library
+    outputData += `mtllib ${materialFilename}\n`;
+  }
+
+  // Write material if a texture is specified
+  if (materialName) {
+    // declare material in obj file
+    outputData += `usemtl ${materialName}\n`;
+  }
+
+  // Write points
+  outputData += writePoints(pts, normals, tcoords);
+
+  // Decompose any triangle strips into triangles
+  const polyStrips = vtkCellArray.newInstance();
+  if (strips && strips.length > 0) {
+    vtkTriangleStrip.decomposeStrip(pts, polyStrips);
+  }
+
+  // Write triangle strips
+  if (polyStrips.getNumberOfCells() > 0) {
+    outputData += writeFaces(polyStrips, hasPtNormals, hasPtTCoords);
+  }
+
+  // Write polygons.
+  if (polys) {
+    outputData += writeFaces(polys, hasPtNormals, hasPtTCoords);
+  }
+
+  // Write lines.
+  if (lines) {
+    outputData += writeLines(lines);
+  }
+  return outputData;
+};
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+const STATIC = {
+  writeOBJ
+};
+
+// ----------------------------------------------------------------------------
+// vtkOBJWriter methods
+// ----------------------------------------------------------------------------
+
+function vtkOBJWriter(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkOBJWriter');
+  publicAPI.exportAsZip = () => {
+    publicAPI.update();
+    const modelFilename = model.modelFilename;
+    const materialFilename = model.materialFilename;
+    const textureFileName = model.textureFileName;
+    const imageData = model.texture.getInputAsJsImageData?.();
+    const zipContent = {};
+    zipContent[`${modelFilename}.obj`] = strToU8(model.output[0]);
+    zipContent[`${materialFilename}.mtl`] = strToU8(model.mtl);
+    const canvas = new OffscreenCanvas(imageData.width, imageData.height);
+    const ctx = canvas.getContext('2d');
+    ctx.putImageData(imageData, 0, 0);
+    return new Promise(resolve => {
+      canvas.toBlob(async blob => {
+        const arrayBuffer = await blob.arrayBuffer();
+        zipContent[`${textureFileName}.png`] = new Uint8Array(arrayBuffer);
+        resolve(zipSync(zipContent));
+      }, 'image/png');
+    });
+  };
+  publicAPI.requestData = (inData, outData) => {
+    const input = inData[0];
+    if (!input || !input.isA('vtkPolyData')) {
+      vtkErrorMacro('Invalid or missing vtkPolyData input');
+      return;
+    }
+
+    // Update output
+    const materialFilename = `${model.materialFilename}.mtl`;
+    const textureFileName = `${model.textureFileName}.png`;
+    outData[0] = writeOBJ(input, materialFilename, model.materialName);
+    model.mtl = writeMTL(model.materialName, textureFileName);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  modelFilename: 'model',
+  materialName: 'mat_01',
+  materialFilename: 'material',
+  texture: null,
+  textureFileName: 'texture'
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
+
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 1, 1);
+  macro.get(publicAPI, model, ['mtl']);
+  macro.set(publicAPI, model, ['modelFilename', 'materialFilename', 'texture', 'textureFileName']);
+
+  // Object specific methods
+  vtkOBJWriter(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkOBJWriter');
+
+// ----------------------------------------------------------------------------
+
+var vtkOBJWriter$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
+
+export { STATIC, vtkOBJWriter$1 as default, extend, newInstance };

package/IO/Misc.js

@@ -5,6 +5,7 @@ import vtkJSONNucleoReader from './Misc/JSONNucleoReader.js';
 import vtkJSONReader from './Misc/JSONReader.js';
 import vtkMTLReader from './Misc/MTLReader.js';
 import vtkOBJReader from './Misc/OBJReader.js';
+import vtkOBJWriter from './Misc/OBJWriter.js';
 import vtkPDBReader from './Misc/PDBReader.js';
 import vtkSkyboxReader from './Misc/SkyboxReader.js';
 import vtkGCodeReader from './Misc/GCodeReader.js';
@@ -17,6 +18,7 @@ var Misc = {
   vtkJSONReader,
   vtkMTLReader,
   vtkOBJReader,
+  vtkOBJWriter,
   vtkPDBReader,
   vtkSkyboxReader,
   vtkGCodeReader

package/Interaction/Manipulators/MouseCameraTrackballRollManipulator.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { r as radiansFromDegrees, A as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, B as degreesFromRadians } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballRollManipulator methods

package/Interaction/Manipulators/MouseCameraTrackballRotateManipulator.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { w as multiplyScalar, d as dot, k as add, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
+import { x as multiplyScalar, d as dot, k as add, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballRotateManipulator methods

package/Interaction/Manipulators/MouseCameraUnicamManipulator.js

@@ -3,7 +3,7 @@ import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import vtkInteractorStyleConstants from '../../Rendering/Core/InteractorStyle/Constants.js';
 import vtkMouseCameraUnicamRotateManipulator from './MouseCameraUnicamRotateManipulator.js';
 import { m as macro } from '../../macros2.js';
-import { s as subtract, w as multiplyScalar, l as normalize, d as dot, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
+import { s as subtract, x as multiplyScalar, l as normalize, d as dot, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
 
 const {
   States