src/image/labelingThread.jsjavascript
import {ThreadPool, WorkerTask} from '../utils/thread.js';
/**
* @import {Geometry} from './geometry.js';
* @import {Size} from './size.js';
* @import {Spacing} from './spacing.js';
* @import {TypedArray} from '../math/types.js';
*/
/**
* Generate a worker message with geometry metadata only.
*
* @param {Size} imageSize The image size.
* @param {Spacing} imageSpacing The image spacing.
*
* @returns {object} The geometry part of a worker message.
*/
export function generateGeometryMessage(imageSize, imageSpacing) {
// We can't pass these metadata objects directly, so we will just
// pull out what we need and pass that.
const ndims = imageSize.length();
// Cache the unit vector offsets to make a couple calculations faster.
const unitVectors = Array(ndims).fill(0);
for (let d = 0; d < ndims; d++) {
unitVectors[d] = imageSize.getDimSize(d);
}
const sizes = Array(ndims).fill(0);
for (let d = 0; d < ndims; d++) {
sizes[d] = imageSize.get(d);
}
return {
unitVectors,
sizes,
spacing: imageSpacing.getValues(),
totalSize: imageSize.getTotalSize()
};
}
/**
* Generate a worker message to send to the labeling worker.
*
* @param {TypedArray} imageBuffer The buffer to label.
* @param {Geometry} imageGeometry The image geometry.
*
* @returns {object} The message to send to the worker.
*/
export function generateWorkerMessage(imageBuffer, imageGeometry) {
return {
imageBuffer,
...generateGeometryMessage(
imageGeometry.getSize(), imageGeometry.getSpacing()
)
};
}
/**
* Labeling worker task.
*/
class LabelingWorkerTask extends WorkerTask {
getWorker() {
return new Worker(
new URL('./labeling.worker.js', import.meta.url),
{
name: 'labeling.worker'
}
);
}
}
/**
* Labeling thread.
*/
export class LabelingThread {
/**
* The thread pool.
*
* @type {ThreadPool}
*/
#threadPool = new ThreadPool(5);
constructor() {
this.#threadPool.onerror = ((e) => {
console.error('Labeling failed!', e.error);
});
}
/**
* Trigger a labels recalculation.
*
* @param {TypedArray} imageBuffer The buffer to label.
* @param {Geometry} geometry The image geometry.
*/
run(imageBuffer, geometry) {
// We can't just pass in an Image or we would get a circular dependency
this.#threadPool.onworkitem = this.ondone;
this.#threadPool.onwork = () => {};
const workerTask = new LabelingWorkerTask(
generateWorkerMessage(imageBuffer, geometry),
{}
);
// add it the queue and run it
this.#threadPool.addWorkerTask(workerTask);
}
/**
* Trigger a labels recalculation for overlapping segments.
* Spawns one worker task per segment for parallel execution.
*
* @param {Array.<{segNumber: number, size: Size,
* slices: Array.<{sliceIndex: number, data: Uint8Array}>,
* minSlice: number}>} segments Per-segment raw slice
* data with local (0-based) slice indices and the global minSlice offset.
* @param {Geometry} geometry The full image geometry.
*/
runOverlap(segments, geometry) {
const allLabels = [];
const minSliceBySegNumber = new Map(
segments.map(({segNumber, minSlice}) => [segNumber, minSlice ?? 0])
);
this.#threadPool.onworkitem = (event) => {
for (const label of event.data.labels) {
const sliceOffset = minSliceBySegNumber.get(label.id) ?? 0;
label.centroidIndex[2] += sliceOffset;
label.largestSliceZ += sliceOffset;
label.minZ += sliceOffset;
label.maxZ += sliceOffset;
}
allLabels.push(...event.data.labels);
};
this.#threadPool.onwork = () => {
this.ondone({data: {labels: allLabels}});
};
for (const {segNumber, size, slices} of segments) {
const geoMsg = generateGeometryMessage(size, geometry.getSpacing());
this.#threadPool.addWorkerTask(new LabelingWorkerTask(
{segmentSlice: {segNumber, slices}, ...geoMsg},
{}
));
}
}
/**
* Handle a completed labeling. Default behavior is do nothing,
* this is meant to be overridden.
*
* @param {object} _event The work item event fired when a labeling
* calculation is completed. Event.data should contain a 'labels' item.
*/
ondone(_event) {}
}