@kitware/vtk.js 33.3.2 → 34.0.0-beta.2

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

@@ -2,7 +2,7 @@ import { mat3, mat4, vec3 } from 'gl-matrix';
 import { n as newInstance$1, e as setGet, o as obj, c as macro } from '../../macros2.js';
 import vtkHelper from './Helper.js';
 import vtkMapper from '../Core/Mapper.js';
-import { l as normalize, u as uninitializeBounds } from '../../Common/Core/Math/index.js';
+import { l as normalize } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
 import vtkProp from '../Core/Prop.js';
 import vtkProperty from '../Core/Property.js';
@@ -941,13 +941,6 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);
   };
-  publicAPI.computeBounds = (ren, actor) => {
-    if (!publicAPI.getInput()) {
-      uninitializeBounds(model.bounds);
-      return;
-    }
-    model.bounds = publicAPI.getInput().getBounds();
-  };
   publicAPI.updateBufferObjects = (ren, actor) => {
     // Rebuild buffers if needed
     if (publicAPI.getNeedToRebuildBufferObjects(ren, actor)) {
@@ -1021,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/RenderWindow/resourceSharingHelper.d.ts

@@ -9,8 +9,8 @@ import { vtkObject } from '../../../interfaces';
  * @param useIndependentComponents A boolean taken from the image or volume property, using getIndependentComponents()
  * @param numberOfComponents Taken from the data array, using getNumberOfComponents()
  */
-export function getTransferFunctionHash(
-  transferFunction: vtkObject | undefined,
+export function getTransferFunctionsHash(
+  transferFunctions: (vtkObject | null | undefined)[],
   useIndependentComponents: boolean,
   numberOfComponents: number
 ): string;
@@ -27,7 +27,7 @@ export function getImageDataHash(
 ): string;
 
 declare const defaultExport: {
-  getTransferFunctionHash: typeof getTransferFunctionHash;
+  getTransferFunctionsHash: typeof getTransferFunctionsHash;
   getImageDataHash: typeof getImageDataHash;
 };
 

package/Rendering/OpenGL/RenderWindow/resourceSharingHelper.js

@@ -1,14 +1,17 @@
 // See typescript header for documentation
 
-function getTransferFunctionHash(transferFunction, useIndependentComponents, numberOfComponents) {
-  return transferFunction ? `${transferFunction.getMTime()}-${useIndependentComponents}-${numberOfComponents}` : '0';
+function getTransferFunctionsHash(transferFunctions, useIndependentComponents, numberOfComponents) {
+  return transferFunctions.length > 0 ? `${transferFunctions.map(tf => tf?.getMTime() ?? 'x').join('/')}-${useIndependentComponents}-${numberOfComponents}` : '0';
 }
 function getImageDataHash(image, scalars) {
-  return `${image.getMTime()}A${scalars.getMTime()}`;
+  // Don't use the image data, as the scalars will define the texture
+  // If using the image data in the hash, it will cause issues when two image data
+  // using the same scalars are in the same mapper (for example the VolumeMapper)
+  return `${scalars.getMTime()}`;
 }
 var resourceSharingHelper = {
-  getTransferFunctionHash,
+  getTransferFunctionsHash,
   getImageDataHash
 };
 
-export { resourceSharingHelper as default, getImageDataHash, getTransferFunctionHash };
+export { resourceSharingHelper as default, getImageDataHash, getTransferFunctionsHash };

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);