InteractorObserver

Methods

computeDisplayToWorld

Transform from display to world coordinates.

Argument Type Required Description
renderer vtkRenderer Yes The vtkRenderer instance.
x Number Yes
y Number Yes
z Number Yes

computeWorldToDisplay

Transform from world to display coordinates.

Argument Type Required Description
renderer vtkRenderer Yes The vtkRenderer instance.
x Number Yes
y Number Yes
z Number Yes

getEnabled

Get wether or not this InteractorObserver instance is enabled.

getInteractor

Retrieve the render window interactor instance.

getPriority

Get the priority.

getProcessEvents

Get whether or not the interactor observer instance should process events.

invokeEndInteractionEvent

Invoke an end interaction event.

Argument Type Required Description
args Yes Event payload.

invokeInteractionEvent

Invoke an interaction event.

Argument Type Required Description
args Yes Event payload.

invokeStartInteractionEvent

Invoke a start interaction event.

Argument Type Required Description
args Yes Event payload.

onEndInteractionEvent

Registers a callback to be invoked when an end interaction event occurs.

Argument Type Required Description
cb EventHandler Yes The callback to be called.
priority Number No The callback to be called

onInteractionEvent

Registers a callback to be invoked when an interaction event occurs.

Argument Type Required Description
cb EventHandler Yes The callback to be called.
priority Number No The priority of the event.

onStartInteractionEvent

Registers a callback to be invoked when a start interaction event occurs.

Argument Type Required Description
cb EventHandler Yes The callback to be called.
priority Number No The callback to be called

setEnabled

Enable/disable the interactor observer. Note that if you are enabling the interactor observer, an interactor instance must exists on the model.
Typically you can call setInteractor

Argument Type Required Description
enable Boolean Yes

setInteractor

Set the interactor instance.

Argument Type Required Description
interactor vtkRenderWindowInteractor Yes

setPriority

Set the priority.

Argument Type Required Description
priority Number Yes The priority level.

setProcessEvents

Set whether or not the interactor observer instance should process events.

Argument Type Required Description
processEvents Boolean Yes

Source

index.d.ts
import vtkRenderer from '../Renderer';
import vtkRenderWindowInteractor from '../RenderWindowInteractor';
import { vtkObject, EventHandler, vtkSubscription } from '../../../interfaces';
import { Vector3 } from '../../../types';

export interface vtkInteractorObserver extends vtkObject {
/**
* Invoke an interaction event.
*
* @param args Event payload.
*/
invokeInteractionEvent(...args: unknown[]): void;

/**
* Registers a callback to be invoked when an interaction event occurs.
*
* @param {EventHandler} cb The callback to be called.
* @param {Number} [priority] The priority of the event.
*/
onInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;

/**
* Invoke a start interaction event.
*
* @param args Event payload.
*/
invokeStartInteractionEvent(...args: unknown[]): void;

/**
* Registers a callback to be invoked when a start interaction event occurs.
*
* @param {EventHandler} cb The callback to be called.
* @param {Number} [priority] The callback to be called
*/
onStartInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;

/**
* Invoke an end interaction event.
*
* @param args Event payload.
*/
invokeEndInteractionEvent(...args: unknown[]): void;

/**
* Registers a callback to be invoked when an end interaction event occurs.
*
* @param {EventHandler} cb The callback to be called.
* @param {Number?} [priority] The callback to be called
*/
onEndInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;

/**
* Retrieve the render window interactor instance.
*/
getInteractor(): vtkRenderWindowInteractor;

/**
* Get wether or not this InteractorObserver instance is enabled.
*/
getEnabled(): boolean;

/**
* Enable/disable the interactor observer. Note that if you are enabling the interactor observer, an interactor instance must exists on the model.
* Typically you can call `setInteractor`
*
* @param {Boolean} enable
*/
setEnabled(enable: boolean): void;

/**
* Set the priority.
*
* @param {Number} priority The priority level.
*/
setPriority(priority: number): void;

/**
* Get the priority.
*/
getPriority(): number;

/**
* Set whether or not the interactor observer instance should process events.
*
* @param {Boolean} processEvents
*/
setProcessEvents(processEvents: boolean): boolean;

/**
* Get whether or not the interactor observer instance should process events.
*/
getProcessEvents(): boolean;

/**
* Set the interactor instance.
*
* @param {vtkRenderWindowInteractor} interactor
*/
setInteractor(interactor: vtkRenderWindowInteractor): void;

/**
* Transform from world to display coordinates.
*
* @param {vtkRenderer} renderer The vtkRenderer instance.
* @param {Number} x
* @param {Number} y
* @param {Number} z
*/
computeWorldToDisplay(
renderer: vtkRenderer,
x: number,
y: number,
z: number
): Vector3;

/**
* Transform from display to world coordinates.
*
* @param {vtkRenderer} renderer The vtkRenderer instance.
* @param {Number} x
* @param {Number} y
* @param {Number} z
*/
computeDisplayToWorld(
renderer: vtkRenderer,
x: number,
y: number,
z: number
): Vector3;
}

export default vtkInteractorObserver;
index.js
import macro from 'vtk.js/Sources/macros';
import vtkRenderWindowInteractor from 'vtk.js/Sources/Rendering/Core/RenderWindowInteractor';

const { vtkErrorMacro, VOID } = macro;

// ----------------------------------------------------------------------------
// Global methods
// ----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Description:
// Transform from world to display coordinates.
function computeWorldToDisplay(renderer, x, y, z) {
const view = renderer.getRenderWindow().getViews()[0];
return view.worldToDisplay(x, y, z, renderer);
}

//----------------------------------------------------------------------------
// Description:
// Transform from display to world coordinates.
function computeDisplayToWorld(renderer, x, y, z) {
const view = renderer.getRenderWindow().getViews()[0];
return view.displayToWorld(x, y, z, renderer);
}

// ----------------------------------------------------------------------------
// Static API
// ----------------------------------------------------------------------------
export const STATIC = {
computeWorldToDisplay,
computeDisplayToWorld,
};

// ----------------------------------------------------------------------------
// vtkInteractorObserver methods
// ----------------------------------------------------------------------------

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

const superClass = { ...publicAPI };

//----------------------------------------------------------------------------
function unsubscribeFromEvents() {
while (model.subscribedEvents.length) {
model.subscribedEvents.pop().unsubscribe();
}
}

//----------------------------------------------------------------------------
// Check what events we can handle and register callbacks
function subscribeToEvents() {
vtkRenderWindowInteractor.handledEvents.forEach((eventName) => {
if (publicAPI[`handle${eventName}`]) {
model.subscribedEvents.push(
model._interactor[`on${eventName}`]((callData) => {
if (model.processEvents) {
return publicAPI[`handle${eventName}`](callData);
}
return VOID;
}, model.priority)
);
}
});
}

//----------------------------------------------------------------------------
// Public API methods
//----------------------------------------------------------------------------
publicAPI.setInteractor = (i) => {
if (i === model._interactor) {
return;
}

unsubscribeFromEvents();

model._interactor = i;

if (i && model.enabled) {
subscribeToEvents();
}

publicAPI.modified();
};

//----------------------------------------------------------------------------
publicAPI.setEnabled = (enable) => {
if (enable === model.enabled) {
return;
}

unsubscribeFromEvents();

if (enable) {
if (model._interactor) {
subscribeToEvents();
} else {
vtkErrorMacro(`
The interactor must be set before subscribing to events
`);
}
}

model.enabled = enable;
publicAPI.modified();
};

//----------------------------------------------------------------------------
// Description:
// Transform from display to world coordinates.
publicAPI.computeDisplayToWorld = (renderer, x, y, z) => {
if (!renderer) {
return null;
}

return model._interactor.getView().displayToWorld(x, y, z, renderer);
};

//----------------------------------------------------------------------------
// Description:
// Transform from world to display coordinates.
publicAPI.computeWorldToDisplay = (renderer, x, y, z) => {
if (!renderer) {
return null;
}

return model._interactor.getView().worldToDisplay(x, y, z, renderer);
};

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

publicAPI.setPriority = (priority) => {
const modified = superClass.setPriority(priority);

if (modified && model._interactor) {
unsubscribeFromEvents();
subscribeToEvents();
}
};
}

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

const DEFAULT_VALUES = {
enabled: true,
// _interactor: null,
priority: 0.0,
processEvents: true,
subscribedEvents: [],
};

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

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

// Object methods
macro.obj(publicAPI, model);

macro.event(publicAPI, model, 'InteractionEvent');
macro.event(publicAPI, model, 'StartInteractionEvent');
macro.event(publicAPI, model, 'EndInteractionEvent');

// Create get-only macros
macro.get(publicAPI, model, ['_interactor', 'enabled']);

// Create get-set macros
macro.setGet(publicAPI, model, ['priority', 'processEvents']);

macro.moveToProtected(publicAPI, model, ['interactor']);

// For more macro methods, see "Sources/macros.js"

// Object specific methods
vtkInteractorObserver(publicAPI, model);
}

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

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

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

export default { newInstance, extend, ...STATIC };