All files / extensions/default/src/utils layerConfigurationUtils.ts

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
34x
34x
34x
34x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
export const DERIVED_OVERLAY_MODALITIES = ['SEG', 'RTSTRUCT'];
export const DEFAULT_COLORMAP = 'hsv';
export const DEFAULT_OPACITY = 0.9;
export const DEFAULT_OPACITY_PERCENT = DEFAULT_OPACITY * 100;
 
/**
 * Get modality-specific color and opacity settings from the customization service
 */
export function getModalityOverlayColormap(customizationService, modality) {
  const modalityOverlayDefaultColorMaps = customizationService?.getCustomization(
    'cornerstone.modalityOverlayDefaultColorMaps'
  ) || { defaultSettings: {} };
 
  return (
    modalityOverlayDefaultColorMaps.defaultSettings[modality] || {
      colormap: DEFAULT_COLORMAP,
      opacity: DEFAULT_OPACITY,
    }
  );
}
 
/**
 * Create display set options based on modality and opacity settings
 */
export function createColormapOverlayDisplaySetOptions(displaySet, opacity, customizationService) {
  Iif (displaySet.Modality === 'SEG') {
    return {};
  }
 
  const modalitySettings = getModalityOverlayColormap(customizationService, displaySet.Modality);
  return {
    colormap: {
      name: modalitySettings.colormap || DEFAULT_COLORMAP,
      opacity: opacity / 100, // Convert from percentage to 0-1 range
    },
  };
}
 
/**
 * Configure viewport for adding a display set layer
 */
export function configureViewportForLayerAddition(params: {
  viewport: any;
  displaySetInstanceUID: string;
  currentDisplaySetUIDs: string[];
  servicesManager: AppTypes.ServicesManager;
}): any {
  const { viewport, displaySetInstanceUID, currentDisplaySetUIDs, servicesManager } = params;
  const { cornerstoneViewportService, displaySetService, customizationService } =
    servicesManager.services;
 
  const { viewportId } = viewport;
 
  // Set the display set UIDs for the viewport
  const allDisplaySetInstanceUIDs = [...currentDisplaySetUIDs, displaySetInstanceUID];
  viewport.displaySetInstanceUIDs = allDisplaySetInstanceUIDs;
 
  Iif (!viewport.viewportOptions) {
    viewport.viewportOptions = {};
  }
 
  const requestedLayerDisplaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
 
  Iif (!viewport.viewportOptions.orientation) {
    viewport.viewportOptions.orientation = cornerstoneViewportService.getOrientation(viewportId);
  }
 
  // Do not force volume for SEG and RTSTRUCT if there is only one display set
  if (requestedLayerDisplaySet.isOverlayDisplaySet && currentDisplaySetUIDs.length === 1) {
    viewport.viewportOptions.viewportType = 'stack';
  } else {
    viewport.viewportOptions.viewportType = 'volume';
  }
 
  // create same amount of display set options as the number of display set UIDs
  const displaySetOptions = allDisplaySetInstanceUIDs.map((uid, index) => {
    Iif (index === 0) {
      // no colormap for background
      return {};
    }
 
    const displaySet = displaySetService.getDisplaySetByUID(uid);
    return createColormapOverlayDisplaySetOptions(displaySet, 90, customizationService);
  });
 
  viewport.displaySetOptions = displaySetOptions;
 
  return viewport;
}
 
/**
 * Configure viewport for removing a display set layer
 */
export function configureViewportForLayerRemoval(params: {
  viewport: any;
  displaySetInstanceUID: string;
  currentDisplaySetUIDs: string[];
  servicesManager: AppTypes.ServicesManager;
}): any {
  const { viewport, displaySetInstanceUID, currentDisplaySetUIDs, servicesManager } = params;
  const { cornerstoneViewportService, displaySetService } = servicesManager.services;
 
  const { viewportId } = viewport;
 
  // Filter out the display set to remove
  viewport.displaySetInstanceUIDs = currentDisplaySetUIDs.filter(
    uid => uid !== displaySetInstanceUID
  );
 
  Iif (!viewport.viewportOptions) {
    viewport.viewportOptions = {};
  }
 
  viewport.viewportOptions.viewportType = 'volume';
 
  // orientation
  Iif (!viewport.viewportOptions.orientation) {
    viewport.viewportOptions.orientation = cornerstoneViewportService.getOrientation(viewportId);
  }
 
  // Recreate the display set options
  viewport.displaySetOptions = viewport.displaySetInstanceUIDs.map(() => {
    // For simplicity, we're returning empty options for now
    // In a more complete implementation, we would need to preserve existing display set options
    return {};
  });
 
  return viewport;
}
 
/**
 * Check if a display set can be added as a layer to the specified viewport
 */
export function canAddDisplaySetToViewport(params: {
  viewportId: string;
  displaySetInstanceUID: string;
  servicesManager: AppTypes.ServicesManager;
}): boolean {
  const { viewportId, displaySetInstanceUID, servicesManager } = params;
  const { displaySetService, viewportGridService } = servicesManager.services;
 
  // Check if the display set exists
  const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
  Iif (!displaySet) {
    return false;
  }
 
  // Get current display sets in the viewport
  const currentDisplaySetUIDs = viewportGridService.getDisplaySetsUIDsForViewport(viewportId);
 
  // Check if the display set is already in the viewport
  Iif (currentDisplaySetUIDs.includes(displaySetInstanceUID)) {
    return false;
  }
 
  return true;
}