@kitware/vtk.js 33.0.0 → 33.0.1

package/Rendering/OpenGL/CellArrayBufferObject/helpers.js

@@ -0,0 +1,45 @@
+function computeCoordShiftAndScale(points) {
+  // Find out if shift scale should be used
+  // Compute squares of diagonal size and distance from the origin
+  let diagSq = 0.0;
+  let distSq = 0.0;
+  for (let i = 0; i < 3; ++i) {
+    const range = points.getRange(i);
+    const delta = range[1] - range[0];
+    diagSq += delta * delta;
+    const distShift = 0.5 * (range[1] + range[0]);
+    distSq += distShift * distShift;
+  }
+  const useShiftAndScale = diagSq > 0 && (Math.abs(distSq) / diagSq > 1.0e6 ||
+  // If data is far from the origin relative to its size
+  Math.abs(Math.log10(diagSq)) > 3.0 ||
+  // If the size is huge when not far from the origin
+  diagSq === 0 && distSq > 1.0e6); // If data is a point, but far from the origin
+
+  if (useShiftAndScale) {
+    // Compute shift and scale vectors
+    const coordShift = new Float64Array(3);
+    const coordScale = new Float64Array(3);
+    for (let i = 0; i < 3; ++i) {
+      const range = points.getRange(i);
+      const delta = range[1] - range[0];
+      coordShift[i] = 0.5 * (range[1] + range[0]);
+      coordScale[i] = delta > 0 ? 1.0 / delta : 1.0;
+    }
+    return {
+      useShiftAndScale,
+      coordShift,
+      coordScale
+    };
+  }
+  return {
+    useShiftAndScale,
+    coordShift: new Float32Array([0, 0, 0]),
+    coordScale: new Float32Array([1, 1, 1])
+  };
+}
+var helpers = {
+  computeCoordShiftAndScale
+};
+
+export { computeCoordShiftAndScale, helpers as default };

package/Rendering/OpenGL/CellArrayBufferObject.js

@@ -3,6 +3,7 @@ import { m as macro } from '../../macros2.js';
 import vtkBufferObject from './BufferObject.js';
 import { ObjectType } from './BufferObject/Constants.js';
 import { Representation } from '../Core/Property/Constants.js';
+import { computeCoordShiftAndScale } from './CellArrayBufferObject/helpers.js';
 
 const {
   vtkErrorMacro
@@ -217,32 +218,12 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
     let ucidx = 0;
 
     // Find out if shift scale should be used
-    // Compute squares of diagonal size and distance from the origin
-    let diagSq = 0.0;
-    let distSq = 0.0;
-    for (let i = 0; i < 3; ++i) {
-      const range = options.points.getRange(i);
-      const delta = range[1] - range[0];
-      diagSq += delta * delta;
-      const distShift = 0.5 * (range[1] + range[0]);
-      distSq += distShift * distShift;
-    }
-    const useShiftAndScale = diagSq > 0 && (Math.abs(distSq) / diagSq > 1.0e6 ||
-    // If data is far from the origin relative to its size
-    Math.abs(Math.log10(diagSq)) > 3.0 ||
-    // If the size is huge when not far from the origin
-    diagSq === 0 && distSq > 1.0e6); // If data is a point, but far from the origin
-
+    const {
+      useShiftAndScale,
+      coordShift,
+      coordScale
+    } = computeCoordShiftAndScale(options.points);
     if (useShiftAndScale) {
-      // Compute shift and scale vectors
-      const coordShift = new Float64Array(3);
-      const coordScale = new Float64Array(3);
-      for (let i = 0; i < 3; ++i) {
-        const range = options.points.getRange(i);
-        const delta = range[1] - range[0];
-        coordShift[i] = 0.5 * (range[1] + range[0]);
-        coordScale[i] = delta > 0 ? 1.0 / delta : 1.0;
-      }
       publicAPI.setCoordShiftAndScale(coordShift, coordScale);
     } else if (model.coordShiftAndScaleEnabled === true) {
       // Make sure to reset

package/Rendering/OpenGL/SphereMapper.js

@@ -8,6 +8,7 @@ import vtkOpenGLPolyDataMapper from './PolyDataMapper.js';
 import { v as vtkSphereMapperVS } from './glsl/vtkSphereMapperVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import { computeCoordShiftAndScale } from './CellArrayBufferObject/helpers.js';
 
 const {
   vtkErrorMacro
@@ -112,14 +113,24 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
     if (program.isUniformUsed('VCPCMatrix')) {
       program.setUniformMatrix('VCPCMatrix', keyMats.vcpc);
     }
+
+    // mat4.create() defaults to Float32Array b/c of gl-matrix's settings.
+    // We need Float64Array to avoid loss of precision with large coordinates.
+    const tmp4 = new Float64Array(16);
     if (program.isUniformUsed('MCVCMatrix')) {
       if (!actor.getIsIdentity()) {
         const actMats = model.openGLActor.getKeyMatrices();
-        const tmp4 = new Float64Array(16);
         mat4.multiply(tmp4, keyMats.wcvc, actMats.mcwc);
+        if (cellBO.getCABO().getCoordShiftAndScaleEnabled()) {
+          mat4.multiply(tmp4, tmp4, cellBO.getCABO().getInverseShiftAndScaleMatrix());
+        }
         program.setUniformMatrix('MCVCMatrix', tmp4);
       } else {
-        program.setUniformMatrix('MCVCMatrix', keyMats.wcvc);
+        mat4.copy(tmp4, keyMats.wcvc);
+        if (cellBO.getCABO().getCoordShiftAndScaleEnabled()) {
+          mat4.multiply(tmp4, tmp4, cellBO.getCABO().getInverseShiftAndScaleMatrix());
+        }
+        program.setUniformMatrix('MCVCMatrix', tmp4);
       }
     }
     if (program.isUniformUsed('cameraParallel')) {
@@ -166,6 +177,14 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
     const cos30 = Math.cos(radiansFromDegrees(30.0));
     let pointIdx = 0;
     let colorIdx = 0;
+    const {
+      useShiftAndScale,
+      coordShift,
+      coordScale
+    } = computeCoordShiftAndScale(points);
+    if (useShiftAndScale) {
+      vbo.setCoordShiftAndScale(coordShift, coordScale);
+    }
 
     //
     // Generate points and point data for sides
@@ -178,9 +197,12 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
         radius = scales[i];
       }
       pointIdx = i * 3;
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
+      const ptX = (pointArray[pointIdx++] - coordShift[0]) * coordScale[0];
+      const ptY = (pointArray[pointIdx++] - coordShift[1]) * coordScale[1];
+      const ptZ = (pointArray[pointIdx++] - coordShift[2]) * coordScale[2];
+      packedVBO[vboIdx++] = ptX;
+      packedVBO[vboIdx++] = ptY;
+      packedVBO[vboIdx++] = ptZ;
       packedVBO[vboIdx++] = -2.0 * radius * cos30;
       packedVBO[vboIdx++] = -radius;
       if (colorData) {
@@ -190,10 +212,9 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
         packedUCVBO[ucIdx++] = colorData[colorIdx + 2];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 3];
       }
-      pointIdx = i * 3;
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
+      packedVBO[vboIdx++] = ptX;
+      packedVBO[vboIdx++] = ptY;
+      packedVBO[vboIdx++] = ptZ;
       packedVBO[vboIdx++] = 2.0 * radius * cos30;
       packedVBO[vboIdx++] = -radius;
       if (colorData) {
@@ -202,10 +223,9 @@ function vtkOpenGLSphereMapper(publicAPI, model) {
         packedUCVBO[ucIdx++] = colorData[colorIdx + 2];
         packedUCVBO[ucIdx++] = colorData[colorIdx + 3];
       }
-      pointIdx = i * 3;
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
-      packedVBO[vboIdx++] = pointArray[pointIdx++];
+      packedVBO[vboIdx++] = ptX;
+      packedVBO[vboIdx++] = ptY;
+      packedVBO[vboIdx++] = ptZ;
       packedVBO[vboIdx++] = 0.0;
       packedVBO[vboIdx++] = 2.0 * radius;
       if (colorData) {

package/package.json

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