@kitware/vtk.js 25.10.0 → 26.0.0-beta.2

package/Widgets/Representations/SphereHandleRepresentation.js

@@ -1,12 +1,7 @@
 import macro from '../../macros.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
-import vtkDataArray from '../../Common/Core/DataArray.js';
-import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
-import vtkHandleRepresentation from './HandleRepresentation.js';
+import vtkGlyphRepresentation from './GlyphRepresentation.js';
 import vtkPixelSpaceCallbackMapper from '../../Rendering/Core/PixelSpaceCallbackMapper.js';
-import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
-import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
 
 // vtkSphereHandleRepresentation methods
 // ----------------------------------------------------------------------------
@@ -14,27 +9,6 @@ import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
 function vtkSphereHandleRepresentation(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSphereHandleRepresentation'); // --------------------------------------------------------------------------
-  // Internal polydata dataset
-  // --------------------------------------------------------------------------
-
-  model.internalPolyData = vtkPolyData.newInstance({
-    mtime: 0
-  });
-  model.internalArrays = {
-    points: model.internalPolyData.getPoints(),
-    scale: vtkDataArray.newInstance({
-      name: 'scale',
-      numberOfComponents: 1,
-      empty: true
-    }),
-    color: vtkDataArray.newInstance({
-      name: 'color',
-      numberOfComponents: 1,
-      empty: true
-    })
-  };
-  model.internalPolyData.getPointData().addArray(model.internalArrays.scale);
-  model.internalPolyData.getPointData().addArray(model.internalArrays.color); // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
@@ -51,27 +25,16 @@ function vtkSphereHandleRepresentation(publicAPI, model) {
   model.displayActor.setMapper(model.displayMapper);
   model.displayMapper.setInputConnection(publicAPI.getOutputPort());
   publicAPI.addActor(model.displayActor);
-  model.alwaysVisibleActors = [model.displayActor];
-  model.mapper = vtkGlyph3DMapper.newInstance({
-    scaleArray: 'scale',
-    colorByArrayName: 'color',
-    scalarMode: ScalarMode.USE_POINT_FIELD_DATA
-  });
-  model.actor = vtkActor.newInstance({
-    parentProp: publicAPI
-  });
-  model.glyph = vtkSphereSource.newInstance({
-    phiResolution: model.glyphResolution,
-    thetaResolution: model.glyphResolution
-  });
-  model.mapper.setInputConnection(publicAPI.getOutputPort(), 0);
-  model.mapper.setInputConnection(model.glyph.getOutputPort(), 1);
-  model.actor.setMapper(model.mapper);
-  publicAPI.addActor(model.actor); // --------------------------------------------------------------------------
-
-  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, function (r) {
-    return model.glyph.setPhiResolution(r) && model.glyph.setThetaResolution(r);
-  }); // --------------------------------------------------------------------------
+  model.alwaysVisibleActors = [model.displayActor]; // --------------------------------------------------------------------------
+
+  publicAPI.getGlyphResolution = function () {
+    return model._pipeline.glyph.getPhiResolution();
+  };
+
+  publicAPI.setGlyphResolution = function (resolution) {
+    return model._pipeline.glyph.setPhiResolution(resolution) || model._pipeline.glyph.setThetaResolution(resolution);
+  }; // --------------------------------------------------------------------------
+
 
   function callbackProxy(coords) {
     if (model.displayCallback) {
@@ -97,75 +60,15 @@ function vtkSphereHandleRepresentation(publicAPI, model) {
     model.displayCallback = callback;
     model.displayMapper.setCallback(callback ? callbackProxy : null);
   };
-
-  var superGetRepresentationStates = publicAPI.getRepresentationStates;
-
-  publicAPI.getRepresentationStates = function () {
-    var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.inputData[0];
-    return superGetRepresentationStates(input).filter(function (state) {
-      var _state$getOrigin, _state$isVisible;
-
-      return ((_state$getOrigin = state.getOrigin) === null || _state$getOrigin === void 0 ? void 0 : _state$getOrigin.call(state)) && ((_state$isVisible = state.isVisible) === null || _state$isVisible === void 0 ? void 0 : _state$isVisible.call(state));
-    });
-  }; // --------------------------------------------------------------------------
-
-
-  publicAPI.requestData = function (inData, outData) {
-    var _model$internalArrays = model.internalArrays,
-        points = _model$internalArrays.points,
-        scale = _model$internalArrays.scale,
-        color = _model$internalArrays.color;
-    var list = publicAPI.getRepresentationStates(inData[0]);
-    var totalCount = list.length;
-
-    if (color.getNumberOfValues() !== totalCount) {
-      // Need to resize dataset
-      points.setData(new Float32Array(3 * totalCount), 3);
-      scale.setData(new Float32Array(totalCount));
-      color.setData(new Float32Array(totalCount));
-    }
-
-    var typedArray = {
-      points: points.getData(),
-      scale: scale.getData(),
-      color: color.getData()
-    };
-
-    for (var i = 0; i < totalCount; i++) {
-      var state = list[i];
-      var isActive = state.getActive();
-      var scaleFactor = isActive ? model.activeScaleFactor : 1;
-      var coord = state.getOrigin();
-      typedArray.points[i * 3 + 0] = coord[0];
-      typedArray.points[i * 3 + 1] = coord[1];
-      typedArray.points[i * 3 + 2] = coord[2];
-      typedArray.scale[i] = scaleFactor * (state.getScale1 ? state.getScale1() : model.defaultScale);
-
-      if (publicAPI.getScaleInPixels()) {
-        typedArray.scale[i] *= publicAPI.getPixelWorldHeightAtCoord(coord);
-      }
-
-      typedArray.color[i] = model.useActiveColor && isActive ? model.activeColor : state.getColor();
-    }
-
-    model.internalPolyData.modified();
-    outData[0] = model.internalPolyData;
-  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  glyphResolution: 8,
-  defaultScale: 1
-}; // ----------------------------------------------------------------------------
-
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-  vtkHandleRepresentation.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['glyph', 'mapper', 'actor']); // Object specific methods
+  vtkGlyphRepresentation.extend(publicAPI, model, initialValues); // Object specific methods
 
   vtkSphereHandleRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Representations/SplineContextRepresentation.js

@@ -7,6 +7,7 @@ import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkSpline3D from '../../Common/DataModel/Spline3D.js';
 import vtkTriangleFilter from '../../Filters/General/TriangleFilter.js';
 import vtkLineFilter from '../../Filters/General/LineFilter.js';
+import vtkWidgetRepresentation, { allocateArray } from './WidgetRepresentation.js';
 
 // vtkSplineContextRepresentation methods
 // ----------------------------------------------------------------------------
@@ -17,55 +18,71 @@ function vtkSplineContextRepresentation(publicAPI, model) {
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
-  model.pipelines = {
+  model.internalPolyData = vtkPolyData.newInstance({
+    mtime: 0
+  });
+  model._pipelines = {
     area: {
+      source: publicAPI,
+      filter: vtkTriangleFilter.newInstance(),
+      mapper: vtkMapper.newInstance(),
       actor: vtkActor.newInstance({
         parentProp: publicAPI
-      }),
-      mapper: vtkMapper.newInstance(),
-      triangleFilter: vtkTriangleFilter.newInstance()
+      })
     },
     border: {
+      source: publicAPI,
+      filter: vtkLineFilter.newInstance(),
+      mapper: vtkMapper.newInstance(),
       actor: vtkActor.newInstance({
         parentProp: publicAPI
-      }),
-      mapper: vtkMapper.newInstance(),
-      lineFilter: vtkLineFilter.newInstance()
+      })
     }
   };
-  model.pipelines.area.triangleFilter.setInputConnection(publicAPI.getOutputPort());
-  model.pipelines.area.mapper.setInputConnection(model.pipelines.area.triangleFilter.getOutputPort());
-  model.pipelines.area.actor.setMapper(model.pipelines.area.mapper);
-  model.pipelines.area.actor.getProperty().setOpacity(0.2);
-  model.pipelines.area.actor.getProperty().setColor(0, 1, 0);
-  publicAPI.addActor(model.pipelines.area.actor);
-  model.pipelines.border.lineFilter.setInputConnection(publicAPI.getOutputPort());
-  model.pipelines.border.mapper.setInputConnection(model.pipelines.border.lineFilter.getOutputPort());
-  model.pipelines.border.actor.setMapper(model.pipelines.border.mapper);
-  model.pipelines.border.actor.getProperty().setOpacity(1);
-  model.pipelines.border.actor.getProperty().setColor(0.1, 1, 0.1);
-  model.pipelines.border.actor.setVisibility(model.outputBorder);
-  publicAPI.addActor(model.pipelines.border.actor); // --------------------------------------------------------------------------
+  vtkWidgetRepresentation.connectPipeline(model._pipelines.area);
+
+  model._pipelines.area.actor.getProperty().setOpacity(0.2);
+
+  model._pipelines.area.actor.getProperty().setColor(0, 1, 0);
+
+  publicAPI.addActor(model._pipelines.area.actor);
+  vtkWidgetRepresentation.connectPipeline(model._pipelines.border);
+
+  model._pipelines.border.actor.getProperty().setOpacity(1);
+
+  model._pipelines.border.actor.getProperty().setColor(0.1, 1, 0.1);
+
+  model._pipelines.border.actor.setVisibility(model.outputBorder);
+
+  publicAPI.addActor(model._pipelines.border.actor); // --------------------------------------------------------------------------
+
+  var superGetRepresentationStates = publicAPI.getRepresentationStates;
+
+  publicAPI.getRepresentationStates = function () {
+    var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.inputData[0];
+    return superGetRepresentationStates(input).filter(function (state) {
+      var _state$getOrigin, _state$isVisible;
+
+      return ((_state$getOrigin = state.getOrigin) === null || _state$getOrigin === void 0 ? void 0 : _state$getOrigin.call(state)) && ((_state$isVisible = state.isVisible) === null || _state$isVisible === void 0 ? void 0 : _state$isVisible.call(state));
+    });
+  };
 
   publicAPI.requestData = function (inData, outData) {
-    var _model$pipelines$bord;
+    var _model$_pipelines$bor;
 
     if (model.deleted) {
       return;
     }
 
-    var polydata = vtkPolyData.newInstance();
     var widgetState = inData[0];
     var closed = widgetState.getSplineClosed();
-    var list = publicAPI.getRepresentationStates(widgetState).filter(function (state) {
-      return state.getVisible && state.getVisible() && state.getOrigin && state.getOrigin();
-    });
+    var list = publicAPI.getRepresentationStates(widgetState);
     var inPoints = list.map(function (state) {
       return state.getOrigin();
     });
 
     if (inPoints.length <= 1) {
-      outData[0] = polydata;
+      outData[0] = model.internalPolyData;
       return;
     }
 
@@ -87,7 +104,7 @@ function vtkSplineContextRepresentation(publicAPI, model) {
       boundaryConditionValues: widgetState.getSplineBoundaryConditionValues()
     });
     spline.computeCoefficients(inPoints);
-    var outPoints = new Float32Array(3 * ((numVertices + !closed) * model.resolution));
+    var outPoints = allocateArray(model.internalPolyData, 'points', (numVertices + !closed) * model.resolution).getData();
     var outCells = new Uint32Array(numVertices * model.resolution + 2);
     outCells[0] = numVertices * model.resolution + 1;
     outCells[numVertices * model.resolution + 1] = 0;
@@ -114,17 +131,17 @@ function vtkSplineContextRepresentation(publicAPI, model) {
       outCells[numVertices * model.resolution + 1] = lastPointIndex;
     }
 
-    polydata.getPoints().setData(outPoints);
-
     if (model.fill) {
-      polydata.getPolys().setData(outCells);
+      model.internalPolyData.getPolys().setData(outCells);
     }
 
-    polydata.getLines().setData(model.outputBorder ? outCells : []);
-    outData[0] = polydata;
-    model.pipelines.area.triangleFilter.update();
+    model.internalPolyData.getLines().setData(model.outputBorder ? outCells : []);
+    model.internalPolyData.modified();
+    outData[0] = model.internalPolyData;
+
+    model._pipelines.area.filter.update();
 
-    (_model$pipelines$bord = model.pipelines.border.actor.getProperty()).setColor.apply(_model$pipelines$bord, _toConsumableArray(inPoints.length <= 3 || model.pipelines.area.triangleFilter.getErrorCount() === 0 ? model.borderColor : model.errorBorderColor));
+    (_model$_pipelines$bor = model._pipelines.border.actor.getProperty()).setColor.apply(_model$_pipelines$bor, _toConsumableArray(inPoints.length <= 3 || model._pipelines.area.filter.getErrorCount() === 0 ? model.borderColor : model.errorBorderColor));
   };
 
   publicAPI.getSelectedState = function (prop, compositeID) {
@@ -132,12 +149,12 @@ function vtkSplineContextRepresentation(publicAPI, model) {
   };
 
   function updateAreaVisibility() {
-    model.pipelines.area.actor.setVisibility(model.fill);
+    model._pipelines.area.actor.setVisibility(model.fill);
   }
 
   publicAPI.setFill = macro.chain(publicAPI.setFill, updateAreaVisibility);
   publicAPI.setOutputBorder = macro.chain(publicAPI.setOutputBorder, function (v) {
-    return model.pipelines.border.actor.setVisibility(v);
+    return model._pipelines.border.actor.setVisibility(v);
   });
 } // ----------------------------------------------------------------------------
 // Object factory

package/Widgets/Representations/WidgetRepresentation.d.ts

@@ -1,9 +1,19 @@
+import vtkDataArray from './../../Common/Core/DataArray';
+import vtkPolyData from './../../Common/DataModel/PolyData';
+import { vtkObject } from './../../interfaces';
 import vtkProp from './../../Rendering/Core/Prop';
+export interface IDisplayScaleParams {
+	dispHeightFactor: number,
+	cameraPosition: number[],
+	cameraDir: number[],
+	isParallel: boolean,
+	rendererPixelDims: number[],
+}
 
 export interface IWidgetRepresentationInitialValues {
     labels?: Array<any>,
     coincidentTopologyParameters?: object,
-    displayScaleParams?: object,
+    displayScaleParams?: IDisplayScaleParams,
     scaleInPixels?: boolean
 }
 
@@ -55,6 +65,47 @@ export function extend(publicAPI: object, model: object, initialValues?: IWidget
  */
 export function newInstance(initialValues?: IWidgetRepresentationInitialValues): vtkWidgetRepresentation;
 
+/**
+ * Static function to get the pixel size of a 3D point.
+ * @param {Number[]} worldCoord 3D point in world coordinates
+ * @param {IDisplayScaleParams} displayScaleParams Display and camera information
+ */
+export function getPixelWorldHeightAtCoord(worldCoord: number[], displayScaleParams: IDisplayScaleParams): number[];
+
+export interface IWidgetPipeline {
+	source?: object,
+	filter?: object,
+	glyph?: object,
+	mapper: object,
+	actor: object
+}
+/**
+ * If provided, connects `source` (dataset or filter) to `filter`.
+ * If provided, connects `filter` (otherwise `source`) to mapper
+ * If provided, connects glyph as 2nd input to mapper. This is typically for the glyph mapper.
+ * Connects mapper to actor.
+ * @param {IWidgetPipeline} pipeline of source, filter, mapper and actor to connect
+ */
+export function connectPipeline(pipeline: IWidgetPipeline): void;
+
+/**
+ * Allocate or resize a vtkPoint(name='point'), vtkCellArray (name=
+ * 'line'|'poly') or vtkDataArray (name=any) and add it to the vtkPolyData.
+ * If allocated, the array is automatically added to the polydata
+ * Connects mapper to actor.
+ * @param {vtkPolyData} polyData The polydata to add array to
+ * @param {string} name The name of the array to add (special handling for
+ * 'point', 'line, 'poly')
+ * @param {Number} numberOfTuples The number of tuples to (re)allocate.
+ * @param {String} dataType The typed array type name.
+ * @param {Number} numberOfComponents The number of components of the array.
+ */
+ export function allocateArray(polyData: vtkPolyData,
+    name: string,
+    numberOfTuples: number,
+    dataType?: string,
+    numberOfComponents?: number): vtkDataArray|null;
+
 export declare const vtkWidgetRepresentation: {
 	newInstance: typeof newInstance;
 	extend: typeof extend;

package/Widgets/Representations/WidgetRepresentation.js

@@ -1,11 +1,15 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkProp from '../../Rendering/Core/Prop.js';
-import { s as subtract, d as dot } from '../../Common/Core/Math/index.js';
+import { g as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import vtkPoints from '../../Common/Core/Points.js';
 import { Behavior } from './WidgetRepresentation/Constants.js';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 import { CATEGORIES } from '../../Rendering/Core/Mapper/CoincidentTopologyHelper.js';
+import { POLYDATA_FIELDS } from '../../Common/DataModel/PolyData/Constants.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; }
 
@@ -67,10 +71,24 @@ function applyStyles(pipelines, styles, activeActor) {
 } // ----------------------------------------------------------------------------
 
 function connectPipeline(pipeline) {
-  if (pipeline.source.isA('vtkDataSet')) {
-    pipeline.mapper.setInputData(pipeline.source);
-  } else {
-    pipeline.mapper.setInputConnection(pipeline.source.getOutputPort());
+  var source = pipeline.source;
+
+  if (pipeline.filter) {
+    if (source.isA('vtkDataSet')) {
+      pipeline.filter.setInputData(source);
+    } else {
+      pipeline.filter.setInputConnection(source.getOutputPort());
+    }
+
+    source = pipeline.filter;
+  }
+
+  if (source) {
+    if (source.isA('vtkDataSet')) {
+      pipeline.mapper.setInputData(source);
+    } else {
+      pipeline.mapper.setInputConnection(source.getOutputPort());
+    }
   }
 
   if (pipeline.glyph) {
@@ -78,16 +96,84 @@ function connectPipeline(pipeline) {
   }
 
   pipeline.actor.setMapper(pipeline.mapper);
+}
+function getPixelWorldHeightAtCoord(worldCoord, displayScaleParams) {
+  var dispHeightFactor = displayScaleParams.dispHeightFactor,
+      cameraPosition = displayScaleParams.cameraPosition,
+      cameraDir = displayScaleParams.cameraDir,
+      isParallel = displayScaleParams.isParallel,
+      rendererPixelDims = displayScaleParams.rendererPixelDims;
+  var scale = 1;
+
+  if (isParallel) {
+    scale = dispHeightFactor;
+  } else {
+    var worldCoordToCamera = _toConsumableArray(worldCoord);
+
+    vtkMath.subtract(worldCoordToCamera, cameraPosition, worldCoordToCamera);
+    scale = vtkMath.dot(worldCoordToCamera, cameraDir) * dispHeightFactor;
+  }
+
+  var rHeight = rendererPixelDims[1];
+  return scale / rHeight;
+} // Internal convenient function to create a data array:
+
+function allocateArray(polyData, name, numberOfTuples, dataType, numberOfComponents) {
+  var _polyData$;
+
+  // Check first whether name is points, verts, lines, polys, otherwise it is a point data array.
+  var dataArray = ((_polyData$ = polyData["get".concat(macro.capitalize(name))]) === null || _polyData$ === void 0 ? void 0 : _polyData$.call(polyData)) || polyData.getPointData().getArrayByName(name);
+
+  if (!dataArray || dataType !== undefined && dataArray.getDataType() !== dataType || numberOfComponents !== undefined && dataArray.getNumberOfComponents() !== numberOfComponents) {
+    var arrayType = vtkDataArray;
+    var arrayDataType = dataType;
+    var arrayNumberOfComponents = numberOfComponents;
+
+    if (name === 'points') {
+      var _arrayDataType;
+
+      arrayType = vtkPoints;
+      arrayDataType = (_arrayDataType = arrayDataType) !== null && _arrayDataType !== void 0 ? _arrayDataType : 'Float32Array';
+      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 3;
+    } else if (POLYDATA_FIELDS.includes(name)) {
+      var _arrayDataType2;
+
+      arrayType = vtkCellArray;
+      arrayDataType = (_arrayDataType2 = arrayDataType) !== null && _arrayDataType2 !== void 0 ? _arrayDataType2 : 'Uint16Array';
+      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 1;
+    } else {
+      var _arrayDataType3;
+
+      // data array
+      arrayDataType = (_arrayDataType3 = arrayDataType) !== null && _arrayDataType3 !== void 0 ? _arrayDataType3 : 'Float32Array';
+      arrayNumberOfComponents = numberOfComponents !== null && numberOfComponents !== void 0 ? numberOfComponents : 1;
+    }
+
+    dataArray = arrayType.newInstance({
+      name: name,
+      dataType: arrayDataType,
+      numberOfComponents: arrayNumberOfComponents,
+      size: arrayNumberOfComponents * numberOfTuples,
+      empty: numberOfTuples === 0
+    });
+
+    if (name === 'points' || POLYDATA_FIELDS.includes(name)) {
+      polyData["set".concat(macro.capitalize(name))](dataArray);
+    } else {
+      polyData.getPointData().addArray(dataArray);
+    }
+  } else if (dataArray.getNumberOfTuples() !== numberOfTuples) {
+    dataArray.resize(numberOfTuples);
+  }
+
+  return dataArray;
 } // ----------------------------------------------------------------------------
 // vtkWidgetRepresentation
 // ----------------------------------------------------------------------------
 
 function vtkWidgetRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWidgetRepresentation');
-
-  var superclass = _objectSpread({}, publicAPI); // Internal cache
-
+  model.classHierarchy.push('vtkWidgetRepresentation'); // Internal cache
 
   var cache = {
     mtimes: {},
@@ -217,35 +303,10 @@ function vtkWidgetRepresentation(publicAPI, model) {
   };
 
   publicAPI.setCoincidentTopologyParameters = function (parameters) {
-    var modified = superclass.setCoincidentTopologyParameters(parameters);
-
-    if (modified) {
-      publicAPI.getActors().forEach(function (actor) {
-        applyCoincidentTopologyParametersToMapper(actor.getMapper(), model.coincidentTopologyParameters);
-      });
-    }
-  };
-
-  publicAPI.getPixelWorldHeightAtCoord = function (worldCoord) {
-    var _model$displayScalePa = model.displayScaleParams,
-        dispHeightFactor = _model$displayScalePa.dispHeightFactor,
-        cameraPosition = _model$displayScalePa.cameraPosition,
-        cameraDir = _model$displayScalePa.cameraDir,
-        isParallel = _model$displayScalePa.isParallel,
-        rendererPixelDims = _model$displayScalePa.rendererPixelDims;
-    var scale = 1;
-
-    if (isParallel) {
-      scale = dispHeightFactor;
-    } else {
-      var worldCoordToCamera = _toConsumableArray(worldCoord);
-
-      subtract(worldCoordToCamera, cameraPosition, worldCoordToCamera);
-      scale = dot(worldCoordToCamera, cameraDir) * dispHeightFactor;
-    }
-
-    var rHeight = rendererPixelDims[1];
-    return scale / rHeight;
+    model.coincidentTopologyParameters = parameters;
+    publicAPI.getActors().forEach(function (actor) {
+      applyCoincidentTopologyParametersToMapper(actor.getMapper(), model.coincidentTopologyParameters);
+    });
   }; // Make sure setting the labels at build time works with string/array...
 
 
@@ -255,49 +316,49 @@ function vtkWidgetRepresentation(publicAPI, model) {
 // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  actors: [],
-  labels: [],
-  behavior: Behavior.CONTEXT,
-  coincidentTopologyParameters: {
-    Point: {
-      factor: -1.0,
-      offset: -1.0
+function defaultValues(initialValues) {
+  return _objectSpread({
+    activeScaleFactor: 1.2,
+    activeColor: 1,
+    useActiveColor: true,
+    actors: [],
+    labels: [],
+    behavior: Behavior.CONTEXT,
+    coincidentTopologyParameters: {
+      Point: {
+        factor: -1.0,
+        offset: -1.0
+      },
+      Line: {
+        factor: -1.0,
+        offset: -1.0
+      },
+      Polygon: {
+        factor: -1.0,
+        offset: -1.0
+      }
     },
-    Line: {
-      factor: -1.0,
-      offset: -1.0
+    scaleInPixels: false,
+    displayScaleParams: {
+      dispHeightFactor: 1,
+      cameraPosition: [0, 0, 0],
+      cameraDir: [1, 0, 0],
+      isParallel: false,
+      rendererPixelDims: [1, 1]
     },
-    Polygon: {
-      factor: -1.0,
-      offset: -1.0
-    }
-  },
-  scaleInPixels: false,
-  displayScaleParams: {
-    dispHeightFactor: 1,
-    cameraPosition: [0, 0, 0],
-    cameraDir: [1, 0, 0],
-    isParallel: false,
-    rendererPixelDims: [1, 1]
-  }
-}; // ----------------------------------------------------------------------------
+    _internalArrays: {}
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
-
-  vtkProp.extend(publicAPI, model, initialValues);
+  // Object methods
+  vtkProp.extend(publicAPI, model, defaultValues(initialValues));
   macro.algo(publicAPI, model, 1, 1);
-  macro.get(publicAPI, model, ['labels']);
-  macro.set(publicAPI, model, [{
-    type: 'object',
-    name: 'displayScaleParams'
-  }, {
-    type: 'object',
-    name: 'coincidentTopologyParameters'
-  }]);
-  macro.setGet(publicAPI, model, ['scaleInPixels']); // Object specific methods
+  macro.get(publicAPI, model, ['labels', 'coincidentTopologyParameters']);
+  macro.set(publicAPI, model, ['displayScaleParams']);
+  macro.setGet(publicAPI, model, ['scaleInPixels', 'activeScaleFactor', 'activeColor', 'useActiveColor']); // Object specific methods
 
   vtkWidgetRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------
@@ -306,7 +367,8 @@ var vtkWidgetRepresentation$1 = {
   extend: extend,
   mergeStyles: mergeStyles,
   applyStyles: applyStyles,
-  connectPipeline: connectPipeline
+  connectPipeline: connectPipeline,
+  getPixelWorldHeightAtCoord: getPixelWorldHeightAtCoord
 };
 
-export { applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, mergeStyles };
+export { allocateArray, applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, getPixelWorldHeightAtCoord, mergeStyles };