@kitware/vtk.js 34.7.0 → 34.8.1

package/Filters/Sources/EllipseArcSource.js

@@ -0,0 +1,159 @@
+import { m as macro } from '../../macros2.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import { f as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+const {
+  VtkDataTypes
+} = vtkDataArray;
+
+// ----------------------------------------------------------------------------
+// vtkEllipseArcSource methods
+// ----------------------------------------------------------------------------
+
+function vtkEllipseArcSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkEllipseArcSource');
+  publicAPI.requestData = (inData, outData) => {
+    const isClosedShape = Math.abs(model.segmentAngle - 360.0) < 1e-5;
+    const resolution = model.close && !isClosedShape ? model.resolution + 1 : model.resolution;
+    const numLines = resolution;
+    const numPts = resolution + 1;
+    const tc = [0.0, 0.0];
+    const output = outData[0] || vtkPolyData.newInstance();
+
+    // Make sure the normal vector is normalized
+    const normal = [...model.normal];
+    vtkMath.normalize(normal);
+
+    // Get orthogonal vector between user-defined major radius and normal
+    const orthogonalVect = [0, 0, 0];
+    vtkMath.cross(normal, model.majorRadiusVector, orthogonalVect);
+    if (vtkMath.norm(orthogonalVect) < 1e-10) {
+      vtkErrorMacro('Ellipse normal vector and major radius axis are collinear');
+      return;
+    }
+    vtkMath.normalize(orthogonalVect);
+    const majorRadiusVect = [0, 0, 0];
+    vtkMath.cross(orthogonalVect, normal, majorRadiusVect);
+    vtkMath.normalize(majorRadiusVect);
+    const a = vtkMath.norm(model.majorRadiusVector);
+    const b = a * model.ratio;
+    let startAngleRad = vtkMath.radiansFromDegrees(model.startAngle);
+    if (startAngleRad < 0) {
+      startAngleRad += 2.0 * Math.PI;
+    }
+    const segmentAngleRad = vtkMath.radiansFromDegrees(model.segmentAngle);
+    const angleIncRad = segmentAngleRad / model.resolution;
+    let pointType = VtkDataTypes.FLOAT;
+    if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
+      pointType = VtkDataTypes.FLOAT;
+    } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
+      pointType = VtkDataTypes.DOUBLE;
+    }
+    const points = vtkPoints.newInstance({
+      dataType: pointType
+    });
+    points.setNumberOfPoints(numPts);
+    const tcoords = vtkDataArray.newInstance({
+      numberOfComponents: 2,
+      size: numPts * 2,
+      dataType: VtkDataTypes.FLOAT,
+      name: 'TextureCoordinates'
+    });
+    const lines = vtkCellArray.newInstance();
+    lines.allocate(numLines);
+    const skipLastPoint = model.close && isClosedShape;
+    let theta = startAngleRad;
+    let pointIndex = 0;
+    for (let i = 0; i <= resolution; ++i, theta += angleIncRad) {
+      const quotient = Math.floor(theta / (2.0 * Math.PI));
+      const normalizedTheta = theta - quotient * 2.0 * Math.PI;
+      let thetaEllipse = Math.atan(Math.tan(normalizedTheta) * model.ratio);
+      if (normalizedTheta > Math.PI / 2 && normalizedTheta <= Math.PI) {
+        thetaEllipse += Math.PI;
+      } else if (normalizedTheta > Math.PI && normalizedTheta <= 1.5 * Math.PI) {
+        thetaEllipse -= Math.PI;
+      }
+      const cosTheta = Math.cos(thetaEllipse);
+      const sinTheta = Math.sin(thetaEllipse);
+      const p = [model.center[0] + a * cosTheta * majorRadiusVect[0] + b * sinTheta * orthogonalVect[0], model.center[1] + a * cosTheta * majorRadiusVect[1] + b * sinTheta * orthogonalVect[1], model.center[2] + a * cosTheta * majorRadiusVect[2] + b * sinTheta * orthogonalVect[2]];
+      tc[0] = i / resolution;
+      tc[1] = 0.0;
+      if (i !== resolution || !skipLastPoint) {
+        points.setPoint(pointIndex, ...p);
+        tcoords.setTuple(pointIndex, tc);
+        pointIndex++;
+      }
+    }
+    const actualNumPts = pointIndex;
+    const pointIds = [];
+    for (let k = 0; k < actualNumPts - 1; ++k) {
+      pointIds.push(k);
+    }
+    if (model.close) {
+      pointIds.push(0);
+    } else {
+      pointIds.push(actualNumPts - 1);
+    }
+    lines.insertNextCell(pointIds);
+    output.setPoints(points);
+    output.getPointData().setTCoords(tcoords);
+    output.setLines(lines);
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  center: [0.0, 0.0, 0.0],
+  normal: [0.0, 0.0, 1.0],
+  majorRadiusVector: [1.0, 0.0, 0.0],
+  startAngle: 0.0,
+  segmentAngle: 90.0,
+  resolution: 100,
+  close: false,
+  outputPointsPrecision: DesiredOutputPrecision.SINGLE,
+  ratio: 1.0
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Ensure resolution is at least 1
+  if (model.resolution < 1) {
+    model.resolution = 1;
+  }
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 0, 1);
+  macro.setGet(publicAPI, model, ['resolution', 'startAngle', 'segmentAngle', 'close', 'outputPointsPrecision', 'ratio']);
+  macro.setGetArray(publicAPI, model, ['center', 'normal', 'majorRadiusVector'], 3);
+  vtkEllipseArcSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkEllipseArcSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkEllipseArcSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkEllipseArcSource$1 as default, extend, newInstance };

package/Filters/Sources/PlatonicSolidSource/Constants.d.ts

@@ -0,0 +1,12 @@
+export declare enum SolidType {
+  VTK_SOLID_TETRAHEDRON = 0,
+  VTK_SOLID_CUBE = 1,
+  VTK_SOLID_OCTAHEDRON = 2,
+  VTK_SOLID_ICOSAHEDRON = 3,
+  VTK_SOLID_DODECAHEDRON = 4,
+}
+
+declare const _default: {
+  SolidType: typeof SolidType;
+};
+export default _default;

package/Filters/Sources/PlatonicSolidSource/Constants.js

@@ -0,0 +1,12 @@
+const SolidType = {
+  VTK_SOLID_TETRAHEDRON: 0,
+  VTK_SOLID_CUBE: 1,
+  VTK_SOLID_OCTAHEDRON: 2,
+  VTK_SOLID_ICOSAHEDRON: 3,
+  VTK_SOLID_DODECAHEDRON: 4
+};
+var Constants = {
+  SolidType
+};
+
+export { SolidType, Constants as default };

package/Filters/Sources/PlatonicSolidSource.d.ts

@@ -0,0 +1,109 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { DesiredOutputPrecision } from './../../Common/DataModel/DataSetAttributes';
+import { SolidType } from './PlatonicSolidSource/Constants';
+
+/**
+ *
+ */
+export interface IPlatonicSolidSourceInitialValues {
+  solidType?: SolidType;
+  outputPointsPrecision?: DesiredOutputPrecision;
+  scale?: number;
+}
+
+type vtkPlatonicSolidSourceBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkPlatonicSolidSource extends vtkPlatonicSolidSourceBase {
+  /**
+   * Get the desired output precision.
+   * @returns {DesiredOutputPrecision}
+   */
+  getOutputPointsPrecision(): DesiredOutputPrecision;
+
+  /**
+   * Get the scale factor of the source.
+   */
+  getScale(): number;
+
+  /**
+   * Get the solid type of the source.
+   * @returns {SolidType}
+   */
+  getSolidType(): SolidType;
+
+  /**
+   * Request data for the source.
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the desired output precision.
+   * @param {DesiredOutputPrecision} outputPointsPrecision
+   */
+  setOutputPointsPrecision(
+    outputPointsPrecision: DesiredOutputPrecision
+  ): boolean;
+
+  /**
+   * Set the scale factor of the source.
+   * @param {Number} scale The scale factor.
+   */
+  setScale(scale: number): boolean;
+
+  /**
+   * Set the solid type of the source.
+   * @param {SolidType} solidType
+   */
+  setSolidType(solidType: SolidType): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkPlatonicSolidSource characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPlatonicSolidSourceInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPlatonicSolidSourceInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkPlatonicSolidSource.
+ * @param {IPlatonicSolidSourceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IPlatonicSolidSourceInitialValues
+): vtkPlatonicSolidSource;
+
+/**
+ * vtkPlatonicSolidSource can generate each of the five Platonic solids:
+ * tetrahedron, cube, octahedron, icosahedron, and dodecahedron. Each of the
+ * solids is placed inside a sphere centered at the origin with radius 1.0.
+ *
+ * @example
+ * ```js
+ * import vtkPlatonicSolidSource from '@kitware/vtk.js/Filters/Sources/RegularPolygonSource';
+ *
+ * const regularPolygonSource = vtkPlatonicSolidSource.newInstance();
+ * const polydata = regularPolygonSource.getOutputData();
+ * ```
+ */
+export declare const vtkPlatonicSolidSource: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkPlatonicSolidSource;

package/Filters/Sources/PlatonicSolidSource.js

@@ -0,0 +1,149 @@
+import { m as macro } from '../../macros2.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import { SolidType } from './PlatonicSolidSource/Constants.js';
+import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+
+const a = 0.61803398875;
+const b = 0.38196601125;
+const c = 0.5;
+const d = 0.30901699;
+const e = Math.sqrt(2);
+const f = Math.sqrt(3.0);
+const geometries = {
+  tetrahedron: {
+    points: [1, 1, 1, -1, 1, -1, 1, -1, -1, -1, -1, 1],
+    cells: [0, 2, 1, 1, 2, 3, 0, 3, 2, 0, 1, 3],
+    numPoints: 4,
+    cellSize: 3,
+    numCells: 4,
+    scale: 1.0 / f
+  },
+  cube: {
+    points: [-1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1],
+    cells: [0, 1, 5, 4, 0, 4, 7, 3, 4, 5, 6, 7, 3, 7, 6, 2, 1, 2, 6, 5, 0, 3, 2, 1],
+    numPoints: 8,
+    cellSize: 4,
+    numCells: 6,
+    scale: 1.0 / f
+  },
+  octahedron: {
+    points: [-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0, 0, 0, -e, 0, 0, e],
+    cells: [4, 1, 0, 4, 2, 1, 4, 3, 2, 4, 0, 3, 0, 1, 5, 1, 2, 5, 2, 3, 5, 3, 0, 5],
+    numPoints: 6,
+    cellSize: 3,
+    numCells: 8,
+    scale: 1.0 / e
+  },
+  icosahedron: {
+    points: [0, d, -c, 0, d, c, 0, -d, c, -d, c, 0, -d, -c, 0, d, c, 0, d, -c, 0, 0, -d, -c, c, 0, d, -c, 0, d, -c, 0, -d, c, 0, -d],
+    cells: [0, 3, 5, 1, 5, 3, 1, 9, 2, 1, 2, 8, 0, 11, 7, 0, 7, 10, 2, 4, 6, 7, 6, 4, 3, 10, 9, 4, 9, 10, 5, 8, 11, 6, 11, 8, 1, 3, 9, 1, 8, 5, 0, 10, 3, 0, 5, 11, 7, 4, 10, 7, 11, 6, 2, 9, 4, 2, 6, 8],
+    numPoints: 12,
+    cellSize: 3,
+    numCells: 20,
+    scale: 1.0 / 0.58778524999243
+  },
+  dodecahedron: {
+    points: [b, 0, 1, -b, 0, 1, b, 0, -1, -b, 0, -1, 0, 1, -b, 0, 1, b, 0, -1, -b, 0, -1, b, 1, b, 0, 1, -b, 0, -1, b, 0, -1, -b, 0, -a, a, a, a, -a, a, -a, -a, -a, a, a, -a, a, a, a, -a, a, -a, -a, -a, a, a, -a, -a],
+    cells: [0, 16, 5, 12, 1, 1, 18, 7, 13, 0, 2, 19, 6, 14, 3, 3, 17, 4, 15, 2, 4, 5, 16, 8, 15, 5, 4, 17, 10, 12, 6, 7, 18, 11, 14, 7, 6, 19, 9, 13, 8, 16, 0, 13, 9, 9, 19, 2, 15, 8, 10, 17, 3, 14, 11, 11, 18, 1, 12, 10],
+    numPoints: 20,
+    cellSize: 5,
+    numCells: 12,
+    scale: 1.0 / 1.070466269319
+  }
+};
+
+// ----------------------------------------------------------------------------
+// vtkPlatonicSolidSource methods
+// ----------------------------------------------------------------------------
+
+function vtkPlatonicSolidSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPlatonicSolidSource');
+  publicAPI.requestData = (inData, outData) => {
+    const output = outData[0] || vtkPolyData.newInstance();
+    let solidData;
+    switch (model.solidType) {
+      case SolidType.VTK_SOLID_TETRAHEDRON:
+        solidData = geometries.tetrahedron;
+        break;
+      case SolidType.VTK_SOLID_CUBE:
+        solidData = geometries.cube;
+        break;
+      case SolidType.VTK_SOLID_OCTAHEDRON:
+        solidData = geometries.octahedron;
+        break;
+      case SolidType.VTK_SOLID_ICOSAHEDRON:
+        solidData = geometries.icosahedron;
+        break;
+      case SolidType.VTK_SOLID_DODECAHEDRON:
+        solidData = geometries.dodecahedron;
+        break;
+      default:
+        solidData = geometries.tetrahedron;
+        break;
+    }
+    let pointType;
+    if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
+      pointType = VtkDataTypes.FLOAT;
+    } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
+      pointType = VtkDataTypes.DOUBLE;
+    }
+    const points = vtkPoints.newInstance({
+      dataType: pointType,
+      numberOfPoints: solidData.numPoints
+    });
+    for (let i = 0; i < solidData.points.length; i += 3) {
+      points.insertNextPoint(solidData.scale * solidData.points[i] * model.scale, solidData.scale * solidData.points[i + 1] * model.scale, solidData.scale * solidData.points[i + 2] * model.scale);
+    }
+    const polys = vtkCellArray.newInstance();
+    for (let i = 0; i < solidData.cells.length; i += solidData.cellSize) {
+      const cell = solidData.cells.slice(i, i + solidData.cellSize);
+      polys.insertNextCell(cell);
+    }
+    output.setPoints(points);
+    output.setPolys(polys);
+    outData[0] = output;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  solidType: SolidType.VTK_SOLID_TETRAHEDRON,
+  outputPointsPrecision: DesiredOutputPrecision.DEFAULT,
+  scale: 1
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['solidType', 'outputPointsPrecision', 'scale']);
+  macro.algo(publicAPI, model, 0, 1);
+
+  // Object methods
+  vtkPlatonicSolidSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPlatonicSolidSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkPlatonicSolidSource$1 = {
+  newInstance,
+  extend,
+  SolidType
+};
+
+export { vtkPlatonicSolidSource$1 as default, extend, newInstance };

package/Filters/Sources.js

@@ -1,3 +1,4 @@
+import vtkArcSource from './Sources/ArcSource.js';
 import vtkArrowSource from './Sources/ArrowSource.js';
 import vtkCircleSource from './Sources/CircleSource.js';
 import vtkConcentricCylinderSource from './Sources/ConcentricCylinderSource.js';
@@ -6,15 +7,18 @@ import vtkCubeSource from './Sources/CubeSource.js';
 import vtkCursor3D from './Sources/Cursor3D.js';
 import vtkCylinderSource from './Sources/CylinderSource.js';
 import vtkDiskSource from './Sources/DiskSource.js';
+import vtkEllipseArcSource from './Sources/EllipseArcSource.js';
 import vtkImageGridSource from './Sources/ImageGridSource.js';
 import vtkLineSource from './Sources/LineSource.js';
 import vtkPlaneSource from './Sources/PlaneSource.js';
+import vtkPlatonicSolidSource from './Sources/PlatonicSolidSource.js';
 import vtkPointSource from './Sources/PointSource.js';
 import vtkRTAnalyticSource from './Sources/RTAnalyticSource.js';
 import vtkSLICSource from './Sources/SLICSource.js';
 import vtkSphereSource from './Sources/SphereSource.js';
 
 var Sources = {
+  vtkArcSource,
   vtkArrowSource,
   vtkCircleSource,
   vtkConcentricCylinderSource,
@@ -23,9 +27,11 @@ var Sources = {
   vtkCursor3D,
   vtkCylinderSource,
   vtkDiskSource,
+  vtkEllipseArcSource,
   vtkImageGridSource,
   vtkLineSource,
   vtkPlaneSource,
+  vtkPlatonicSolidSource,
   vtkPointSource,
   vtkRTAnalyticSource,
   vtkSLICSource,

package/IO/Misc/OBJWriter.js

@@ -164,7 +164,9 @@ function vtkOBJWriter(publicAPI, model) {
     const zipContent = {};
     zipContent[`${modelFilename}.obj`] = strToU8(model.output[0]);
     zipContent[`${materialFilename}.mtl`] = strToU8(model.mtl);
-    const canvas = new OffscreenCanvas(imageData.width, imageData.height);
+    const canvas = document.createElement('canvas');
+    canvas.width = imageData.width;
+    canvas.height = imageData.height;
     const ctx = canvas.getContext('2d');
     ctx.putImageData(imageData, 0, 0);
     return new Promise(resolve => {

package/Proxy/Representations/GlyphRepresentationProxy.js

@@ -7,6 +7,7 @@ import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkColorTransferFunction from '../../Rendering/Core/ColorTransferFunction.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
+import '../../Filters/Sources/ArcSource.js';
 import '../../Filters/Sources/ArrowSource.js';
 import '../../Filters/Sources/CircleSource.js';
 import '../../Filters/Sources/ConcentricCylinderSource.js';
@@ -15,9 +16,11 @@ import '../../Filters/Sources/CubeSource.js';
 import '../../Filters/Sources/Cursor3D.js';
 import '../../Filters/Sources/CylinderSource.js';
 import '../../Filters/Sources/DiskSource.js';
+import '../../Filters/Sources/EllipseArcSource.js';
 import '../../Filters/Sources/ImageGridSource.js';
 import '../../Filters/Sources/LineSource.js';
 import '../../Filters/Sources/PlaneSource.js';
+import '../../Filters/Sources/PlatonicSolidSource.js';
 import '../../Filters/Sources/PointSource.js';
 import '../../Filters/Sources/RTAnalyticSource.js';
 import '../../Filters/Sources/SLICSource.js';

package/Rendering/Core/VectorText/Utils.js

@@ -384,7 +384,7 @@ function addTriangle(layers, a, b, c, verticesArray, uvArray, colorArray, color)
     uvArray.push(uv[0], uv[1]);
   });
   if (colorArray && color) {
-    for (let i = 0; i < 3; ++i) colorArray.push(color[0], color[1], color[2]);
+    for (let i = 0; i < 3; ++i) colorArray.push(color[0] * 255, color[1] * 255, color[2] * 255);
   }
 }
 
@@ -417,7 +417,7 @@ function addQuad(layers, a, b, c, d, verticesArray, uvArray, colorArray, color)
   uvArray.push(uvs[2][0], uvs[2][1]);
   uvArray.push(uvs[3][0], uvs[3][1]);
   if (colorArray && color) {
-    for (let i = 0; i < 6; ++i) colorArray.push(color[0], color[1], color[2]);
+    for (let i = 0; i < 6; ++i) colorArray.push(color[0] * 255, color[1] * 255, color[2] * 255);
   }
 }
 

package/Rendering/Core/VectorText.js

@@ -258,7 +258,7 @@ function vtkVectorText(publicAPI, model) {
     let letterIndex = 0;
     model.shapes.forEach(shape => {
       let color = null;
-      if (typeof model.perLetterFaceColors === 'function') {
+      if (model.perLetterFaceColors) {
         color = model.perLetterFaceColors(letterIndex) || [1, 1, 1];
       }
       addShape(shape, offsetSize, color);
@@ -285,12 +285,12 @@ function vtkVectorText(publicAPI, model) {
     polyData.setPolys(cells);
 
     // Set points (vertices)
-    polyData.getPoints().setData(new Float32Array(model.verticesArray), 3);
+    polyData.getPoints().setData(Float32Array.from(model.verticesArray), 3);
 
     // Set texture coordinates
     const da = vtkDataArray.newInstance({
       numberOfComponents: 2,
-      values: new Float32Array(model.uvArray),
+      values: Float32Array.from(model.uvArray),
       name: 'TEXCOORD_0'
     });
     pointData.addArray(da);
@@ -300,7 +300,7 @@ function vtkVectorText(publicAPI, model) {
     if (model.colorArray && model.colorArray.length) {
       const ca = vtkDataArray.newInstance({
         numberOfComponents: 3,
-        values: new Float32Array(model.colorArray),
+        values: Uint8Array.from(model.colorArray),
         name: 'Colors'
       });
       pointData.addArray(ca);

package/Rendering/OpenGL/Glyph3DMapper.js

@@ -5,7 +5,9 @@ import vtkHardwareSelector from './HardwareSelector.js';
 import vtkProperty from '../Core/Property.js';
 import vtkOpenGLPolyDataMapper from './PolyDataMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
+import { computeCoordShiftAndScale } from './CellArrayBufferObject/helpers.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import { primTypes } from './Helper.js';
 
 const {
   vtkErrorMacro
@@ -25,6 +27,17 @@ const StartEvent = {
 const EndEvent = {
   type: 'EndEvent'
 };
+const MAT4_BYTE_SIZE = 64;
+const MAT4_ELEMENT_COUNT = 16;
+function applyShiftScaleToMat(mat, shift, scale) {
+  // the translation component of a 4x4 column-major matrix
+  mat[12] = (mat[12] - shift[0]) * scale[0];
+  mat[13] = (mat[13] - shift[1]) * scale[1];
+  mat[14] = (mat[14] - shift[2]) * scale[2];
+  mat[0] *= scale[0];
+  mat[5] *= scale[1];
+  mat[10] *= scale[2];
+}
 
 // ----------------------------------------------------------------------------
 // vtkOpenGLSphereMapper methods
@@ -389,9 +402,15 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
     return false;
   };
   publicAPI.buildBufferObjects = (ren, actor) => {
+    const garray = model.renderable.getMatrixArray();
+    const pts = model.renderable.getInputData(0).getPoints();
+    const {
+      useShiftAndScale,
+      coordShift,
+      coordScale
+    } = computeCoordShiftAndScale(pts);
     if (model.hardwareSupport) {
       // update the buffer objects if needed
-      const garray = model.renderable.getMatrixArray();
       const narray = model.renderable.getNormalArray();
       const carray = model.renderable.getColorArray();
       if (!model.matrixBuffer) {
@@ -404,6 +423,13 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
         model.pickBuffer = vtkBufferObject.newInstance();
         model.pickBuffer.setOpenGLRenderWindow(model._openGLRenderWindow);
       }
+      if (useShiftAndScale) {
+        const buf = garray.buffer;
+        for (let ptIdx = 0; ptIdx < garray.byteLength; ptIdx += MAT4_BYTE_SIZE) {
+          const mat = new Float32Array(buf, ptIdx, MAT4_ELEMENT_COUNT);
+          applyShiftScaleToMat(mat, coordShift, coordScale);
+        }
+      }
       if (model.renderable.getBuildTime().getMTime() > model.glyphBOBuildTime.getMTime()) {
         model.matrixBuffer.upload(garray, ObjectType.ARRAY_BUFFER);
         model.normalBuffer.upload(narray, ObjectType.ARRAY_BUFFER);
@@ -430,7 +456,15 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
         model.glyphBOBuildTime.modified();
       }
     }
-    return superClass.buildBufferObjects(ren, actor);
+    superClass.buildBufferObjects(ren, actor);
+
+    // apply shift + scale to primitives AFTER vtkOpenGLPolyDataMapper.buildBufferObjects
+    // so that the Glyph3DMapper gets the last say in the shift + scale
+    if (useShiftAndScale) {
+      for (let i = primTypes.Start; i < primTypes.End; i++) {
+        model.primitives[i].getCABO().setCoordShiftAndScale(coordShift, coordScale);
+      }
+    }
   };
 }
 

package/index.d.ts

@@ -67,9 +67,11 @@
 /// <reference path="./Filters/General/ImageStreamline.d.ts" />
 /// <reference path="./Filters/General/LineFilter.d.ts" />
 /// <reference path="./Filters/General/OutlineFilter.d.ts" />
+/// <reference path="./Filters/General/ShrinkPolyData.d.ts" />
 /// <reference path="./Filters/General/TransformPolyDataFilter.d.ts" />
 /// <reference path="./Filters/General/TriangleFilter.d.ts" />
 /// <reference path="./Filters/General/TubeFilter.d.ts" />
+/// <reference path="./Filters/Sources/ArcSource.d.ts" />
 /// <reference path="./Filters/Sources/Arrow2DSource.d.ts" />
 /// <reference path="./Filters/Sources/ArrowSource.d.ts" />
 /// <reference path="./Filters/Sources/CircleSource.d.ts" />
@@ -78,8 +80,11 @@
 /// <reference path="./Filters/Sources/Cursor3D.d.ts" />
 /// <reference path="./Filters/Sources/CylinderSource.d.ts" />
 /// <reference path="./Filters/Sources/DiskSource.d.ts" />
+/// <reference path="./Filters/Sources/EllipseArcSource.d.ts" />
 /// <reference path="./Filters/Sources/LineSource.d.ts" />
 /// <reference path="./Filters/Sources/PlaneSource.d.ts" />
+/// <reference path="./Filters/Sources/PlatonicSolidSource/Constants.d.ts" />
+/// <reference path="./Filters/Sources/PlatonicSolidSource.d.ts" />
 /// <reference path="./Filters/Sources/PointSource.d.ts" />
 /// <reference path="./Filters/Sources/SphereSource.d.ts" />
 /// <reference path="./Filters/Texture/TextureMapToPlane.d.ts" />