@kitware/vtk.js 26.9.13 → 27.0.0

package/Rendering/Core/ImageResliceMapper.js

@@ -0,0 +1,70 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
+import Constants from './ImageResliceMapper/Constants.js';
+import macro from '../../macros.js';
+import vtkAbstractImageMapper from './AbstractImageMapper.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.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; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var SlabTypes = Constants.SlabTypes;
+var staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
+    otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods; // ----------------------------------------------------------------------------
+// vtkImageResliceMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkImageResliceMapper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageResliceMapper');
+
+  publicAPI.getBounds = function () {
+    var bds = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS);
+
+    var image = publicAPI.getInputData();
+
+    if (publicAPI.getSlicePolyData()) {
+      bds = publicAPI.getSlicePolyData().getBounds();
+    } else if (image) {
+      bds = image.getBounds();
+
+      if (publicAPI.getSlicePlane()) {
+        vtkBoundingBox.cutWithPlane(bds, publicAPI.getSlicePlane().getOrigin(), publicAPI.getSlicePlane().getNormal());
+      }
+    }
+
+    return bds;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  slabThickness: 0.0,
+  slabTrapezoidIntegration: 0,
+  slabType: SlabTypes.MEAN,
+  slicePlane: null,
+  slicePolyData: null
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+
+  vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData']);
+  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
+
+  vtkImageResliceMapper(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkImageResliceMapper'); // ----------------------------------------------------------------------------
+
+var vtkImageResliceMapper$1 = _objectSpread(_objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, staticOffsetAPI), otherStaticMethods);
+
+export { vtkImageResliceMapper$1 as default, extend, newInstance };

package/Rendering/Core/Mapper.js

@@ -553,7 +553,6 @@ var DEFAULT_VALUES = {
   forceCompileOnly: 0,
   useInvertibleColors: false,
   invertibleScalars: null,
-  viewSpecificProperties: null,
   customShaderAttributes: []
 }; // ----------------------------------------------------------------------------
 
@@ -563,14 +562,9 @@ function extend(publicAPI, model) {
 
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['colorCoordinates', 'colorMapColors', 'colorTextureMap']);
-  macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'populateSelectionSettings', 'renderTime', 'scalarMode', 'scalarVisibility', 'selectionWebGLIdsToVTKIds', 'static', 'useLookupTableScalarRange', 'viewSpecificProperties', 'customShaderAttributes' // point data array names that will be transferred to the VBO
+  macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'populateSelectionSettings', 'renderTime', 'scalarMode', 'scalarVisibility', 'selectionWebGLIdsToVTKIds', 'static', 'useLookupTableScalarRange', 'customShaderAttributes' // point data array names that will be transferred to the VBO
   ]);
   macro.setGetArray(publicAPI, model, ['scalarRange'], 2);
-
-  if (!model.viewSpecificProperties) {
-    model.viewSpecificProperties = {};
-  }
-
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
 
   vtkMapper(publicAPI, model);

package/Rendering/Core.js

@@ -17,6 +17,7 @@ import vtkGlyph3DMapper from './Core/Glyph3DMapper.js';
 import vtkHardwareSelector from './Core/HardwareSelector.js';
 import vtkImageMapper from './Core/ImageMapper.js';
 import vtkImageProperty from './Core/ImageProperty.js';
+import vtkImageResliceMapper from './Core/ImageResliceMapper.js';
 import vtkImageSlice from './Core/ImageSlice.js';
 import vtkInteractorObserver from './Core/InteractorObserver.js';
 import vtkInteractorStyle from './Core/InteractorStyle.js';
@@ -66,6 +67,7 @@ var Core = {
   vtkHardwareSelector: vtkHardwareSelector,
   vtkImageMapper: vtkImageMapper,
   vtkImageProperty: vtkImageProperty,
+  vtkImageResliceMapper: vtkImageResliceMapper,
   vtkImageSlice: vtkImageSlice,
   vtkInteractorObserver: vtkInteractorObserver,
   vtkInteractorStyle: vtkInteractorStyle,

package/Rendering/OpenGL/ImageMapper.js

@@ -104,17 +104,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     publicAPI.renderPiece(ren, actor);
   };
 
-  publicAPI.buildShaders = function (shaders, ren, actor) {
-    publicAPI.getShaderTemplate(shaders, ren, actor);
-    model.lastRenderPassShaderReplacement = model.currentRenderPass ? model.currentRenderPass.getShaderReplacement() : null; // apply any renderPassReplacements
-
-    if (model.lastRenderPassShaderReplacement) {
-      model.lastRenderPassShaderReplacement(shaders);
-    }
-
-    publicAPI.replaceShaderValues(shaders, ren, actor);
-  };
-
   publicAPI.getShaderTemplate = function (shaders, ren, actor) {
     shaders.Vertex = vtkPolyDataVS;
     shaders.Fragment = vtkPolyDataFS;
@@ -875,6 +864,7 @@ function extend(publicAPI, model) {
 
   vtkViewNode.extend(publicAPI, model, initialValues);
   vtkReplacementShaderMapper.implementReplaceShaderCoincidentOffset(publicAPI, model, initialValues);
+  vtkReplacementShaderMapper.implementBuildShadersWithReplacements(publicAPI, model, initialValues);
   model.tris = vtkHelper.newInstance();
   model.openGLTexture = vtkOpenGLTexture.newInstance({
     resizable: true