Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | import { Events, ImageQualityStatus } from '../../enums';
import eventTarget from '../../eventTarget';
import type {
IDynamicImageVolume,
ImageVolumeProps,
IStreamingVolumeProperties,
} from '../../types';
import { triggerEvent } from '../../utilities';
import BaseStreamingImageVolume from './BaseStreamingImageVolume';
/**
* Streaming Image Volume Class that extends StreamingImageVolume base class.
* It implements load method to load the imageIds and insert them into the volume.
*/
export default class StreamingDynamicImageVolume
extends BaseStreamingImageVolume
implements IDynamicImageVolume
{
private _dimensionGroupNumber = 1;
private _splittingTag: string;
private _imageIdGroups: string[][];
private _loadedDimensionGroups: Set<number> = new Set();
public numDimensionGroups: number;
constructor(
imageVolumeProperties: ImageVolumeProps & {
splittingTag: string;
imageIdGroups: string[][];
},
streamingProperties: IStreamingVolumeProperties
) {
super(imageVolumeProperties, streamingProperties);
const { imageIdGroups, splittingTag } = imageVolumeProperties;
this._splittingTag = splittingTag;
this._imageIdGroups = imageIdGroups;
this.numDimensionGroups = this._imageIdGroups.length;
}
private _getImageIdsToLoad(): string[] {
const imageIdGroups = this._imageIdGroups;
const initialImageIdGroupIndex = this._dimensionGroupNumber - 1;
const imageIds = [...imageIdGroups[initialImageIdGroupIndex]];
let leftIndex = initialImageIdGroupIndex - 1;
let rightIndex = initialImageIdGroupIndex + 1;
while (leftIndex >= 0 || rightIndex < imageIdGroups.length) {
if (leftIndex >= 0) {
imageIds.push(...imageIdGroups[leftIndex--]);
}
if (rightIndex < imageIdGroups.length) {
imageIds.push(...imageIdGroups[rightIndex++]);
}
}
return imageIds;
}
private _getImageIdRequests = (imageIds, priority: number) => {
return this.getImageIdsRequests(imageIds, priority);
};
public getImageIdsToLoad(): string[] {
return this._getImageIdsToLoad();
}
/**
* Returns the active dimension group number (1-based)
* @returns active dimension group number
*/
public get dimensionGroupNumber(): number {
return this._dimensionGroupNumber;
}
/**
* Set the active dimension group number which also updates the active scalar data
* Dimension group numbers are 1-based.
*
* @param dimensionGroupNumber - The dimension group number to set as active (1-based)
*/
public set dimensionGroupNumber(dimensionGroupNumber: number) {
if (this._dimensionGroupNumber === dimensionGroupNumber) {
return;
}
this._dimensionGroupNumber = dimensionGroupNumber;
// @ts-expect-error
this.voxelManager.setDimensionGroupNumber(dimensionGroupNumber);
this.invalidateVolume(true);
triggerEvent(eventTarget, Events.DYNAMIC_VOLUME_DIMENSION_GROUP_CHANGED, {
volumeId: this.volumeId,
dimensionGroupNumber: dimensionGroupNumber,
numDimensionGroups: this.numDimensionGroups,
imageIdGroupIndex: dimensionGroupNumber - 1,
numImageIdGroups: this.numDimensionGroups,
splittingTag: this.splittingTag,
});
}
/**
* Scroll properly to enable looping
* @param delta - The amount to scroll
*/
public scroll(delta: number): void {
const newDimensionGroupNumber = this._dimensionGroupNumber + delta;
if (newDimensionGroupNumber < 1) {
this.dimensionGroupNumber = this.numDimensionGroups;
} else if (newDimensionGroupNumber > this.numDimensionGroups) {
this.dimensionGroupNumber = 1;
} else {
this.dimensionGroupNumber = newDimensionGroupNumber;
}
}
public getCurrentDimensionGroupImageIds(): string[] {
return this._imageIdGroups[this._dimensionGroupNumber - 1];
}
public flatImageIdIndexToDimensionGroupNumber(
flatImageIdIndex: number
): number {
return Math.floor(flatImageIdIndex / this._imageIdGroups[0].length) + 1;
}
public flatImageIdIndexToImageIdIndex(flatImageIdIndex: number): number {
return flatImageIdIndex % this._imageIdGroups[0].length;
}
/**
* Returns the splitting tag used to split the imageIds in the volume
*/
public get splittingTag(): string {
return this._splittingTag;
}
/**
* It returns the imageLoad requests for the streaming image volume instance.
* It involves getting all the imageIds of the volume and creating a success callback
* which would update the texture (when the image has loaded) and the failure callback.
* Note that this method does not execute the requests but only returns the requests.
* It can be used for sorting requests outside of the volume loader itself
* e.g. loading a single slice of CT, followed by a single slice of PET (interleaved), before
* moving to the next slice.
*
* @returns Array of requests including imageId of the request, its imageIdIndex,
* options (targetBuffer and scaling parameters), and additionalDetails (volumeId)
*/
public getImageLoadRequests = (priority: number) => {
const imageIds = this.getImageIdsToLoad();
return this._getImageIdRequests(imageIds, priority);
};
/**
* Checks if a specific dimension group is fully loaded
* @param dimensionGroupNumber - The dimension group number to check (1-based)
* @returns boolean indicating if the dimension group is fully loaded
*/
public isDimensionGroupLoaded(dimensionGroupNumber: number): boolean {
return this._loadedDimensionGroups.has(dimensionGroupNumber);
}
/**
* Marks a dimension group as fully loaded
* @param dimensionGroupNumber - The dimension group number to mark as loaded (1-based)
*/
private markDimensionGroupAsLoaded(dimensionGroupNumber: number): void {
this._loadedDimensionGroups.add(dimensionGroupNumber);
// Trigger new dimension group-based event
triggerEvent(eventTarget, Events.DYNAMIC_VOLUME_DIMENSION_GROUP_LOADED, {
volumeId: this.volumeId,
dimensionGroupNumber: dimensionGroupNumber,
});
}
protected checkDimensionGroupCompletion(imageIdIndex: number): void {
const dimensionGroupNumber =
this.flatImageIdIndexToDimensionGroupNumber(imageIdIndex);
const imageIdsInDimensionGroup =
this._imageIdGroups[dimensionGroupNumber - 1];
const allLoaded = imageIdsInDimensionGroup.every((imageId) => {
const index = this.getImageIdIndex(imageId);
return this.cachedFrames[index] === ImageQualityStatus.FULL_RESOLUTION;
});
if (allLoaded && !this.isDimensionGroupLoaded(dimensionGroupNumber)) {
this.markDimensionGroupAsLoaded(dimensionGroupNumber);
}
}
}
|