@kitware/vtk.js 26.8.0 → 26.8.2

package/Common/DataModel/SelectionNode/Constants.d.ts

@@ -0,0 +1,27 @@
+export declare enum SelectionContent {
+    GLOBALIDS = 0,
+    PEDIGREEIDS = 1,
+    VALUES = 2,
+    INDICES = 3,
+    FRUSTUM = 4,
+    LOCATIONS = 5,
+    THRESHOLDS = 6,
+    BLOCKS = 7,
+    QUERY = 8,
+}
+
+export declare enum SelectionField {
+    CELL = 0,
+    POINT = 1,
+    FIELD = 2,
+    VERTEX = 3,
+    EDGE = 4,
+    ROW = 5,
+}
+
+declare const _default: {
+    SelectionContent: typeof SelectionContent;
+    SelectionField: typeof SelectionField;
+}
+
+export default _default;

package/Common/DataModel/SelectionNode.d.ts

@@ -1,35 +1,70 @@
 import { vtkObject } from './../../interfaces' ;
 import { Bounds } from './../../types';
+import { SelectionContent, SelectionField } from './SelectionNode/Constants';
+import vtkProp from './../../Rendering/Core/Prop';
 
-export enum SelectionContent {
-	GLOBALIDS,
-	PEDIGREEIDS,
-	VALUES,
-	INDICES,
-	FRUSTUM,
-	LOCATIONS,
-	THRESHOLDS,
-	BLOCKS,
-	QUERY,
+export interface ISelectionNodeInitialValues {
+	contentType?: SelectionContent;
+	fieldType?: SelectionField;
+	properties?: ISelectionNodeProperties;
+	selectionList?: number[];
 }
 
-export enum SelectionField {
-	CELL,
-	POINT,
-	FIELD,
-	VERTEX,
-	EDGE,
-	ROW,
+export interface ISelectionNodeProperties {
+	propID?: number;
+	prop?: vtkProp;
+	compositeID?: number;
+	attributeID?: number;
+	pixelCount?: number;
+	displayPosition?: [number, number, number];
+	worldPosition?: [number, number, number];
 }
 
-export interface ISelectionNodeInitialValues {}
-
 export interface vtkSelectionNode extends vtkObject {
-	
 	/**
-	 * 
+	 * Get the bounds of the selection points.
 	 */
 	getBounds(): Bounds;
+
+	/**
+	 * Returns -1 if not initialized.
+	 */
+	getContentType(): SelectionContent | -1;
+
+	/**
+	 * This functions is called internally by VTK.js and is not intended for public use.
+	 */
+	setContentType(contentType: SelectionContent): void;
+
+	/**
+	 * Returns -1 if not initialized.
+	 */
+	getFieldType(): SelectionField | -1;
+
+	/**
+	 * This functions is called internally by VTK.js and is not intended for public use.
+	 */
+	setFieldType(fieldType: SelectionField): void;
+
+	/**
+	 * Get the selection properties.
+	 */
+	getProperties(): ISelectionNodeProperties;
+
+	/**
+	 * This functions is called internally by VTK.js and is not intended for public use.
+	 */
+	setProperties(properties: ISelectionNodeProperties);
+	
+	/**
+	 * Get the list of the underlying selected attribute IDs.
+	 */
+	getSelectionList(): number[];
+
+	/**
+	 * This functions is called internally by VTK.js and is not intended for public use.
+	 */
+	setSelectionList(selectionAttributeIDs: ISelectionNodeProperties);
 }
 
 /**
@@ -57,5 +92,7 @@ export function newInstance(initialValues?: ISelectionNodeInitialValues): vtkSel
 export declare const vtkSelectionNode: {
 	newInstance: typeof newInstance,
 	extend: typeof extend;
+	SelectionContent: typeof SelectionContent;
+    SelectionField: typeof SelectionField;
 };
 export default vtkSelectionNode;

package/Rendering/Core/AxesActor.js

@@ -19,6 +19,16 @@ function centerDataSet(ds) {
   var center = [-(bounds[0] + bounds[1]) * 0.5, -(bounds[2] + bounds[3]) * 0.5, -(bounds[4] + bounds[5]) * 0.5];
 
   (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromDegree()).translate.apply(_vtkMatrixBuilder$bui, center).apply(ds.getPoints().getData());
+}
+
+function shiftDataset(ds, axis) {
+  var _vtkMatrixBuilder$bui2;
+
+  var bounds = ds.getPoints().getBounds();
+  var center = [0, 0, 0];
+  center[axis] = -bounds[axis * 2];
+
+  (_vtkMatrixBuilder$bui2 = vtkMatrixBuilder.buildFromDegree()).translate.apply(_vtkMatrixBuilder$bui2, center).apply(ds.getPoints().getData());
 } // ----------------------------------------------------------------------------
 
 
@@ -47,33 +57,100 @@ function vtkAxesActor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkAxesActor');
 
+  var _mapper = vtkMapper.newInstance();
+
+  publicAPI.setMapper(_mapper);
+
   publicAPI.update = function () {
     var xAxis = vtkArrowSource.newInstance(_objectSpread({
       direction: [1, 0, 0]
     }, model.config)).getOutputData();
-    centerDataSet(xAxis);
+
+    if (model.config.recenter) {
+      centerDataSet(xAxis);
+    } else {
+      shiftDataset(xAxis, 0);
+    }
+
     addColor.apply(void 0, [xAxis].concat(_toConsumableArray(model.xAxisColor)));
     var yAxis = vtkArrowSource.newInstance(_objectSpread({
       direction: [0, 1, 0]
     }, model.config)).getOutputData();
-    centerDataSet(yAxis);
+
+    if (model.config.recenter) {
+      centerDataSet(yAxis);
+    } else {
+      shiftDataset(yAxis, 1);
+    }
+
     addColor.apply(void 0, [yAxis].concat(_toConsumableArray(model.yAxisColor)));
     var zAxis = vtkArrowSource.newInstance(_objectSpread({
       direction: [0, 0, 1]
     }, model.config)).getOutputData();
-    centerDataSet(zAxis);
+
+    if (model.config.recenter) {
+      centerDataSet(zAxis);
+    } else {
+      shiftDataset(zAxis, 2);
+    }
+
     addColor.apply(void 0, [zAxis].concat(_toConsumableArray(model.zAxisColor)));
     var source = vtkAppendPolyData.newInstance();
     source.setInputData(xAxis);
     source.addInputData(yAxis);
-    source.addInputData(zAxis); // set mapper
+    source.addInputData(zAxis);
 
-    var mapper = vtkMapper.newInstance();
-    mapper.setInputConnection(source.getOutputPort());
-    publicAPI.setMapper(mapper);
+    _mapper.setInputConnection(source.getOutputPort());
   };
 
   publicAPI.update();
+
+  var _debouncedUpdate = macro.debounce(publicAPI.update, 0);
+
+  var setConfig = publicAPI.setConfig,
+      setXAxisColor = publicAPI.setXAxisColor,
+      setYAxisColor = publicAPI.setYAxisColor,
+      setZAxisColor = publicAPI.setZAxisColor;
+
+  publicAPI.setConfig = function (c) {
+    if (setConfig(c)) {
+      _debouncedUpdate();
+
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.setXAxisColor = function (c) {
+    if (setXAxisColor(c)) {
+      _debouncedUpdate();
+
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.setYAxisColor = function (c) {
+    if (setYAxisColor(c)) {
+      _debouncedUpdate();
+
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.setZAxisColor = function (c) {
+    if (setZAxisColor(c)) {
+      _debouncedUpdate();
+
+      return true;
+    }
+
+    return false;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -81,6 +158,7 @@ function vtkAxesActor(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   config: {
+    recenter: true,
     tipResolution: 60,
     tipRadius: 0.1,
     tipLength: 0.2,

package/Rendering/Core/ColorTransferFunction.d.ts

@@ -1,10 +1,9 @@
 import vtkDataArray from './../../Common/Core/DataArray';
-import { vtkObject } from './../../interfaces';
+import vtkScalarsToColors from './../../Common/Core/ScalarsToColors'
 import { ColorSpace, Scale } from './ColorTransferFunction/Constants';
 
 
-/* TODO: use VtkScalarsToColors instead of VtkObject */
-export interface vtkColorTransferFunction extends vtkObject {
+export interface vtkColorTransferFunction extends vtkScalarsToColors {
   /**
    * Add a point defined in RGB
    * @param {Number} x The index of the point.
@@ -270,13 +269,6 @@ export interface vtkColorTransferFunction extends vtkObject {
    */
   fillFromDataPointer(nb: number, ptr: any): void;
 
-  /**
-   * Set the range of scalars being mapped.
-   * @param {Number} min
-   * @param {Number} max
-   */
-  setMappingRange(min: number, max: number): void;
-
   /**
    * Remove all points out of the new range, and make sure there is a point at
    * each end of that range.

package/Rendering/Core/Mapper.d.ts

@@ -485,6 +485,10 @@ export interface vtkMapper extends vtkAbstractMapper3D {
 	 *
 	 */
 	setInterpolateScalarsBeforeMapping(interpolateScalarsBeforeMapping: boolean): boolean;
+
+	setResolveCoincidentTopologyToPolygonOffset(): boolean;
+
+	setResolveCoincidentTopologyToOff(): boolean;
 }
 
 /**

package/Rendering/Core/Renderer.d.ts

@@ -628,6 +628,32 @@ export interface vtkRenderer extends vtkViewport {
 	 * Not Implemented yet
 	 */
 	visibleVolumeCount(): any;
+
+	/**
+     * Set the viewport background.
+	 *
+     * @param {Number} r Defines the red component (between 0 and 1).
+     * @param {Number} g Defines the green component (between 0 and 1).
+     * @param {Number} b Defines the blue component (between 0 and 1).
+     * @param {Number} b Defines the alpha component (between 0 and 1).
+     */
+	setBackground(r: number, g: number, b: number, a: number): boolean;
+
+	/**
+     * Set the viewport background.
+	 *
+     * @param {Number} r Defines the red component (between 0 and 1).
+     * @param {Number} g Defines the green component (between 0 and 1).
+     * @param {Number} b Defines the blue component (between 0 and 1).
+     */
+    setBackground(r: number, g: number, b: number): boolean;
+
+	/**
+     * Set the viewport background.
+	 *
+     * @param {Number[]} background The RGB color array.
+     */
+    setBackground(background: number[]): boolean;
 }
 
 /**

package/Rendering/Misc/SynchronizableRenderWindow/ObjectManager.js

@@ -27,6 +27,7 @@ import vtkImageProperty from '../../Core/ImageProperty.js';
 import vtkPiecewiseFunction from '../../../Common/DataModel/PiecewiseFunction.js';
 import vtkCubeAxesActor from '../../Core/CubeAxesActor.js';
 import vtkScalarBarActor from '../../Core/ScalarBarActor.js';
+import vtkAxesActor from '../../Core/AxesActor.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
@@ -583,6 +584,10 @@ var DEFAULT_ALIASES = {
 }; // ----------------------------------------------------------------------------
 
 var DEFAULT_MAPPING = {
+  vtkAxesActor: {
+    build: vtkAxesActor.newInstance,
+    update: genericUpdater
+  },
   vtkRenderWindow: {
     build: vtkRenderWindow.newInstance,
     update: vtkRenderWindowUpdater

package/Rendering/Misc/SynchronizableRenderWindow.d.ts

@@ -54,42 +54,42 @@ export interface IViewState {
 export interface vtkSynchronizableRenderWindow extends vtkRenderWindow {
 
   /**
-   * 
+   *
    */
   getSynchronizerContext(): ISynchronizerContext;
 
   // methods added by createSyncFunction
 
   /**
-   * 
-   * @param {IViewState} state 
+   *
+   * @param {IViewState} state
    */
   synchronize(state: IViewState): Promise<boolean>;
 
   /**
-   * 
-   * @param {String} viewId 
+   *
+   * @param {String} viewId
    */
   setSynchronizedViewId(viewId: string): void;
 
   /**
-   * 
+   *
    */
   getSynchronizedViewId(): string;
 
   /**
-   * 
-   * @param {Number} v 
+   *
+   * @param {Number} v
    */
   updateGarbageCollectorThreshold(v: number): void;
 
   /**
-   * 
+   *
    */
   getManagedInstanceIds(): string[];
 
   /**
-   * 
+   *
    */
   clearOneTimeUpdaters(): void;
 }
@@ -110,52 +110,60 @@ export function extend(publicAPI: object, model: object, initialValues?: ISynchr
 export function newInstance(initialValues?: ISynchronizableRenderWindowInitialValues): vtkSynchronizableRenderWindow;
 
 /**
- * 
- * @param {String} [name] 
+ *
+ * @param {String} [name]
  */
 export function getSynchronizerContext(name?: string): ISynchronizerContext;
 
 /**
- * 
- * @param {String} name 
- * @param {ISynchronizerContext} ctx 
+ *
+ * @param {String} name
+ * @param {Nullable<ISynchronizerContext>} ctx
  */
-export function setSynchronizerContext(name: string, ctx: ISynchronizerContext): ISynchronizerContext;
+export function setSynchronizerContext(name: string, ctx: Nullable<ISynchronizerContext>);
+
 
 /**
- * 
- * @param {vtkRenderWindow} renderWindow 
- * @param {String} [name] 
+ *
+ * @param name of the context to remove and if nothing provided clear them all.
+ */
+export function clearSynchronizerContext(name: Nullable<string>);
+
+/**
+ *
+ * @param {vtkRenderWindow} renderWindow
+ * @param {String} [name]
  */
 export function decorate(renderWindow: vtkRenderWindow, name?: string): object;
 
 /**
- * 
+ *
  */
 export function createInstanceMap(): object;
 
 /**
- * 
+ *
  */
 export function createArrayHandler(): object;
 
 /**
- * 
+ *
  */
 export function createProgressHandler(): object;
 
 /**
- * 
+ *
  */
 export function createSceneMtimeHandler(): object;
 
 /**
- * 
+ *
  */
 export declare const vtkSynchronizableRenderWindow: {
   newInstance: typeof newInstance;
   getSynchronizerContext: typeof getSynchronizerContext;
   setSynchronizerContext: typeof setSynchronizerContext;
+  clearSynchronizerContext: typeof clearSynchronizerContext;
   decorate: typeof decorate,
   createInstanceMap: typeof createInstanceMap,
   createArrayHandler: typeof createArrayHandler,

package/Rendering/Misc/SynchronizableRenderWindow.js

@@ -220,6 +220,20 @@ function getSynchronizerContext() {
 
 function setSynchronizerContext(name, ctx) {
   SYNCHRONIZER_CONTEXTS[name] = ctx;
+}
+
+function clearSynchronizerContext(name) {
+  if (name && SYNCHRONIZER_CONTEXTS[name]) {
+    delete SYNCHRONIZER_CONTEXTS[name];
+  }
+
+  if (!name) {
+    var keys = Object.keys(SYNCHRONIZER_CONTEXTS);
+
+    for (var i = 0; i < keys.length; i++) {
+      delete SYNCHRONIZER_CONTEXTS[keys[i]];
+    }
+  }
 } // ----------------------------------------------------------------------------
 
 
@@ -346,6 +360,7 @@ var vtkSynchronizableRenderWindow$1 = {
   extend: extend,
   getSynchronizerContext: getSynchronizerContext,
   setSynchronizerContext: setSynchronizerContext,
+  clearSynchronizerContext: clearSynchronizerContext,
   decorate: decorate,
   createInstanceMap: createInstanceMap,
   createArrayHandler: createArrayHandler,

package/Rendering/OpenGL/OrderIndependentTranslucentPass.js

@@ -151,7 +151,7 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
     // have the forward pass use a texture backed zbuffer
 
     if (forwardPass.getOpaqueActorCount() > 0) {
-      forwardPass.setCurrentOperation('opaquePass');
+      forwardPass.setCurrentOperation('opaqueZBufferPass');
       renNode.traverse(forwardPass);
     }
 

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -34,9 +34,9 @@ export interface IOpenGLRenderWindowInitialValues {
 }
 
 export interface ICaptureOptions {
-	resetCamera: boolean;
-	size: Size;
-	scale: number
+	resetCamera?: boolean;
+	size?: Size;
+	scale?: number
 }
 
 export interface I3DContextOptions {
@@ -320,7 +320,7 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * @param {String} format
 	 * @param {ICaptureOptions} options
 	 */
-	captureNextImage(format: string, options: ICaptureOptions): Nullable<Promise<string>>;
+	captureNextImage(format: string, options?: ICaptureOptions): Nullable<Promise<string>>;
 
 	/**
 	 *

package/Rendering/OpenGL/SurfaceLIC/SurfaceLICInterface.js

@@ -376,16 +376,19 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     fb.bind();
     model.geometryImage.activate();
     model.vectorImage.activate();
-    model.maskVectorImage.activate();
+    model.maskVectorImage.activate(); // Don't use location 1 as it can be used by order independant translucent pass
+    // Translucent pass uses location 1 because of this line:
+    // gl_FragData[1].r = weight;
+
     fb.removeColorBuffer(0);
-    fb.removeColorBuffer(1);
     fb.removeColorBuffer(2);
+    fb.removeColorBuffer(3);
     fb.setColorBuffer(model.geometryImage, 0);
-    fb.setColorBuffer(model.vectorImage, 1);
-    fb.setColorBuffer(model.maskVectorImage, 2);
+    fb.setColorBuffer(model.vectorImage, 2);
+    fb.setColorBuffer(model.maskVectorImage, 3);
     fb.setDepthBuffer(model.depthTexture);
     var gl = model.context;
-    gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]);
+    gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.NONE, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]);
     gl.viewport.apply(gl, [0, 0].concat(_toConsumableArray(model.size)));
     gl.scissor.apply(gl, [0, 0].concat(_toConsumableArray(model.size)));
     gl.disable(gl.BLEND);

package/Rendering/OpenGL/SurfaceLIC/SurfaceLICMapper.js

@@ -30,7 +30,7 @@ function vtkOpenGLSurfaceLICMapper(publicAPI, model) {
     var array = model.renderable.getInputArrayToProcess(0);
 
     if (array && model.canDrawLIC) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Output::Dec', ['//VTK::Output::Dec', 'layout(location = 1) out vec4 vectorTexture;', 'layout(location = 2) out vec4 maskVectorTexture;']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Output::Dec', ['//VTK::Output::Dec', 'layout(location = 2) out vec4 vectorTexture;', 'layout(location = 3) out vec4 maskVectorTexture;']).result;
       var arrayName = array.getName();
       var attributeName = "".concat(arrayName, "MC"); // We need normals even with no lighting
 

package/index.d.ts

@@ -43,6 +43,7 @@
 /// <reference path="./Common/DataModel/PolyLine.d.ts" />
 /// <reference path="./Common/DataModel/Polygon.d.ts" />
 /// <reference path="./Common/DataModel/Quad.d.ts" />
+/// <reference path="./Common/DataModel/SelectionNode/Constants.d.ts" />
 /// <reference path="./Common/DataModel/SelectionNode.d.ts" />
 /// <reference path="./Common/DataModel/Sphere.d.ts" />
 /// <reference path="./Common/DataModel/Spline1D.d.ts" />

package/package.json

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