Prop

Introduction

vtkProp is an abstract superclass for any objects that can exist in a
rendered scene (either 2D or 3D). Instances of vtkProp may respond to
various render methods (e.g., RenderOpaqueGeometry()). vtkProp also
defines the API for picking, LOD manipulation, and common instance
variables that control visibility, picking, and dragging.

Methods

addEstimatedRenderTime

Argument	Type	Required	Description
estimatedRenderTime		Yes

addTexture

Argument	Type	Required	Description
texture		Yes

extend

Method use to decorate a given object (publicAPI+model) with vtkProp characteristics.

Argument	Type	Required	Description
publicAPI		Yes	object on which methods will be bounds (public)
model		Yes	object on which data structure will be bounds (protected)
initialValues	IPropInitialValues	No	(default: {})

getActors

Not implemented yet
For some exporters and other other operations we must be able
to collect all the actors or volumes.

getActors2D

Not implemented yet

getAllocatedRenderTime

getDragable

Get the value of the dragable instance variable.

getEstimatedRenderTime

The value is returned in seconds. For simple geometry the accuracy may not be great
due to buffering. For ray casting, which is already multi-resolution,
the current resolution of the image is factored into the time. We need the viewport
for viewing parameters that affect timing. The no-arguments version simply returns the value of the variable with no estimation.

getNestedProps

getPickable

Get the pickable instance variable.

getRedrawMTime

Return the mtime of anything that would cause the rendered image to appear differently.
Usually this involves checking the mtime of the prop plus anything else it depends on such as properties,
textures etc.

getRendertimemultiplier

getSupportsSelection

getTextures

getUseBounds

getVisibility

Get visibility of this vtkProp.

getVolumes

Not implemented yet

hasKey

Not Implemented yet

hasTexture

Argument	Type	Required	Description
texture		Yes

newInstance

Method use to create a new instance of vtkProp

Argument	Type	Required	Description
initialValues	IPropInitialValues	No	for pre-setting some of its content

pick

Not Implemented yet
Method fires PickEvent if the prop is picked.

removeAllTextures

removeTexture

Argument	Type	Required	Description
texture		Yes

restoreEstimatedRenderTime

This method is used to restore that old value should the render be aborted.

setAllocatedRenderTime

Argument	Type	Required	Description
allocatedRenderTime		Yes

setDragable

Argument	Type	Required	Description
dragable		Yes

setEstimatedRenderTime

Argument	Type	Required	Description
estimatedRenderTime		Yes

setPickable

Argument	Type	Required	Description
pickable		Yes

setRendertimemultiplier

This is used for culling and is a number between 0 and 1. It is used to create the allocated render time value.

Argument	Type	Required	Description
renderTimeMultiplier		Yes

setUseBounds

In case the Visibility flag is true, tell if the bounds of this prop should be taken into
account or ignored during the computation of other bounding boxes, like in vtkRenderer::ResetCamera().

Argument	Type	Required	Description
useBounds		Yes

setVisibility

Argument	Type	Required	Description
visibility		Yes

Source

index.d.ts

import { vtkAlgorithm, vtkObject } from "vtk.js/Sources/interfaces";
import vtkActor from "vtk.js/Sources/Rendering/Core/Actor";
import vtkActor2D from "vtk.js/Sources/Rendering/Core/Actor2D";
import vtkTexture from "vtk.js/Sources/Rendering/Core/Texture";
import vtkVolume from "vtk.js/Sources/Rendering/Core/Volume";


interface IPropInitialValues {

    /**
     * Set/Get visibility of this vtkProp. Initial value is true.
     */
    visibility?: boolean;

    /**
     * Set/Get the pickable instance variable. This determines if the vtkProp
     * can be picked (typically using the mouse). Also see dragable.
     * @default true.
     */
    pickable?: boolean;

    /**
     * This determines if an Prop, once picked, can be dragged (translated) through space.
     * This is typically done through an interactive mouse interface.
     * This does not affect methods such as SetPosition, which will continue
     * to work. It is just intended to prevent some vtkProp’ss from being
     * dragged from within a user interface.
     * @default true.
     */
    dragable?: boolean;

    /**
     * In case the Visibility flag is true, tell if the bounds of this prop
     * should be taken into account or ignored during the computation of other
     * bounding boxes, like in vtkRenderer::ResetCamera().
     */
    useBounds?: boolean;

    /**
     * 
     */
    allocatedRenderTime?: number;

    /**
     * 
     */
    estimatedRenderTime?: number;

    /**
     * 
     */
    savedEstimatedRenderTime?: number;

    /**
     * 
     */
    renderTimeMultiplier?: number;

    /**
     * 
     */
    textures?: Array<any>;
}

export interface vtkProp extends vtkObject {

    /**
     * 
     * @param estimatedRenderTime 
     */
    addEstimatedRenderTime(estimatedRenderTime: number): void;

    /**
     * Not implemented yet
     * For some exporters and other other operations we must be able
     * to collect all the actors or volumes.
     */
    getActors(): vtkActor[];

    /**
     * Not implemented yet
     */
    getActors2D(): vtkActor2D[];

    /**
     * Get the value of the dragable instance variable.
     */
    getDragable(): boolean;

    /**
     * Get visibility of this vtkProp.
     */
    getVisibility(): boolean;

    /**
     * Get the pickable instance variable.
     */
    getPickable(): boolean;

    /**
     * Return the mtime of anything that would cause the rendered image to appear differently. 
     * Usually this involves checking the mtime of the prop plus anything else it depends on such as properties, 
     * textures etc.
     */
    getRedrawMTime(): number

    /**
     * 
     */
    getRendertimemultiplier(): number;

    /**
     * The value is returned in seconds. For simple geometry the accuracy may not be great
     * due to buffering. For ray casting, which is already multi-resolution, 
     * the current resolution of the image is factored into the time. We need the viewport 
     * for viewing parameters that affect timing. The no-arguments version simply returns the value of the variable with no estimation.
     */
    getEstimatedRenderTime(): number;

    /**
     * 
     */
    getAllocatedRenderTime(): number;

    /**
     * 
     */
    getNestedProps(): null;

    /**
     * 
     * Not implemented yet
     */
    getVolumes(): vtkVolume[];

    /**
     * 
     */
    getUseBounds(): boolean;

    /**
     * 
     */
    getSupportsSelection(): boolean;

    /**
     * 
     */
    getTextures(): vtkTexture[];

    /**
     * 
     * @param texture 
     *
     */
    hasTexture(texture: vtkTexture): boolean;

    /**
     * 
     * @param texture 
     */
    addTexture(texture: vtkTexture): void;

    /**
     * 
     * @param texture 
     */
    removeTexture(texture: vtkTexture): void;

    /**
     * 
     */
    removeAllTextures(): void;

    /**
     * This method is used to restore that old value should the render be aborted.
     */
    restoreEstimatedRenderTime(): void;

    /**
     * 
     * @param allocatedRenderTime 
     */
    setAllocatedRenderTime(allocatedRenderTime: number): void;

    /**
     * 
     * @param dragable 
     * @default true
     */
    setDragable(dragable: boolean): boolean;

    /**
     * 
     * @param estimatedRenderTime 
     */
    setEstimatedRenderTime(estimatedRenderTime: number): void;

    /**
     * 
     * @param visibility 
     * @default true
     */
    setVisibility(visibility: boolean): boolean;

    /**
     * 
     * @param pickable 
     * @default true
     */
    setPickable(pickable: boolean): boolean;

    /**
     * In case the Visibility flag is true, tell if the bounds of this prop should be taken into 
     * account or ignored during the computation of other bounding boxes, like in vtkRenderer::ResetCamera().
     * @param useBounds
     * @default true
     */
    setUseBounds(useBounds: boolean): boolean;

    /**
     * This is used for culling and is a number between 0 and 1. It is used to create the allocated render time value.
     * @param renderTimeMultiplier 
     */
    setRendertimemultiplier(renderTimeMultiplier): boolean;

    /**
     * Not Implemented yet
     * Method fires PickEvent if the prop is picked.
     */
    pick(): any;

    /**
     * Not Implemented yet
     */
    hasKey(): any;
}


/**
 * Method use to decorate a given object (publicAPI+model) with vtkProp characteristics.
 *
 * @param publicAPI object on which methods will be bounds (public)
 * @param model object on which data structure will be bounds (protected)
 * @param {IPropInitialValues} [initialValues] (default: {})
 */
export function extend(publicAPI: object, model: object, initialValues?: IPropInitialValues): void;

/**
 * Method use to create a new instance of vtkProp
 * @param {IPropInitialValues} [initialValues] for pre-setting some of its content
 */
export function newInstance(initialValues?: IPropInitialValues): vtkProp;


/** 
 * vtkProp is an abstract superclass for any objects that can exist in a
 * rendered scene (either 2D or 3D). Instances of vtkProp may respond to
 * various render methods (e.g., RenderOpaqueGeometry()). vtkProp also
 * defines the API for picking, LOD manipulation, and common instance
 * variables that control visibility, picking, and dragging.
 */
export declare const vtkProp: {
    newInstance: typeof newInstance,
    extend: typeof extend,
};
export default vtkProp;

index.js

import macro from 'vtk.js/Sources/macro';

function notImplemented(method) {
  return () => macro.vtkErrorMacro(`vtkProp::${method} - NOT IMPLEMENTED`);
}

// ----------------------------------------------------------------------------
// vtkProp methods
// ----------------------------------------------------------------------------

function vtkProp(publicAPI, model) {
  // Set our className
  model.classHierarchy.push('vtkProp');

  publicAPI.getMTime = () => {
    let m1 = model.mtime;
    for (let index = 0; index < model.textures.length; ++index) {
      const m2 = model.textures[index].getMTime();
      if (m2 > m1) {
        m1 = m2;
      }
    }
    return m1;
  };

  publicAPI.getNestedProps = () => null;
  publicAPI.getActors = () => [];
  publicAPI.getActors2D = () => [];
  publicAPI.getVolumes = () => [];

  publicAPI.pick = notImplemented('pick');
  publicAPI.hasKey = notImplemented('hasKey');

  publicAPI.getRedrawMTime = () => model.mtime;

  publicAPI.setEstimatedRenderTime = (t) => {
    model.estimatedRenderTime = t;
    model.savedEstimatedRenderTime = t;
  };

  publicAPI.restoreEstimatedRenderTime = () => {
    model.estimatedRenderTime = model.savedEstimatedRenderTime;
  };

  publicAPI.addEstimatedRenderTime = (t) => {
    model.estimatedRenderTime += t;
  };

  publicAPI.setAllocatedRenderTime = (t) => {
    model.allocatedRenderTime = t;
    model.savedEstimatedRenderTime = model.estimatedRenderTime;
    model.estimatedRenderTime = 0;
  };

  publicAPI.getSupportsSelection = () => false;

  publicAPI.getTextures = () => model.textures;
  publicAPI.hasTexture = (texture) => model.textures.indexOf(texture) !== -1;
  publicAPI.addTexture = (texture) => {
    if (texture && !publicAPI.hasTexture(texture)) {
      model.textures = model.textures.concat(texture);
      publicAPI.modified();
    }
  };

  publicAPI.removeTexture = (texture) => {
    const newTextureList = model.textures.filter((item) => item !== texture);
    if (model.textures.length !== newTextureList.length) {
      model.textures = newTextureList;
      publicAPI.modified();
    }
  };

  publicAPI.removeAllTextures = () => {
    model.textures = [];
    publicAPI.modified();
  };
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
  visibility: true,
  pickable: true,
  dragable: true,
  useBounds: true,
  allocatedRenderTime: 10,
  estimatedRenderTime: 0,
  savedEstimatedRenderTime: 0,
  renderTimeMultiplier: 1,
  paths: null,
  textures: [],
};

// ----------------------------------------------------------------------------

export function extend(publicAPI, model, initialValues = {}) {
  Object.assign(model, DEFAULT_VALUES, initialValues);

  // Build VTK API
  macro.obj(publicAPI, model);
  macro.get(publicAPI, model, ['estimatedRenderTime', 'allocatedRenderTime']);
  macro.setGet(publicAPI, model, [
    'visibility',
    'pickable',
    'dragable',
    'useBounds',
    'renderTimeMultiplier',
  ]);

  // Object methods
  vtkProp(publicAPI, model);
}

// ----------------------------------------------------------------------------

export const newInstance = macro.newInstance(extend, 'vtkProp');

// ----------------------------------------------------------------------------

export default { newInstance, extend };