@kitware/vtk.js 19.8.0 → 20.0.3

package/BREAKING_CHANGES.md

@@ -1,3 +1,13 @@
+## From 19.x to 20
+
+In ShapeWidget: 
+- `setLabelTextCallback` is replaced by `text` substate.  
+- `setPixelScale` has been removed. It should be replaced by point handle `scale1` mixin and `scaleInPixels`.  
+- `useHandles` has been removed. It should be replaced by `setHandleVisibility`.
+- `resetAfterPointPlacement` is now false by default.
+
+RectangleWidget and EllipseWidget handles now scale up automatically.
+
 ## From 18.x to 19
 
 vtkWidgetRepresentation.updateActorVisibility(...) lost the widgetVisibility parameter.

package/Common/Core/Math/index.js

@@ -1922,6 +1922,7 @@ function uninitializeBounds(bounds) {
   bounds[3] = -1.0;
   bounds[4] = 1.0;
   bounds[5] = -1.0;
+  return bounds;
 }
 function areBoundsInitialized(bounds) {
   return !(bounds[1] - bounds[0] < 0.0);
@@ -1933,6 +1934,7 @@ function computeBoundsFromPoints(point1, point2, bounds) {
   bounds[3] = Math.max(point1[1], point2[1]);
   bounds[4] = Math.min(point1[2], point2[2]);
   bounds[5] = Math.max(point1[2], point2[2]);
+  return bounds;
 }
 function clampValue(value, minValue, maxValue) {
   if (value < minValue) {

package/Common/Core/Math.d.ts

@@ -657,10 +657,10 @@ export function rgb2lab(rgb: number[], lab: number[]): void;
 export function lab2rgb(lab: number[], rgb: number[]): void;
 
 /**
- *
- * @param {Number[]} bounds 
+ * Returns bounds.
+ * @param {Number[]} bounds Output array that hold bounds, optionally empty.
  */
-export function uninitializeBounds(bounds: number[]): void;
+export function uninitializeBounds(bounds: number[]): number[];
 
 /**
  *
@@ -669,12 +669,12 @@ export function uninitializeBounds(bounds: number[]): void;
 export function areBoundsInitialized(bounds: number[]): boolean;
 
 /**
- *
- * @param {Number[]} point1 
- * @param {Number[]} point2 
- * @param {Number[]} bounds 
+ * Returns bounds.
+ * @param {Number[]} point1
+ * @param {Number[]} point2
+ * @param {Number[]} bounds Output array that hold bounds, optionally empty.
  */
-export function computeBoundsFromPoints(point1: number[], point2: number[], bounds: number[]): void;
+export function computeBoundsFromPoints(point1: number[], point2: number[], bounds: number[]): number[];
 
 /**
  *

package/Common/DataModel/ImageData.js

@@ -326,8 +326,7 @@ function vtkImageData(publicAPI, model) {
     var out2 = [0, 0, 0];
     transformMat4(out1, in1, model.indexToWorld);
     transformMat4(out2, in2, model.indexToWorld);
-    computeBoundsFromPoints(out1, out2, bout);
-    return bout;
+    return computeBoundsFromPoints(out1, out2, bout);
   };
 
   publicAPI.worldToIndexBounds = function (bin) {
@@ -339,8 +338,7 @@ function vtkImageData(publicAPI, model) {
     var out2 = [0, 0, 0];
     transformMat4(out1, in1, model.worldToIndex);
     transformMat4(out2, in2, model.worldToIndex);
-    computeBoundsFromPoints(out1, out2, bout);
-    return bout;
+    return computeBoundsFromPoints(out1, out2, bout);
   }; // Make sure the transform is correct
 
 

package/Common/DataModel/Plane.d.ts

@@ -337,9 +337,9 @@ export declare const vtkPlane: {
 	extend: typeof extend,
 	evaluate: typeof evaluate,
 	distanceToPlane: typeof distanceToPlane,
-	projectPoint: typeof projectVector3,
+	projectPoint: typeof projectPoint,
 	projectVector: typeof projectVector,
-	generalizedProjectPoint: typeof generalizedProjectVector3,
+	generalizedProjectPoint: typeof generalizedProjectPoint,
 	intersectWithLine: typeof intersectWithLine,
 	intersectWithPlane: typeof intersectWithPlane,
 };

package/Filters/General/AppendPolyData.js

@@ -65,8 +65,8 @@ function vtkAppendPolyData(publicAPI, model) {
       var ds = inData[i];
 
       if (!ds) {
-        vtkErrorMacro('Invalid or missing input');
-        return;
+        // eslint-disable-next-line
+        continue;
       }
 
       var dsNumPts = ds.getPoints().getNumberOfPoints();

package/Interaction/Manipulators/MouseCameraTrackballZoomManipulator.js

@@ -102,7 +102,7 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model);
   vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
   vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['zoomScale', 'flipDirection']); // Object specific methods
+  macro.setGet(publicAPI, model, ['flipDirection']); // Object specific methods
 
   vtkMouseCameraTrackballZoomManipulator(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/Core/Picker.js

@@ -108,13 +108,13 @@ function vtkPicker(publicAPI, model) {
     var camera = renderer.getActiveCamera();
     cameraPos = camera.getPosition();
     cameraFP = camera.getFocalPoint();
-    displayCoords = renderer.worldToNormalizedDisplay(cameraFP[0], cameraFP[1], cameraFP[2]);
+    var dims = view.getViewportSize(renderer);
+    var aspect = dims[0] / dims[1];
+    displayCoords = renderer.worldToNormalizedDisplay(cameraFP[0], cameraFP[1], cameraFP[2], aspect);
     displayCoords = view.normalizedDisplayToDisplay(displayCoords[0], displayCoords[1], displayCoords[2]);
     selectionZ = displayCoords[2]; // Convert the selection point into world coordinates.
 
     var normalizedDisplay = view.displayToNormalizedDisplay(selectionX, selectionY, selectionZ);
-    var dims = view.getViewportSize(renderer);
-    var aspect = dims[0] / dims[1];
     worldCoords = renderer.normalizedDisplayToWorld(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2], aspect);
 
     for (var i = 0; i < 3; i++) {

package/Rendering/Core/RenderWindow.js

@@ -77,9 +77,21 @@ function vtkRenderWindow(publicAPI, model) {
 
   publicAPI.hasView = function (view) {
     return model.views.indexOf(view) !== -1;
+  }; // handle any pre render initializations
+
+
+  publicAPI.preRender = function () {
+    model.renderers.forEach(function (ren) {
+      // make sure we have a camera
+      if (!ren.isActiveCameraCreated()) {
+        ren.resetCamera();
+      }
+    });
   };
 
   publicAPI.render = function () {
+    publicAPI.preRender();
+
     if (model.interactor) {
       model.interactor.render();
     } else {

package/Rendering/OpenGL/HardwareSelector.js

@@ -361,7 +361,10 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
       return false;
     }
 
-    model.openGLRenderer = model.openGLRenderWindow.getViewNodeFor(model.renderer); // int rgba[4];
+    model.openGLRenderer = model.openGLRenderWindow.getViewNodeFor(model.renderer); // todo revisit making selection part of core
+    // then we can do this in core
+
+    model.openGLRenderWindow.getRenderable().preRender(); // int rgba[4];
     // rwin.getColorBufferSizes(rgba);
     // if (rgba[0] < 8 || rgba[1] < 8 || rgba[2] < 8) {
     //   vtkErrorMacro("Color buffer depth must be at least 8 bit. "

package/Rendering/OpenGL/Renderer.js

@@ -16,11 +16,6 @@ function vtkOpenGLRenderer(publicAPI, model) {
     if (prepass) {
       if (!model.renderable) {
         return;
-      } // make sure we have a camera
-
-
-      if (!model.renderable.isActiveCameraCreated()) {
-        model.renderable.resetCamera();
       }
 
       publicAPI.updateLights();

package/Rendering/OpenGL/Texture.js

@@ -1,5 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import Constants from './Texture/Constants.js';
+import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { newInstance as newInstance$1, obj, set, setGet, get, newTypedArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { P as isPowerOfTwo, K as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
@@ -14,83 +15,10 @@ var Wrap = Constants.Wrap,
 var VtkDataTypes = vtkDataArray.VtkDataTypes;
 var vtkDebugMacro = vtkDebugMacro$1,
     vtkErrorMacro = vtkErrorMacro$1,
-    vtkWarningMacro = vtkWarningMacro$1;
-var floatView = new Float32Array(1);
-var int32View = new Int32Array(floatView.buffer);
-/* eslint-disable no-bitwise */
-
-/* This method is faster than the OpenEXR implementation (very often
- * used, eg. in Ogre), with the additional benefit of rounding, inspired
- * by James Tursa?s half-precision code. */
-
-function toHalf(val) {
-  floatView[0] = val;
-  var x = int32View[0];
-  var bits = x >> 16 & 0x8000;
-  /* Get the sign */
-
-  var m = x >> 12 & 0x07ff;
-  /* Keep one extra bit for rounding */
-
-  var e = x >> 23 & 0xff;
-  /* Using int is faster here */
-
-  /* If zero, or denormal, or exponent underflows too much for a denormal
-   * half, return signed zero. */
-
-  if (e < 103) {
-    return bits;
-  }
-  /* If NaN, return NaN. If Inf or exponent overflow, return Inf. */
-
-
-  if (e > 142) {
-    bits |= 0x7c00;
-    /* If exponent was 0xff and one mantissa bit was set, it means NaN,
-     * not Inf, so make sure we set one mantissa bit too. */
-
-    bits |= (e === 255 ? 0 : 1) && x & 0x007fffff;
-    return bits;
-  }
-  /* If exponent underflows but not too much, return a denormal */
-
-
-  if (e < 113) {
-    m |= 0x0800;
-    /* Extra rounding may overflow and set mantissa to 0 and exponent
-     * to 1, which is OK. */
-
-    bits |= (m >> 114 - e) + (m >> 113 - e & 1);
-    return bits;
-  }
-
-  bits |= e - 112 << 10 | m >> 1;
-  /* Extra rounding. An overflow will set mantissa to 0 and increment
-   * the exponent, which is OK. */
-
-  bits += m & 1;
-  return bits;
-}
-
-function fromHalf(h) {
-  var s = (h & 0x8000) >> 15;
-  var e = (h & 0x7c00) >> 10;
-  var f = h & 0x03ff;
-
-  if (e === 0) {
-    return (s ? -1 : 1) * Math.pow(2, -14) * (f / Math.pow(2, 10));
-  }
-
-  if (e === 0x1f) {
-    return f ? NaN : (s ? -1 : 1) * Infinity;
-  }
-
-  return (s ? -1 : 1) * Math.pow(2, e - 15) * (1 + f / Math.pow(2, 10));
-} // ----------------------------------------------------------------------------
+    vtkWarningMacro = vtkWarningMacro$1; // ----------------------------------------------------------------------------
 // vtkOpenGLTexture methods
 // ----------------------------------------------------------------------------
 
-
 function vtkOpenGLTexture(publicAPI, model) {
   var _this = this;
 
@@ -638,7 +566,7 @@ function vtkOpenGLTexture(publicAPI, model) {
         var _newArray2 = new Uint16Array(pixCount);
 
         for (var _i2 = 0; _i2 < pixCount; _i2++) {
-          _newArray2[_i2] = toHalf(data[_idx2][_i2]);
+          _newArray2[_i2] = HalfFloat.toHalf(data[_idx2][_i2]);
         }
 
         pixData.push(_newArray2);
@@ -721,7 +649,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
               for (var c = 0; c < numComps; c++) {
                 if (usingHalf) {
-                  newArray[joff + ioff + c] = toHalf(fromHalf(data[idx][jlow + ilow + c]) * jmix1 * (1.0 - imix) + fromHalf(data[idx][jlow + ihi + c]) * jmix1 * imix + fromHalf(data[idx][jhi + ilow + c]) * jmix * (1.0 - imix) + fromHalf(data[idx][jhi + ihi + c]) * jmix * imix);
+                  newArray[joff + ioff + c] = HalfFloat.toHalf(HalfFloat.fromHalf(data[idx][jlow + ilow + c]) * jmix1 * (1.0 - imix) + HalfFloat.fromHalf(data[idx][jlow + ihi + c]) * jmix1 * imix + HalfFloat.fromHalf(data[idx][jhi + ilow + c]) * jmix * (1.0 - imix) + HalfFloat.fromHalf(data[idx][jhi + ihi + c]) * jmix * imix);
                 } else {
                   newArray[joff + ioff + c] = data[idx][jlow + ilow + c] * jmix1 * (1.0 - imix) + data[idx][jlow + ihi + c] * jmix1 * imix + data[idx][jhi + ilow + c] * jmix * (1.0 - imix) + data[idx][jhi + ihi + c] * jmix * imix;
                 }

package/Rendering/WebGPU/HardwareSelector.js

@@ -234,28 +234,32 @@ function vtkWebGPUHardwareSelector(publicAPI, model) {
               return _context.abrupt("return", false);
 
             case 3:
+              // todo revisit making selection part of core
+              // then we can do this in core
+              model.WebGPURenderWindow.getRenderable().preRender();
+
               if (model.WebGPURenderWindow.getInitialized()) {
-                _context.next = 7;
+                _context.next = 8;
                 break;
               }
 
               model.WebGPURenderWindow.initialize();
-              _context.next = 7;
+              _context.next = 8;
               return new Promise(function (resolve) {
                 return model.WebGPURenderWindow.onInitialized(resolve);
               });
 
-            case 7:
+            case 8:
               webGPURenderer = model.WebGPURenderWindow.getViewNodeFor(renderer);
 
               if (webGPURenderer) {
-                _context.next = 10;
+                _context.next = 11;
                 break;
               }
 
               return _context.abrupt("return", false);
 
-            case 10:
+            case 11:
               // Initialize renderer for selection.
               // change the renderer's background to black, which will indicate a miss
               originalSuppress = webGPURenderer.getSuppressClear();
@@ -342,25 +346,25 @@ function vtkWebGPUHardwareSelector(publicAPI, model) {
               cLoad = colorBuffer.mapAsync(GPUMapMode.READ);
 
               if (!model.captureZValues) {
-                _context.next = 36;
+                _context.next = 37;
                 break;
               }
 
               zLoad = zbuffer.mapAsync(GPUMapMode.READ);
-              _context.next = 32;
+              _context.next = 33;
               return Promise.all([cLoad, zLoad]);
 
-            case 32:
+            case 33:
               result.depthValues = new Float32Array(zbuffer.getMappedRange().slice());
               zbuffer.unmap();
-              _context.next = 38;
+              _context.next = 39;
               break;
 
-            case 36:
-              _context.next = 38;
+            case 37:
+              _context.next = 39;
               return cLoad;
 
-            case 38:
+            case 39:
               /* eslint-enable no-undef */
               result.colorValues = new Uint32Array(colorBuffer.getMappedRange().slice());
               colorBuffer.unmap();
@@ -371,7 +375,7 @@ function vtkWebGPUHardwareSelector(publicAPI, model) {
 
               return _context.abrupt("return", result);
 
-            case 42:
+            case 43:
             case "end":
               return _context.stop();
           }

package/Rendering/WebGPU/ImageMapper.js

@@ -12,7 +12,7 @@ import { i as identity, t as translate, j as transpose, g as invert, m as multip
 import { t as transformMat4, s as subtract } from '../../vendor/gl-matrix/esm/vec4.js';
 
 var SlicingMode = Constants.SlicingMode;
-var imgFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Image::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  //VTK::Image::Sample\n  computedColor.g = computedColor.r;\n  computedColor.b = computedColor.r;\n  computedColor.a = 1.0;\n\n  // var computedColor: vec4<f32> = vec4<f32>(1.0,0.7, 0.5, 1.0);\n\n//VTK::RenderEncoder::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var imgFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Image::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  //VTK::Image::Sample\n\n  // var computedColor: vec4<f32> = vec4<f32>(1.0,0.7, 0.5, 1.0);\n\n//VTK::RenderEncoder::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // helper methods
 // ----------------------------------------------------------------------------
 
@@ -223,10 +223,16 @@ function vtkWebGPUImageMapper(publicAPI, model) {
 
           {
             for (var _i = 0; _i < model.rowLength; _i++) {
-              colorArray[c * model.rowLength * 8 + _i * 4] = 255.0 * tmpTable[_i * 3];
-              colorArray[c * model.rowLength * 8 + _i * 4 + 1] = 255.0 * tmpTable[_i * 3 + 1];
-              colorArray[c * model.rowLength * 8 + _i * 4 + 2] = 255.0 * tmpTable[_i * 3 + 2];
-              colorArray[c * model.rowLength * 8 + _i * 4 + 3] = 255.0;
+              var _idx = c * model.rowLength * 8 + _i * 4;
+
+              colorArray[_idx] = 255.0 * tmpTable[_i * 3];
+              colorArray[_idx + 1] = 255.0 * tmpTable[_i * 3 + 1];
+              colorArray[_idx + 2] = 255.0 * tmpTable[_i * 3 + 2];
+              colorArray[_idx + 3] = 255.0;
+
+              for (var _j = 0; _j < 4; _j++) {
+                colorArray[_idx + model.rowLength * 4 + _j] = colorArray[_idx + _j];
+              }
             }
           }
         }
@@ -238,8 +244,8 @@ function vtkWebGPUImageMapper(publicAPI, model) {
           colorArray[_i2 * 4 + 2] = grey;
           colorArray[_i2 * 4 + 3] = 255.0;
 
-          for (var _j = 0; _j < 4; _j++) {
-            colorArray[_i2 * 4 + model.rowLength * 4 + _j] = colorArray[_i2 * 4 + _j];
+          for (var _j2 = 0; _j2 < 4; _j2++) {
+            colorArray[_i2 * 4 + model.rowLength * 4 + _j2] = colorArray[_i2 * 4 + _j2];
           }
         }
       }

package/Rendering/WebGPU/Renderer.js

@@ -22,11 +22,6 @@ function vtkWebGPURenderer(publicAPI, model) {
     if (prepass) {
       if (!model.renderable) {
         return;
-      } // make sure we have a camera
-
-
-      if (!model.renderable.isActiveCameraCreated()) {
-        model.renderable.resetCamera();
       }
 
       publicAPI.updateLights();

package/Rendering/WebGPU/Texture.js

@@ -89,7 +89,7 @@ function vtkWebGPUTexture(publicAPI, model) {
         var bufferWidthInBytes = 256 * Math.floor((currWidthInBytes + 255) / 256);
         var bufferWidth = bufferWidthInBytes / tDetails.elementSize;
         var inWidth = currWidthInBytes / inArray.BYTES_PER_ELEMENT;
-        var outArray = macro.newTypedArray(halfFloat ? 'Uint16Array' : 'Uint8Array', bufferWidth * model.height * model.depth);
+        var outArray = macro.newTypedArray(inArray.constructor.name, bufferWidth * model.height * model.depth);
 
         for (var v = 0; v < model.height * model.depth; v++) {
           if (halfFloat) {

package/Widgets/Representations/CircleContextRepresentation.js

@@ -2,9 +2,9 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkCircleSource from '../../Filters/Sources/CircleSource.js';
+import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
-import vtkHandleRepresentation from './HandleRepresentation.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkWidgetRepresentation from './WidgetRepresentation.js';
@@ -79,7 +79,7 @@ function vtkCircleContextRepresentation(publicAPI, model) {
   model.transform = vtkMatrixBuilder.buildFromDegree(); // --------------------------------------------------------------------------
 
   publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, function (r) {
-    return model.glyph.setResolution(r);
+    return model.pipelines.circle.glyph.setResolution(r);
   }); // --------------------------------------------------------------------------
 
   publicAPI.setDrawBorder = function (draw) {
@@ -168,8 +168,6 @@ function vtkCircleContextRepresentation(publicAPI, model) {
   // Initialization
   // --------------------------------------------------------------------------
 
-
-  publicAPI.setActiveScaleFactor(1);
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -185,7 +183,7 @@ var DEFAULT_VALUES = {
 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);
+  vtkContextRepresentation.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['glyphResolution', 'defaultScale']);
   macro.get(publicAPI, model, ['glyph', 'mapper', 'actor']); // Object specific methods
 

package/Widgets/Representations/ContextRepresentation.js

@@ -16,6 +16,9 @@ function vtkContextRepresentation(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
+  activeScaleFactor: 1.2,
+  activeColor: 1,
+  useActiveColor: true,
   behavior: Behavior.CONTEXT,
   pickable: false,
   dragable: true

package/Widgets/Representations/RectangleContextRepresentation.js

@@ -1,6 +1,6 @@
 import macro from '../../macros.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
-import vtkHandleRepresentation from './HandleRepresentation.js';
+import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { a as subtract, d as dot } from '../../vendor/gl-matrix/esm/vec3.js';
@@ -104,7 +104,7 @@ var DEFAULT_VALUES = {
 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);
+  vtkContextRepresentation.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['color'], 1);
   macro.get(publicAPI, model, ['mapper', 'actor']); // Object specific methods
 

package/Widgets/SVG/SVGLandmarkRepresentation/Constants.js

@@ -0,0 +1,28 @@
+var VerticalTextAlignment = {
+  TOP: 'TOP',
+  BOTTOM: 'BOTTOM',
+  MIDDLE: 'MIDDLE'
+};
+/**
+ * fontSize can be a number or a string representing a size in px
+ * @param {Number|String} fontSize
+ * @returns Number representing the fontSize in pixels
+ */
+
+function fontSizeToPixels(fontProperties) {
+  var defaultFontSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 16;
+
+  if (fontProperties != null && fontProperties.fontSize) {
+    if (typeof fontProperties.fontSize === 'string') {
+      if (fontProperties.fontSize.slice(-2) === 'px') {
+        return window.devicePixelRatio * parseInt(fontProperties.fontSize, 10);
+      }
+    } else {
+      return window.devicePixelRatio * fontProperties.fontSize;
+    }
+  }
+
+  return window.devicePixelRatio * defaultFontSize;
+}
+
+export { VerticalTextAlignment, VerticalTextAlignment as default, fontSizeToPixels };

package/Widgets/SVG/SVGLandmarkRepresentation.js

@@ -1,6 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkSVGRepresentation from './SVGRepresentation.js';
+import { fontSizeToPixels, VerticalTextAlignment } from './SVGLandmarkRepresentation/Constants.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -51,23 +52,36 @@ function vtkSVGLandmarkRepresentation(publicAPI, model) {
         }
 
         var splitText = texts[i].split('\n');
-        var newlineOffset = model.fontProperties != null && model.fontProperties.fontSize ? model.fontProperties.fontSize : 15;
+        var fontSize = fontSizeToPixels(model.fontProperties);
         splitText.forEach(function (subText, j) {
           var text = publicAPI.createListenableSvgElement('text', i);
           Object.keys(model.textProps || {}).forEach(function (prop) {
-            var propValue = model.textProps[prop];
-
-            if (model.offsetText === true && prop === 'dy') {
-              propValue = model.textProps.dy + newlineOffset * j;
-            }
-
-            text.setAttribute(prop, propValue);
+            text.setAttribute(prop, model.textProps[prop]);
           });
           text.setAttribute('x', x);
-          text.setAttribute('y', y);
+          text.setAttribute('y', y); // Vertical offset (dy) calculation based on VerticalTextAlignment
+
+          var dy = model.textProps.dy ? model.textProps.dy : 0;
+
+          switch (model.textProps.verticalAlign) {
+            case VerticalTextAlignment.MIDDLE:
+              dy -= fontSize * (0.5 * splitText.length - j - 1);
+              break;
+
+            case VerticalTextAlignment.TOP:
+              dy += fontSize * (j + 1);
+              break;
+
+            case VerticalTextAlignment.BOTTOM:
+            default:
+              dy -= fontSize * (splitText.length - j - 1);
+              break;
+          }
+
+          text.setAttribute('dy', dy);
 
           if (model.fontProperties != null) {
-            text.setAttribute('font-size', model.fontProperties.fontSize);
+            text.setAttribute('font-size', fontSize);
             text.setAttribute('font-family', model.fontProperties.fontFamily);
             text.setAttribute('font-weight', model.fontProperties.fontStyle);
             text.setAttribute('fill', model.fontProperties.fontColor);
@@ -91,27 +105,31 @@ function vtkSVGLandmarkRepresentation(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
+/**
+ * textProps can contain any "svg" attribute (e.g. text-anchor, text-align,
+ * alignment-baseline...)
+ * @param {*} initialValues
+ * @returns
+ */
+
 
 function defaultValues(initialValues) {
-  return _objectSpread({
-    circleProps: {
+  return _objectSpread(_objectSpread({}, initialValues), {}, {
+    circleProps: _objectSpread({
       r: 5,
       stroke: 'red',
       fill: 'red'
-    },
-    textProps: {
-      fill: 'white',
-      dx: 12,
-      dy: -12
-    }
-  }, initialValues);
+    }, initialValues.circleProps),
+    textProps: _objectSpread({
+      fill: 'white'
+    }, initialValues.textProps)
+  });
 } // ----------------------------------------------------------------------------
 
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues));
-  vtkSVGRepresentation.extend(publicAPI, model, initialValues);
+  vtkSVGRepresentation.extend(publicAPI, model, defaultValues(initialValues));
   macro.setGet(publicAPI, model, ['circleProps', 'fontProperties', 'name', 'textProps']); // Object specific methods
 
   vtkSVGLandmarkRepresentation(publicAPI, model);

package/Widgets/Widgets3D/EllipseWidget/behavior.js

@@ -6,7 +6,12 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 function widgetBehavior(publicAPI, model) {
-  // We inherit shapeBehavior
+  model.shapeHandle = model.widgetState.getEllipseHandle();
+  model.point1Handle = model.widgetState.getPoint1Handle();
+  model.point2Handle = model.widgetState.getPoint2Handle();
+  model.point1Handle.setManipulator(model.manipulator);
+  model.point2Handle.setManipulator(model.manipulator); // We inherit shapeBehavior
+
   widgetBehavior$1(publicAPI, model);
 
   var superClass = _objectSpread({}, publicAPI);