ITKPolyDataReader

Introduction

The vtkITKPolyDataReader aims to read a ITK file format.

Methods

extend

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

getArrayName

Get the array name.

getFileName

Get the filename.

newInstance

Method used to create a new instance of vtkITKPolyDataReader

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

parseAsArrayBuffer

Parse data as array buffer.

Argument Type Required Description
arrayBuffer ArrayBuffer Yes The array buffer to parse.

requestData

Argument Type Required Description
inData Yes
outData Yes

setArrayName

Set the array name.

Argument Type Required Description
arrayName String Yes The name of the array.

setFileName

Set the filename.

Argument Type Required Description
filename String Yes

setReadPolyDataArrayBufferFromITK

Argument Type Required Description
fn any Yes

Source

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

/**
*
*/
interface IITKPolyDataReaderInitialValues {
fileName?: string;
arrayName?: string;
}

type vtkITKPolyDataReaderBase = vtkObject & Omit<vtkAlgorithm,
| 'getInputData'
| 'setInputData'
| 'setInputConnection'
| 'getInputConnection'
| 'addInputConnection'
| 'addInputData'>;

export interface vtkITKPolyDataReader extends vtkITKPolyDataReaderBase {

/**
* Get the array name.
*/
getArrayName(): string;

/**
* Get the filename.
*/
getFileName(): string;

/**
* Parse data as array buffer.
* @param {ArrayBuffer} arrayBuffer The array buffer to parse.
*/
parseAsArrayBuffer(arrayBuffer: ArrayBuffer): void;

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

/**
* Set the array name.
* @param {String} arrayName The name of the array.
*/
setArrayName(arrayName: string): boolean;

/**
* Set the filename.
* @param {String} filename
*/
setFileName(filename: string): boolean;
}

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

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

/**
*
* @param {*} fn
*/
export function setReadPolyDataArrayBufferFromITK(fn : any): Promise<any>;

/**
* The vtkITKPolyDataReader aims to read a ITK file format.
*/
export declare const vtkITKPolyDataReader: {
newInstance: typeof newInstance;
extend: typeof extend;
setReadPolyDataArrayBufferFromITK: typeof setReadPolyDataArrayBufferFromITK;
}
export default vtkITKPolyDataReader;
index.js
import macro from 'vtk.js/Sources/macros';
import vtk from 'vtk.js/Sources/vtk';

let readPolyDataArrayBuffer = null;
let resultPreprocessor = (result) => result;

function setReadPolyDataArrayBufferFromITK(fn) {
readPolyDataArrayBuffer = fn;

// first arg is a webworker if reuse is desired.
readPolyDataArrayBuffer = (...args) => fn(null, ...args);

// an object is now passed out which includes a webworker which we
// should terminate
resultPreprocessor = ({ webWorker, polyData }) => {
webWorker.terminate();
return polyData;
};
}

// ----------------------------------------------------------------------------
// vtkITKPolyDataReader methods
// ----------------------------------------------------------------------------

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

// Returns a promise to signal when polyData is ready
publicAPI.parseAsArrayBuffer = (arrayBuffer) => {
if (!arrayBuffer || arrayBuffer === model.rawDataBuffer) {
return Promise.resolve();
}

model.rawDataBuffer = arrayBuffer;

return readPolyDataArrayBuffer(arrayBuffer, model.fileName)
.then(resultPreprocessor)
.then((polyData) => {
model.output[0] = vtk(polyData);

publicAPI.modified();
});
};

publicAPI.requestData = (inData, outData) => {
publicAPI.parseAsArrayBuffer(model.rawDataBuffer, model.fileName);
};
}

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

const DEFAULT_VALUES = {
fileName: '',
// If null/undefined a unique array will be generated
arrayName: null,
};

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

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

// Build VTK API
macro.obj(publicAPI, model);
macro.algo(publicAPI, model, 0, 1);
macro.setGet(publicAPI, model, ['fileName', 'arrayName']);

// vtkITKPolyDataReader methods
vtkITKPolyDataReader(publicAPI, model);

// Check that ITK function has been injected
if (!readPolyDataArrayBuffer) {
console.error(`
// Dependency needs to be added inside your project
import readPolyDataArrayBuffer from 'itk/readPolyDataArrayBuffer';
vtkITKPolyDataReader.setReadPolyDataArrayBufferFromITK(readPolyDataArrayBuffer);
`);
}
}

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

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

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

export default { newInstance, extend, setReadPolyDataArrayBufferFromITK };