@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.
@@ -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
- normalizedViewUp.map((value) => value.toFixed(3)).join(','),
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(viewport, volume);
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
- ...(useStablePlanarUID ? {} : { sliceStateKey: state.key }),
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 = createSliceImageData(volume, viewport);
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.state.sliceIndex, 0), Math.max(volume.imageIds.length - 1, 0))];
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 = createSliceImageData(volume, viewport);
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 getSliceRenderingCamera(viewport: SliceRenderingViewport): Pick<Types.ICamera, 'focalPoint' | 'viewPlaneNormal' | 'viewUp'> | undefined;
21
- declare function getSliceState(viewport: SliceRenderingViewport, volume: Types.IImageVolume): ImageMapperSliceState | undefined;
22
- declare function createSliceImageData(volume: Types.IImageVolume, viewport: SliceRenderingViewport): {
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, };
@@ -1 +1 @@
1
- export declare const version = "5.18.1";
1
+ export declare const version = "5.18.3";
@@ -1 +1 @@
1
- export const version = '5.18.1';
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.1",
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.1",
129
+ "@cornerstonejs/core": "5.18.3",
130
130
  "canvas": "3.2.0"
131
131
  },
132
132
  "peerDependencies": {
133
- "@cornerstonejs/core": "5.18.1",
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",