PixelSpaceCallbackMapper

Introduction

vtkPixelSpaceCallbackMapper iterates over the points of its input dataset,
using the transforms from the active camera to compute the screen coordinates
of each point.

Methods

extend

Method use to decorate a given object (publicAPI+model) with vtkPixelSpaceCallbackMapper 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 IPixelSpaceCallbackMapperInitialValues No (default: {})

getCallback

getUseZValues

invokeCallback

Argument Type Required Description
dataset Yes
camera Yes
aspect Yes
windowSize Yes
depthValues Yes

newInstance

Method use to create a new instance of vtkPixelSpaceCallbackMapper

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

setCallback

Set the callback function the mapper will call, during the rendering
process, with the screen coords of the points in dataset. The callback
function will have the following parameters:

// An array of 4-component arrays, in the index-order of the datasets points

coords: [
[screenx, screeny, screenz, zBufValue],

]

// The active camera of the renderer, in case you may need to compute alternate
// depth values for your dataset points. Using the sphere mapper in your
// application code is one example where this may be useful, so that you can
// account for that mapper’s radius when doing depth checks.

camera: vtkCamera

// The aspect ratio of the render view and depthBuffer
aspect: float

// A Uint8Array of size width * height * 4, where the zbuffer values are
// encoded in the red and green components of each pixel. This will only
// be non-null after you call setUseZValues(true) on the mapper before
// rendering.

depthBuffer: Uint8Array

Argument Type Required Description
callback Yes called with coords, camera, aspect and depthBuffer

setUseZValues

Set whether or not this mapper should capture the zbuffer during
rendering. Useful for allowing depth checks in the application code.

Argument Type Required Description
useZValues Yes

Source

index.d.ts
import { Vector3 } from "../../../types";
import vtkCamera from "../Camera";
import vtkMapper, { IMapperInitialValues } from "../Mapper";

/**
*
*/
export interface IPixelSpaceCallbackMapperInitialValues extends IMapperInitialValues {
callback?: any,
useZValues?: boolean;
}

interface IWindowSize {
usize: number;
vsize: number;
}

export interface vtkPixelSpaceCallbackMapper extends vtkMapper {

/**
*
*/
getCallback(): any;

/**
*
*/
getUseZValues(): boolean

/**
*
* @param dataset
* @param camera
* @param aspect
* @param windowSize
* @param depthValues
*/
invokeCallback(dataset: any, camera: vtkCamera, aspect: number, windowSize: IWindowSize, depthValues: number[]): void;

/**
* Set the callback function the mapper will call, during the rendering
* process, with the screen coords of the points in dataset. The callback
* function will have the following parameters:
*
* // An array of 4-component arrays, in the index-order of the datasets points
*
* coords: [
* [screenx, screeny, screenz, zBufValue],
* ...
* ]

* // The active camera of the renderer, in case you may need to compute alternate
* // depth values for your dataset points. Using the sphere mapper in your
* // application code is one example where this may be useful, so that you can
* // account for that mapper's radius when doing depth checks.
*
* camera: vtkCamera

* // The aspect ratio of the render view and depthBuffer
* aspect: float

* // A Uint8Array of size width * height * 4, where the zbuffer values are
* // encoded in the red and green components of each pixel. This will only
* // be non-null after you call setUseZValues(true) on the mapper before
* // rendering.
*
* depthBuffer: Uint8Array
*
* @example
* ```js
* // there is some text canvas and label data
* const textCtx = textCanvas.getContext('2d');
* const psMapper = vtkPixelSpaceCallbackMapper.newInstance();
* psMapper.setInputData(pointPoly);
* psMapper.setCallback((coords, camera, aspect, depthBuffer) => {
* textCtx.clearRect(0, 0, oglCtx.drawingBufferWidth, oglCtx.drawingBufferHeight);
* coords.forEach((xy, idx) => {
* let label = data.labels[idx]
* textCtx.fillStyle = "white";
* textCtx.font = "12px Arial";
* textCtx.fillText(label, xy[0], oglCtx.drawingBufferHeight - xy[1]);
* })
* })
*
* const textActor = vtkActor.newInstance();
* textActor.setMapper(psMapper);
* renderer.addActor(textActor);
* ```
*
* @param callback called with coords, camera, aspect and depthBuffer
*/
setCallback(callback: (coords: Vector3[], camera: vtkCamera, aspect: number, depthBuffer: Uint8Array) => any): boolean


/**
* Set whether or not this mapper should capture the zbuffer during
* rendering. Useful for allowing depth checks in the application code.
* @param useZValues
*/
setUseZValues(useZValues: boolean): boolean
}


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

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


/**
* vtkPixelSpaceCallbackMapper iterates over the points of its input dataset,
* using the transforms from the active camera to compute the screen coordinates
* of each point.
*/
export declare const vtkPixelSpaceCallbackMapper: {
newInstance: typeof newInstance,
extend: typeof extend,
};
export default vtkPixelSpaceCallbackMapper;
index.js
import { mat4, vec3 } from 'gl-matrix';

import macro from 'vtk.js/Sources/macros';
import vtkMapper from 'vtk.js/Sources/Rendering/Core/Mapper';

// ----------------------------------------------------------------------------
// vtkPixelSpaceCallbackMapper methods
// ----------------------------------------------------------------------------

function vtkPixelSpaceCallbackMapper(publicAPI, model) {
model.classHierarchy.push('vtkPixelSpaceCallbackMapper');

if (!model.callback) {
model.callback = () => {};
}

publicAPI.invokeCallback = (
dataset,
camera,
aspect,
windowSize,
depthValues
) => {
if (!model.callback) {
return;
}

const matrix = camera.getCompositeProjectionMatrix(aspect, -1, 1);
mat4.transpose(matrix, matrix);

const dataPoints = dataset.getPoints();
const result = new Float64Array(3);
const width = windowSize.usize;
const height = windowSize.vsize;
const hw = width / 2;
const hh = height / 2;
const coords = [];

for (let pidx = 0; pidx < dataPoints.getNumberOfPoints(); pidx += 1) {
const point = dataPoints.getPoint(pidx);
vec3.transformMat4(result, point, matrix);
const coord = [result[0] * hw + hw, result[1] * hh + hh, result[2], 0];

if (depthValues) {
const linIdx = Math.floor(coord[1]) * width + Math.floor(coord[0]);
const idx = linIdx * 4;
const r = depthValues[idx] / 255;
const g = depthValues[idx + 1] / 255;
const z = (r * 256 + g) / 257;
coord[3] = z * 2 - 1;
}

coords.push(coord);
}

model.callback(coords, camera, aspect, depthValues, [width, height]);
};
}

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

const DEFAULT_VALUES = {
callback: null,
useZValues: false,
};

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

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

// Inheritance
vtkMapper.extend(publicAPI, model, initialValues);

macro.setGet(publicAPI, model, ['callback', 'useZValues']);

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

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

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

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

export default { newInstance, extend };