@kitware/vtk.js 33.0.0-beta.3 → 33.0.0

package/BREAKING_CHANGES.md

@@ -1,6 +1,3 @@
-## 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`.
 ## 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/Common/Core/DataArray.d.ts

@@ -83,6 +83,23 @@ export interface vtkDataArray extends vtkObject {
    */
   setRange(rangeValue: vtkRange, componentIndex: number): Range;
 
+  /**
+   * Returns an array of the ranges for each component of the DataArray.
+   * Defaults to computing all the ranges if they aren't already computed.
+   *
+   * If the number of components is greater than 1, the last element in the
+   * ranges array is the min,max magnitude of the dataset. This is the same as
+   * calling `getRange(-1)`.
+   *
+   * Passing `getRanges(false)` will return  a clone of the ranges that have
+   * already been computed. This is useful when you want to avoid recomputing
+   * the ranges, which can be expensive.
+   *
+   * @param {boolean} [computeRanges] (default: true)
+   * @returns {vtkRange[]}
+   */
+  getRanges(computeRanges: boolean): vtkRange[];
+
   /**
    * Set the given tuple at the given index.
    * @param {Number} idx

package/Common/Core/DataArray.js

@@ -268,6 +268,35 @@ function vtkDataArray(publicAPI, model) {
     model.rangeTuple[1] = range.max;
     return model.rangeTuple;
   };
+  publicAPI.getRanges = function () {
+    let computeRanges = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    if (!computeRanges) {
+      return structuredClone(model.ranges);
+    }
+    /** @type {import('../../../interfaces').vtkRange[]} */
+    const ranges = [];
+    for (let i = 0; i < model.numberOfComponents; i++) {
+      const [min, max] = publicAPI.getRange(i);
+      /** @type {import('../../../interfaces').vtkRange} */
+      const range = {
+        min,
+        max
+      };
+      ranges.push(range);
+    }
+    // where the number of components is greater than 1, the last element in
+    // the range array is the min,max magnitude of the entire dataset.
+    if (model.numberOfComponents > 1) {
+      const [min, max] = publicAPI.getRange(-1);
+      /** @type {import('../../../interfaces').vtkRange} */
+      const range = {
+        min,
+        max
+      };
+      ranges.push(range);
+    }
+    return ranges;
+  };
   publicAPI.setTuple = (idx, tuple) => {
     const offset = idx * model.numberOfComponents;
     for (let i = 0; i < model.numberOfComponents; i++) {
@@ -426,12 +455,19 @@ function vtkDataArray(publicAPI, model) {
     }
     return sortedObj;
   };
+
+  /**
+   * @param {import("./index").vtkDataArray} other
+   */
   publicAPI.deepCopy = other => {
     // Retain current dataType and array reference before shallowCopy call.
     const currentType = publicAPI.getDataType();
     const currentArray = model.values;
     publicAPI.shallowCopy(other);
 
+    // set the ranges
+    model.ranges = structuredClone(other.getRanges());
+
     // Avoid array reallocation if size already sufficient
     // and dataTypes match.
     if (currentArray?.length >= other.getNumberOfValues() && currentType === other.getDataType()) {

package/Common/Core/ScalarsToColors/Constants.js

@@ -9,9 +9,14 @@ const ScalarMappingTarget = {
   RGB: 3,
   RGBA: 4
 };
+const Scale = {
+  LINEAR: 0,
+  LOG10: 1
+};
 var vtkScalarsToColors = {
   VectorMode,
-  ScalarMappingTarget
+  ScalarMappingTarget,
+  Scale
 };
 
-export { ScalarMappingTarget, VectorMode, vtkScalarsToColors as default };
+export { ScalarMappingTarget, Scale, VectorMode, vtkScalarsToColors as default };

package/Common/Core/ScalarsToColors.js

@@ -5,6 +5,7 @@ import Constants from '../../Rendering/Core/Mapper/Constants.js';
 
 const {
   ScalarMappingTarget,
+  Scale,
   VectorMode
 } = vtkScalarsToColors$2;
 const {
@@ -469,7 +470,8 @@ const DEFAULT_VALUES = {
   mappingRange: null,
   annotationArray: null,
   annotatedValueMap: null,
-  indexedLookup: false
+  indexedLookup: false,
+  scale: Scale.LINEAR
 };
 
 // ----------------------------------------------------------------------------

package/Rendering/Core/AbstractImageMapper.d.ts

@@ -122,6 +122,87 @@ export interface vtkAbstractImageMapper extends vtkAbstractMapper3D {
    * @param customDisplayExtent
    */
   setCustomDisplayExtentFrom(customDisplayExtent: number[]): boolean;
+
+  /**
+   * Set the opacity texture width.
+   *
+   * The default width (1024) should be fine in most instances.
+   * Only set this property if your opacity function range width is
+   * larger than 1024.
+   *
+   * A reasonable max texture size would be either 2048 or 4096, as those
+   * widths are supported by the vast majority of devices. Any width larger
+   * than that will have issues with device support.
+   *
+   * Specifying a width that is less than or equal to 0 will use the largest
+   * possible texture width on the device. Use this with caution! The max texture
+   * width of one device may not be the same for another device.
+   *
+   * You can find more information about supported texture widths at the following link:
+   * https://web3dsurvey.com/webgl/parameters/MAX_TEXTURE_SIZE
+   *
+   * @param {Number} width the texture width (defaults to 1024)
+   */
+  setOpacityTextureWidth(width: number): boolean;
+
+  /**
+   * Get the opacity texture width.
+   */
+  getOpacityTextureWidth(): number;
+
+  /**
+   * Set the color texture width.
+   *
+   * The default width (1024) should be fine in most instances.
+   * Only set this property if your color transfer function range width is
+   * larger than 1024.
+   *
+   * A reasonable max texture size would be either 2048 or 4096, as those
+   * widths are supported by the vast majority of devices. Any width larger
+   * than that will have issues with device support.
+   *
+   * Specifying a width that is less than or equal to 0 will use the largest
+   * possible texture width on the device. Use this with caution! The max texture
+   * width of one device may not be the same for another device.
+   *
+   * You can find more information about supported texture widths at the following link:
+   * https://web3dsurvey.com/webgl/parameters/MAX_TEXTURE_SIZE
+   *
+   * @param {Number} width the texture width (defaults to 1024)
+   */
+  setColorTextureWidth(width: number): boolean;
+
+  /**
+   * Get the color texture width.
+   */
+  getColorTextureWidth(): number;
+
+  /**
+   * Set the label outline texture width.
+   *
+   * The default width (1024) should be fine in most instances.
+   * Only set this property if you have more than 1024 labels
+   * that you want to render with thickness.
+   *
+   * A reasonable max texture size would be either 2048 or 4096, as those
+   * widths are supported by the vast majority of devices. Any width larger
+   * than that will have issues with device support.
+   *
+   * Specifying a width that is less than or equal to 0 will use the largest
+   * possible texture width on the device. Use this with caution! The max texture
+   * width of one device may not be the same for another device.
+   *
+   * You can find more information about supported texture widths at the following link:
+   * https://web3dsurvey.com/webgl/parameters/MAX_TEXTURE_SIZE
+   *
+   * @param {Number} width the texture width (defaults to 1024)
+   */
+  setLabelOutlineTextureWidth(width: number): boolean;
+
+  /**
+   * Get the label outline texture width.
+   */
+  getLabelOutlineTextureWidth(): number;
 }
 
 /**

package/Rendering/Core/AbstractImageMapper.js

@@ -24,7 +24,10 @@ const DEFAULT_VALUES = {
   slice: 0,
   customDisplayExtent: [0, 0, 0, 0, 0, 0],
   useCustomExtents: false,
-  backgroundColor: [0, 0, 0, 1]
+  backgroundColor: [0, 0, 0, 1],
+  colorTextureWidth: 1024,
+  opacityTextureWidth: 1024,
+  labelOutlineTextureWidth: 1024
 };
 
 // ----------------------------------------------------------------------------
@@ -35,7 +38,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['slice', 'useCustomExtents']);
+  macro.setGet(publicAPI, model, ['slice', 'useCustomExtents', 'colorTextureWidth', 'opacityTextureWidth', 'labelOutlineTextureWidth']);
   macro.setGetArray(publicAPI, model, ['customDisplayExtent'], 6);
   macro.setGetArray(publicAPI, model, ['backgroundColor'], 4);
   vtkAbstractImageMapper(publicAPI, model);

package/Rendering/Core/AbstractPicker.d.ts

@@ -1,6 +1,6 @@
 import { vtkObject } from './../../interfaces';
 import { Vector3 } from './../../types';
-import vtkActor from './Actor';
+import vtkProp3D from './Prop3D';
 import vtkRenderer from './Renderer';
 
 /**
@@ -10,8 +10,8 @@ export interface IAbstractPickerInitialValues {
   renderer?: vtkRenderer;
   selectionPoint?: Vector3;
   pickPosition?: Vector3;
-  pickFromList?: number;
-  pickList?: vtkActor[];
+  pickFromList?: boolean;
+  pickList?: vtkProp3D[];
 }
 
 /**
@@ -20,15 +20,15 @@ export interface IAbstractPickerInitialValues {
 export interface vtkAbstractPicker extends vtkObject {
   /**
    *
-   * @param {vtkActor} actor
+   * @param {vtkProp3D} prop
    */
-  addPickList(actor: vtkActor): void;
+  addPickList(prop: vtkProp3D): void;
 
   /**
    *
-   * @param {vtkActor} actor
+   * @param {vtkProp3D} prop
    */
-  deletePickList(actor: vtkActor): void;
+  deletePickList(prop: vtkProp3D): void;
 
   /**
    *
@@ -38,7 +38,7 @@ export interface vtkAbstractPicker extends vtkObject {
   /**
    *
    */
-  getPickList(): boolean;
+  getPickList(): vtkProp3D[];
 
   /**
    * Get the picked position
@@ -82,17 +82,17 @@ export interface vtkAbstractPicker extends vtkObject {
 
   /**
    *
-   * @param {Number}  pickFromList
-   * @default 0
+   * @param {Boolean}  pickFromList
+   * @default false
    */
-  setPickFromList(pickFromList: number): boolean;
+  setPickFromList(pickFromList: boolean): boolean;
 
   /**
    *
-   * @param {vtkActor[]} pickList
+   * @param {vtkProp3D[]} pickList
    * @default []
    */
-  setPickList(pickList: vtkActor[]): boolean;
+  setPickList(pickList: vtkProp3D[]): boolean;
 }
 
 /**

package/Rendering/Core/AbstractPicker.js

@@ -38,7 +38,7 @@ const DEFAULT_VALUES = {
   renderer: null,
   selectionPoint: [0.0, 0.0, 0.0],
   pickPosition: [0.0, 0.0, 0.0],
-  pickFromList: 0,
+  pickFromList: false,
   pickList: []
 };
 

package/Rendering/Core/Actor.d.ts

@@ -36,6 +36,12 @@ export interface vtkActor extends vtkProp3D {
    */
   getBackfaceProperty(): vtkProperty;
 
+  /**
+   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * @return {Bounds} The bounds for the mapper.
+   */
+  getBounds(): Bounds;
+
   /**
    * Check whether the opaque is forced or not.
    */
@@ -57,6 +63,16 @@ export interface vtkActor extends vtkProp3D {
    */
   getMapper(): Nullable<vtkMapper>;
 
+  /**
+   * Get the property object that controls this actors surface
+   * properties. This should be an instance of a vtkProperty object. Every
+   * actor must have a property associated with it. If one isn’t specified,
+   * then one will be generated automatically. Multiple actors can share one
+   * property object.
+   * @return {vtkProperty} The property object
+   */
+  getProperty(): vtkProperty;
+
   /**
    * Check whether if the actor supports selection
    * @return {Boolean} true if the actor support selection.
@@ -95,12 +111,11 @@ export interface vtkActor extends vtkProp3D {
    */
   setMapper(mapper: vtkMapper): boolean;
 
-  // Inherited from vtkProp3D, but takes a vtkProperty instead of a generic vtkObject
-  getProperty(mapperInputPort?: number): vtkProperty;
-  getProperties(): vtkProperty[];
-  setProperty(mapperInputPort: number, property: vtkProperty): boolean;
+  /**
+   * Set the property object that controls this actors surface properties.
+   * @param {vtkProperty} property The vtkProperty instance.
+   */
   setProperty(property: vtkProperty): boolean;
-  setProperties(properties: vtkProperty[]): boolean;
 }
 
 /**

package/Rendering/Core/Actor.js

@@ -1,7 +1,13 @@
+import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkProperty from './Property.js';
 
+const {
+  vtkDebugMacro
+} = macro;
+
 // ----------------------------------------------------------------------------
 // vtkActor methods
 // ----------------------------------------------------------------------------
@@ -23,11 +29,11 @@ function vtkActor(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (!model.properties[0]) {
+    if (!model.property) {
       // force creation of a property
       publicAPI.getProperty();
     }
-    let isOpaque = model.properties[0].getOpacity() >= 1.0;
+    let isOpaque = model.property.getOpacity() >= 1.0;
 
     // are we using an opaque texture, if any?
     isOpaque = isOpaque && (!model.texture || !model.texture.isTranslucent());
@@ -41,17 +47,71 @@ function vtkActor(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (!model.properties[0]) {
+    if (model.property === null) {
       // force creation of a property
-      publicAPI.getProperty();
+      publicAPI.setProperty(publicAPI.makeProperty());
     }
 
     // is this actor opaque ?
     return !publicAPI.getIsOpaque();
   };
   publicAPI.makeProperty = vtkProperty.newInstance;
+  publicAPI.getProperty = () => {
+    if (model.property === null) {
+      model.property = publicAPI.makeProperty();
+    }
+    return model.property;
+  };
+  publicAPI.getBounds = () => {
+    if (model.mapper === null) {
+      return model.bounds;
+    }
+
+    // Check for the special case when the mapper's bounds are unknown
+    const bds = model.mapper.getBounds();
+    if (!bds || bds.length !== 6) {
+      return bds;
+    }
+
+    // Check for the special case when the actor is empty.
+    if (bds[0] > bds[1]) {
+      model.mapperBounds = bds.concat(); // copy the mapper's bounds
+      model.bounds = [1, -1, 1, -1, 1, -1];
+      model.boundsMTime.modified();
+      return bds;
+    }
+
+    // Check if we have cached values for these bounds - we cache the
+    // values returned by model.mapper.getBounds() and we store the time
+    // of caching. If the values returned this time are different, or
+    // the modified time of this class is newer than the cached time,
+    // then we need to rebuild.
+    if (!model.mapperBounds || bds[0] !== model.mapperBounds[0] || bds[1] !== model.mapperBounds[1] || bds[2] !== model.mapperBounds[2] || bds[3] !== model.mapperBounds[3] || bds[4] !== model.mapperBounds[4] || bds[5] !== model.mapperBounds[5] || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
+      vtkDebugMacro('Recomputing bounds...');
+      model.mapperBounds = bds.concat(); // copy the mapper's bounds
+      const bbox = [];
+      vtkBoundingBox.getCorners(bds, bbox);
+      publicAPI.computeMatrix();
+      const tmp4 = new Float64Array(16);
+      mat4.transpose(tmp4, model.matrix);
+      bbox.forEach(pt => vec3.transformMat4(pt, pt, tmp4));
+
+      /* eslint-disable no-multi-assign */
+      model.bounds[0] = model.bounds[2] = model.bounds[4] = Number.MAX_VALUE;
+      model.bounds[1] = model.bounds[3] = model.bounds[5] = -Number.MAX_VALUE;
+      /* eslint-enable no-multi-assign */
+
+      model.bounds = model.bounds.map((d, i) => i % 2 === 0 ? bbox.reduce((a, b) => a > b[i / 2] ? b[i / 2] : a, d) : bbox.reduce((a, b) => a < b[(i - 1) / 2] ? b[(i - 1) / 2] : a, d));
+      model.boundsMTime.modified();
+    }
+    return model.bounds;
+  };
   publicAPI.getMTime = () => {
     let mt = superClass.getMTime();
+    if (model.property !== null) {
+      const time = model.property.getMTime();
+      mt = time > mt ? time : mt;
+    }
     if (model.backfaceProperty !== null) {
       const time = model.backfaceProperty.getMTime();
       mt = time > mt ? time : mt;
@@ -86,9 +146,11 @@ function vtkActor(publicAPI, model) {
 
 const DEFAULT_VALUES = {
   mapper: null,
+  property: null,
   backfaceProperty: null,
   forceOpaque: false,
-  forceTranslucent: false
+  forceTranslucent: false,
+  bounds: [1, -1, 1, -1, 1, -1]
 };
 
 // ----------------------------------------------------------------------------
@@ -105,6 +167,7 @@ function extend(publicAPI, model) {
   macro.obj(model.boundsMTime);
 
   // Build VTK API
+  macro.set(publicAPI, model, ['property']);
   macro.setGet(publicAPI, model, ['backfaceProperty', 'forceOpaque', 'forceTranslucent', 'mapper']);
 
   // Object methods

package/Rendering/Core/Actor2D.d.ts

@@ -54,6 +54,28 @@ export interface vtkActor2D extends vtkProp {
    */
   getMapper(): vtkMapper2D;
 
+  /**
+   * Set the layer number for this 2D actor.
+   * The scenegraph uses this layer number to sort actor 2D overlays/underlays on top of each other.
+   * The actor2D with the highest layer number is going to be rendered at the very front i.e. it is
+   * the top-most layer.
+   * If two actor2D instances share the same layer number, they are rendered in the order in which
+   * they were added to the renderer via `addActor` or `addActor2D`.
+   * By default, each actor2D has a layer number of 0.
+   */
+  setLayerNumber(layer: number): void;
+
+  /**
+   * Get the layer number for this 2D actor.
+   * The scenegraph uses this layer number to sort actor 2D overlays/underlays on top of each other.
+   * The actor2D with the highest layer number is going to be rendered at the very front i.e. it is
+   * the top-most layer.
+   * If two actor2D instances share the same layer number, they are rendered in the order in which
+   * they were added to the renderer via `addActor` or `addActor2D`.
+   * By default, each actor2D has a layer number of 0.
+   */
+  getLayerNumber(): number;
+
   /**
    *
    */

package/Rendering/Core/Actor2D.js

@@ -145,7 +145,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   macro.set(publicAPI, model, ['property']);
-  macro.setGet(publicAPI, model, ['mapper']);
+  macro.setGet(publicAPI, model, ['mapper', 'layerNumber']);
 
   // Object methods
   vtkActor2D(publicAPI, model);

package/Rendering/Core/CellPicker.js

@@ -219,7 +219,10 @@ function vtkCellPicker(publicAPI, model) {
 
     // calculate opacity table
     const numIComps = 1;
-    const oWidth = 1024;
+    let oWidth = mapper.getOpacityTextureWidth();
+    if (oWidth <= 0) {
+      oWidth = 1024;
+    }
     const tmpTable = new Float32Array(oWidth);
     const opacityArray = new Float32Array(oWidth);
     let ofun;

package/Rendering/Core/ColorTransferFunction.js

@@ -400,13 +400,18 @@ function vtkColorTransferFunction(publicAPI, model) {
     publicAPI.getColor(x, rgb);
     return rgb[2];
   };
+  publicAPI.logScaleEnabled = () => model.scale === Scale.LOG10;
+  publicAPI.usingLogScale = () => publicAPI.logScaleEnabled() && model.mappingRange[0] > 0.0;
 
   //----------------------------------------------------------------------------
   // Returns a table of RGB colors at regular intervals along the function
   publicAPI.getTable = (xStart_, xEnd_, size, table) => {
+    // Note: This requires range[0] <= range[1].
+    const usingLogScale = publicAPI.usingLogScale();
+
     // To handle BigInt limitation
-    const xStart = Number(xStart_);
-    const xEnd = Number(xEnd_);
+    const xStart = usingLogScale ? Math.log10(Number(xStart_)) : Number(xStart_);
+    const xEnd = usingLogScale ? Math.log10(Number(xEnd_)) : Number(xEnd_);
 
     // Special case: If either the start or end is a NaN, then all any
     // interpolation done on them is also a NaN.  Therefore, fill the table with
@@ -443,17 +448,9 @@ function vtkColorTransferFunction(publicAPI, model) {
     const tmpVec = [];
 
     // If the scale is logarithmic, make sure the range is valid.
-    let usingLogScale = model.scale === Scale.LOG10;
-    if (usingLogScale) {
-      // Note: This requires range[0] <= range[1].
-      usingLogScale = model.mappingRange[0] > 0.0;
-    }
-    let logStart = 0.0;
-    let logEnd = 0.0;
-    let logX = 0.0;
+    let scaledMappingRange = model.mappingRange;
     if (usingLogScale) {
-      logStart = Math.log10(xStart);
-      logEnd = Math.log10(xEnd);
+      scaledMappingRange = [Math.log10(model.mappingRange[0]), Math.log10(model.mappingRange[1])];
     }
 
     // For each table entry
@@ -465,15 +462,7 @@ function vtkColorTransferFunction(publicAPI, model) {
       // it halfway between start and end (usually start and end will
       // be the same in this case)
       if (size > 1) {
-        if (usingLogScale) {
-          logX = logStart + i / (size - 1.0) * (logEnd - logStart);
-          x = 10.0 ** logX;
-        } else {
-          x = xStart + i / (size - 1.0) * (xEnd - xStart);
-        }
-      } else if (usingLogScale) {
-        logX = 0.5 * (logStart + logEnd);
-        x = 10.0 ** logX;
+        x = xStart + i / (size - 1.0) * (xEnd - xStart);
       } else {
         x = 0.5 * (xStart + xEnd);
       }
@@ -482,7 +471,7 @@ function vtkColorTransferFunction(publicAPI, model) {
       // discretize (round down to the closest integer),
       // then map back to mappingRange
       if (model.discretize) {
-        const range = model.mappingRange;
+        const range = scaledMappingRange;
         if (x >= range[0] && x <= range[1]) {
           const numberOfValues = model.numberOfValues;
           const deltaRange = range[1] - range[0];
@@ -509,10 +498,6 @@ function vtkColorTransferFunction(publicAPI, model) {
         if (idx < numNodes) {
           x1 = model.nodes[idx - 1].x;
           x2 = model.nodes[idx].x;
-          if (usingLogScale) {
-            x1 = Math.log10(x1);
-            x2 = Math.log10(x2);
-          }
           rgb1[0] = model.nodes[idx - 1].r;
           rgb2[0] = model.nodes[idx].r;
           rgb1[1] = model.nodes[idx - 1].g;
@@ -537,7 +522,7 @@ function vtkColorTransferFunction(publicAPI, model) {
       }
 
       // Are we at or past the end? If so, just use the last value
-      if (x > model.mappingRange[1]) {
+      if (x > scaledMappingRange[1]) {
         table[tidx] = 0.0;
         table[tidx + 1] = 0.0;
         table[tidx + 2] = 0.0;
@@ -552,7 +537,7 @@ function vtkColorTransferFunction(publicAPI, model) {
             table[tidx + 2] = lastB;
           }
         }
-      } else if (x < model.mappingRange[0] || isInf(x) && x < 0) {
+      } else if (x < scaledMappingRange[0] || isInf(x) && x < 0) {
         // we are before the first node? If so, duplicate this node's values.
         // We have to deal with -inf here
         table[tidx] = 0.0;
@@ -586,11 +571,7 @@ function vtkColorTransferFunction(publicAPI, model) {
         // sharpness to get the curve shape we want and to have
         // it pass through (y1+y2)/2 at the midpoint.
         let s = 0.0;
-        if (usingLogScale) {
-          s = (logX - x1) / (x2 - x1);
-        } else {
-          s = (x - x1) / (x2 - x1);
-        }
+        s = (x - x1) / (x2 - x1);
 
         // Readjust based on the midpoint - linear adjustment
         if (s < midpoint) {
@@ -975,7 +956,9 @@ function vtkColorTransferFunction(publicAPI, model) {
   //----------------------------------------------------------------------------
   publicAPI.setMappingRange = (min, max) => {
     const range = [min, max];
+    const scaledRange = [min, max];
     const originalRange = publicAPI.getRange();
+    const logScaleEnabled = publicAPI.logScaleEnabled();
     if (originalRange[1] === range[1] && originalRange[0] === range[0]) {
       return;
     }
@@ -983,8 +966,16 @@ function vtkColorTransferFunction(publicAPI, model) {
       vtkErrorMacro('attempt to set zero width color range');
       return;
     }
-    const scale = (range[1] - range[0]) / (originalRange[1] - originalRange[0]);
-    const shift = range[0] - originalRange[0] * scale;
+    if (logScaleEnabled) {
+      if (range[0] <= 0.0) {
+        console.warn('attempt to set log scale color range with non-positive minimum');
+      } else {
+        scaledRange[0] = Math.log10(range[0]);
+        scaledRange[1] = Math.log10(range[1]);
+      }
+    }
+    const scale = (scaledRange[1] - scaledRange[0]) / (originalRange[1] - originalRange[0]);
+    const shift = scaledRange[0] - originalRange[0] * scale;
     for (let i = 0; i < model.nodes.length; ++i) {
       model.nodes[i].x = model.nodes[i].x * scale + shift;
     }