@thewtex/vtk.js-esm/Widgets/Representations/ConvexFaceContextRepresentation.js

Visualization Toolkit for the Web

import macro from '../../macro.js';
import vtkActor from '../../Rendering/Core/Actor.js';
import vtkContextRepresentation from './ContextRepresentation.js';
import vtkMapper from '../../Rendering/Core/Mapper.js';
import vtkPolyData from '../../Common/DataModel/PolyData.js';
import { Behavior } from './WidgetRepresentation/Constants.js';
import { RenderingTypes } from '../Core/WidgetManager/Constants.js';

// vtkPlaneHandleRepresentation methods
// ----------------------------------------------------------------------------

function vtkConvexFaceContextRepresentation(publicAPI, model) {
  // Set our className
  model.classHierarchy.push('vtkConvexFaceContextRepresentation'); // --------------------------------------------------------------------------
  // Internal polydata dataset
  // --------------------------------------------------------------------------

  model.internalPolyData = vtkPolyData.newInstance({
    mtime: 0
  });
  model.points = new Float32Array(3 * 4);
  model.cells = new Uint8Array([4, 0, 1, 2, 3]);
  model.internalPolyData.getPoints().setData(model.points, 3);
  model.internalPolyData.getPolys().setData(model.cells);

  function allocateSize(size) {
    if (model.cells.length - 1 !== size) {
      model.points = new Float32Array(size * 3);
      model.cells = new Uint8Array(size + 1);
      model.cells[0] = size;

      for (var i = 0; i < size; i++) {
        model.cells[i + 1] = i;
      }

      model.internalPolyData.getPoints().setData(model.points, 3);
      model.internalPolyData.getPolys().setData(model.cells);
    }

    return model.points;
  } // --------------------------------------------------------------------------
  // Generic rendering pipeline
  // --------------------------------------------------------------------------


  model.mapper = vtkMapper.newInstance({
    scalarVisibility: false
  });
  model.actor = vtkActor.newInstance();
  model.actor.getProperty().setOpacity(model.opacity);
  model.mapper.setInputConnection(publicAPI.getOutputPort());
  model.actor.setMapper(model.mapper);
  publicAPI.addActor(model.actor); // --------------------------------------------------------------------------

  publicAPI.requestData = function (inData, outData) {
    var list = publicAPI.getRepresentationStates(inData[0]);
    var points = allocateSize(list.length);

    for (var i = 0; i < list.length; i++) {
      var coords = list[i].getOrigin();
      points[i * 3] = coords[0];
      points[i * 3 + 1] = coords[1];
      points[i * 3 + 2] = coords[2];
    }

    model.internalPolyData.modified();
    outData[0] = model.internalPolyData;
  }; // --------------------------------------------------------------------------


  publicAPI.getSelectedState = function (prop, compositeID) {
    var state = model.inputData[0];
    var list = publicAPI.getRepresentationStates(state); // Update state orientation based on face

    if (state.updateFromOriginRightUp) {
      state.updateFromOriginRightUp(list[0].getOrigin(), list[list.length - 1].getOrigin(), list[1].getOrigin());
    }

    return state;
  }; // --------------------------------------------------------------------------


  var superUpdateActorVisibility = publicAPI.updateActorVisibility;

  publicAPI.updateActorVisibility = function () {
    var renderingType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
    var widgetVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
    var ctxVisible = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
    var handleVisible = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;

    switch (model.behavior) {
      case Behavior.HANDLE:
        if (renderingType === RenderingTypes.PICKING_BUFFER) {
          model.actor.getProperty().setOpacity(1);
        } else {
          model.actor.getProperty().setOpacity(model.opacity);
        }

        break;

      case Behavior.CONTEXT:
      default:
        model.actor.getProperty().setOpacity(model.opacity);
        break;
    }

    superUpdateActorVisibility(renderingType, widgetVisible, ctxVisible, handleVisible);
  };
} // ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------


var DEFAULT_VALUES = {
  defaultColor: [1, 0, 0.5],
  opacity: 0.2
}; // ----------------------------------------------------------------------------

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.setGetArray(publicAPI, model, ['defaultColor'], 3);
  macro.get(publicAPI, model, ['mapper', 'actor']);
  macro.setGet(publicAPI, model, ['opacity']); // Object specific methods

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

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

var vtkConvexFaceContextRepresentation$1 = {
  newInstance: newInstance,
  extend: extend
};

export default vtkConvexFaceContextRepresentation$1;
export { extend, newInstance };