TextureMapToSphere

Introduction

vtkTextureMapToSphere generate texture coordinates by mapping points to
sphere The TCoords DataArray is name ‘Texture Coordinate’

Methods

extend

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

getAutomaticSphereGeneration

Get whether the automatic sphere generation is set.

getCenter

Get the point defining the center of the sphere.

getCenterByReference

Get the normal object.

getPreventSeam

Get whether the prevent seam is set.

newInstance

Method used to create a new instance of vtkTextureMapToSphere

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

requestData

Argument Type Required Description
inData Yes
outData Yes

setAutomaticSphereGeneration

Turn on/off the automatic sphere generation.

Argument Type Required Description
automaticSphereGeneration Yes

setCenter

Set the point defining the center of the sphere.

Argument Type Required Description
x Yes
y Yes
z Yes

setCenter

Set the point defining the center of the sphere.

Argument Type Required Description
center Array. Yes The center point coordinates.

setCenterFrom

Set the point defining the center of the sphere.

Argument Type Required Description
center Array. Yes The center point coordinates.

setPreventSeam

Control how the texture coordinates are generated.

If PreventSeam is set, the s-coordinate ranges :

  • from 0->1 and 1->0 corresponding to the theta angle variation between 0->180 and 180->0 degrees
  • Otherwise, the s-coordinate ranges from 0->1 between 0->360 degrees.
Argument Type Required Description
preventSeam Yes

Source

index.d.ts
import { vtkAlgorithm, vtkObject } from "../../../interfaces";

/**
*
*/
interface ITextureMapToSphere {
center?: number[];
automaticSphereGeneration?: number;
preventSeam?: number;
}

type vtkTextureMapToSphereBase = vtkObject & vtkAlgorithm;

export interface vtkTextureMapToSphere extends vtkTextureMapToSphereBase {

/**
* Get whether the automatic sphere generation is set.
*/
getAutomaticSphereGeneration(): number;

/**
* Get the point defining the center of the sphere.
*/
getCenter(): number[];

/**
* Get the normal object.
*/
getCenterByReference(): number[];

/**
* Get whether the prevent seam is set.
*/
getPreventSeam(): number;

/**
*
* @param inData
* @param outData
*/
requestData(inData: any, outData: any): void;

/**
* Turn on/off the automatic sphere generation.
* @param automaticSphereGeneration
*/
setAutomaticSphereGeneration(automaticSphereGeneration: number): boolean;

/**
* Control how the texture coordinates are generated.
*
* If PreventSeam is set, the s-coordinate ranges :
*
* - from 0->1 and 1->0 corresponding to the theta angle variation between 0->180 and 180->0 degrees
* - Otherwise, the s-coordinate ranges from 0->1 between 0->360 degrees.
* @param preventSeam
*/
setPreventSeam(preventSeam: number): boolean;

/**
* Set the point defining the center of the sphere.
* @param {Number[]} center The center point coordinates.
*/
setCenter(center: number[]): boolean;

/**
* Set the point defining the center of the sphere.
* @param x
* @param y
* @param z
*/
setCenter(x: number, y: number, z: number): boolean;

/**
* Set the point defining the center of the sphere.
* @param {Number[]} center The center point coordinates.
*/
setCenterFrom(center: number[]): boolean;
}

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

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

/**
* vtkTextureMapToSphere generate texture coordinates by mapping points to
* sphere The TCoords DataArray is name 'Texture Coordinate'
*/
export declare const vtkTextureMapToSphere: {
newInstance: typeof newInstance;
extend: typeof extend;
}
export default vtkTextureMapToSphere;
index.js
import macro from 'vtk.js/Sources/macros';
import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';

const { vtkErrorMacro } = macro;

// ----------------------------------------------------------------------------
// vtkTextureMapToSphere methods
// ----------------------------------------------------------------------------

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

publicAPI.requestData = (inData, outData) => {
if (model.deleted) {
return;
}
const input = inData[0];

const nbPoints = input.getPoints().getNumberOfPoints();
if (nbPoints <= 1) {
vtkErrorMacro("Can't generate texture coordinates without points");
return;
}

const piOverTwo = Math.PI / 2;
const x = [];
const points = input.getPoints();
if (model.automaticSphereGeneration) {
model.center = [0, 0, 0];
for (let i = 0; i < nbPoints; i++) {
points.getPoint(i, x);
model.center[0] += x[0];
model.center[1] += x[1];
model.center[2] += x[2];
}
model.center[0] /= nbPoints;
model.center[1] /= nbPoints;
model.center[2] /= nbPoints;
}

let rho = 0;
let diff = 0;
let phi = 0;
const tc = [0, 0];
let r = 0;
let thetaX = 0;
let thetaY = 0;
const tcoordsData = [];
for (let i = 0; i < nbPoints; i++) {
points.getPoint(i, x);
rho = Math.sqrt(vtkMath.distance2BetweenPoints(x, model.center));
if (rho !== 0) {
diff = x[2] - model.center[2];
if (Math.abs(diff) > rho) {
phi = 0;
if (diff > 0) {
tc[1] = 0;
} else {
tc[1] = 1;
}
} else {
phi = Math.acos(diff / rho);
tc[1] = phi / Math.PI;
}
} else {
tc[1] = 0;
}

r = rho * Math.sin(phi);
if (r !== 0) {
diff = x[0] - model.center[0];
if (Math.abs(diff) > r) {
if (diff > 0) {
thetaX = 0;
} else {
thetaX = Math.PI;
}
} else {
thetaX = Math.acos(diff / r);
}

diff = x[1] - model.center[1];
if (Math.abs(diff) > r) {
if (diff > 0) {
thetaY = piOverTwo;
} else {
thetaY = -piOverTwo;
}
} else {
thetaY = Math.asin(diff / r);
}
} else {
thetaX = 0;
thetaY = 0;
}

if (model.preventSeam) {
tc[0] = thetaX / Math.PI;
} else {
tc[0] = thetaX / (2 * Math.PI);
if (thetaY < 0) {
tc[0] = 1 - tc[0];
}
}
tcoordsData.push(...tc);
}

const tCoords = vtkDataArray.newInstance({
name: 'Texture Coordinates',
numberOfComponents: 2,
size: nbPoints,
values: tcoordsData,
});

const output = vtkPolyData.newInstance();
output
.getPoints()
.setData(new Float32Array(input.getPoints().getData()), 3);
output.getPolys().setData(new Uint32Array(input.getPolys().getData()));
output.getPointData().setTCoords(tCoords);

// Update output
outData[0] = output;
};
}

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

const DEFAULT_VALUES = {
center: [0, 0, 0],
automaticSphereGeneration: 1,
preventSeam: 1,
};

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

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

// Build VTK API
macro.obj(publicAPI, model);

macro.setGetArray(publicAPI, model, ['center']);
macro.setGet(publicAPI, model, ['automaticSphereGeneration', 'preventSeam']);

macro.algo(publicAPI, model, 1, 1);
vtkTextureMapToSphere(publicAPI, model);
}

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

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

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

export default { newInstance, extend };