@kitware/vtk.js 33.0.0-beta.4 → 33.0.0-beta.5

package/BREAKING_CHANGES.md

@@ -1,6 +1,8 @@
 ## From 32.x to 33
 
 - **vtkMapper**: many properties have moved to `vtkVolumeProperty`. The full list of changed methods is: `getAnisotropy`, `getComputeNormalFromOpacity`, `getFilterMode`, `getFilterModeAsString`, `getGlobalIlluminationReach`, `getIpScalarRange`, `getIpScalarRangeByReference`, `getLAOKernelRadius`, `getLAOKernelSize`, `getLocalAmbientOcclusion`, `getPreferSizeOverAccuracy`, `getVolumetricScatteringBlending`, `setAnisotropy`, `setAverageIPScalarRange`, `setComputeNormalFromOpacity`, `setFilterMode`, `setFilterModeToNormalized`, `setFilterModeToOff`, `setFilterModeToRaw`, `setGlobalIlluminationReach`, `setIpScalarRange`, `setIpScalarRangeFrom`, `setLAOKernelRadius`, `setLAOKernelSize`, `setLocalAmbientOcclusion`, `setPreferSizeOverAccuracy`, `setVolumetricScatteringBlending`.
+- **vtkOpenGLTexture**: The public `create2D*` and `create3D*` methods used to have positional parameters. These methods now use named parameters via passing in an object record.
+
 ## From 31.x to 32
 
 - **vtkMapper**: remove `mapScalarsToTexture` from the public API. The function becomes protected and its API changes. This shouldn't cause any issue in most cases.

package/Rendering/OpenGL/Framebuffer.js

@@ -162,7 +162,13 @@ function vtkFramebuffer(publicAPI, model) {
     texture.setOpenGLRenderWindow(model._openGLRenderWindow);
     texture.setMinificationFilter(Filter.LINEAR);
     texture.setMagnificationFilter(Filter.LINEAR);
-    texture.create2DFromRaw(model.glFramebuffer.width, model.glFramebuffer.height, 4, VtkDataTypes.UNSIGNED_CHAR, null);
+    texture.create2DFromRaw({
+      width: model.glFramebuffer.width,
+      height: model.glFramebuffer.height,
+      numComps: 4,
+      dataType: VtkDataTypes.UNSIGNED_CHAR,
+      data: null
+    });
     publicAPI.setColorBuffer(texture);
 
     // for now do not count on having a depth buffer texture

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -167,7 +167,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       // Use norm16 for scalar texture if the extension is available
       model.volumeTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       model.volumeTexture.resetFormatAndType();
-      model.volumeTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
+      model.volumeTexture.create3DFilterableFromDataArray({
+        width: dims[0],
+        height: dims[1],
+        depth: dims[2],
+        dataArray: scalars,
+        preferSizeOverAccuracy: model.renderable.getPreferSizeOverAccuracy()
+      });
       model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.volumeTexture, volumeTextureHash);
       if (scalars !== model._scalars) {
         model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
@@ -182,7 +188,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       // clear the array to acknowledge the update.
       property.setUpdatedExtents([]);
       const dims = image.getDimensions();
-      model.volumeTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+      model.volumeTexture.create3DFilterableFromDataArray({
+        width: dims[0],
+        height: dims[1],
+        depth: dims[2],
+        dataArray: scalars,
+        updatedExtents
+      });
     }
 
     // Rebuild the color texture if needed
@@ -226,7 +238,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           }
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: textureHeight,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       } else {
         for (let i = 0; i < cWidth * 3; ++i) {
           cTable[i] = 255.0 * i / ((cWidth - 1) * 3);
@@ -234,7 +252,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           cTable[i + 2] = 255.0 * i / ((cWidth - 1) * 3);
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: 1,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       }
       if (firstColorTransferFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, model.colorTexture, colorTextureHash);
@@ -293,12 +317,24 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           }
         }
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: pwfFloatTable
+        });
       } else {
         // default is opaque
         pwfTable.fill(255.0);
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: 1,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: pwfTable
+        });
       }
       if (firstPwFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, model.pwfTexture, pwfTextureHash);

package/Rendering/OpenGL/ImageMapper.js

@@ -622,14 +622,26 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           }
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: textureHeight,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       } else {
         for (let i = 0; i < cWidth * 3; ++i) {
           cTable[i] = 255.0 * i / ((cWidth - 1) * 3);
           cTable[i + 1] = 255.0 * i / ((cWidth - 1) * 3);
           cTable[i + 2] = 255.0 * i / ((cWidth - 1) * 3);
         }
-        model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: 1,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       }
       if (firstColorTransferFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, model.colorTexture, cfunToString);
@@ -699,11 +711,23 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           }
         }
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: pwfFloatTable
+        });
       } else {
         // default is opaque
         pwfTable.fill(255.0);
-        model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: 1,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: pwfTable
+        });
       }
       if (firstPwFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, model.pwfTexture, pwfunToString);
@@ -887,7 +911,15 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       // Don't share this resource as `scalars` is created in this function
       // so it is impossible to share
       model.openGLTexture.resetFormatAndType();
-      model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, model.renderable.getPreferSizeOverAccuracy?.(), ranges);
+      model.openGLTexture.create2DFilterableFromRaw({
+        width: dims[0],
+        height: dims[1],
+        numComps: numComp,
+        dataType: imgScalars.getDataType(),
+        data: scalars,
+        preferSizeOverAccuracy: !!model.renderable.getPreferSizeOverAccuracy?.(),
+        ranges
+      });
       model.openGLTexture.activate();
       model.openGLTexture.sendParameters();
       model.openGLTexture.deactivate();
@@ -957,7 +989,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model.labelOutlineThicknessTexture.setMagnificationFilter(Filter.NEAREST);
 
       // Create a 2D texture (acting as 1D) from the raw data
-      model.labelOutlineThicknessTexture.create2DFromRaw(lWidth, lHeight, 1, VtkDataTypes.UNSIGNED_CHAR, lTable);
+      model.labelOutlineThicknessTexture.create2DFromRaw({
+        width: lWidth,
+        height: lHeight,
+        numComps: 1,
+        dataType: VtkDataTypes.UNSIGNED_CHAR,
+        data: lTable
+      });
       if (labelOutlineThicknessArray) {
         model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, model.labelOutlineThicknessTexture, toString);
         if (labelOutlineThicknessArray !== model._labelOutlineThicknessArray) {

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -266,7 +266,12 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         // Use norm16 for scalar texture if the extension is available
         newScalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
         newScalarTexture.resetFormatAndType();
-        newScalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars);
+        newScalarTexture.create3DFilterableFromDataArray({
+          width: dims[0],
+          height: dims[1],
+          depth: dims[2],
+          dataArray: scalars
+        });
         model._openGLRenderWindow.setGraphicsResourceForObject(scalars, newScalarTexture, scalarsHash);
         model.scalarTextures[component] = newScalarTexture;
       } else {
@@ -277,7 +282,13 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         // clear the array to acknowledge the update.
         actorProperty.setUpdatedExtents([]);
         const dims = imageData.getDimensions();
-        model.scalarTextures[component].create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+        model.scalarTextures[component].create3DFilterableFromDataArray({
+          width: dims[0],
+          height: dims[1],
+          depth: dims[2],
+          dataArray: scalars,
+          updatedExtents
+        });
       }
       replaceGraphicsResource(model._openGLRenderWindow, model._scalarTexturesCore[component], scalars);
       model._scalarTexturesCore[component] = scalars;
@@ -322,7 +333,13 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           }
         }
         newColorTexture.resetFormatAndType();
-        newColorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        newColorTexture.create2DFromRaw({
+          width: cWidth,
+          height: textureHeight,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       } else {
         for (let column = 0; column < cWidth * 3; ++column) {
           const opacity = 255.0 * column / ((cWidth - 1) * 3);
@@ -334,7 +351,13 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           }
         }
         newColorTexture.resetFormatAndType();
-        newColorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        newColorTexture.create2DFromRaw({
+          width: cWidth,
+          height: 1,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       }
       if (firstColorTransferFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, newColorTexture, colorFuncHash);
@@ -391,12 +414,24 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           }
         }
         newOpacityTexture.resetFormatAndType();
-        newOpacityTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        newOpacityTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: pwfFloatTable
+        });
       } else {
         // default is opaque
         pwfTable.fill(255.0);
         newOpacityTexture.resetFormatAndType();
-        newOpacityTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+        newOpacityTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: pwfTable
+        });
       }
       if (firstPwFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, newOpacityTexture, opacityFuncHash);

package/Rendering/OpenGL/OrderIndependentTranslucentPass.js

@@ -91,16 +91,33 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
     model.translucentRGBATexture.setFormat(gl.RGBA);
     model.translucentRGBATexture.setOpenGLDataType(gl.HALF_FLOAT);
     model.translucentRGBATexture.setOpenGLRenderWindow(viewNode);
-    model.translucentRGBATexture.create2DFromRaw(size[0], size[1], 4, 'Float32Array', null);
+    model.translucentRGBATexture.create2DFromRaw({
+      width: size[0],
+      height: size[1],
+      numComps: 4,
+      dataType: 'Float32Array',
+      data: null
+    });
     model.translucentRTexture = vtkOpenGLTexture.newInstance();
     model.translucentRTexture.setInternalFormat(gl.R16F);
     model.translucentRTexture.setFormat(gl.RED);
     model.translucentRTexture.setOpenGLDataType(gl.HALF_FLOAT);
     model.translucentRTexture.setOpenGLRenderWindow(viewNode);
-    model.translucentRTexture.create2DFromRaw(size[0], size[1], 1, 'Float32Array', null);
+    model.translucentRTexture.create2DFromRaw({
+      width: size[0],
+      height: size[1],
+      numComps: 1,
+      dataType: 'Float32Array',
+      data: null
+    });
     model.translucentZTexture = vtkOpenGLTexture.newInstance();
     model.translucentZTexture.setOpenGLRenderWindow(viewNode);
-    model.translucentZTexture.createDepthFromRaw(size[0], size[1], 'Float32Array', null);
+    model.translucentZTexture.createDepthFromRaw({
+      width: size[0],
+      height: size[1],
+      dataType: 'Float32Array',
+      data: null
+    });
     model.framebuffer.setColorBuffer(model.translucentRGBATexture, 0);
     model.framebuffer.setColorBuffer(model.translucentRTexture, 1);
     model.framebuffer.setDepthBuffer(model.translucentZTexture);

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1014,7 +1014,13 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       const input = model.renderable.getColorTextureMap();
       const ext = input.getExtent();
       const inScalars = input.getPointData().getScalars();
-      tex.create2DFromRaw(ext[1] - ext[0] + 1, ext[3] - ext[2] + 1, inScalars.getNumberOfComponents(), inScalars.getDataType(), inScalars.getData());
+      tex.create2DFromRaw({
+        width: ext[1] - ext[0] + 1,
+        height: ext[3] - ext[2] + 1,
+        numComps: inScalars.getNumberOfComponents(),
+        dataType: inScalars.getDataType(),
+        data: inScalars.getData()
+      });
       tex.activate();
       tex.sendParameters();
       tex.deactivate();

package/Rendering/OpenGL/SurfaceLIC/LineIntegralConvolution2D/pingpong.js

@@ -64,7 +64,13 @@ function allocateBuffer(openGLRenderWindow, _ref, filter, wrapping) {
   });
   texture.setOpenGLRenderWindow(openGLRenderWindow);
   texture.setInternalFormat(gl.RGBA32F);
-  texture.create2DFromRaw(width, height, 4, 'Float32Array', null);
+  texture.create2DFromRaw({
+    width,
+    height,
+    numComps: 4,
+    dataType: 'Float32Array',
+    data: null
+  });
   texture.activate();
   texture.sendParameters();
   texture.deactivate();

package/Rendering/OpenGL/SurfaceLIC/SurfaceLICInterface.js

@@ -206,7 +206,13 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
         autoParameters: false
       });
       texture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      texture.create2DFromRaw(length, length, 4, 'Float32Array', values);
+      texture.create2DFromRaw({
+        width: length,
+        height: length,
+        numComps: 4,
+        dataType: 'Float32Array',
+        data: values
+      });
       texture.activate();
       texture.sendParameters();
       texture.deactivate();
@@ -255,7 +261,13 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     });
     texture.setOpenGLRenderWindow(openGLRenderWindow);
     texture.setInternalFormat(gl.RGBA32F);
-    texture.create2DFromRaw(...model.size, 4, 'Float32Array', null);
+    texture.create2DFromRaw({
+      width: model.size[0],
+      height: model.size[1],
+      numComps: 4,
+      dataType: 'Float32Array',
+      data: null
+    });
     texture.activate();
     texture.sendParameters();
     texture.deactivate();
@@ -269,7 +281,12 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
       autoParameters: false
     });
     texture.setOpenGLRenderWindow(openGLRenderWindow);
-    texture.createDepthFromRaw(...model.size, 'Float32Array', null);
+    texture.createDepthFromRaw({
+      width: model.size[0],
+      height: model.size[1],
+      dataType: 'Float32Array',
+      data: null
+    });
     texture.activate();
     texture.sendParameters();
     texture.deactivate();

package/Rendering/OpenGL/Texture.d.ts

@@ -199,17 +199,24 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @param numComps The number of components in the texture.
    * @param dataType The data type of the texture.
    * @param data The raw data for the texture.
-   * @param flip Whether to flip the texture vertically.
+   * @param flip Whether to flip the texture vertically. Defaults to false.
    * @returns {boolean} True if the texture was successfully created, false otherwise.
    */
-  create2DFromRaw(
-    width: number,
-    height: number,
-    numComps: number,
-    dataType: VtkDataTypes,
-    data: any,
-    flip: boolean
-  ): boolean;
+  create2DFromRaw({
+    width,
+    height,
+    numComps,
+    dataType,
+    data,
+    flip,
+  }: {
+    width: number;
+    height: number;
+    numComps: number;
+    dataType: VtkDataTypes;
+    data: any;
+    flip?: boolean;
+  }): boolean;
 
   /**
    * Creates a cube texture from raw data.
@@ -218,17 +225,21 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @param numComps The number of components in the texture.
    * @param dataType The data type of the texture.
    * @param data The raw data for the texture.
-   * @param flip Whether to flip the texture vertically.
    * @returns {boolean} True if the cube texture was successfully created, false otherwise.
    */
-  createCubeFromRaw(
-    width: number,
-    height: number,
-    numComps: number,
-    dataType: VtkDataTypes,
-    data: any,
-    flip: boolean
-  ): boolean;
+  createCubeFromRaw({
+    width,
+    height,
+    numComps,
+    dataType,
+    data,
+  }: {
+    width: number;
+    height: number;
+    numComps: number;
+    dataType: VtkDataTypes;
+    data: any;
+  }): boolean;
 
   /**
    * Creates a 2D texture from an image.
@@ -248,15 +259,23 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @param [ranges] The precomputed ranges of the data (optional). Provided to prevent computation of the data ranges.
    * @returns {boolean} True if the texture was successfully created, false otherwise.
    */
-  create2DFilterableFromRaw(
-    width: number,
-    height: number,
-    numComps: number,
-    dataType: VtkDataTypes,
-    data: any,
-    preferSizeOverAccuracy?: boolean,
-    ranges?: vtkRange[]
-  ): boolean;
+  create2DFilterableFromRaw({
+    width,
+    height,
+    numComps,
+    dataType,
+    data,
+    preferSizeOverAccuracy,
+    ranges,
+  }: {
+    width: number;
+    height: number;
+    numComps: number;
+    dataType: VtkDataTypes;
+    data: any;
+    preferSizeOverAccuracy?: boolean;
+    ranges?: vtkRange[];
+  }): boolean;
 
   /**
    * Creates a 2D filterable texture from a data array, with a preference for size over accuracy if necessary.
@@ -266,12 +285,17 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @param preferSizeOverAccuracy Whether to prefer texture size over accuracy.
    * @returns {boolean} True if the texture was successfully created, false otherwise.
    */
-  create2DFilterableFromDataArray(
-    width: number,
-    height: number,
-    dataArray: any,
-    preferSizeOverAccuracy: boolean
-  ): boolean;
+  create2DFilterableFromDataArray({
+    width,
+    height,
+    dataArray,
+    preferSizeOverAccuracy,
+  }: {
+    width: number;
+    height: number;
+    dataArray: any;
+    preferSizeOverAccuracy?: boolean;
+  }): boolean;
 
   /**
    * Creates a 3D texture from raw data.
@@ -287,15 +311,23 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @param updatedExtents Only update the specified extents (default: [])
    * @returns {boolean} True if the texture was successfully created, false otherwise.
    */
-  create3DFromRaw(
-    width: number,
-    height: number,
-    depth: number,
-    numComps: number,
-    dataType: VtkDataTypes,
-    data: any,
-    updatedExtents?: Extent[]
-  ): boolean;
+  create3DFromRaw({
+    width,
+    height,
+    depth,
+    numComps,
+    dataType,
+    data,
+    updatedExtents,
+  }: {
+    width: number;
+    height: number;
+    depth: number;
+    numComps: number;
+    dataType: VtkDataTypes;
+    data: any;
+    updatedExtents?: Extent[];
+  }): boolean;
 
   /**
    * Creates a 3D filterable texture from raw data, with a preference for size over accuracy if necessary.
@@ -307,7 +339,7 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @param depth The depth of the texture.
    * @param numComps The number of components in the texture.
    * @param dataType The data type of the texture.
-   * @param values The raw data for the texture.
+   * @param data The raw data for the texture.
    * @param preferSizeOverAccuracy Whether to prefer texture size over accuracy.
    * @param [ranges] The precomputed ranges of the data (optional). Provided to
    * @param updatedExtents Only update the specified extents (default: [])
@@ -315,17 +347,27 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @returns {boolean} True if the texture was successfully created, false
    * otherwise.
    */
-  create3DFilterableFromRaw(
-    width: number,
-    height: number,
-    depth: number,
-    numComps: number,
-    dataType: VtkDataTypes,
-    values: any,
-    preferSizeOverAccuracy: boolean,
-    ranges?: vtkRange[],
-    updatedExtents?: Extent[]
-  ): boolean;
+  create3DFilterableFromRaw({
+    width,
+    height,
+    depth,
+    numComps,
+    dataType,
+    data,
+    preferSizeOverAccuracy,
+    ranges,
+    updatedExtents,
+  }: {
+    width: number;
+    height: number;
+    depth: number;
+    numComps: number;
+    dataType: VtkDataTypes;
+    data: any;
+    preferSizeOverAccuracy?: boolean;
+    ranges?: vtkRange[];
+    updatedExtents?: Extent[];
+  }): boolean;
 
   /**
    * Creates a 3D filterable texture from a data array, with a preference for size over accuracy if necessary.
@@ -340,14 +382,20 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @param updatedExtents Only update the specified extents (default: [])
    * @returns {boolean} True if the texture was successfully created, false otherwise.
    */
-  create3DFilterableFromDataArray(
-    width: number,
-    height: number,
-    depth: number,
-    dataArray: any,
-    preferSizeOverAccuracy: boolean,
-    updatedExtents?: Extent[]
-  ): boolean;
+  create3DFilterableFromDataArray({
+    width,
+    height,
+    depth,
+    dataArray,
+    preferSizeOverAccuracy,
+  }: {
+    width: number;
+    height: number;
+    depth: number;
+    dataArray: any;
+    preferSizeOverAccuracy?: boolean;
+    updatedExtents?: Extent[];
+  }): boolean;
 
   /**
    * Sets the OpenGL render window in which the texture will be used.

package/Rendering/OpenGL/Texture.js

@@ -18,7 +18,8 @@ const {
 const {
   vtkDebugMacro,
   vtkErrorMacro,
-  vtkWarningMacro
+  vtkWarningMacro,
+  requiredParam
 } = macro;
 const {
   toHalf
@@ -95,7 +96,14 @@ function vtkOpenGLTexture(publicAPI, model) {
           publicAPI.setMinificationFilter(Filter.LINEAR_MIPMAP_LINEAR);
         }
         const canvas = model.renderable.getCanvas();
-        publicAPI.create2DFromRaw(canvas.width, canvas.height, 4, VtkDataTypes.UNSIGNED_CHAR, canvas, true);
+        publicAPI.create2DFromRaw({
+          width: canvas.width,
+          height: canvas.height,
+          numComps: 4,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: canvas,
+          flip: true
+        });
         publicAPI.activate();
         publicAPI.sendParameters();
         model.textureBuildTime.modified();
@@ -107,7 +115,14 @@ function vtkOpenGLTexture(publicAPI, model) {
           model.generateMipmap = true;
           publicAPI.setMinificationFilter(Filter.LINEAR_MIPMAP_LINEAR);
         }
-        publicAPI.create2DFromRaw(jsid.width, jsid.height, 4, VtkDataTypes.UNSIGNED_CHAR, jsid.data, true);
+        publicAPI.create2DFromRaw({
+          width: jsid.width,
+          height: jsid.height,
+          numComps: 4,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: jsid.data,
+          flip: true
+        });
         publicAPI.activate();
         publicAPI.sendParameters();
         model.textureBuildTime.modified();
@@ -132,9 +147,21 @@ function vtkOpenGLTexture(publicAPI, model) {
           publicAPI.setMinificationFilter(Filter.LINEAR_MIPMAP_LINEAR);
         }
         if (data.length % 6 === 0) {
-          publicAPI.createCubeFromRaw(ext[1] - ext[0] + 1, ext[3] - ext[2] + 1, inScalars.getNumberOfComponents(), inScalars.getDataType(), data);
+          publicAPI.createCubeFromRaw({
+            width: ext[1] - ext[0] + 1,
+            height: ext[3] - ext[2] + 1,
+            numComps: inScalars.getNumberOfComponents(),
+            dataType: inScalars.getDataType(),
+            data
+          });
         } else {
-          publicAPI.create2DFromRaw(ext[1] - ext[0] + 1, ext[3] - ext[2] + 1, inScalars.getNumberOfComponents(), inScalars.getDataType(), inScalars.getData());
+          publicAPI.create2DFromRaw({
+            width: ext[1] - ext[0] + 1,
+            height: ext[3] - ext[2] + 1,
+            numComps: inScalars.getNumberOfComponents(),
+            dataType: inScalars.getDataType(),
+            data: inScalars.getData()
+          });
         }
         publicAPI.activate();
         publicAPI.sendParameters();
@@ -786,8 +813,16 @@ function vtkOpenGLTexture(publicAPI, model) {
   }
 
   //----------------------------------------------------------------------------
-  publicAPI.create2DFromRaw = function (width, height, numComps, dataType, data) {
-    let flip = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+
+  publicAPI.create2DFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data'),
+      flip = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     // Now determine the texture parameters using the arguments.
     publicAPI.getOpenGLDataType(dataType, true);
     publicAPI.getInternalFormat(dataType, numComps);
@@ -836,7 +871,14 @@ function vtkOpenGLTexture(publicAPI, model) {
   };
 
   //----------------------------------------------------------------------------
-  publicAPI.createCubeFromRaw = (width, height, numComps, dataType, data) => {
+  publicAPI.createCubeFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data')
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     // Now determine the texture parameters using the arguments.
     publicAPI.getOpenGLDataType(dataType);
     publicAPI.getInternalFormat(dataType, numComps);
@@ -917,7 +959,13 @@ function vtkOpenGLTexture(publicAPI, model) {
   };
 
   //----------------------------------------------------------------------------
-  publicAPI.createDepthFromRaw = (width, height, dataType, data) => {
+  publicAPI.createDepthFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data')
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     // Now determine the texture parameters using the arguments.
     publicAPI.getOpenGLDataType(dataType);
     model.format = model.context.DEPTH_COMPONENT;
@@ -1090,24 +1138,47 @@ function vtkOpenGLTexture(publicAPI, model) {
       scaleOffsets
     };
   }
-  publicAPI.create2DFilterableFromRaw = function (width, height, numberOfComponents, dataType, values) {
-    let preferSizeOverAccuracy = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
-    let ranges = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : undefined;
-    return publicAPI.create2DFilterableFromDataArray(width, height, vtkDataArray.newInstance({
-      numberOfComponents,
-      dataType,
-      values,
-      ranges
-    }), preferSizeOverAccuracy);
+  publicAPI.create2DFilterableFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data'),
+      preferSizeOverAccuracy = false,
+      ranges = undefined
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return publicAPI.create2DFilterableFromDataArray({
+      width,
+      height,
+      dataArray: vtkDataArray.newInstance({
+        numComps,
+        dataType,
+        values: data,
+        ranges
+      }),
+      preferSizeOverAccuracy
+    });
   };
-  publicAPI.create2DFilterableFromDataArray = function (width, height, dataArray) {
-    let preferSizeOverAccuracy = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  publicAPI.create2DFilterableFromDataArray = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      dataArray = requiredParam('dataArray'),
+      preferSizeOverAccuracy = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const {
       numComps,
       dataType,
       data
     } = processDataArray(dataArray, preferSizeOverAccuracy);
-    publicAPI.create2DFromRaw(width, height, numComps, dataType, data);
+    publicAPI.create2DFromRaw({
+      width,
+      height,
+      numComps,
+      dataType,
+      data
+    });
   };
   publicAPI.updateVolumeInfoForGL = (dataType, numComps) => {
     let isScalingApplied = false;
@@ -1162,8 +1233,16 @@ function vtkOpenGLTexture(publicAPI, model) {
   };
 
   //----------------------------------------------------------------------------
-  publicAPI.create3DFromRaw = function (width, height, depth, numComps, dataType, data) {
-    let updatedExtents = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [];
+  publicAPI.create3DFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      depth = requiredParam('depth'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data'),
+      updatedExtents = []
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     let dataTypeToUse = dataType;
     let dataToUse = data;
     if (!publicAPI.updateVolumeInfoForGL(dataTypeToUse, numComps) && dataToUse) {
@@ -1253,23 +1332,44 @@ function vtkOpenGLTexture(publicAPI, model) {
   //----------------------------------------------------------------------------
   // This method simulates a 3D texture using 2D
   // Prefer create3DFilterableFromDataArray to enable caching of min and max values
-  publicAPI.create3DFilterableFromRaw = function (width, height, depth, numberOfComponents, dataType, values) {
-    let preferSizeOverAccuracy = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
-    let ranges = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : undefined;
-    let updatedExtents = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : [];
-    return publicAPI.create3DFilterableFromDataArray(width, height, depth, vtkDataArray.newInstance({
-      numberOfComponents,
-      dataType,
-      values,
-      ranges
-    }), preferSizeOverAccuracy, updatedExtents);
+  publicAPI.create3DFilterableFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      depth = requiredParam('depth'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data'),
+      preferSizeOverAccuracy = false,
+      ranges = undefined,
+      updatedExtents = []
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return publicAPI.create3DFilterableFromDataArray({
+      width,
+      height,
+      depth,
+      dataArray: vtkDataArray.newInstance({
+        numComps,
+        dataType,
+        values: data,
+        ranges
+      }),
+      preferSizeOverAccuracy,
+      updatedExtents
+    });
   };
 
   //----------------------------------------------------------------------------
   // This method create a 3D texture from dimensions and a DataArray
-  publicAPI.create3DFilterableFromDataArray = function (width, height, depth, dataArray) {
-    let preferSizeOverAccuracy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-    let updatedExtents = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+  publicAPI.create3DFilterableFromDataArray = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      depth = requiredParam('depth'),
+      dataArray = requiredParam('dataArray'),
+      preferSizeOverAccuracy = false,
+      updatedExtents = []
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const {
       numComps,
       dataType,
@@ -1304,7 +1404,15 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     // WebGL2 path, we have 3d textures etc
     if (model._openGLRenderWindow.getWebgl2()) {
-      return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data, updatedExtents);
+      return publicAPI.create3DFromRaw({
+        width,
+        height,
+        depth,
+        numComps,
+        dataType,
+        data,
+        updatedExtents
+      });
     }
     const numPixelsIn = width * height * depth;
     const scaleOffsetsCopy = structuredClone(scaleOffsets);

package/Rendering/OpenGL/VolumeMapper.js

@@ -1013,7 +1013,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       }
       model.jitterTexture.setMinificationFilter(Filter.NEAREST);
       model.jitterTexture.setMagnificationFilter(Filter.NEAREST);
-      model.jitterTexture.create2DFromRaw(32, 32, 1, VtkDataTypes.FLOAT, jitterArray);
+      model.jitterTexture.create2DFromRaw({
+        width: 32,
+        height: 32,
+        numComps: 1,
+        dataType: VtkDataTypes.FLOAT,
+        data: jitterArray
+      });
     }
     const volumeProperties = actor.getProperties();
     const firstValidInput = model.currentValidInputs[0];
@@ -1061,13 +1067,25 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       // visible artifacts. High values of opacity quickly terminate without
       // artifacts.
       if (model._openGLRenderWindow.getWebgl2() || model.context.getExtension('OES_texture_float') && model.context.getExtension('OES_texture_float_linear')) {
-        newOpacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.FLOAT, ofTable);
+        newOpacityTexture.create2DFromRaw({
+          width: oWidth,
+          height: 2 * numIComps,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: ofTable
+        });
       } else {
         const oTable = new Uint8ClampedArray(oSize);
         for (let i = 0; i < oSize; ++i) {
           oTable[i] = 255.0 * ofTable[i];
         }
-        newOpacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.UNSIGNED_CHAR, oTable);
+        newOpacityTexture.create2DFromRaw({
+          width: oWidth,
+          height: 2 * numIComps,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: oTable
+        });
       }
       if (firstScalarOpacityFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstScalarOpacityFunc, newOpacityTexture, opacityFuncHash);
@@ -1110,7 +1128,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       newColorTexture.resetFormatAndType();
       newColorTexture.setMinificationFilter(Filter.LINEAR);
       newColorTexture.setMagnificationFilter(Filter.LINEAR);
-      newColorTexture.create2DFromRaw(cWidth, 2 * numIComps, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+      newColorTexture.create2DFromRaw({
+        width: cWidth,
+        height: 2 * numIComps,
+        numComps: 3,
+        dataType: VtkDataTypes.UNSIGNED_CHAR,
+        data: cTable
+      });
       model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, newColorTexture, colorFuncHash);
       model.colorTexture = newColorTexture;
     } else {
@@ -1141,7 +1165,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         // Use norm16 for scalar texture if the extension is available
         newScalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
         newScalarTexture.resetFormatAndType();
-        newScalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, volumeProperty.getPreferSizeOverAccuracy());
+        newScalarTexture.create3DFilterableFromDataArray({
+          width: dims[0],
+          height: dims[1],
+          depth: dims[2],
+          dataArray: scalars,
+          preferSizeOverAccuracy: volumeProperty.getPreferSizeOverAccuracy()
+        });
         model._openGLRenderWindow.setGraphicsResourceForObject(scalars, newScalarTexture, scalarsHash);
         model.scalarTextures[component] = newScalarTexture;
       } else {
@@ -1152,7 +1182,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         // clear the array to acknowledge the update.
         volumeProperty.setUpdatedExtents([]);
         const dims = imageData.getDimensions();
-        model.scalarTextures[component].create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+        model.scalarTextures[component].create3DFilterableFromDataArray({
+          width: dims[0],
+          height: dims[1],
+          depth: dims[2],
+          dataArray: scalars,
+          updatedExtents
+        });
       }
       replaceGraphicsResource(model._openGLRenderWindow, model._scalarTexturesCore[component], scalars);
       model._scalarTexturesCore[component] = scalars;
@@ -1186,7 +1222,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       newLabelOutlineThicknessTexture.setMagnificationFilter(Filter.NEAREST);
 
       // Create a 2D texture (acting as 1D) from the raw data
-      newLabelOutlineThicknessTexture.create2DFromRaw(lWidth, lHeight, 1, VtkDataTypes.UNSIGNED_CHAR, lTable);
+      newLabelOutlineThicknessTexture.create2DFromRaw({
+        width: lWidth,
+        height: lHeight,
+        numComps: 1,
+        dataType: VtkDataTypes.UNSIGNED_CHAR,
+        data: lTable
+      });
       if (labelOutlineThicknessArray) {
         model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, newLabelOutlineThicknessTexture, labelOutlineThicknessHash);
       }

package/macros.js

@@ -1,4 +1,4 @@
 import 'fast-deep-equal';
 import './vtk.js';
 import './Common/Core/ClassHierarchy.js';
-export { G as EVENT_ABORT, T as TYPED_ARRAYS, V as VOID, _ as _capitalize, d as algo, q as capitalize, h as chain, I as debounce, m as default, f as event, B as formatBytesToProperUnit, C as formatNumbersWithThousandSeparator, g as get, k as getArray, H as isVtkObject, K as keystore, E as measurePromiseExecution, i as moveToProtected, n as newInstance, a as newTypedArray, b as newTypedArrayFrom, M as normalizeWheel, o as obj, p as proxy, j as proxyPropertyMapping, L as proxyPropertyState, s as set, F as setArray, e as setGet, l as setGetArray, D as setImmediateVTK, u as setLoggerFunction, J as throttle, t as traverseInstanceTree, A as uncapitalize, y as vtkDebugMacro, r as vtkErrorMacro, x as vtkInfoMacro, w as vtkLogMacro, z as vtkOnceErrorMacro, v as vtkWarningMacro } from './macros2.js';
+export { H as EVENT_ABORT, T as TYPED_ARRAYS, V as VOID, _ as _capitalize, d as algo, q as capitalize, h as chain, J as debounce, m as default, f as event, C as formatBytesToProperUnit, D as formatNumbersWithThousandSeparator, g as get, k as getArray, I as isVtkObject, L as keystore, F as measurePromiseExecution, i as moveToProtected, n as newInstance, a as newTypedArray, b as newTypedArrayFrom, N as normalizeWheel, o as obj, p as proxy, j as proxyPropertyMapping, M as proxyPropertyState, u as requiredParam, s as set, G as setArray, e as setGet, l as setGetArray, E as setImmediateVTK, w as setLoggerFunction, K as throttle, t as traverseInstanceTree, B as uncapitalize, z as vtkDebugMacro, r as vtkErrorMacro, y as vtkInfoMacro, x as vtkLogMacro, A as vtkOnceErrorMacro, v as vtkWarningMacro } from './macros2.js';

package/macros2.js

@@ -7,6 +7,9 @@ import ClassHierarchy from './Common/Core/ClassHierarchy.js';
  * The name change is so we do not get eaten by babel-plugin-macros.
  */
 let globalMTime = 0;
+const requiredParam = name => {
+  throw new Error(`Named parameter '${name}' is missing`);
+};
 const VOID = Symbol('void');
 function getCurrentGlobalMTime() {
   return globalMTime;
@@ -1654,11 +1657,13 @@ var macro = {
   vtkOnceErrorMacro,
   vtkWarningMacro,
   // vtk.js internal use
-  objectSetterMap
+  objectSetterMap,
+  requiredParam
 };
 
 var macro$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  requiredParam: requiredParam,
   VOID: VOID,
   setLoggerFunction: setLoggerFunction,
   vtkLogMacro: vtkLogMacro,
@@ -1702,4 +1707,4 @@ var macro$1 = /*#__PURE__*/Object.freeze({
   'default': macro
 });
 
-export { uncapitalize as A, formatBytesToProperUnit as B, formatNumbersWithThousandSeparator as C, setImmediateVTK as D, measurePromiseExecution as E, setArray as F, EVENT_ABORT as G, isVtkObject as H, debounce as I, throttle as J, keystore as K, proxyPropertyState as L, normalizeWheel as M, TYPED_ARRAYS as T, VOID as V, _capitalize as _, newTypedArray as a, newTypedArrayFrom as b, macro$1 as c, algo as d, setGet as e, event as f, get as g, chain as h, moveToProtected as i, proxyPropertyMapping as j, getArray as k, setGetArray as l, macro as m, newInstance as n, obj as o, proxy as p, capitalize as q, vtkErrorMacro as r, set as s, traverseInstanceTree as t, setLoggerFunction as u, vtkWarningMacro as v, vtkLogMacro as w, vtkInfoMacro as x, vtkDebugMacro as y, vtkOnceErrorMacro as z };
+export { vtkOnceErrorMacro as A, uncapitalize as B, formatBytesToProperUnit as C, formatNumbersWithThousandSeparator as D, setImmediateVTK as E, measurePromiseExecution as F, setArray as G, EVENT_ABORT as H, isVtkObject as I, debounce as J, throttle as K, keystore as L, proxyPropertyState as M, normalizeWheel as N, TYPED_ARRAYS as T, VOID as V, _capitalize as _, newTypedArray as a, newTypedArrayFrom as b, macro$1 as c, algo as d, setGet as e, event as f, get as g, chain as h, moveToProtected as i, proxyPropertyMapping as j, getArray as k, setGetArray as l, macro as m, newInstance as n, obj as o, proxy as p, capitalize as q, vtkErrorMacro as r, set as s, traverseInstanceTree as t, requiredParam as u, vtkWarningMacro as v, setLoggerFunction as w, vtkLogMacro as x, vtkInfoMacro as y, vtkDebugMacro as z };

package/package.json

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