@kitware/vtk.js 33.0.0 → 33.0.2

package/IO/Geometry/PLYReader.d.ts

@@ -13,7 +13,19 @@ interface IPLYReaderOptions {
 /**
  *
  */
-export interface IPLYReaderInitialValues {}
+export interface IPLYReaderInitialValues {
+  /**
+   * Controls whether points are duplicated for face-texture mapping.
+   * Default is true.
+   */
+  duplicatePointsForFaceTexture?: boolean;
+
+  /**
+   * The tolerance used to determine if two points are the same.
+   * Default is 0.000001.
+   */
+  faceTextureTolerance?: number;
+}
 
 type vtkPLYReaderBase = vtkObject &
   Omit<
@@ -41,6 +53,16 @@ export interface vtkPLYReader extends vtkPLYReaderBase {
     | JSZipDataAccessHelper
     | LiteHttpDataAccessHelper;
 
+  /**
+   * Controls whether points are duplicated for face-texture mapping.
+   */
+  getDuplicatePointsForFaceTexture(): boolean;
+
+  /**
+   * Get the tolerance used to determine if two points are the same.
+   */
+  getFaceTextureTolerance(): number;
+
   /**
    * Get the url of the object to load.
    */

package/IO/Geometry/PLYReader.js

@@ -95,7 +95,7 @@ function parseHeader(data) {
   }
   return header;
 }
-function postProcess(buffer, elements) {
+function postProcess(buffer, elements, faceTextureTolerance, duplicatePointsForFaceTexture) {
   const vertElement = elements.find(element => element.name === 'vertex');
   const faceElement = elements.find(element => element.name === 'face');
   let nbVerts = 0;
@@ -106,14 +106,20 @@ function postProcess(buffer, elements) {
   if (faceElement) {
     nbFaces = faceElement.count;
   }
-  const pointValues = new Float32Array(nbVerts * 3);
-  const colorArray = new Uint8Array(nbVerts * 3);
-  const tcoordsArray = new Float32Array(nbVerts * 2);
-  const normalsArray = new Float32Array(nbVerts * 3);
+  let pointValues = new Float32Array(nbVerts * 3);
+  let colorArray = new Uint8Array(nbVerts * 3);
+  let tcoordsArray = new Float32Array(nbVerts * 2);
+  let normalsArray = new Float32Array(nbVerts * 3);
   const hasColor = buffer.colors.length > 0;
   const hasVertTCoords = buffer.uvs.length > 0;
   const hasNorms = buffer.normals.length > 0;
   const hasFaceTCoords = buffer.faceVertexUvs.length > 0;
+
+  // For duplicate point handling
+  const pointIds = new Map(); // Maps texture coords to arrays of point IDs
+  let nextPointId = nbVerts;
+
+  // Initialize base points
   for (let vertIdx = 0; vertIdx < nbVerts; vertIdx++) {
     let a = vertIdx * 3 + 0;
     let b = vertIdx * 3 + 1;
@@ -131,6 +137,10 @@ function postProcess(buffer, elements) {
       b = vertIdx * 2 + 1;
       tcoordsArray[a] = buffer.uvs[a];
       tcoordsArray[b] = buffer.uvs[b];
+    } else {
+      // Initialize with sentinel value
+      tcoordsArray[vertIdx * 2] = -1;
+      tcoordsArray[vertIdx * 2 + 1] = -1;
     }
     if (hasNorms) {
       normalsArray[a] = buffer.normals[a];
@@ -138,33 +148,153 @@ function postProcess(buffer, elements) {
       normalsArray[c] = buffer.normals[c];
     }
   }
-  if (!hasVertTCoords && hasFaceTCoords) {
+
+  // Process face texture coordinates
+  if (hasFaceTCoords && !hasVertTCoords && nbFaces > 0) {
     // don't use array.shift, because buffer.indices will be used later
     let idxVerts = 0;
     let idxCoord = 0;
-    for (let faceIdx = 0; faceIdx < nbFaces; ++faceIdx) {
-      const nbFaceVerts = buffer.indices[idxVerts++];
-      const texcoords = buffer.faceVertexUvs[idxCoord++];
-      if (texcoords && nbFaceVerts * 2 === texcoords.length) {
-        // grab the vertex index
-        for (let vertIdx = 0; vertIdx < nbFaceVerts; ++vertIdx) {
-          const vert = buffer.indices[idxVerts++];
-          // new texture stored at the current face
-          tcoordsArray[vert * 2 + 0] = texcoords[vertIdx * 2 + 0];
-          tcoordsArray[vert * 2 + 1] = texcoords[vertIdx * 2 + 1];
+    if (duplicatePointsForFaceTexture) {
+      // Arrays to store duplicated point data
+      const extraPoints = [];
+      const extraColors = [];
+      const extraNormals = [];
+      const extraTCoords = [];
+      for (let faceIdx = 0; faceIdx < nbFaces; ++faceIdx) {
+        const nbFaceVerts = buffer.indices[idxVerts++];
+        const texcoords = buffer.faceVertexUvs[idxCoord++];
+        if (texcoords && nbFaceVerts * 2 === texcoords.length) {
+          for (let vertIdx = 0; vertIdx < nbFaceVerts; ++vertIdx) {
+            const vertId = buffer.indices[idxVerts + vertIdx];
+            const newTex = [texcoords[vertIdx * 2], texcoords[vertIdx * 2 + 1]];
+            const currentTex = [tcoordsArray[vertId * 2], tcoordsArray[vertId * 2 + 1]];
+            if (currentTex[0] === -1) {
+              // First time seeing texture coordinates for this vertex
+              tcoordsArray[vertId * 2] = newTex[0];
+              tcoordsArray[vertId * 2 + 1] = newTex[1];
+              const key = `${newTex[0]},${newTex[1]}`;
+              if (!pointIds.has(key)) {
+                pointIds.set(key, []);
+              }
+              pointIds.get(key).push(vertId);
+            } else {
+              // Check if we need to duplicate the vertex
+              const needsDuplication = Math.abs(currentTex[0] - newTex[0]) > faceTextureTolerance || Math.abs(currentTex[1] - newTex[1]) > faceTextureTolerance;
+              if (needsDuplication) {
+                const key = `${newTex[0]},${newTex[1]}`;
+                let existingPointId = -1;
+
+                // Check if we already have a point with these texture coordinates
+                if (pointIds.has(key)) {
+                  const candidates = pointIds.get(key);
+                  for (let i = 0, len = candidates.length; i < len; i++) {
+                    const candidateId = candidates[i];
+                    const samePosition = Math.abs(pointValues[candidateId * 3] - pointValues[vertId * 3]) <= faceTextureTolerance && Math.abs(pointValues[candidateId * 3 + 1] - pointValues[vertId * 3 + 1]) <= faceTextureTolerance && Math.abs(pointValues[candidateId * 3 + 2] - pointValues[vertId * 3 + 2]) <= faceTextureTolerance;
+                    if (samePosition) {
+                      existingPointId = candidateId;
+                      break;
+                    }
+                  }
+                }
+                if (existingPointId === -1) {
+                  // Create new point
+                  extraPoints.push(pointValues[vertId * 3], pointValues[vertId * 3 + 1], pointValues[vertId * 3 + 2]);
+                  if (hasColor) {
+                    extraColors.push(colorArray[vertId * 3], colorArray[vertId * 3 + 1], colorArray[vertId * 3 + 2]);
+                  }
+                  if (hasNorms) {
+                    extraNormals.push(normalsArray[vertId * 3], normalsArray[vertId * 3 + 1], normalsArray[vertId * 3 + 2]);
+                  }
+                  extraTCoords.push(newTex[0], newTex[1]);
+                  if (!pointIds.has(key)) {
+                    pointIds.set(key, []);
+                  }
+                  pointIds.get(key).push(nextPointId);
+                  buffer.indices[idxVerts + vertIdx] = nextPointId;
+                  nextPointId++;
+                } else {
+                  buffer.indices[idxVerts + vertIdx] = existingPointId;
+                }
+              }
+            }
+          }
         }
-      } else {
         idxVerts += nbFaceVerts;
       }
+
+      // Extend arrays with duplicated points if needed
+      if (extraPoints.length > 0) {
+        const newPointCount = nbVerts + extraPoints.length / 3;
+        const newPointValues = new Float32Array(newPointCount * 3);
+        const newTcoordsArray = new Float32Array(newPointCount * 2);
+        const newColorArray = hasColor ? new Uint8Array(newPointCount * 3) : null;
+        const newNormalsArray = hasNorms ? new Float32Array(newPointCount * 3) : null;
+
+        // Copy existing data
+        newPointValues.set(pointValues);
+        newTcoordsArray.set(tcoordsArray);
+        if (hasColor && newColorArray) {
+          newColorArray.set(colorArray);
+        }
+        if (hasNorms && newNormalsArray) {
+          newNormalsArray.set(normalsArray);
+        }
+
+        // Add new data
+        newPointValues.set(extraPoints, nbVerts * 3);
+        newTcoordsArray.set(extraTCoords, nbVerts * 2);
+        if (hasColor && newColorArray) {
+          newColorArray.set(extraColors, nbVerts * 3);
+        }
+        if (hasNorms && newNormalsArray) {
+          newNormalsArray.set(extraNormals, nbVerts * 3);
+        }
+        pointValues = newPointValues;
+        tcoordsArray = newTcoordsArray;
+        if (hasColor) {
+          colorArray = newColorArray;
+        }
+        if (hasNorms) {
+          normalsArray = newNormalsArray;
+        }
+      }
+    } else {
+      for (let faceIdx = 0; faceIdx < nbFaces; ++faceIdx) {
+        const nbFaceVerts = buffer.indices[idxVerts++];
+        const texcoords = buffer.faceVertexUvs[idxCoord++];
+        if (texcoords && nbFaceVerts * 2 === texcoords.length) {
+          for (let vertIdx = 0; vertIdx < nbFaceVerts; ++vertIdx) {
+            const vert = buffer.indices[idxVerts++];
+            tcoordsArray[vert * 2] = texcoords[vertIdx * 2];
+            tcoordsArray[vert * 2 + 1] = texcoords[vertIdx * 2 + 1];
+          }
+        } else {
+          idxVerts += nbFaceVerts;
+        }
+      }
     }
   }
   const polydata = vtkPolyData.newInstance();
   polydata.getPoints().setData(pointValues, 3);
+
+  // If we have faces, add them as polys
+  if (nbFaces > 0) {
+    polydata.getPolys().setData(Uint32Array.from(buffer.indices));
+  } else {
+    // Point cloud - create a vertex list containing all points
+    const verts = new Uint32Array(nbVerts * 2);
+    for (let i = 0; i < nbVerts; i++) {
+      verts[i * 2] = 1; // number of points in vertex cell (always 1)
+      verts[i * 2 + 1] = i; // point index
+    }
+
+    polydata.getVerts().setData(verts);
+  }
   if (hasColor) {
     polydata.getPointData().setScalars(vtkDataArray.newInstance({
       numberOfComponents: 3,
       values: colorArray,
-      name: 'Scalars'
+      name: 'RGB'
     }));
   }
   if (hasVertTCoords || hasFaceTCoords) {
@@ -184,7 +314,6 @@ function postProcess(buffer, elements) {
       values: normalsArray
     }));
   }
-  polydata.getPolys().setData(Uint32Array.from(buffer.indices));
   return polydata;
 }
 function parseNumber(n, type) {
@@ -410,7 +539,10 @@ function vtkPLYReader(publicAPI, model) {
     }
 
     // Header
-    const text = BinaryHelper.arrayBufferToString(content);
+    let text = content;
+    if (content instanceof ArrayBuffer) {
+      text = BinaryHelper.arrayBufferToString(content);
+    }
     const header = parseHeader(text);
 
     // ascii/binary detection
@@ -418,7 +550,7 @@ function vtkPLYReader(publicAPI, model) {
 
     // Check if ascii format
     if (!isBinary) {
-      publicAPI.parseAsText(content);
+      publicAPI.parseAsText(text);
       return;
     }
     model.parseData = content;
@@ -445,7 +577,7 @@ function vtkPLYReader(publicAPI, model) {
         handleElement(buffer, header.elements[elem].name, element);
       }
     }
-    const polydata = postProcess(buffer, header.elements);
+    const polydata = postProcess(buffer, header.elements, model.faceTextureTolerance, model.duplicatePointsForFaceTexture);
 
     // Add new output
     model.output[0] = polydata;
@@ -462,7 +594,10 @@ function vtkPLYReader(publicAPI, model) {
     model.parseData = content;
 
     // Header
-    const text = BinaryHelper.arrayBufferToString(content);
+    let text = content;
+    if (content instanceof ArrayBuffer) {
+      text = BinaryHelper.arrayBufferToString(content);
+    }
     const header = parseHeader(text);
 
     // ascii/binary detection
@@ -504,7 +639,7 @@ function vtkPLYReader(publicAPI, model) {
         idx++;
       }
     }
-    const polydata = postProcess(buffer, header.elements);
+    const polydata = postProcess(buffer, header.elements, model.faceTextureTolerance, model.duplicatePointsForFaceTexture);
 
     // Add new output
     model.output[0] = polydata;
@@ -522,6 +657,8 @@ const DEFAULT_VALUES = {
   // baseURL: null,
   // dataAccessHelper: null,
   // url: null,
+  faceTextureTolerance: 1e-6,
+  duplicatePointsForFaceTexture: true
 };
 
 // ----------------------------------------------------------------------------
@@ -532,7 +669,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['url', 'baseURL']);
+  macro.get(publicAPI, model, ['url', 'baseURL', 'duplicatePointsForFaceTexture', 'faceTextureTolerance']);
   macro.setGet(publicAPI, model, ['dataAccessHelper']);
   macro.algo(publicAPI, model, 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.2",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",