@cornerstonejs/tools 5.18.1 → 5.18.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/esm/stateManagement/segmentation/helpers/labelmapImageMapperSupport.js +3 -1
- package/dist/esm/tools/displayTools/Labelmap/volumeLabelmapImageMapper.js +20 -7
- package/dist/esm/tools/displayTools/Labelmap/volumeLabelmapResampledSliceData.d.ts +23 -0
- package/dist/esm/tools/displayTools/Labelmap/volumeLabelmapResampledSliceData.js +216 -0
- package/dist/esm/tools/displayTools/Labelmap/volumeLabelmapSliceData.d.ts +12 -5
- package/dist/esm/tools/displayTools/Labelmap/volumeLabelmapSliceData.js +4 -9
- package/dist/esm/version.d.ts +1 -1
- package/dist/esm/version.js +1 -1
- package/package.json +3 -3
|
@@ -200,7 +200,9 @@ export function getVolumeViewportLabelmapImageMapperState(viewport) {
|
|
|
200
200
|
const slabThickness = getCompatibilitySlabThickness(viewport);
|
|
201
201
|
const orientationKey = [
|
|
202
202
|
normalizedNormal.map((value) => value.toFixed(3)).join(','),
|
|
203
|
-
|
|
203
|
+
...(isLegacyVolumeViewport
|
|
204
|
+
? [normalizedViewUp.map((value) => value.toFixed(3)).join(',')]
|
|
205
|
+
: []),
|
|
204
206
|
].join('|');
|
|
205
207
|
if (isLegacyVolumeViewport && !isSupportedImageMapperBlendMode(blendMode)) {
|
|
206
208
|
return {
|
|
@@ -5,6 +5,7 @@ import { canRenderVolumeViewportLabelmapAsImage } from '../../../stateManagement
|
|
|
5
5
|
import { getLabelmap, getOrCreateLabelmapVolume, getLabelmaps, getLabelmapForImageId, getLabelmapForVolumeId, } from '../../../stateManagement/segmentation/helpers/labelmapSegmentationState.js';
|
|
6
6
|
import { createLabelmapRepresentationUID, isLabelmapRepresentationUID, } from './labelmapRepresentationUID.js';
|
|
7
7
|
import { applyPlanarOverlayDepthOffset, createSliceImageData, getSliceRenderingCamera, getSliceState, } from './volumeLabelmapSliceData.js';
|
|
8
|
+
import { canCreateResampledSliceImageData, createPlanarSliceImageData, } from './volumeLabelmapResampledSliceData.js';
|
|
8
9
|
const OVERLAY_RENDERER_SUFFIX = 'labelmap-image-mapper-overlay';
|
|
9
10
|
function isPlanarSliceRenderingViewport(viewport) {
|
|
10
11
|
const compatibilityViewport = viewport;
|
|
@@ -70,20 +71,32 @@ export function getVolumeLabelmapImageMapperRepresentationUIDs(viewport, segment
|
|
|
70
71
|
return [];
|
|
71
72
|
}
|
|
72
73
|
const useStablePlanarUID = isPlanarSliceRenderingViewport(viewport);
|
|
74
|
+
const sliceViewport = viewport;
|
|
75
|
+
const camera = getSliceRenderingCamera(sliceViewport);
|
|
73
76
|
return getLabelmaps(segmentation)
|
|
74
77
|
.map((layer) => {
|
|
75
78
|
const volume = getOrCreateLabelmapVolume(layer);
|
|
76
79
|
if (!volume) {
|
|
77
80
|
return;
|
|
78
81
|
}
|
|
79
|
-
const state = getSliceState(
|
|
82
|
+
const state = getSliceState(sliceViewport, volume, camera);
|
|
83
|
+
if (useStablePlanarUID) {
|
|
84
|
+
const canShowSlice = !!state ||
|
|
85
|
+
canCreateResampledSliceImageData(volume, sliceViewport, camera);
|
|
86
|
+
return canShowSlice
|
|
87
|
+
? createLabelmapRepresentationUID({
|
|
88
|
+
segmentationId,
|
|
89
|
+
referencedId: layer.labelmapId,
|
|
90
|
+
})
|
|
91
|
+
: undefined;
|
|
92
|
+
}
|
|
80
93
|
if (!state) {
|
|
81
94
|
return;
|
|
82
95
|
}
|
|
83
96
|
return createLabelmapRepresentationUID({
|
|
84
97
|
segmentationId,
|
|
85
98
|
referencedId: layer.labelmapId,
|
|
86
|
-
|
|
99
|
+
sliceStateKey: state.key,
|
|
87
100
|
});
|
|
88
101
|
})
|
|
89
102
|
.filter((value) => !!value);
|
|
@@ -194,17 +207,18 @@ export function getLabelmapForActorReference(segmentation, referencedId) {
|
|
|
194
207
|
}
|
|
195
208
|
async function addPlanarLabelmapImageMapperActors(args) {
|
|
196
209
|
const { viewport, segmentation, segmentationId } = args;
|
|
210
|
+
const camera = getSliceRenderingCamera(viewport);
|
|
197
211
|
for (const [index, layer] of getLabelmaps(segmentation).entries()) {
|
|
198
212
|
const volume = getOrCreateLabelmapVolume(layer);
|
|
199
213
|
if (!volume) {
|
|
200
214
|
continue;
|
|
201
215
|
}
|
|
202
|
-
const sliceData =
|
|
216
|
+
const sliceData = createPlanarSliceImageData(volume, viewport, camera);
|
|
203
217
|
if (!sliceData) {
|
|
204
218
|
continue;
|
|
205
219
|
}
|
|
206
220
|
const currentImageId = viewport.getCurrentImageId() ??
|
|
207
|
-
volume.imageIds[Math.min(Math.max(sliceData.
|
|
221
|
+
volume.imageIds[Math.min(Math.max(sliceData.sliceIndex, 0), Math.max(volume.imageIds.length - 1, 0))];
|
|
208
222
|
if (!currentImageId) {
|
|
209
223
|
continue;
|
|
210
224
|
}
|
|
@@ -227,7 +241,6 @@ async function addPlanarLabelmapImageMapperActors(args) {
|
|
|
227
241
|
excludeFromFidelity: true,
|
|
228
242
|
callback: ({ imageActor }) => {
|
|
229
243
|
const mapper = imageActor.getMapper();
|
|
230
|
-
const camera = getSliceRenderingCamera(viewport);
|
|
231
244
|
mapper.setInputData(sliceData.imageData);
|
|
232
245
|
mapper.modified();
|
|
233
246
|
if (camera) {
|
|
@@ -244,6 +257,7 @@ function updatePlanarLabelmapImageMapperActors(args) {
|
|
|
244
257
|
const actorEntriesByLabelmapId = new Map((actorEntries ?? viewport.getActors())
|
|
245
258
|
.filter((actorEntry) => isLabelmapRepresentationUID(actorEntry.representationUID, segmentationId))
|
|
246
259
|
.map((actorEntry) => [actorEntry.referencedId, actorEntry]));
|
|
260
|
+
const camera = getSliceRenderingCamera(viewport);
|
|
247
261
|
getLabelmaps(segmentation).forEach((layer, index) => {
|
|
248
262
|
const actorEntry = actorEntriesByLabelmapId.get(layer.labelmapId);
|
|
249
263
|
if (!actorEntry) {
|
|
@@ -253,14 +267,13 @@ function updatePlanarLabelmapImageMapperActors(args) {
|
|
|
253
267
|
if (!volume) {
|
|
254
268
|
return;
|
|
255
269
|
}
|
|
256
|
-
const sliceData =
|
|
270
|
+
const sliceData = createPlanarSliceImageData(volume, viewport, camera);
|
|
257
271
|
if (!sliceData) {
|
|
258
272
|
return;
|
|
259
273
|
}
|
|
260
274
|
const mapper = actorEntry.actor.getMapper();
|
|
261
275
|
mapper.setInputData(sliceData.imageData);
|
|
262
276
|
mapper.modified();
|
|
263
|
-
const camera = getSliceRenderingCamera(viewport);
|
|
264
277
|
if (camera) {
|
|
265
278
|
applyPlanarOverlayDepthOffset(actorEntry.actor, camera.viewPlaneNormal, index + 1);
|
|
266
279
|
}
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
|
|
2
|
+
import { type Types } from '@cornerstonejs/core';
|
|
3
|
+
import { type SliceRenderingCamera, type SliceRenderingViewport } from './volumeLabelmapSliceData.js';
|
|
4
|
+
type ResampledSliceGeometry = {
|
|
5
|
+
origin: Types.Point3;
|
|
6
|
+
xDirection: Types.Point3;
|
|
7
|
+
yDirection: Types.Point3;
|
|
8
|
+
zDirection: Types.Point3;
|
|
9
|
+
spacing: Types.Point2;
|
|
10
|
+
width: number;
|
|
11
|
+
height: number;
|
|
12
|
+
sliceIndex: number;
|
|
13
|
+
};
|
|
14
|
+
type PlanarSliceImageData = {
|
|
15
|
+
imageData: vtkImageData;
|
|
16
|
+
sliceIndex: number;
|
|
17
|
+
};
|
|
18
|
+
declare function getResampledSliceGeometry(viewport: SliceRenderingViewport, volume: Types.IImageVolume, camera?: SliceRenderingCamera | undefined): ResampledSliceGeometry | undefined;
|
|
19
|
+
declare function createResampledSliceImageData(volume: Types.IImageVolume, viewport: SliceRenderingViewport, camera?: SliceRenderingCamera | undefined): PlanarSliceImageData | undefined;
|
|
20
|
+
declare function createPlanarSliceImageData(volume: Types.IImageVolume, viewport: SliceRenderingViewport, camera?: SliceRenderingCamera | undefined): PlanarSliceImageData | undefined;
|
|
21
|
+
declare function canCreateResampledSliceImageData(volume: Types.IImageVolume, viewport: SliceRenderingViewport, camera?: SliceRenderingCamera | undefined): boolean;
|
|
22
|
+
export { canCreateResampledSliceImageData, createPlanarSliceImageData, createResampledSliceImageData, getResampledSliceGeometry, };
|
|
23
|
+
export type { PlanarSliceImageData, ResampledSliceGeometry };
|
|
@@ -0,0 +1,216 @@
|
|
|
1
|
+
import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray.js';
|
|
2
|
+
import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData.js';
|
|
3
|
+
import { Enums, utilities } from '@cornerstonejs/core';
|
|
4
|
+
import { vec3 } from 'gl-matrix';
|
|
5
|
+
import { createSliceImageData, getSliceRenderingCamera, getVolumeAxes, matchAxis, } from './volumeLabelmapSliceData.js';
|
|
6
|
+
const MAX_RESAMPLED_SLICE_SIZE = 2048;
|
|
7
|
+
const SLICE_INDEX_EPSILON = 1e-6;
|
|
8
|
+
const MINIMUM_PLANE_INTERSECTION_POINTS = 3;
|
|
9
|
+
const EXACT_SLICE_ALIGNMENT = 1 - 1e-8;
|
|
10
|
+
function createVector() {
|
|
11
|
+
return [0, 0, 0];
|
|
12
|
+
}
|
|
13
|
+
function getExactSliceAxis(volume, viewPlaneNormal) {
|
|
14
|
+
const axes = getVolumeAxes(volume);
|
|
15
|
+
const sliceAxis = matchAxis(viewPlaneNormal, axes);
|
|
16
|
+
if (!sliceAxis) {
|
|
17
|
+
return;
|
|
18
|
+
}
|
|
19
|
+
const axisDirection = axes[sliceAxis.axis];
|
|
20
|
+
const alignment = Math.abs(vec3.dot(viewPlaneNormal, axisDirection)) /
|
|
21
|
+
(vec3.length(viewPlaneNormal) *
|
|
22
|
+
vec3.length(axisDirection));
|
|
23
|
+
return alignment >= EXACT_SLICE_ALIGNMENT ? sliceAxis.axis : undefined;
|
|
24
|
+
}
|
|
25
|
+
function stepAlong(start, direction, distance) {
|
|
26
|
+
return vec3.scaleAndAdd(createVector(), start, direction, distance);
|
|
27
|
+
}
|
|
28
|
+
function getPlaneVolumeIntersectionPoints(volume, planePoint, planeNormal) {
|
|
29
|
+
const { dimensions, imageData } = volume;
|
|
30
|
+
const corners = [];
|
|
31
|
+
const distances = [];
|
|
32
|
+
for (let cornerIndex = 0; cornerIndex < 8; cornerIndex++) {
|
|
33
|
+
const corner = utilities.transformIndexToWorld(imageData, [
|
|
34
|
+
cornerIndex & 1 ? dimensions[0] - 0.5 : -0.5,
|
|
35
|
+
cornerIndex & 2 ? dimensions[1] - 0.5 : -0.5,
|
|
36
|
+
cornerIndex & 4 ? dimensions[2] - 0.5 : -0.5,
|
|
37
|
+
]);
|
|
38
|
+
corners.push(corner);
|
|
39
|
+
distances.push(vec3.dot(vec3.subtract(createVector(), corner, planePoint), planeNormal));
|
|
40
|
+
}
|
|
41
|
+
const points = [];
|
|
42
|
+
for (let cornerIndex = 0; cornerIndex < 8; cornerIndex++) {
|
|
43
|
+
for (let axisBit = 1; axisBit <= 4; axisBit <<= 1) {
|
|
44
|
+
if (cornerIndex & axisBit) {
|
|
45
|
+
continue;
|
|
46
|
+
}
|
|
47
|
+
const otherIndex = cornerIndex | axisBit;
|
|
48
|
+
const startDistance = distances[cornerIndex];
|
|
49
|
+
const endDistance = distances[otherIndex];
|
|
50
|
+
if (startDistance === 0) {
|
|
51
|
+
points.push(corners[cornerIndex]);
|
|
52
|
+
}
|
|
53
|
+
if (endDistance === 0) {
|
|
54
|
+
points.push(corners[otherIndex]);
|
|
55
|
+
}
|
|
56
|
+
if (startDistance * endDistance < 0) {
|
|
57
|
+
points.push(vec3.lerp(createVector(), corners[cornerIndex], corners[otherIndex], startDistance / (startDistance - endDistance)));
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
return points;
|
|
62
|
+
}
|
|
63
|
+
function getInPlaneRotatedSliceGeometry(volume, focalPoint, viewPlaneNormal, sliceAxis) {
|
|
64
|
+
const { dimensions, imageData, spacing } = volume;
|
|
65
|
+
const axes = getVolumeAxes(volume);
|
|
66
|
+
const continuousIndex = utilities.transformWorldToIndexContinuous(imageData, focalPoint);
|
|
67
|
+
const sliceIndex = Math.floor(continuousIndex[sliceAxis] + 0.5 - SLICE_INDEX_EPSILON);
|
|
68
|
+
if (sliceIndex < 0 || sliceIndex >= dimensions[sliceAxis]) {
|
|
69
|
+
return;
|
|
70
|
+
}
|
|
71
|
+
const [xAxis, yAxis] = [0, 1, 2].filter((axis) => axis !== sliceAxis);
|
|
72
|
+
const handedness = vec3.dot(vec3.cross(createVector(), axes[xAxis], axes[yAxis]), viewPlaneNormal);
|
|
73
|
+
const rowsFollowAxis = handedness < 0;
|
|
74
|
+
const originIndex = [0, 0, 0];
|
|
75
|
+
originIndex[sliceAxis] = sliceIndex;
|
|
76
|
+
originIndex[yAxis] = rowsFollowAxis ? 0 : dimensions[yAxis] - 1;
|
|
77
|
+
return {
|
|
78
|
+
origin: utilities.transformIndexToWorld(imageData, originIndex),
|
|
79
|
+
xDirection: axes[xAxis],
|
|
80
|
+
yDirection: rowsFollowAxis
|
|
81
|
+
? axes[yAxis]
|
|
82
|
+
: vec3.negate(createVector(), axes[yAxis]),
|
|
83
|
+
zDirection: viewPlaneNormal,
|
|
84
|
+
spacing: [spacing[xAxis], spacing[yAxis]],
|
|
85
|
+
width: dimensions[xAxis],
|
|
86
|
+
height: dimensions[yAxis],
|
|
87
|
+
sliceIndex,
|
|
88
|
+
};
|
|
89
|
+
}
|
|
90
|
+
function getObliqueSliceGeometry(volume, focalPoint, viewPlaneNormal) {
|
|
91
|
+
const { dimensions, imageData } = volume;
|
|
92
|
+
const sliceAxisDirection = getVolumeAxes(volume)[2];
|
|
93
|
+
const xDirection = vec3.normalize(createVector(), vec3.cross(createVector(), sliceAxisDirection, viewPlaneNormal));
|
|
94
|
+
const yDirection = vec3.normalize(createVector(), vec3.cross(createVector(), xDirection, viewPlaneNormal));
|
|
95
|
+
const points = getPlaneVolumeIntersectionPoints(volume, focalPoint, viewPlaneNormal);
|
|
96
|
+
if (points.length < MINIMUM_PLANE_INTERSECTION_POINTS) {
|
|
97
|
+
return;
|
|
98
|
+
}
|
|
99
|
+
const extent = {
|
|
100
|
+
minX: Infinity,
|
|
101
|
+
maxX: -Infinity,
|
|
102
|
+
minY: Infinity,
|
|
103
|
+
maxY: -Infinity,
|
|
104
|
+
};
|
|
105
|
+
points.forEach((point) => {
|
|
106
|
+
const offset = vec3.subtract(createVector(), point, focalPoint);
|
|
107
|
+
const x = vec3.dot(offset, xDirection);
|
|
108
|
+
const y = vec3.dot(offset, yDirection);
|
|
109
|
+
extent.minX = Math.min(extent.minX, x);
|
|
110
|
+
extent.maxX = Math.max(extent.maxX, x);
|
|
111
|
+
extent.minY = Math.min(extent.minY, y);
|
|
112
|
+
extent.maxY = Math.max(extent.maxY, y);
|
|
113
|
+
});
|
|
114
|
+
const extentX = extent.maxX - extent.minX;
|
|
115
|
+
const extentY = extent.maxY - extent.minY;
|
|
116
|
+
const width = Math.min(MAX_RESAMPLED_SLICE_SIZE, Math.max(1, Math.ceil(extentX /
|
|
117
|
+
utilities.getEffectiveSpacingAlongDirection(volume, xDirection))));
|
|
118
|
+
const height = Math.min(MAX_RESAMPLED_SLICE_SIZE, Math.max(1, Math.ceil(extentY /
|
|
119
|
+
utilities.getEffectiveSpacingAlongDirection(volume, yDirection))));
|
|
120
|
+
const pixelSpacing = [extentX / width, extentY / height];
|
|
121
|
+
if (!(pixelSpacing[0] > 0) || !(pixelSpacing[1] > 0)) {
|
|
122
|
+
return;
|
|
123
|
+
}
|
|
124
|
+
const origin = stepAlong(stepAlong(focalPoint, xDirection, extent.minX + pixelSpacing[0] / 2), yDirection, extent.minY + pixelSpacing[1] / 2);
|
|
125
|
+
const continuousIndex = utilities.transformWorldToIndexContinuous(imageData, focalPoint);
|
|
126
|
+
return {
|
|
127
|
+
origin,
|
|
128
|
+
xDirection,
|
|
129
|
+
yDirection,
|
|
130
|
+
zDirection: viewPlaneNormal,
|
|
131
|
+
spacing: pixelSpacing,
|
|
132
|
+
width,
|
|
133
|
+
height,
|
|
134
|
+
sliceIndex: Math.min(Math.max(Math.round(continuousIndex[2]), 0), dimensions[2] - 1),
|
|
135
|
+
};
|
|
136
|
+
}
|
|
137
|
+
function getResampledSliceGeometry(viewport, volume, camera = getSliceRenderingCamera(viewport)) {
|
|
138
|
+
if (!camera) {
|
|
139
|
+
return;
|
|
140
|
+
}
|
|
141
|
+
const viewPlaneNormal = vec3.normalize(createVector(), camera.viewPlaneNormal);
|
|
142
|
+
const sliceAxis = getExactSliceAxis(volume, viewPlaneNormal);
|
|
143
|
+
if (sliceAxis !== undefined) {
|
|
144
|
+
return getInPlaneRotatedSliceGeometry(volume, camera.focalPoint, viewPlaneNormal, sliceAxis);
|
|
145
|
+
}
|
|
146
|
+
return getObliqueSliceGeometry(volume, camera.focalPoint, viewPlaneNormal);
|
|
147
|
+
}
|
|
148
|
+
function sampleResampledSlice(volume, geometry) {
|
|
149
|
+
const { imageData, voxelManager } = volume;
|
|
150
|
+
const { origin, xDirection, yDirection, spacing, width, height } = geometry;
|
|
151
|
+
const SliceDataConstructor = voxelManager.getConstructor();
|
|
152
|
+
const pixelData = new SliceDataConstructor(width * height);
|
|
153
|
+
const startIndex = utilities.transformWorldToIndexContinuous(imageData, origin);
|
|
154
|
+
const afterColumn = utilities.transformWorldToIndexContinuous(imageData, stepAlong(origin, xDirection, spacing[0]));
|
|
155
|
+
const afterRow = utilities.transformWorldToIndexContinuous(imageData, stepAlong(origin, yDirection, spacing[1]));
|
|
156
|
+
utilities.sampleVolumeGrid({
|
|
157
|
+
volume,
|
|
158
|
+
pixelData,
|
|
159
|
+
width,
|
|
160
|
+
height,
|
|
161
|
+
startIndex,
|
|
162
|
+
columnStep: [0, 1, 2].map((axis) => afterColumn[axis] - startIndex[axis]),
|
|
163
|
+
rowStep: [0, 1, 2].map((axis) => afterRow[axis] - startIndex[axis]),
|
|
164
|
+
interpolationType: Enums.InterpolationType.NEAREST,
|
|
165
|
+
});
|
|
166
|
+
return pixelData;
|
|
167
|
+
}
|
|
168
|
+
function createResampledSliceImageData(volume, viewport, camera = getSliceRenderingCamera(viewport)) {
|
|
169
|
+
const geometry = getResampledSliceGeometry(viewport, volume, camera);
|
|
170
|
+
if (!geometry) {
|
|
171
|
+
return;
|
|
172
|
+
}
|
|
173
|
+
const pixelData = sampleResampledSlice(volume, geometry);
|
|
174
|
+
const dataType = vtkDataArray.getDataType(pixelData);
|
|
175
|
+
const scalarArray = vtkDataArray.newInstance({
|
|
176
|
+
dataType,
|
|
177
|
+
name: 'Pixels',
|
|
178
|
+
numberOfComponents: 1,
|
|
179
|
+
values: pixelData,
|
|
180
|
+
});
|
|
181
|
+
const imageData = vtkImageData.newInstance();
|
|
182
|
+
imageData.set({ dataType, numberOfComponents: 1 }, true);
|
|
183
|
+
imageData.setDimensions(geometry.width, geometry.height, 1);
|
|
184
|
+
imageData.setSpacing([geometry.spacing[0], geometry.spacing[1], 1]);
|
|
185
|
+
imageData.setDirection(new Float32Array([
|
|
186
|
+
...geometry.xDirection,
|
|
187
|
+
...geometry.yDirection,
|
|
188
|
+
...geometry.zDirection,
|
|
189
|
+
]));
|
|
190
|
+
imageData.setOrigin(geometry.origin);
|
|
191
|
+
imageData.getPointData().setScalars(scalarArray);
|
|
192
|
+
imageData.modified();
|
|
193
|
+
return {
|
|
194
|
+
imageData,
|
|
195
|
+
sliceIndex: geometry.sliceIndex,
|
|
196
|
+
};
|
|
197
|
+
}
|
|
198
|
+
function createPlanarSliceImageData(volume, viewport, camera = getSliceRenderingCamera(viewport)) {
|
|
199
|
+
if (!camera) {
|
|
200
|
+
return;
|
|
201
|
+
}
|
|
202
|
+
const alignedSlice = getExactSliceAxis(volume, camera.viewPlaneNormal) !== undefined
|
|
203
|
+
? createSliceImageData(volume, viewport, camera)
|
|
204
|
+
: undefined;
|
|
205
|
+
if (alignedSlice) {
|
|
206
|
+
return {
|
|
207
|
+
imageData: alignedSlice.imageData,
|
|
208
|
+
sliceIndex: alignedSlice.state.sliceIndex,
|
|
209
|
+
};
|
|
210
|
+
}
|
|
211
|
+
return createResampledSliceImageData(volume, viewport, camera);
|
|
212
|
+
}
|
|
213
|
+
function canCreateResampledSliceImageData(volume, viewport, camera = getSliceRenderingCamera(viewport)) {
|
|
214
|
+
return !!getResampledSliceGeometry(viewport, volume, camera);
|
|
215
|
+
}
|
|
216
|
+
export { canCreateResampledSliceImageData, createPlanarSliceImageData, createResampledSliceImageData, getResampledSliceGeometry, };
|
|
@@ -1,6 +1,10 @@
|
|
|
1
1
|
import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
|
|
2
2
|
import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
|
|
3
3
|
import { type Types } from '@cornerstonejs/core';
|
|
4
|
+
type AxisMatch = {
|
|
5
|
+
axis: number;
|
|
6
|
+
sign: 1 | -1;
|
|
7
|
+
};
|
|
4
8
|
type ImageMapperSliceState = {
|
|
5
9
|
key: string;
|
|
6
10
|
xAxis: number;
|
|
@@ -17,11 +21,14 @@ type SliceRenderingViewport = Types.IViewport & {
|
|
|
17
21
|
} | undefined;
|
|
18
22
|
};
|
|
19
23
|
declare function applyPlanarOverlayDepthOffset(actor: vtkImageSlice, viewPlaneNormal: Types.Point3, overlayOrder: number): void;
|
|
20
|
-
declare function
|
|
21
|
-
|
|
22
|
-
declare function
|
|
24
|
+
declare function matchAxis(vector: Types.Point3, axes: Types.Point3[]): AxisMatch | undefined;
|
|
25
|
+
type SliceRenderingCamera = Pick<Types.ICamera, 'focalPoint' | 'viewPlaneNormal' | 'viewUp'>;
|
|
26
|
+
declare function getSliceRenderingCamera(viewport: SliceRenderingViewport): SliceRenderingCamera | undefined;
|
|
27
|
+
declare function getVolumeAxes(volume: Types.IImageVolume): Types.Point3[];
|
|
28
|
+
declare function getSliceState(viewport: SliceRenderingViewport, volume: Types.IImageVolume, camera?: SliceRenderingCamera): ImageMapperSliceState | undefined;
|
|
29
|
+
declare function createSliceImageData(volume: Types.IImageVolume, viewport: SliceRenderingViewport, camera?: SliceRenderingCamera): {
|
|
23
30
|
imageData: vtkImageData;
|
|
24
31
|
state: ImageMapperSliceState;
|
|
25
32
|
} | undefined;
|
|
26
|
-
export { applyPlanarOverlayDepthOffset, createSliceImageData, getSliceRenderingCamera, getSliceState, };
|
|
27
|
-
export type { ImageMapperSliceState, SliceRenderingViewport };
|
|
33
|
+
export { applyPlanarOverlayDepthOffset, createSliceImageData, getSliceRenderingCamera, getSliceState, getVolumeAxes, matchAxis, };
|
|
34
|
+
export type { ImageMapperSliceState, SliceRenderingCamera, SliceRenderingViewport, };
|
|
@@ -79,8 +79,7 @@ function getVolumeAxes(volume) {
|
|
|
79
79
|
[direction[6], direction[7], direction[8]],
|
|
80
80
|
];
|
|
81
81
|
}
|
|
82
|
-
function getSliceState(viewport, volume) {
|
|
83
|
-
const camera = getSliceRenderingCamera(viewport);
|
|
82
|
+
function getSliceState(viewport, volume, camera = getSliceRenderingCamera(viewport)) {
|
|
84
83
|
if (!camera) {
|
|
85
84
|
return;
|
|
86
85
|
}
|
|
@@ -120,8 +119,8 @@ function getSliceState(viewport, volume) {
|
|
|
120
119
|
sliceIndex,
|
|
121
120
|
};
|
|
122
121
|
}
|
|
123
|
-
function createSliceImageData(volume, viewport) {
|
|
124
|
-
const state = getSliceState(viewport, volume);
|
|
122
|
+
function createSliceImageData(volume, viewport, camera = getSliceRenderingCamera(viewport)) {
|
|
123
|
+
const state = camera && getSliceState(viewport, volume, camera);
|
|
125
124
|
if (!state) {
|
|
126
125
|
return;
|
|
127
126
|
}
|
|
@@ -151,10 +150,6 @@ function createSliceImageData(volume, viewport) {
|
|
|
151
150
|
originIndex[state.yAxis] = state.ySign > 0 ? 0 : height - 1;
|
|
152
151
|
const xDirection = axisVectors[state.xAxis].map((value) => value * state.xSign);
|
|
153
152
|
const yDirection = axisVectors[state.yAxis].map((value) => value * state.ySign);
|
|
154
|
-
const camera = getSliceRenderingCamera(viewport);
|
|
155
|
-
if (!camera) {
|
|
156
|
-
return;
|
|
157
|
-
}
|
|
158
153
|
const zDirection = vec3.normalize(vec3.create(), camera.viewPlaneNormal);
|
|
159
154
|
const dataType = vtkDataArray.getDataType(pixelData);
|
|
160
155
|
const scalarArray = vtkDataArray.newInstance({
|
|
@@ -182,4 +177,4 @@ function createSliceImageData(volume, viewport) {
|
|
|
182
177
|
state,
|
|
183
178
|
};
|
|
184
179
|
}
|
|
185
|
-
export { applyPlanarOverlayDepthOffset, createSliceImageData, getSliceRenderingCamera, getSliceState, };
|
|
180
|
+
export { applyPlanarOverlayDepthOffset, createSliceImageData, getSliceRenderingCamera, getSliceState, getVolumeAxes, matchAxis, };
|
package/dist/esm/version.d.ts
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
export declare const version = "5.18.
|
|
1
|
+
export declare const version = "5.18.3";
|
package/dist/esm/version.js
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
export const version = '5.18.
|
|
1
|
+
export const version = '5.18.3';
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@cornerstonejs/tools",
|
|
3
|
-
"version": "5.18.
|
|
3
|
+
"version": "5.18.3",
|
|
4
4
|
"description": "Cornerstone3D Tools",
|
|
5
5
|
"types": "./dist/esm/index.d.ts",
|
|
6
6
|
"module": "./dist/esm/index.js",
|
|
@@ -126,11 +126,11 @@
|
|
|
126
126
|
"lodash.get": "4.4.2"
|
|
127
127
|
},
|
|
128
128
|
"devDependencies": {
|
|
129
|
-
"@cornerstonejs/core": "5.18.
|
|
129
|
+
"@cornerstonejs/core": "5.18.3",
|
|
130
130
|
"canvas": "3.2.0"
|
|
131
131
|
},
|
|
132
132
|
"peerDependencies": {
|
|
133
|
-
"@cornerstonejs/core": "5.18.
|
|
133
|
+
"@cornerstonejs/core": "5.18.3",
|
|
134
134
|
"@kitware/vtk.js": "36.4.1",
|
|
135
135
|
"@types/d3-array": "3.2.1",
|
|
136
136
|
"@types/d3-interpolate": "3.0.4",
|