RTAnalyticSource

vtkRTAnalyticSource just produces images with pixel values determined
by a

Maximum*Gaussian

  • mag0sin(freq0x)
  • mag1sin(freq1y)
  • mag2cos(freq2z)
  • offset

wholeExtent (get/set)

The extent of the whole output image, default is [0, 255, 0, 255, 0, 0]

center (get/set)

The center of the function

maximum (get/set)

maximum value of the gaussian function

standardDeviation (get/set)

frequency[3] (get/set)

Natural frequency of the function on X Y Z

magnitude[3] (get/set)

Magnitude of the function on X Y Z

Source

index.js
import macro from 'vtk.js/Sources/macro';
import vtkImageData from 'vtk.js/Sources/Common/DataModel/ImageData';
import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';

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

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

publicAPI.requestData = (inData, outData) => {
if (model.deleted) {
return;
}

const state = {};
const dataset = {
type: 'vtkImageData',
mtime: model.mtime,
metadata: {
source: 'vtkRTAnalyticSource',
state,
},
};

// Add parameter used to create dataset as metadata.state[*]
[
'standardDeviation',
'center',
'frequency',
'magnitude',
'maximum',
].forEach((field) => {
state[field] = [].concat(model[field]);
});

const id = vtkImageData.newInstance(dataset);

id.setSpacing(1.0, 1.0, 1.0);
id.setExtent.apply(this, model.wholeExtent);
id.setOrigin(0.0, 0.0, 0.0);
id.setDirection(model.dataDirection);

let dims = [0, 0, 0];
dims = dims.map(
(_, i) => model.wholeExtent[i * 2 + 1] - model.wholeExtent[i * 2] + 1
);

const newArray = new Uint8Array(dims[0] * dims[1] * dims[2]);
const temp2 =
1.0 / (2.0 * model.standardDeviation * model.standardDeviation);

let xval = 0;
let yval = 0;
let zval = 0;
const scale = [
1.0 / (model.wholeExtent[1] - model.wholeExtent[0]),
1.0 / (model.wholeExtent[3] - model.wholeExtent[2]),
1.0 / (model.wholeExtent[5] - model.wholeExtent[4]),
];

let i = 0;
for (let z = model.wholeExtent[4]; z <= model.wholeExtent[5]; z++) {
zval = (model.center[2] - z) * scale[2];
const zfactor = model.magnitude[2] * Math.cos(model.frequency[2] * zval);
zval *= zval;
for (let y = model.wholeExtent[2]; y <= model.wholeExtent[3]; y++) {
yval = (model.center[1] - y) * scale[1];
const yfactor =
model.magnitude[1] * Math.sin(model.frequency[1] * yval);
yval *= yval;
for (let x = model.wholeExtent[0]; x <= model.wholeExtent[1]; x++) {
xval = (model.center[0] - x) * scale[0];
const sum = zval + yval + xval * xval;
const xfactor =
model.magnitude[0] * Math.sin(model.frequency[0] * xval);
newArray[i] =
model.maximum * Math.exp(-sum * temp2) +
xfactor +
yfactor +
zfactor +
model.offset;
i++;
}
}
}

const da = vtkDataArray.newInstance({
numberOfComponents: 1,
values: newArray,
});
da.setName('scalars');

const cpd = id.getPointData();
cpd.setScalars(da);

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

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

const DEFAULT_VALUES = {
offset: 40,
maximum: 120,
center: [0, 0, 0],
frequency: [60, 30, 40],
magnitude: [10, 18, 5],
standardDeviation: 0.5,
wholeExtent: [-10, 10, -10, 10, -10, 10],
dataDirection: [1, 0, 0, 0, 1, 0, 0, 0, 1],
};

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

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

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

macro.setGet(publicAPI, model, ['offset', 'maximum', 'standardDeviation']);

macro.setGetArray(publicAPI, model, ['center', 'frequency', 'magnitude'], 3);

macro.setGetArray(publicAPI, model, ['wholeExtent'], 6);

macro.setGetArray(publicAPI, model, ['dataDirection'], 9);

macro.algo(publicAPI, model, 0, 1);
vtkRTAnalyticSource(publicAPI, model);
}

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

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

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

export default { newInstance, extend };