Coordinate

Introduction

vtkCoordinate represents position in a variety of coordinate systems, and
converts position to other coordinate systems. It also supports relative
positioning, so you can create a cascade of vtkCoordinate objects (no loops
please!) that refer to each other. The typical usage of this object is to set
the coordinate system in which to represent a position (e.g.,
SetCoordinateSystemToNormalizedDisplay()), set the value of the coordinate
(e.g., SetValue()), and then invoke the appropriate method to convert to
another coordinate system (e.g., GetComputedWorldValue()).

The coordinate systems in vtk are as follows:

  • DISPLAY - x-y pixel values in window 0, 0 is the lower left of the first
    pixel, size, size is the upper right of the last pixel
  • NORMALIZED DISPLAY - x-y (0,1) normalized values 0, 0 is the lower left of
    the first pixel, 1, 1 is the upper right of the last pixel
  • VIEWPORT - x-y pixel values in viewport 0, 0 is the lower left of the first
    pixel, size, size is the upper right of the last pixel
  • NORMALIZED VIEWPORT - x-y (0,1) normalized value in viewport 0, 0 is the
    lower left of the first pixel, 1, 1 is the upper right of the last pixel
  • VIEW - x-y-z (-1,1) values in pose coordinates. (z is depth)
  • POSE - world coords translated and rotated to the camera position and view
    direction
  • STABILIZED - used by rendering backends to deal with floating point
    resolution issues. Similar to world coordinates but with a translation to
    try to get the matricies to be well behaved.
  • WORLD - x-y-z global coordinate values
  • MODEL - x-y-z coordinate values in the data’s coordinates, the actor holds
    a matrix to go to world
  • BUFFER - x-y-x coordinates as stored int he VBO
  • DATA - x-y-z the original coordintes of the dataset
  • USERDEFINED - x-y-z in User defined space

If you cascade vtkCoordinate objects, you refer to another vtkCoordinate
object which in turn can refer to others, and so on. This allows you to
create composite groups of things like vtkActor2D that are positioned
relative to one another.

!!! note
In cascaded sequences, each vtkCoordinate object may be specified in different coordinate systems!

How the data may go from a dataset through the rendering pipeline in steps

Dataset -> GPU buffer: DCBCMatrix usually this is just a shift and/or scale
to get the GPU buffer for the points into values that will nto run into
floating point resolution issues. This is handled when creating the buffer

  • Buffer to Model: BCMCMatrix just reverses the shift/scale applied to the
    buffer above
  • Model to World: MCWCMatrix uses the Actor’s matrix to transform the points
    to World coordinates
  • World to Stabilized: WCSCMatrix Maps world to the shifted maybe scalede
    renderer’s stabilized center/matrix
  • Stabilized to View: SCVCMatrix captures the rest of the transformation to
    View coordinates
  • View to Projection: VCPCMatrix cpatures the ortho/perspective matrix
  • Projection to …: done by the GPU hardware as part of the vertex to
    fragment

Typically the process is simplified into the 4 following steps :

  • DataSet to Buffer - done when creating the buffer
  • Buffer To Stabilized - BCSCMatrix done in the vertex shader, part of the
    mapperUBO
  • Stabilized To Projection - SCPCMatrix second matrix mult done in the vertex
    shader, part of the rendererUBO
  • Projection to …: vertex to fragment shader operations

See Also

vtkActor2D

Methods

extend

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

getComputedDisplayValue

Argument Type Required Description
ren vtkRenderer Yes

getComputedDoubleDisplayValue

Argument Type Required Description
ren vtkRenderer Yes

getComputedDoubleViewportValue

Argument Type Required Description
ren vtkRenderer Yes

getComputedLocalDisplayValue

Argument Type Required Description
ren vtkRenderer Yes

getComputedValue

Argument Type Required Description
ren vtkRenderer Yes

getComputedViewportValue

Argument Type Required Description
ren vtkRenderer Yes

getComputedWorldValue

Argument Type Required Description
ren vtkRenderer Yes

getCoordinateSystem

Get the coordinate system which this coordinate is defined in. The
options are Display, Normalized Display, Viewport, Normalized Viewport,
View, and World.

getCoordinateSystemAsString

Get the coordinate system which this coordinate is defined in as string.

getReferenceCoordinate

getRenderer

Get mapper that was picked (if any)

getValue

Get the value of this coordinate.

newInstance

Method use to create a new instance of vtkCoordinate

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

setCoordinateSystem

Set the coordinate system which this coordinate is defined in. The
options are Display, Normalized Display, Viewport, Normalized Viewport,
View, and World.

Argument Type Required Description
coordinateSystem Yes

setCoordinateSystemToDisplay

Set the coordinate system to Coordinate.DISPLAY

setCoordinateSystemToNormalizedDisplay

Set the coordinate system to Coordinate.NORMALIZED_DISPLAY

setCoordinateSystemToNormalizedViewport

Set the coordinate system to Coordinate.NORMALIZED_VIEWPORT

setCoordinateSystemToProjection

Set the coordinate system to Coordinate.PROJECTION

setCoordinateSystemToView

Set the coordinate system to Coordinate.VIEW

setCoordinateSystemToViewport

Set the coordinate system to Coordinate.VIEWPORT

setCoordinateSystemToWorld

Set the coordinate system to Coordinate.WORLD

setProperty

Argument Type Required Description
property Yes

setReferenceCoordinate

Argument Type Required Description
referenceCoordinate Yes

setRenderer

Argument Type Required Description
renderer Yes

setValue

Set the value of this coordinate.

Argument Type Required Description
...args Yes

Source

Constants.js
export const Coordinate = {
DISPLAY: 0,
NORMALIZED_DISPLAY: 1,
VIEWPORT: 2,
NORMALIZED_VIEWPORT: 3,
PROJECTION: 4,
VIEW: 5,
WORLD: 6,
};

export default {
Coordinate,
};
index.d.ts
import { vtkObject, vtkProperty } from "../../../interfaces";
import vtkRenderer from '../Renderer';

export enum Coordinate {
DISPLAY,
NORMALIZED_DISPLAY,
VIEWPORT,
NORMALIZED_VIEWPORT,
PROJECTION,
VIEW,
WORLD,
}

/**
*
*/
interface ICoordinateInitialValues {
coordinateSystem?: number,
value?: number[],
renderer?: vtkRenderer,
referenceCoordinate?: any,
computing?: number,
computedWorldValue?: number[],
computedDoubleDisplayValue?: number[],
}

export interface vtkCoordinate extends vtkObject {


/**
*
* @param {vtkRenderer} ren
*/
getComputedWorldValue(ren: vtkRenderer): number[];

/**
*
* @param {vtkRenderer} ren
*/
getComputedViewportValue(ren: vtkRenderer): number[];

/**
*
* @param {vtkRenderer} ren
*/
getComputedDisplayValue(ren: vtkRenderer): number[];

/**
*
* @param {vtkRenderer} ren
*/
getComputedLocalDisplayValue(ren: vtkRenderer): number[];

/**
*
* @param {vtkRenderer} ren
*/
getComputedValue(ren: vtkRenderer): number[];

/**
*
* @param {vtkRenderer} ren
*/
getComputedDoubleViewportValue(ren: vtkRenderer): number[];

/**
*
* @param {vtkRenderer} ren
*/
getComputedDoubleDisplayValue(ren: vtkRenderer): number[];

/**
* Get the coordinate system which this coordinate is defined in. The
* options are Display, Normalized Display, Viewport, Normalized Viewport,
* View, and World.
*/
getCoordinateSystem(): number;

/**
* Get the coordinate system which this coordinate is defined in as string.
*/
getCoordinateSystemAsString(): string;

/**
* Get the value of this coordinate.
*/
getValue(): number[];

/**
*
*/
getReferenceCoordinate(): vtkCoordinate;

/**
* Get mapper that was picked (if any)
*/
getRenderer(): null | vtkRenderer;

/**
* Set the coordinate system which this coordinate is defined in. The
* options are Display, Normalized Display, Viewport, Normalized Viewport,
* View, and World.
* @param coordinateSystem
*/
setCoordinateSystem(coordinateSystem: Coordinate): boolean

/**
* Set the coordinate system to Coordinate.DISPLAY
*/
setCoordinateSystemToDisplay(): void;

/**
* Set the coordinate system to Coordinate.NORMALIZED_DISPLAY
*/
setCoordinateSystemToNormalizedDisplay(): void;

/**
* Set the coordinate system to Coordinate.NORMALIZED_VIEWPORT
*/
setCoordinateSystemToNormalizedViewport(): void;

/**
* Set the coordinate system to Coordinate.PROJECTION
*/
setCoordinateSystemToProjection(): void;

/**
* Set the coordinate system to Coordinate.VIEW
*/
setCoordinateSystemToView(): void;

/**
* Set the coordinate system to Coordinate.VIEWPORT
*/
setCoordinateSystemToViewport(): void;

/**
* Set the coordinate system to Coordinate.WORLD
*/
setCoordinateSystemToWorld(): void;

/**
*
* @param property
*/
setProperty(property: vtkProperty): boolean;

/**
*
* @param referenceCoordinate
*/
setReferenceCoordinate(referenceCoordinate: vtkCoordinate): boolean;

/**
*
* @param renderer
*/
setRenderer(renderer: vtkRenderer): boolean;

/**
* Set the value of this coordinate.
* @param ...args
*/
setValue(value: number[]): boolean;
}

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

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

/**
* vtkCoordinate represents position in a variety of coordinate systems, and
* converts position to other coordinate systems. It also supports relative
* positioning, so you can create a cascade of vtkCoordinate objects (no loops
* please!) that refer to each other. The typical usage of this object is to set
* the coordinate system in which to represent a position (e.g.,
* SetCoordinateSystemToNormalizedDisplay()), set the value of the coordinate
* (e.g., SetValue()), and then invoke the appropriate method to convert to
* another coordinate system (e.g., GetComputedWorldValue()).
*
* The coordinate systems in vtk are as follows:
*
* - DISPLAY - x-y pixel values in window 0, 0 is the lower left of the first
* pixel, size, size is the upper right of the last pixel
* - NORMALIZED DISPLAY - x-y (0,1) normalized values 0, 0 is the lower left of
* the first pixel, 1, 1 is the upper right of the last pixel
* - VIEWPORT - x-y pixel values in viewport 0, 0 is the lower left of the first
* pixel, size, size is the upper right of the last pixel
* - NORMALIZED VIEWPORT - x-y (0,1) normalized value in viewport 0, 0 is the
* lower left of the first pixel, 1, 1 is the upper right of the last pixel
* - VIEW - x-y-z (-1,1) values in pose coordinates. (z is depth)
* - POSE - world coords translated and rotated to the camera position and view
* direction
* - STABILIZED - used by rendering backends to deal with floating point
* resolution issues. Similar to world coordinates but with a translation to
* try to get the matricies to be well behaved.
* - WORLD - x-y-z global coordinate values
* - MODEL - x-y-z coordinate values in the data's coordinates, the actor holds
* a matrix to go to world
* - BUFFER - x-y-x coordinates as stored int he VBO
* - DATA - x-y-z the original coordintes of the dataset
* - USERDEFINED - x-y-z in User defined space
*
* If you cascade vtkCoordinate objects, you refer to another vtkCoordinate
* object which in turn can refer to others, and so on. This allows you to
* create composite groups of things like vtkActor2D that are positioned
* relative to one another.
*
* !!! note
* In cascaded sequences, each vtkCoordinate object may be specified in different coordinate systems!
*
* How the data may go from a dataset through the rendering pipeline in steps
*
* Dataset -> GPU buffer: DCBCMatrix usually this is just a shift and/or scale
* to get the GPU buffer for the points into values that will nto run into
* floating point resolution issues. This is handled when creating the buffer
*
* - Buffer to Model: BCMCMatrix just reverses the shift/scale applied to the
* buffer above
* - Model to World: MCWCMatrix uses the Actor's matrix to transform the points
* to World coordinates
* - World to Stabilized: WCSCMatrix Maps world to the shifted maybe scalede
* renderer's stabilized center/matrix
* - Stabilized to View: SCVCMatrix captures the rest of the transformation to
* View coordinates
* - View to Projection: VCPCMatrix cpatures the ortho/perspective matrix
* - Projection to ...: done by the GPU hardware as part of the vertex to
* fragment
*
* Typically the process is simplified into the 4 following steps :
*
* - DataSet to Buffer - done when creating the buffer
* - Buffer To Stabilized - BCSCMatrix done in the vertex shader, part of the
* mapperUBO
* - Stabilized To Projection - SCPCMatrix second matrix mult done in the vertex
* shader, part of the rendererUBO
* - Projection to ...: vertex to fragment shader operations
*
* @see [vtkActor](./Rendering_Core_Actor.html)2D
*/
export declare const vtkCoordinate: {
newInstance: typeof newInstance,
extend: typeof extend,
};
export default vtkCoordinate;
index.js
import macro from 'vtk.js/Sources/macros';
import Constants from 'vtk.js/Sources/Rendering/Core/Coordinate/Constants';
import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';

const { Coordinate } = Constants;
const { vtkErrorMacro } = macro;

// ----------------------------------------------------------------------------
// vtkActor methods
// ----------------------------------------------------------------------------

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

publicAPI.setValue = (...args) => {
if (model.deleted) {
vtkErrorMacro('instance deleted - cannot call any method');
return false;
}

let array = args;
// allow an array passed as a single arg.
if (array.length === 1 && Array.isArray(array[0])) {
array = array[0];
}

if (array.length === 2) {
publicAPI.setValue(array[0], array[1], 0.0);
return true;
}
if (array.length !== 3) {
throw new RangeError('Invalid number of values for array setter');
}
let changeDetected = false;
model.value.forEach((item, index) => {
if (item !== array[index]) {
if (changeDetected) {
return;
}
changeDetected = true;
}
});

if (changeDetected) {
model.value = [].concat(array);
publicAPI.modified();
}
return true;
};

publicAPI.setCoordinateSystemToDisplay = () => {
publicAPI.setCoordinateSystem(Coordinate.DISPLAY);
};

publicAPI.setCoordinateSystemToNormalizedDisplay = () => {
publicAPI.setCoordinateSystem(Coordinate.NORMALIZED_DISPLAY);
};

publicAPI.setCoordinateSystemToViewport = () => {
publicAPI.setCoordinateSystem(Coordinate.VIEWPORT);
};

publicAPI.setCoordinateSystemToNormalizedViewport = () => {
publicAPI.setCoordinateSystem(Coordinate.NORMALIZED_VIEWPORT);
};

publicAPI.setCoordinateSystemToProjection = () => {
publicAPI.setCoordinateSystem(Coordinate.PROJECTION);
};

publicAPI.setCoordinateSystemToView = () => {
publicAPI.setCoordinateSystem(Coordinate.VIEW);
};

publicAPI.setCoordinateSystemToWorld = () => {
publicAPI.setCoordinateSystem(Coordinate.WORLD);
};

publicAPI.getCoordinateSystemAsString = () =>
macro.enumToString(Coordinate, model.coordinateSystem);

publicAPI.getComputedWorldValue = (ren) => {
let val = model.computedWorldValue;

if (model.computing) {
return val;
}
model.computing = 1;
val[0] = model.value[0];
val[1] = model.value[1];
val[2] = model.value[2];

// Use our renderer if is defined
let renderer = ren;
if (model.renderer) {
renderer = model.renderer;
}
if (!renderer) {
if (model.coordinateSystem === Coordinate.WORLD) {
if (model.referenceCoordinate) {
const refValue = model.referenceCoordinate.getComputedWorldValue(
renderer
);
val[0] += refValue[0];
val[1] += refValue[1];
val[2] += refValue[2];
}
model.computing = 0;
} else {
vtkErrorMacro(
'Attempt to compute world coordinates from another coordinate system without a renderer'
);
}
return val;
}

// convert to current coordinate system
let view = null;
if (renderer && renderer.getRenderWindow().getViews()) {
view = renderer.getRenderWindow().getViews()[0];
} else {
return model.computedWorldValue;
}

const dims = view.getViewportSize(renderer);
const aspect = dims[0] / dims[1];

if (
model.referenceCoordinate &&
model.coordinateSystem !== Coordinate.WORLD
) {
const fval = model.referenceCoordinate.getComputedDoubleDisplayValue(
renderer
);
let refValue = [fval[0], fval[1], 0.0];

switch (model.coordinateSystem) {
case Coordinate.NORMALIZED_DISPLAY:
refValue = view.displayToNormalizedDisplay(
refValue[0],
refValue[1],
refValue[2]
);
break;
case Coordinate.VIEWPORT:
refValue = view.displayToNormalizedDisplay(
refValue[0],
refValue[1],
refValue[2]
);
refValue = view.normalizedDisplayToViewport(
refValue[0],
refValue[1],
refValue[2],
renderer
);
break;
case Coordinate.NORMALIZED_VIEWPORT:
refValue = view.displayToNormalizedDisplay(
refValue[0],
refValue[1],
refValue[2]
);
refValue = view.normalizedDisplayToViewport(
refValue[0],
refValue[1],
refValue[2],
renderer
);
refValue = view.viewportToNormalizedViewport(
refValue[0],
refValue[1],
refValue[2],
renderer
);
break;
case Coordinate.PROJECTION:
refValue = view.displayToNormalizedDisplay(
refValue[0],
refValue[1],
refValue[2]
);
refValue = view.normalizedDisplayToViewport(
refValue[0],
refValue[1],
refValue[2],
renderer
);
refValue = view.viewportToNormalizedViewport(
refValue[0],
refValue[1],
refValue[2],
renderer
);
refValue = renderer.normalizedViewportToProjection(
refValue[0],
refValue[1],
refValue[2]
);
break;
case Coordinate.VIEW:
refValue = view.displayToNormalizedDisplay(
refValue[0],
refValue[1],
refValue[2]
);
refValue = view.normalizedDisplayToViewport(
refValue[0],
refValue[1],
refValue[2],
renderer
);
refValue = view.viewportToNormalizedViewport(
refValue[0],
refValue[1],
refValue[2],
renderer
);
refValue = renderer.normalizedViewportToProjection(
refValue[0],
refValue[1],
refValue[2]
);
refValue = renderer.projectionToView(
refValue[0],
refValue[1],
refValue[2],
aspect
);
break;
default:
break;
}

val[0] += refValue[0];
val[1] += refValue[1];
val[2] += refValue[2];
}

switch (model.coordinateSystem) {
case Coordinate.DISPLAY:
val = view.displayToNormalizedDisplay(val[0], val[1], val[2]);
val = view.normalizedDisplayToViewport(
val[0],
val[1],
val[2],
renderer
);
val = view.viewportToNormalizedViewport(
val[0],
val[1],
val[2],
renderer
);
val = renderer.normalizedViewportToProjection(val[0], val[1], val[2]);
val = renderer.projectionToView(val[0], val[1], val[2], aspect);
val = renderer.viewToWorld(val[0], val[1], val[2]);
break;
case Coordinate.NORMALIZED_DISPLAY:
val = view.normalizedDisplayToViewport(
val[0],
val[1],
val[2],
renderer
);
val = view.viewportToNormalizedViewport(
val[0],
val[1],
val[2],
renderer
);
val = renderer.normalizedViewportToProjection(val[0], val[1], val[2]);
val = renderer.projectionToView(val[0], val[1], val[2], aspect);
val = renderer.viewToWorld(val[0], val[1], val[2]);
break;
case Coordinate.VIEWPORT:
val = view.viewportToNormalizedViewport(
val[0],
val[1],
val[2],
renderer
);
val = renderer.normalizedViewportToProjection(val[0], val[1], val[2]);
val = renderer.projectionToView(val[0], val[1], val[2], aspect);
val = renderer.viewToWorld(val[0], val[1], val[2]);
break;
case Coordinate.NORMALIZED_VIEWPORT:
val = renderer.normalizedViewportToProjection(val[0], val[1], val[2]);
val = renderer.projectionToView(val[0], val[1], val[2], aspect);
val = renderer.viewToWorld(val[0], val[1], val[2]);
break;
case Coordinate.PROJECTION:
val = renderer.projectionToView(val[0], val[1], val[2], aspect);
val = renderer.viewToWorld(val[0], val[1], val[2]);
break;
case Coordinate.VIEW:
val = renderer.viewToWorld(val[0], val[1], val[2]);
break;
default:
break;
}

if (
model.referenceCoordinate &&
model.coordinateSystem === Coordinate.WORLD
) {
const refValue = publicAPI.getComputedWorldValue(renderer);
val[0] += refValue[0];
val[1] += refValue[1];
val[2] += refValue[2];
}

model.computing = 0;
model.computedWorldValue = val.slice(0);
return val;
};

publicAPI.getComputedViewportValue = (ren) => {
const f = publicAPI.getComputedDoubleViewportValue(ren);
return [vtkMath.round(f[0]), vtkMath.round(f[1])];
};

publicAPI.getComputedDisplayValue = (ren) => {
const val = publicAPI.getComputedDoubleDisplayValue(ren);
return [vtkMath.floor(val[0]), vtkMath.floor(val[1])];
};

publicAPI.getComputedLocalDisplayValue = (ren) => {
// Use our renderer if it is defined
let renderer = ren;
if (model.renderer) {
renderer = model.renderer;
}
let val = publicAPI.getComputedDisplayValue(renderer);

if (!renderer) {
vtkErrorMacro(
'Attempt to convert to local display coordinates without a renderer'
);
return val;
}

let view = null;
if (renderer && renderer.getRenderWindow().getViews()) {
view = renderer.getRenderWindow().getViews()[0];
} else {
return val;
}
val = view.displayToLocalDisplay(val[0], val[1], val[2]);
return [vtkMath.round(val[0]), vtkMath.round(val[1])];
};

publicAPI.getComputedDoubleViewportValue = (ren) => {
let renderer = ren;
if (model.renderer) {
renderer = model.renderer;
}
let val = publicAPI.getComputedDoubleDisplayValue(renderer);

if (!renderer) {
return val;
}
let view = null;
if (renderer && renderer.getRenderWindow().getViews()) {
view = renderer.getRenderWindow().getViews()[0];
} else {
return val;
}

val = view.displayToNormalizedDisplay(val[0], val[1], val[2]);
val = view.normalizedDisplayToViewport(val[0], val[1], val[2], renderer);

return [val[0], val[1]];
};

publicAPI.getComputedDoubleDisplayValue = (ren) => {
if (model.computing) {
return model.computedDoubleDisplayValue;
}
model.computing = 1;

let val = model.value.slice(0);
let renderer = ren;
if (model.renderer) {
renderer = model.renderer;
}
if (!renderer) {
if (model.coordinateSystem === Coordinate.DISPLAY) {
model.computedDoubleDisplayValue[0] = val[0];
model.computedDoubleDisplayValue[1] = val[1];
if (model.referenceCoordinate) {
const refValue = model.referenceCoordinate.getComputedDoubleDisplayValue();
model.computedDoubleDisplayValue[0] += refValue[0];
model.computedDoubleDisplayValue[1] += refValue[1];
}
} else {
model.computedDoubleDisplayValue[0] = Number.MAX_VALUE;
model.computedDoubleDisplayValue[1] = Number.MAX_VALUE;

vtkErrorMacro(
'Request for coordinate transformation without required viewport'
);
}
return model.computedDoubleDisplayValue;
}

let view = null;
if (renderer && renderer.getRenderWindow().getViews()) {
view = renderer.getRenderWindow().getViews()[0];
} else {
return val;
}

const dims = view.getViewportSize(renderer);
const aspect = dims[0] / dims[1];
switch (model.coordinateSystem) {
case Coordinate.WORLD: {
if (model.referenceCoordinate) {
const refValue = model.referenceCoordinate.getComputedWorldValue(
renderer
);
val[0] += refValue[0];
val[1] += refValue[1];
val[2] += refValue[2];
}
val = renderer.worldToView(val[0], val[1], val[2]);
val = renderer.viewToProjection(val[0], val[1], val[2], aspect);

val = renderer.projectionToNormalizedViewport(val[0], val[1], val[2]);
val = view.normalizedViewportToViewport(
val[0],
val[1],
val[2],
renderer
);
val = view.viewportToNormalizedDisplay(
val[0],
val[1],
val[2],
renderer
);
val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
break;
}
case Coordinate.VIEW: {
val = renderer.viewToProjection(val[0], val[1], val[2], aspect);
val = renderer.projectionToNormalizedViewport(val[0], val[1], val[2]);
val = view.normalizedViewportToViewport(
val[0],
val[1],
val[2],
renderer
);
val = view.viewportToNormalizedDisplay(
val[0],
val[1],
val[2],
renderer
);
val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
break;
}
case Coordinate.PROJECTION: {
val = renderer.projectionToNormalizedViewport(val[0], val[1], val[2]);
val = view.normalizedViewportToViewport(
val[0],
val[1],
val[2],
renderer
);
val = view.viewportToNormalizedDisplay(
val[0],
val[1],
val[2],
renderer
);
val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
break;
}
case Coordinate.NORMALIZED_VIEWPORT: {
val = view.normalizedViewportToViewport(
val[0],
val[1],
val[2],
renderer
);

if (model.referenceCoordinate) {
const refValue = model.referenceCoordinate.getComputedDoubleViewportValue(
renderer
);
val[0] += refValue[0];
val[1] += refValue[1];
}

val = view.viewportToNormalizedDisplay(
val[0],
val[1],
val[2],
renderer
);
val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
break;
}
case Coordinate.VIEWPORT: {
if (model.referenceCoordinate) {
const refValue = model.referenceCoordinate.getComputedDoubleViewportValue(
renderer
);
val[0] += refValue[0];
val[1] += refValue[1];
}
val = view.viewportToNormalizedDisplay(
val[0],
val[1],
val[2],
renderer
);
val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
break;
}
case Coordinate.NORMALIZED_DISPLAY:
val = view.normalizedDisplayToDisplay(val[0], val[1], val[2]);
break;

case Coordinate.USERDEFINED:
val = model.value.slice(0);
break;
default:
break;
}

// if we have a reference coordinate and we haven't handled it yet
if (
model.referenceCoordinate &&
(model.coordinateSystem === Coordinate.DISPLAY ||
model.coordinateSystem === Coordinate.NORMALIZED_DISPLAY)
) {
const refValue = model.referenceCoordinate.getComputedDoubleDisplayValue(
renderer
);
val[0] += refValue[0];
val[1] += refValue[1];
}

model.computedDoubleDisplayValue[0] = val[0];
model.computedDoubleDisplayValue[1] = val[1];

model.computing = 0;

return model.computedDoubleDisplayValue;
};

publicAPI.getComputedValue = (ren) => {
let renderer = ren;
if (model.renderer) {
renderer = model.renderer;
}
switch (model.coordinateSystem) {
case Coordinate.WORLD:
return publicAPI.getComputedWorldValue(renderer);
case Coordinate.VIEW:
case Coordinate.NORMALIZED_VIEWPORT:
case Coordinate.VIEWPORT: {
const val = publicAPI.getComputedViewportValue(renderer);
model.computedWorldValue[0] = val[0];
model.computedWorldValue[1] = val[1];
break;
}
case Coordinate.NORMALIZED_DISPLAY:
case Coordinate.DISPLAY: {
const val = model.getComputedDisplayValue(renderer);
model.computedWorldValue[0] = val[0];
model.computedWorldValue[1] = val[1];
break;
}
default:
break;
}
return model.computedWorldValue;
};
}

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

const DEFAULT_VALUES = {
coordinateSystem: Coordinate.WORLD,
value: [0.0, 0.0, 0.0],
renderer: null,
referenceCoordinate: null,
computing: 0,
computedWorldValue: [0.0, 0.0, 0.0],
computedDoubleDisplayValue: [0.0, 0.0],
};

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

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

macro.obj(publicAPI, model);

// Build VTK API
macro.set(publicAPI, model, ['property']);
macro.get(publicAPI, model, ['value']);
macro.setGet(publicAPI, model, [
'coordinateSystem',
'referenceCoordinate',
'renderer',
]);

macro.getArray(publicAPI, model, ['value'], 3);

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

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

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

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

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