@kitware/vtk.js 25.9.2 → 26.0.0-beta.1

package/Widgets/Representations/SphereContextRepresentation.js

@@ -1,133 +1,54 @@
-import vtkDataArray from '../../Common/Core/DataArray.js';
-import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
-import vtkActor from '../../Rendering/Core/Actor.js';
-import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
-import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
-import vtkContextRepresentation from './ContextRepresentation.js';
-import vtkWidgetRepresentation from './WidgetRepresentation.js';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
+import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
+import vtkGlyphRepresentation from './GlyphRepresentation.js';
+import { Behavior } from './WidgetRepresentation/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; }
+
+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; }
 
 function vtkSphereContextRepresentation(publicAPI, model) {
   model.classHierarchy.push('vtkSphereContextRepresentation');
-  model.internalPolyData = vtkPolyData.newInstance({
-    mtime: 0
-  });
-  model.internalArrays = {
-    points: model.internalPolyData.getPoints(),
-    scale: vtkDataArray.newInstance({
-      name: 'scale',
-      numberOfComponents: 3,
-      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);
-  model.pipelines = {
-    circle: {
-      source: publicAPI,
-      glyph: vtkSphereSource.newInstance({
-        phiResolution: model.glyphResolution,
-        thetaResolution: model.glyphResolution
-      }),
-      mapper: vtkGlyph3DMapper.newInstance({
-        scaleArray: 'scale',
-        scaleMode: vtkGlyph3DMapper.ScaleModes.SCALE_BY_MAGNITUDE,
-        colorByArrayName: 'color',
-        scalarMode: ScalarMode.USE_POINT_FIELD_DATA
-      }),
-      actor: vtkActor.newInstance({
-        pickable: false,
-        parentProp: publicAPI
-      })
-    }
-  };
-  model.pipelines.circle.actor.getProperty().setOpacity(0.2);
-  vtkWidgetRepresentation.connectPipeline(model.pipelines.circle);
-  publicAPI.addActor(model.pipelines.circle.actor);
-  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, function (r) {
-    return model.pipelines.circle.glyph.setResolution(r);
-  });
+  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setThetaResolution, model._pipeline.glyph.setPhiResolution);
 
   publicAPI.setDrawBorder = function (draw) {
-    model.pipelines.circle.glyph.setLines(draw);
+    model._pipeline.glyph.setLines(draw);
   };
 
   publicAPI.setDrawFace = function (draw) {
-    model.pipelines.circle.glyph.setFace(draw);
+    model._pipeline.glyph.setFace(draw);
   };
 
   publicAPI.setOpacity = function (opacity) {
-    model.pipelines.circle.actor.getProperty().setOpacity(opacity);
-  };
-
-  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));
-    });
+    model._pipeline.actor.getProperty().setOpacity(opacity);
   };
 
-  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));
-      scale.setData(new Float32Array(3 * totalCount));
-      color.setData(new Float32Array(totalCount));
-    }
+  model._pipeline.actor.getProperty().setOpacity(0.2);
+}
 
-    var typedArray = {
-      points: points.getData(),
-      scale: scale.getData(),
-      color: color.getData()
-    };
+function defaultValues(initialValues) {
+  var _initialValues$glyphR, _initialValues$glyphR2;
 
-    for (var i = 0; i < totalCount; i += 1) {
-      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);
-      typedArray.color[i] = model.useActiveColor && isActive ? model.activeColor : state.getColor();
+  return _objectSpread({
+    glyphResolution: 32,
+    drawBorder: false,
+    drawFace: true,
+    behavior: Behavior.CONTEXT,
+    _pipeline: {
+      glyph: vtkSphereSource.newInstance({
+        phiResolution: (_initialValues$glyphR = initialValues.glyphResolution) !== null && _initialValues$glyphR !== void 0 ? _initialValues$glyphR : 32,
+        thetaResolution: (_initialValues$glyphR2 = initialValues.glyphResolution) !== null && _initialValues$glyphR2 !== void 0 ? _initialValues$glyphR2 : 32
+      })
     }
+  }, initialValues);
+} // ----------------------------------------------------------------------------
 
-    model.internalPolyData.modified();
-    outData[0] = model.internalPolyData;
-  };
-}
-
-var DEFAULT_VALUES = {
-  glyphResolution: 32,
-  defaultScale: 1,
-  drawBorder: false,
-  drawFace: true
-}; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-  vtkContextRepresentation.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['glyphResolution', 'defaultScale']);
-  macro.get(publicAPI, model, ['glyph', 'mapper', 'actor']);
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
+  macro.setGet(publicAPI, model, ['glyphResolution']);
   vtkSphereContextRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

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;