@kitware/vtk.js 25.0.0 → 25.1.0

package/Rendering/Core/ScalarBarActor.js

@@ -1,6 +1,5 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
 import { N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
@@ -29,15 +28,6 @@ var VectorMode = vtkScalarsToColors.VectorMode; // -----------------------------
 // multiple rendering backends.
 //
 // ----------------------------------------------------------------------------
-// some shared temp variables to reduce heap allocs
-
-var ptv3 = new Float64Array(3);
-var pt2v3 = new Float64Array(3);
-var tmpv3 = new Float64Array(3);
-var tmp2v3 = new Float64Array(3);
-var xDir = new Float64Array(3);
-var yDir = new Float64Array(3);
-var invmat = new Float64Array(16);
 
 function applyTextStyle(ctx, style) {
   ctx.strokeStyle = style.strokeColor;
@@ -94,35 +84,31 @@ function defaultAutoLayout(publicAPI, model) {
     var boxSize = helper.getBoxSizeByReference(); // if vertical
 
     if (helper.getLastAspectRatio() > 1.0) {
-      helper.setTickLabelPixelOffset(0.4 * tickTextStyle.fontSize);
-      var tickWidth = 2.0 * (textSizes.tickWidth + helper.getTickLabelPixelOffset()) / lastSize[0];
-      helper.setAxisTitlePixelOffset(0.8 * axisTextStyle.fontSize); // width required if the title is vertical
-
-      var titleWidth = 2.0 * (textSizes.titleHeight + helper.getAxisTitlePixelOffset()) / lastSize[0]; // if the title will fit within the width of the bar then that looks
+      helper.setTickLabelPixelOffset(0.3 * tickTextStyle.fontSize); // if the title will fit within the width of the bar then that looks
       // nicer to put it at the top (helper.topTitle), otherwise rotate it
       // and place it sideways
 
-      if (tickWidth + 0.4 * titleWidth > 2.0 * textSizes.titleWidth / lastSize[0]) {
+      if (textSizes.titleWidth <= textSizes.tickWidth + helper.getTickLabelPixelOffset() + 0.8 * tickTextStyle.fontSize) {
         helper.setTopTitle(true);
-        boxSize[0] = tickWidth + 0.4 * titleWidth;
+        helper.setAxisTitlePixelOffset(0.2 * tickTextStyle.fontSize);
+        boxSize[0] = 2.0 * (textSizes.tickWidth + helper.getTickLabelPixelOffset() + 0.8 * tickTextStyle.fontSize) / lastSize[0];
         helper.setBoxPosition([0.98 - boxSize[0], -0.92]);
       } else {
-        boxSize[0] = tickWidth + 1.4 * titleWidth;
+        helper.setAxisTitlePixelOffset(0.2 * tickTextStyle.fontSize);
+        boxSize[0] = 2.0 * (textSizes.titleHeight + helper.getAxisTitlePixelOffset() + textSizes.tickWidth + helper.getTickLabelPixelOffset() + 0.8 * tickTextStyle.fontSize) / lastSize[0];
         helper.setBoxPosition([0.99 - boxSize[0], -0.92]);
       }
 
       boxSize[1] = Math.max(1.2, Math.min(1.84 / yAxisAdjust, 1.84));
     } else {
       // horizontal
-      helper.setAxisTitlePixelOffset(2.0 * tickTextStyle.fontSize);
-      helper.setTickLabelPixelOffset(0.5 * tickTextStyle.fontSize);
-      var tickHeight = 2.0 * (textSizes.tickHeight + helper.getTickLabelPixelOffset()) / lastSize[1];
-      var titleHeight = 2.0 * (textSizes.titleHeight + helper.getAxisTitlePixelOffset()) / lastSize[1];
-
-      var _tickWidth = 2.0 * textSizes.tickWidth / lastSize[0];
-
-      boxSize[0] = Math.min(1.9, Math.max(1.4, 1.4 * _tickWidth * (helper.getTicks().length + 3)));
-      boxSize[1] = tickHeight + titleHeight;
+      helper.setAxisTitlePixelOffset(1.2 * tickTextStyle.fontSize);
+      helper.setTickLabelPixelOffset(0.1 * tickTextStyle.fontSize);
+      var titleHeight = // total offset from top of bar (includes ticks)
+      2.0 * (0.8 * tickTextStyle.fontSize + textSizes.titleHeight + helper.getAxisTitlePixelOffset()) / lastSize[1];
+      var tickWidth = 2.0 * textSizes.tickWidth / lastSize[0];
+      boxSize[0] = Math.min(1.9, Math.max(1.4, 1.4 * tickWidth * (helper.getTicks().length + 3)));
+      boxSize[1] = titleHeight;
       helper.setBoxPosition([-0.5 * boxSize[0], -0.97]);
     } // recomute bar segments based on positioning
 
@@ -169,8 +155,10 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     model.renderable = renderable;
     model.barActor.setProperty(renderable.getProperty());
     model.barActor.setParentProp(renderable);
+    model.barActor.setCoordinateSystemToDisplay();
     model.tmActor.setProperty(renderable.getProperty());
     model.tmActor.setParentProp(renderable);
+    model.tmActor.setCoordinateSystemToDisplay();
     model.generateTicks = renderable.generateTicks;
     model.axisTextStyle = _objectSpread({}, renderable.getAxisTextStyle());
     model.tickTextStyle = _objectSpread({}, renderable.getTickTextStyle());
@@ -223,19 +211,10 @@ function vtkScalarBarActorHelper(publicAPI, model) {
         publicAPI.recomputeBarSegments(textSizes);
       }
 
-      model.forceViewUpdate = true;
-      model.lastRebuildTime.modified();
-      model.forceUpdate = false;
-    } // compute bounds for label quads whenever the camera changes or forced
-    // the polydata mapper could be modified to accept NDC coords then this
-    // would be called far less often
-
-
-    if (model.forceViewUpdate || model.camera.getMTime() > model.lastRedrawTime.getMTime()) {
       publicAPI.updatePolyDataForLabels();
       publicAPI.updatePolyDataForBarSegments();
-      model.lastRedrawTime.modified();
-      model.forceViewUpdate = false;
+      model.lastRebuildTime.modified();
+      model.forceUpdate = false;
     }
   }; // create the texture map atlas that contains the rendering of
   // all the text strings. Only needs to be called when the text strings
@@ -349,15 +328,15 @@ function vtkScalarBarActorHelper(publicAPI, model) {
       model.barPosition[1] = model.boxPosition[1];
       segSize[1] = tickHeight;
     } else {
-      var _tickWidth2 = (2.0 * textSizes.tickWidth - 8) / model.lastSize[0];
+      var _tickWidth = (2.0 * textSizes.tickWidth - 8) / model.lastSize[0];
 
       var _titleHeight = 2.0 * (textSizes.titleHeight + model.axisTitlePixelOffset) / model.lastSize[1];
 
       model.barSize[0] = model.boxSize[0];
       model.barPosition[0] = model.boxPosition[0];
-      model.barSize[1] = model.boxSize[1] - _titleHeight - tickHeight;
+      model.barSize[1] = model.boxSize[1] - _titleHeight;
       model.barPosition[1] = model.boxPosition[1];
-      segSize[0] = _tickWidth2;
+      segSize[0] = _tickWidth;
     }
 
     return segSize;
@@ -414,62 +393,91 @@ function vtkScalarBarActorHelper(publicAPI, model) {
       pushSeg('Above', [1.1, 1.1, 1.1, 1.1]);
     }
   }; // called by updatePolyDataForLabels
-  // modifies class constants ptv3, tmpv3
+  // modifies class constants tmp2v3
 
 
-  publicAPI.createPolyDataForOneLabel = function (text, pos, xdir, ydir, dir, offset, results) {
+  var tmp2v3 = new Float64Array(3); // anchor point = pos
+  // H alignment = left, middle, right
+  // V alignment = bottom, middle, top
+  // Text Orientation = horizontal, vertical
+  // orientation
+
+  publicAPI.createPolyDataForOneLabel = function (text, pos, alignment, orientation, offset, results) {
     var value = model._tmAtlas.get(text);
 
     if (!value) {
       return;
     } // have to find the four corners of the texture polygon for this label
-    // convert anchor point to View Coords
 
 
     var ptIdx = results.ptIdx;
-    var cellIdx = results.cellIdx;
-    ptv3[0] = pos[0];
-    ptv3[1] = pos[1];
-    ptv3[2] = pos[2]; // horizontal left, right, or middle alignment based on dir[0]
-
-    if (dir[0] < -0.5) {
-      vec3.scale(tmpv3, xdir, dir[0] * offset - value.width);
-    } else if (dir[0] > 0.5) {
-      vec3.scale(tmpv3, xdir, dir[0] * offset);
+    var cellIdx = results.cellIdx; // get achor point in pixels
+
+    tmp2v3[0] = (0.5 * pos[0] + 0.5) * model.lastSize[0];
+    tmp2v3[1] = (0.5 * pos[1] + 0.5) * model.lastSize[1];
+    tmp2v3[2] = pos[2];
+    tmp2v3[0] += offset[0];
+    tmp2v3[1] += offset[1]; // get text size in display pixels
+
+    var textSize = [];
+    var textAxes = orientation === 'vertical' ? [1, 0] : [0, 1];
+
+    if (orientation === 'vertical') {
+      textSize[0] = value.width;
+      textSize[1] = -value.height; // update anchor point based on alignment
+
+      if (alignment[0] === 'middle') {
+        tmp2v3[1] -= value.width / 2.0;
+      } else if (alignment[0] === 'right') {
+        tmp2v3[1] -= value.width;
+      }
+
+      if (alignment[1] === 'middle') {
+        tmp2v3[0] += value.height / 2.0;
+      } else if (alignment[1] === 'top') {
+        tmp2v3[0] += value.height;
+      }
     } else {
-      vec3.scale(tmpv3, xdir, dir[0] * offset - value.width / 2.0);
+      textSize[0] = value.width;
+      textSize[1] = value.height; // update anchor point based on alignment
+
+      if (alignment[0] === 'middle') {
+        tmp2v3[0] -= value.width / 2.0;
+      } else if (alignment[0] === 'right') {
+        tmp2v3[0] -= value.width;
+      }
+
+      if (alignment[1] === 'middle') {
+        tmp2v3[1] -= value.height / 2.0;
+      } else if (alignment[1] === 'top') {
+        tmp2v3[1] -= value.height;
+      }
     }
 
-    vec3.add(ptv3, ptv3, tmpv3);
-    vec3.scale(tmpv3, ydir, dir[1] * offset - value.height / 2.0);
-    vec3.add(ptv3, ptv3, tmpv3);
-    results.points[ptIdx * 3] = ptv3[0];
-    results.points[ptIdx * 3 + 1] = ptv3[1];
-    results.points[ptIdx * 3 + 2] = ptv3[2];
+    results.points[ptIdx * 3] = tmp2v3[0];
+    results.points[ptIdx * 3 + 1] = tmp2v3[1];
+    results.points[ptIdx * 3 + 2] = tmp2v3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[0];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[1];
     ptIdx++;
-    vec3.scale(tmpv3, xdir, value.width);
-    vec3.add(ptv3, ptv3, tmpv3);
-    results.points[ptIdx * 3] = ptv3[0];
-    results.points[ptIdx * 3 + 1] = ptv3[1];
-    results.points[ptIdx * 3 + 2] = ptv3[2];
+    tmp2v3[textAxes[0]] += textSize[0];
+    results.points[ptIdx * 3] = tmp2v3[0];
+    results.points[ptIdx * 3 + 1] = tmp2v3[1];
+    results.points[ptIdx * 3 + 2] = tmp2v3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[2];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[3];
     ptIdx++;
-    vec3.scale(tmpv3, ydir, value.height);
-    vec3.add(ptv3, ptv3, tmpv3);
-    results.points[ptIdx * 3] = ptv3[0];
-    results.points[ptIdx * 3 + 1] = ptv3[1];
-    results.points[ptIdx * 3 + 2] = ptv3[2];
+    tmp2v3[textAxes[1]] += textSize[1];
+    results.points[ptIdx * 3] = tmp2v3[0];
+    results.points[ptIdx * 3 + 1] = tmp2v3[1];
+    results.points[ptIdx * 3 + 2] = tmp2v3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[4];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[5];
     ptIdx++;
-    vec3.scale(tmpv3, xdir, value.width);
-    vec3.subtract(ptv3, ptv3, tmpv3);
-    results.points[ptIdx * 3] = ptv3[0];
-    results.points[ptIdx * 3 + 1] = ptv3[1];
-    results.points[ptIdx * 3 + 2] = ptv3[2];
+    tmp2v3[textAxes[0]] -= textSize[0];
+    results.points[ptIdx * 3] = tmp2v3[0];
+    results.points[ptIdx * 3 + 1] = tmp2v3[1];
+    results.points[ptIdx * 3 + 2] = tmp2v3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[6];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[7];
     ptIdx++; // add the two triangles to represent the quad
@@ -490,34 +498,10 @@ function vtkScalarBarActorHelper(publicAPI, model) {
   // etc. This changes every time the camera viewpoint changes
 
 
-  publicAPI.updatePolyDataForLabels = function () {
-    var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    mat4.transpose(cmat, cmat);
-    mat4.invert(invmat, cmat);
-    var size = model.lastSize; // compute pixel to distance factors
-
-    tmpv3[0] = 0.0;
-    tmpv3[1] = 0.0;
-    tmpv3[2] = -0.99; // near plane
-
-    vec3.transformMat4(ptv3, tmpv3, invmat); // moving 0.1 in NDC
-
-    tmpv3[0] += 0.1;
-    vec3.transformMat4(pt2v3, tmpv3, invmat); // results in WC move of
-
-    vec3.subtract(xDir, pt2v3, ptv3);
-    tmpv3[0] -= 0.1;
-    tmpv3[1] += 0.1;
-    vec3.transformMat4(pt2v3, tmpv3, invmat); // results in WC move of
-
-    vec3.subtract(yDir, pt2v3, ptv3);
-
-    for (var i = 0; i < 3; i++) {
-      xDir[i] /= 0.5 * 0.1 * size[0];
-      yDir[i] /= 0.5 * 0.1 * size[1];
-    } // update the polydata
-
+  var tmpv3 = new Float64Array(3);
 
+  publicAPI.updatePolyDataForLabels = function () {
+    // update the polydata
     var numLabels = publicAPI.getTickStrings().length + model.barSegments.length;
     var numPts = numLabels * 4;
     var numTris = numLabels * 2;
@@ -530,55 +514,54 @@ function vtkScalarBarActorHelper(publicAPI, model) {
       polys: polys,
       points: points,
       tcoords: tcoords
-    }; // compute the direction vector, to make the code general we place text
+    }; // compute the direction vector
 
     var offsetAxis = model.vertical ? 0 : 1;
-    var spacedAxis = model.vertical ? 1 : 0; // draw the title
+    var spacedAxis = model.vertical ? 1 : 0;
+    tmpv3[2] = -0.99; // near plane
+    // draw the title
 
+    var alignment = model.vertical ? ['right', 'middle'] : ['middle', 'bottom'];
     var dir = [0, 1];
+    var tickOffsets = [0, 0];
 
     if (model.vertical) {
+      tickOffsets[0] = -model.tickLabelPixelOffset;
+
       if (model.topTitle) {
         tmpv3[0] = model.boxPosition[0] + 0.5 * model.boxSize[0];
-        tmpv3[1] = model.barPosition[1] + model.barSize[1];
-        vec3.transformMat4(ptv3, tmpv3, invmat); // write the axis label
+        tmpv3[1] = model.barPosition[1] + model.barSize[1]; // write the axis label
 
-        publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), ptv3, xDir, yDir, [0, 1], model.axisTitlePixelOffset, results);
+        publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), tmpv3, ['middle', 'bottom'], 'horizontal', [0, model.axisTitlePixelOffset], results);
       } else {
         tmpv3[0] = model.barPosition[0] + model.barSize[0];
-        tmpv3[1] = model.barPosition[1] + 0.5 * model.barSize[1];
-        vec3.transformMat4(ptv3, tmpv3, invmat); // write the axis label
+        tmpv3[1] = model.barPosition[1] + 0.5 * model.barSize[1]; // write the axis label
 
-        vec3.scale(xDir, xDir, -1);
-        publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), ptv3, yDir, xDir, [0, -1], model.axisTitlePixelOffset, results);
-        vec3.scale(xDir, xDir, -1);
+        publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), tmpv3, ['middle', 'top'], 'vertical', [model.axisTitlePixelOffset, 0], results);
       }
 
       dir = [-1, 0];
     } else {
+      tickOffsets[1] = model.tickLabelPixelOffset;
       tmpv3[0] = model.barPosition[0] + 0.5 * model.barSize[0];
       tmpv3[1] = model.barPosition[1] + model.barSize[1];
-      vec3.transformMat4(ptv3, tmpv3, invmat);
-      publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), ptv3, xDir, yDir, dir, model.axisTitlePixelOffset, results);
+      publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), tmpv3, ['middle', 'bottom'], 'horizontal', [0, model.axisTitlePixelOffset], results);
     }
 
-    tmp2v3[2] = -0.99; // near plane
-
-    tmp2v3[offsetAxis] = model.barPosition[offsetAxis] + (0.5 * dir[offsetAxis] + 0.5) * model.barSize[offsetAxis];
-    tmp2v3[spacedAxis] = model.barPosition[spacedAxis] + model.barSize[spacedAxis] * 0.5; // draw bar segment labels
+    tmpv3[offsetAxis] = model.barPosition[offsetAxis] + (0.5 * dir[offsetAxis] + 0.5) * model.barSize[offsetAxis];
+    tmpv3[spacedAxis] = model.barPosition[spacedAxis] + model.barSize[spacedAxis] * 0.5; // draw bar segment labels
 
     var tickSeg = null;
 
-    for (var _i = 0; _i < model.barSegments.length; _i++) {
-      var seg = model.barSegments[_i];
+    for (var i = 0; i < model.barSegments.length; i++) {
+      var seg = model.barSegments[i];
 
       if (seg.title === 'ticks') {
         // handle ticks below
         tickSeg = seg;
       } else {
-        tmp2v3[spacedAxis] = model.barPosition[spacedAxis] + 0.5 * model.barSize[spacedAxis] * (seg.corners[2][spacedAxis] + seg.corners[0][spacedAxis]);
-        vec3.transformMat4(ptv3, tmp2v3, invmat);
-        publicAPI.createPolyDataForOneLabel(seg.title, ptv3, xDir, yDir, dir, model.tickLabelPixelOffset, results);
+        tmpv3[spacedAxis] = model.barPosition[spacedAxis] + 0.5 * model.barSize[spacedAxis] * (seg.corners[2][spacedAxis] + seg.corners[0][spacedAxis]);
+        publicAPI.createPolyDataForOneLabel(seg.title, tmpv3, alignment, 'horizontal', tickOffsets, results);
       }
     } // write the tick labels
 
@@ -590,9 +573,8 @@ function vtkScalarBarActorHelper(publicAPI, model) {
 
     for (var t = 0; t < ticks.length; t++) {
       var tickPos = (ticks[t] - model.lastTickBounds[0]) / (model.lastTickBounds[1] - model.lastTickBounds[0]);
-      tmp2v3[spacedAxis] = tickSegmentStart + tickSegmentSize * tickPos;
-      vec3.transformMat4(ptv3, tmp2v3, invmat);
-      publicAPI.createPolyDataForOneLabel(tickStrings[t], ptv3, xDir, yDir, dir, model.tickLabelPixelOffset, results);
+      tmpv3[spacedAxis] = tickSegmentStart + tickSegmentSize * tickPos;
+      publicAPI.createPolyDataForOneLabel(tickStrings[t], tmpv3, alignment, 'horizontal', tickOffsets, results);
     }
 
     var tcoordDA = vtkDataArray.newInstance({
@@ -611,9 +593,6 @@ function vtkScalarBarActorHelper(publicAPI, model) {
   publicAPI.updatePolyDataForBarSegments = function () {
     var _scalarsToColors$getU, _scalarsToColors$getU2;
 
-    var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    mat4.transpose(cmat, cmat);
-    mat4.invert(invmat, cmat);
     var scalarsToColors = model.renderable.getScalarsToColors();
     var numberOfExtraColors = 0;
 
@@ -647,16 +626,13 @@ function vtkScalarBarActorHelper(publicAPI, model) {
 
     for (var i = 0; i < model.barSegments.length; i++) {
       var seg = model.barSegments[i];
-      tmp2v3[1] = model.barPosition[1] + model.barSize[1] * 0.5;
-      tmp2v3[2] = -0.99; // near plane
 
       for (var e = 0; e < 4; e++) {
-        tmp2v3[0] = model.barPosition[0] + seg.corners[e][0] * model.barSize[0];
-        tmp2v3[1] = model.barPosition[1] + seg.corners[e][1] * model.barSize[1];
-        vec3.transformMat4(ptv3, tmp2v3, invmat);
-        points[ptIdx * 3] = ptv3[0];
-        points[ptIdx * 3 + 1] = ptv3[1];
-        points[ptIdx * 3 + 2] = ptv3[2];
+        tmpv3[0] = model.barPosition[0] + seg.corners[e][0] * model.barSize[0];
+        tmpv3[1] = model.barPosition[1] + seg.corners[e][1] * model.barSize[1];
+        points[ptIdx * 3] = (0.5 * tmpv3[0] + 0.5) * model.lastSize[0];
+        points[ptIdx * 3 + 1] = (0.5 * tmpv3[1] + 0.5) * model.lastSize[1];
+        points[ptIdx * 3 + 2] = tmpv3[2];
 
         for (var nc = 0; nc < numComps; nc++) {
           scalars[ptIdx * numComps + nc] = model.lastTickBounds[0] + seg.scalars[e] * (model.lastTickBounds[1] - model.lastTickBounds[0]);
@@ -699,10 +675,6 @@ var newScalarBarActorHelper = macro.newInstance(function (publicAPI, model) {
   macro.getArray(publicAPI, model, ['boxPosition', 'boxSize']);
   macro.setArray(publicAPI, model, ['boxPosition', 'boxSize'], 2);
   model.forceUpdate = false;
-  model.lastRedrawTime = {};
-  macro.obj(model.lastRedrawTime, {
-    mtime: 0
-  });
   model.lastRebuildTime = {};
   macro.obj(model.lastRebuildTime, {
     mtime: 0

package/Rendering/OpenGL/PolyDataMapper.js

@@ -5,6 +5,7 @@ import vtkHelper from './Helper.js';
 import vtkMapper from '../Core/Mapper.js';
 import { l as normalize, u as uninitializeBounds } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
+import vtkProp from '../Core/Prop.js';
 import vtkProperty from '../Core/Property.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
@@ -30,7 +31,8 @@ var StartEvent = {
 };
 var EndEvent = {
   type: 'EndEvent'
-}; // ----------------------------------------------------------------------------
+};
+var CoordinateSystem = vtkProp.CoordinateSystem; // ----------------------------------------------------------------------------
 // vtkOpenGLPolyDataMapper methods
 // ----------------------------------------------------------------------------
 
@@ -904,7 +906,19 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       mcwc: null,
       normalMatrix: null
     } : model.openGLActor.getKeyMatrices();
-    program.setUniformMatrix('MCPCMatrix', safeMatrixMultiply([keyMats.wcpc, actMats.mcwc, inverseShiftScaleMatrix], mat4, model.tmpMat4));
+
+    if (actor.getCoordinateSystem() === CoordinateSystem.DISPLAY) {
+      var size = model.openGLRenderer.getTiledSizeAndOrigin();
+      mat4.identity(model.tmpMat4);
+      model.tmpMat4[0] = 2.0 / size.usize;
+      model.tmpMat4[12] = -1.0;
+      model.tmpMat4[5] = 2.0 / size.vsize;
+      model.tmpMat4[13] = -1.0;
+      mat4.multiply(model.tmpMat4, model.tmpMat4, inverseShiftScaleMatrix);
+      program.setUniformMatrix('MCPCMatrix', model.tmpMat4);
+    } else {
+      program.setUniformMatrix('MCPCMatrix', safeMatrixMultiply([keyMats.wcpc, actMats.mcwc, inverseShiftScaleMatrix], mat4, model.tmpMat4));
+    }
 
     if (program.isUniformUsed('MCVCMatrix')) {
       program.setUniformMatrix('MCVCMatrix', safeMatrixMultiply([keyMats.wcvc, actMats.mcwc, inverseShiftScaleMatrix], mat4, model.tmpMat4));