@kitware/vtk.js/Rendering/Core/AnnotatedCubeActor.js

Visualization Toolkit for the Web

import _defineProperty from '@babel/runtime/helpers/defineProperty';
import macro from '../../macros.js';
import vtkActor from './Actor.js';
import vtkMapper from './Mapper.js';
import vtkTexture from './Texture.js';
import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
import ImageHelper from '../../Common/Core/ImageHelper.js';
import AnnotatedCubePresets from './AnnotatedCubeActor/Presets.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; }
var FACE_TO_INDEX = {
  xPlus: 0,
  xMinus: 1,
  yPlus: 2,
  yMinus: 3,
  zPlus: 4,
  zMinus: 5
}; // ----------------------------------------------------------------------------
// vtkAnnotatedCubeActor
// ----------------------------------------------------------------------------

function vtkAnnotatedCubeActor(publicAPI, model) {
  // Set our className
  model.classHierarchy.push('vtkAnnotatedCubeActor'); // Make sure face properties are not references to the default value

  model.xPlusFaceProperty = _objectSpread({}, model.xPlusFaceProperty);
  model.xMinusFaceProperty = _objectSpread({}, model.xMinusFaceProperty);
  model.yPlusFaceProperty = _objectSpread({}, model.yPlusFaceProperty);
  model.yMinusFaceProperty = _objectSpread({}, model.yMinusFaceProperty);
  model.zPlusFaceProperty = _objectSpread({}, model.zPlusFaceProperty);
  model.zMinusFaceProperty = _objectSpread({}, model.zMinusFaceProperty); // private variables

  var cubeSource = null;
  var canvas = document.createElement('canvas');
  var mapper = vtkMapper.newInstance();
  var texture = vtkTexture.newInstance();
  texture.setInterpolate(true); // private methods

  function updateFaceTexture(faceName) {
    var newProp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

    if (newProp) {
      Object.assign(model["".concat(faceName, "FaceProperty")], newProp);
    }

    var prop = _objectSpread(_objectSpread({}, model.defaultStyle), model["".concat(faceName, "FaceProperty")]); // set canvas resolution


    canvas.width = prop.resolution;
    canvas.height = prop.resolution;
    var ctxt = canvas.getContext('2d'); // set background color

    ctxt.fillStyle = prop.faceColor;
    ctxt.fillRect(0, 0, canvas.width, canvas.height); // draw edge

    if (prop.edgeThickness > 0) {
      ctxt.strokeStyle = prop.edgeColor;
      ctxt.lineWidth = prop.edgeThickness * canvas.width;
      ctxt.strokeRect(0, 0, canvas.width, canvas.height);
    } // set face rotation


    ctxt.save(); // vertical flip

    ctxt.translate(0, canvas.height);
    ctxt.scale(1, -1);
    ctxt.translate(canvas.width / 2, canvas.height / 2);
    ctxt.rotate(-Math.PI * (prop.faceRotation / 180.0)); // set foreground text

    var textSize = prop.fontSizeScale(prop.resolution);
    ctxt.fillStyle = prop.fontColor;
    ctxt.textAlign = 'center';
    ctxt.textBaseline = 'middle';
    ctxt.font = "".concat(prop.fontStyle, " ").concat(textSize, "px \"").concat(prop.fontFamily, "\"");
    ctxt.fillText(prop.text, 0, 0);
    ctxt.restore();
    var vtkImage = ImageHelper.canvasToImageData(canvas);
    texture.setInputData(vtkImage, FACE_TO_INDEX[faceName]);
    publicAPI.modified();
  }

  function updateAllFaceTextures() {
    cubeSource = vtkCubeSource.newInstance({
      generate3DTextureCoordinates: true
    });
    mapper.setInputConnection(cubeSource.getOutputPort());
    updateFaceTexture('xPlus');
    updateFaceTexture('xMinus');
    updateFaceTexture('yPlus');
    updateFaceTexture('yMinus');
    updateFaceTexture('zPlus');
    updateFaceTexture('zMinus');
  } // public methods


  publicAPI.setDefaultStyle = function (style) {
    model.defaultStyle = _objectSpread(_objectSpread({}, model.defaultStyle), style);
    updateAllFaceTextures();
  };

  publicAPI.setXPlusFaceProperty = function (prop) {
    return updateFaceTexture('xPlus', prop);
  };

  publicAPI.setXMinusFaceProperty = function (prop) {
    return updateFaceTexture('xMinus', prop);
  };

  publicAPI.setYPlusFaceProperty = function (prop) {
    return updateFaceTexture('yPlus', prop);
  };

  publicAPI.setYMinusFaceProperty = function (prop) {
    return updateFaceTexture('yMinus', prop);
  };

  publicAPI.setZPlusFaceProperty = function (prop) {
    return updateFaceTexture('zPlus', prop);
  };

  publicAPI.setZMinusFaceProperty = function (prop) {
    return updateFaceTexture('zMinus', prop);
  }; // constructor


  updateAllFaceTextures(); // set mapper

  mapper.setInputConnection(cubeSource.getOutputPort());
  publicAPI.setMapper(mapper); // set texture

  publicAPI.addTexture(texture);
} // ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------


var DEFAULT_VALUES = {
  defaultStyle: {
    text: '',
    faceColor: 'white',
    faceRotation: 0,
    fontFamily: 'Arial',
    fontColor: 'black',
    fontStyle: 'normal',
    fontSizeScale: function fontSizeScale(resolution) {
      return resolution / 1.8;
    },
    edgeThickness: 0.1,
    edgeColor: 'black',
    resolution: 200
  } // xPlusFaceProperty: null,
  // xMinusFaceProperty: null,
  // yPlusFaceProperty: null,
  // yMinusFaceProperty: null,
  // zPlusFaceProperty: null,
  // zMinusFaceProperty: null,

}; // ----------------------------------------------------------------------------

function extend(publicAPI, model) {
  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance

  vtkActor.extend(publicAPI, model, initialValues);
  macro.get(publicAPI, model, ['defaultStyle', 'xPlusFaceProperty', 'xMinusFaceProperty', 'yPlusFaceProperty', 'yMinusFaceProperty', 'zPlusFaceProperty', 'zMinusFaceProperty']); // Object methods

  vtkAnnotatedCubeActor(publicAPI, model);
} // ----------------------------------------------------------------------------

var newInstance = macro.newInstance(extend, 'vtkAnnotatedCubeActor'); // ----------------------------------------------------------------------------

var vtkAnnotatedCubeActor$1 = {
  newInstance: newInstance,
  extend: extend,
  Presets: AnnotatedCubePresets
};

export { DEFAULT_VALUES, vtkAnnotatedCubeActor$1 as default, extend, newInstance };