VTKImageDataModel

Source

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

import pako from 'pako';

import vtk from 'vtk.js/Sources/vtk';
import Monologue from 'monologue.js';
import DataManager from 'paraviewweb/src/IO/Core/DataManager';

let dataManager = new DataManager();
const OBJECT_READY_TOPIC = 'object-ready';

let imageDataModelCounter = 0;

export default class VTKImageDataModel {
constructor(basepath) {
imageDataModelCounter += 1;

this.dataMapping = {};
this.fetchGzip = true;
this.basepath = basepath; // Needed for cloning
this.id = ['VTKImageDataModel', imageDataModelCounter].join('_');
this.colorByMapping = {};
this.currentImageData = null;

this.dataManagerListener = (data, envelope) => {
const url = data.requestedURL;
const dataDescription = this.dataMapping[url];

if (dataDescription && this.currentImageData) {
delete dataDescription.ref;
let values = null;

if (this.fetchGzip) {
values = new window[dataDescription.dataType](
pako.inflate(new Uint8Array(data.data)).buffer
);
} else {
values = new window[dataDescription.dataType](data.data);
}

const dataArray = vtkDataArray.newInstance(
Object.assign({}, dataDescription, { values })
);
this.currentImageData
.get(dataDescription.location)
[dataDescription.location].setScalars(dataArray);
this.currentImageData.modified();

if (
!Object.keys(this.dataMapping)
.map((key) => this.dataMapping[key].ref)
.find((i) => !!i)
) {
this.geometryReady(this.currentImageData);
}
} else {
console.log('skip no vtkImageData');
}
};
this.dataManagerSubscription = dataManager.on(
this.id,
this.dataManagerListener
);
}

setDataManager(dm) {
this.dataManagerSubscription.unsubscribe();
dataManager = dm;
this.dataManagerSubscription = dataManager.on(
this.id,
this.dataManagerListener
);
}

onGeometryReady(callback) {
return this.on(OBJECT_READY_TOPIC, callback);
}

geometryReady(obj) {
this.emit(OBJECT_READY_TOPIC, obj);
}

loadField(objectName, fieldName) {
this.geometryReady(this.currentImageData);
// NoOp
}

setFetchGzip(enable = true) {
this.fetchGzip = !!enable;
}

loadScene(imageDataJSON) {
if (imageDataJSON.processed) {
if (this.currentImageData !== imageDataJSON.processed) {
this.currentImageData = imageDataJSON.processed;
this.geometryReady(this.currentImageData);
}
} else {
const urls = [];
this.dataMapping = {};
if (imageDataJSON) {
['pointData', 'cellData'].forEach((location) => {
if (
imageDataJSON[location] &&
imageDataJSON[location].arrays &&
imageDataJSON[location].arrays.length
) {
imageDataJSON[location].arrays.forEach((dataArray) => {
let url = `${this.basepath}${dataArray.data.ref.basepath}/${
dataArray.data.ref.id
}`;
if (this.fetchGzip) {
url += '.gz';
}
urls.push(url);
this.dataMapping[url] = Object.assign(
{ location, url },
dataArray.data
);
});

// Clear array container
imageDataJSON[location].arrays = [];
}
});

// Create image data
this.currentImageData = vtk(imageDataJSON);
imageDataJSON.processed = this.currentImageData;

// Make the requests
urls.forEach((urlToFecth) => {
dataManager.fetchURL(urlToFecth, 'array', null, this.id);
});
}
}
}
}

// Add Observer pattern using Monologue.js
Monologue.mixInto(VTKImageDataModel);