diff --git a/src/components/DataBrowser.vue b/src/components/DataBrowser.vue
index d5940b256..1de1cd274 100644
--- a/src/components/DataBrowser.vue
+++ b/src/components/DataBrowser.vue
@@ -8,6 +8,7 @@ import PatientList from './dicom-web/PatientList.vue';
 import { useDICOMStore } from '../store/datasets-dicom';
 import { useImageStore } from '../store/datasets-images';
 import { useDataBrowserStore } from '../store/data-browser';
+import { useDatasetStore } from '../store/datasets';
 import { removeFromArray } from '../utils';
 
 const SAMPLE_DATA_KEY = 'sampleData';
@@ -27,6 +28,7 @@ export default defineComponent({
     const imageStore = useImageStore();
     const dicomWeb = useDicomWebStore();
     const dataBrowserStore = useDataBrowserStore();
+    const datasetStore = useDatasetStore();
 
     // TODO show patient ID in parens if there is a name conflict
     const patients = computed(() =>
@@ -65,10 +67,16 @@ export default defineComponent({
 
     const hideSampleData = computed(() => dataBrowserStore.hideSampleData);
 
+    const deletePatient = (key: string) => {
+      dicomStore.patientStudies[key]
+        .flatMap((study) => dicomStore.studyVolumes[study])
+        .forEach(datasetStore.remove);
+    };
+
     return {
       panels,
       patients,
-      deletePatient: dicomStore.deletePatient,
+      deletePatient,
       hasAnonymousImages,
       dicomWeb,
       SAMPLE_DATA_KEY,
diff --git a/src/components/ImageDataBrowser.vue b/src/components/ImageDataBrowser.vue
index cbe5fe0de..50df1e746 100644
--- a/src/components/ImageDataBrowser.vue
+++ b/src/components/ImageDataBrowser.vue
@@ -5,14 +5,15 @@ import GroupableItem from '@/src/components/GroupableItem.vue';
 import ImageListCard from '@/src/components/ImageListCard.vue';
 import { createVTKImageThumbnailer } from '@/src/core/thumbnailers/vtk-image';
 import { useSegmentGroupStore } from '@/src/store/segmentGroups';
-import { useImageStore } from '../store/datasets-images';
-import { useDICOMStore } from '../store/datasets-dicom';
 import {
   DataSelection,
   ImageSelection,
   selectionEquals,
-  useDatasetStore,
-} from '../store/datasets';
+} from '@/src/utils/dataSelection';
+import { useImageStore } from '../store/datasets-images';
+import { useDICOMStore } from '../store/datasets-dicom';
+import { useDatasetStore } from '../store/datasets';
+
 import { useMultiSelection } from '../composables/useMultiSelection';
 import { useLayersStore } from '../store/datasets-layers';
 
@@ -129,9 +130,7 @@ export default defineComponent({
       useMultiSelection(nonDICOMImages);
 
     function removeSelection() {
-      selected.value.forEach((id) => {
-        imageStore.deleteData(id);
-      });
+      selected.value.forEach(dataStore.remove);
       selected.value = [];
     }
 
@@ -145,7 +144,7 @@ export default defineComponent({
     }
 
     function removeData(id: string) {
-      imageStore.deleteData(id);
+      dataStore.remove(id);
     }
 
     return {
diff --git a/src/components/LayerProperties.vue b/src/components/LayerProperties.vue
index 7ecde1f2c..b574d6748 100644
--- a/src/components/LayerProperties.vue
+++ b/src/components/LayerProperties.vue
@@ -1,11 +1,11 @@
 <script lang="ts">
 import { computed, defineComponent, PropType, toRefs } from 'vue';
+import { getImageID } from '@/src/utils/dataSelection';
 import { InitViewSpecs } from '../config';
 import { useImageStore } from '../store/datasets-images';
 import { BlendConfig } from '../types/views';
 import { Layer } from '../store/datasets-layers';
 import useLayerColoringStore from '../store/view-configs/layers';
-import { getImageID } from '../store/datasets';
 
 const VIEWS_2D = Object.entries(InitViewSpecs)
   .filter(([, { viewType }]) => viewType === '2D')
diff --git a/src/components/PatientBrowser.vue b/src/components/PatientBrowser.vue
index ea8427c19..f788df589 100644
--- a/src/components/PatientBrowser.vue
+++ b/src/components/PatientBrowser.vue
@@ -1,12 +1,9 @@
 <script lang="ts">
 import { computed, defineComponent, ref, toRefs, watch } from 'vue';
 import ItemGroup from '@/src/components/ItemGroup.vue';
+import { DataSelection, selectionEquals } from '@/src/utils/dataSelection';
 import { useDICOMStore } from '../store/datasets-dicom';
-import {
-  DataSelection,
-  selectionEquals,
-  useDatasetStore,
-} from '../store/datasets';
+import { useDatasetStore } from '../store/datasets';
 import { useMultiSelection } from '../composables/useMultiSelection';
 import PatientStudyVolumeBrowser from './PatientStudyVolumeBrowser.vue';
 
@@ -62,15 +59,10 @@ export default defineComponent({
       useMultiSelection(studyKeys);
 
     const removeSelectedStudies = () => {
-      selected.value.forEach(async (study) => {
-        dicomStore.deleteStudy(study);
-      });
+      selected.value
+        .flatMap((study) => dicomStore.studyVolumes[study])
+        .forEach(dataStore.remove);
       selected.value = [];
-
-      // Handle the case where we are deleting the selected study
-      // if (selected.value.indexOf(selectedStudy.value) !== -1) {
-      //   dataStore.setPrimarySelection(null);
-      // }
     };
 
     return {
diff --git a/src/components/PatientStudyVolumeBrowser.vue b/src/components/PatientStudyVolumeBrowser.vue
index 7e21769fb..1fba59c19 100644
--- a/src/components/PatientStudyVolumeBrowser.vue
+++ b/src/components/PatientStudyVolumeBrowser.vue
@@ -3,12 +3,9 @@ import { computed, defineComponent, reactive, toRefs, watch } from 'vue';
 import { Image } from 'itk-wasm';
 import type { PropType } from 'vue';
 import GroupableItem from '@/src/components/GroupableItem.vue';
+import { DataSelection, DICOMSelection } from '@/src/utils/dataSelection';
 import { getDisplayName, useDICOMStore } from '../store/datasets-dicom';
-import {
-  DataSelection,
-  DICOMSelection,
-  useDatasetStore,
-} from '../store/datasets';
+import { useDatasetStore } from '../store/datasets';
 import { useMultiSelection } from '../composables/useMultiSelection';
 import { useMessageStore } from '../store/messages';
 import { useLayersStore } from '../store/datasets-layers';
@@ -75,9 +72,10 @@ export default defineComponent({
     const datasetStore = useDatasetStore();
     const layersStore = useLayersStore();
 
+    const primarySelectionRef = computed(() => datasetStore.primarySelection);
     const volumes = computed(() => {
-      const { volumeInfo } = dicomStore;
-      const { primarySelection } = datasetStore;
+      const volumeInfo = dicomStore.volumeInfo;
+      const primarySelection = primarySelectionRef.value;
       const layerVolumes = layersStore
         .getLayers(primarySelection)
         .filter(({ selection }) => selection.type === 'dicom');
@@ -167,13 +165,12 @@ export default defineComponent({
       useMultiSelection(volumeKeys);
 
     const removeData = (key: string) => {
-      dicomStore.deleteVolume(key);
+      datasetStore.remove(key);
     };
 
     const removeSelectedDICOMVolumes = () => {
-      selected.value.forEach((volumeKey) => {
-        removeData(volumeKey);
-      });
+      // make copy of selected as removing selected will change the array
+      [...selected.value].forEach(removeData);
 
       selected.value = [];
     };
diff --git a/src/components/SegmentGroupControls.vue b/src/components/SegmentGroupControls.vue
index fef96e103..8b18f3daa 100644
--- a/src/components/SegmentGroupControls.vue
+++ b/src/components/SegmentGroupControls.vue
@@ -3,9 +3,12 @@ import SegmentList from '@/src/components/SegmentList.vue';
 import CloseableDialog from '@/src/components/CloseableDialog.vue';
 import SaveSegmentGroupDialog from '@/src/components/SaveSegmentGroupDialog.vue';
 import { useCurrentImage } from '@/src/composables/useCurrentImage';
-import { selectionEquals, useDatasetStore } from '@/src/store/datasets';
-import { useDICOMStore } from '@/src/store/datasets-dicom';
-import { useImageStore } from '@/src/store/datasets-images';
+import { useDatasetStore } from '@/src/store/datasets';
+import {
+  getSelectionName,
+  selectionEquals,
+  DataSelection,
+} from '@/src/utils/dataSelection';
 import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import { usePaintToolStore } from '@/src/store/tools/paint';
 import { Maybe } from '@/src/types';
@@ -15,8 +18,6 @@ const UNNAMED_GROUP_NAME = 'Unnamed Segment Group';
 
 const segmentGroupStore = useSegmentGroupStore();
 const { currentImageID } = useCurrentImage();
-const imageStore = useImageStore();
-const dicomStore = useDICOMStore();
 const dataStore = useDatasetStore();
 
 const currentSegmentGroups = computed(() => {
@@ -119,31 +120,25 @@ function createSegmentGroup() {
   startEditing(id);
 }
 
-// Filter and collect all acceptable images, excluding
-// the current background image, that can be converted into
-// a SegmentGroup (labelmap) for the current background image.
-const nonDICOMImages = computed(() => {
+// Collect images that can be converted into
+// a SegmentGroup for the current background image.
+const segmentGroupConvertibles = computed(() => {
   const primarySelection = dataStore.primarySelection;
-  const ids = imageStore.idList.filter(
-    (id) =>
-      !(id in dicomStore.imageIDToVolumeKey) &&
-      primarySelection &&
-      !selectionEquals({ type: 'image', dataID: id }, primarySelection)
-  );
-  return ids.map((id) => ({ id, name: imageStore.metadata[id].name }));
+  if (!primarySelection) return [];
+  return dataStore.idsAsSelections
+    .filter((selection) => !selectionEquals(selection, primarySelection))
+    .map((selection) => ({
+      selection,
+      name: getSelectionName(selection),
+    }));
 });
 
-function createSegmentGroupFromImage(selectedImageID: string) {
-  if (!selectedImageID) {
-    throw new Error('Cannot create a labelmap without a base image');
-  }
+function createSegmentGroupFromImage(selection: DataSelection) {
   const primarySelection = dataStore.primarySelection;
-  if (primarySelection) {
-    segmentGroupStore.convertImageToLabelmap(
-      { type: 'image', dataID: selectedImageID },
-      primarySelection
-    );
+  if (!primarySelection) {
+    throw new Error('No primary selection');
   }
+  segmentGroupStore.convertImageToLabelmap(selection, primarySelection);
 }
 
 const saveId = ref('');
@@ -178,11 +173,11 @@ function openSaveDialog(id: string) {
             <v-icon class="mr-1">mdi-chevron-down</v-icon>From Image
           </v-btn>
         </template>
-        <v-list v-if="nonDICOMImages.length !== 0">
+        <v-list v-if="segmentGroupConvertibles.length !== 0">
           <v-list-item
-            v-for="(item, index) in nonDICOMImages"
+            v-for="(item, index) in segmentGroupConvertibles"
             :key="index"
-            @click="createSegmentGroupFromImage(item.id)"
+            @click="createSegmentGroupFromImage(item.selection)"
           >
             {{ item.name }}
             <v-tooltip activator="parent" location="end" max-width="200px">
diff --git a/src/components/vtk/VtkSegmentationSliceRepresentation.vue b/src/components/vtk/VtkSegmentationSliceRepresentation.vue
index ab9807389..2f63dfeab 100644
--- a/src/components/vtk/VtkSegmentationSliceRepresentation.vue
+++ b/src/components/vtk/VtkSegmentationSliceRepresentation.vue
@@ -6,7 +6,10 @@ import { LPSAxis } from '@/src/types/lps';
 import { onVTKEvent } from '@/src/composables/onVTKEvent';
 import { SlicingMode } from '@kitware/vtk.js/Rendering/Core/ImageMapper/Constants';
 import { VtkViewContext } from '@/src/components/vtk/context';
-import { useSegmentGroupStore } from '@/src/store/segmentGroups';
+import {
+  useSegmentGroupStore,
+  SegmentGroupMetadata,
+} from '@/src/store/segmentGroups';
 import { InterpolationType } from '@kitware/vtk.js/Rendering/Core/ImageProperty/Constants';
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
@@ -29,7 +32,7 @@ const view = inject(VtkViewContext);
 if (!view) throw new Error('No VtkView');
 
 const segmentationStore = useSegmentGroupStore();
-const metadata = computed(
+const metadata = computed<SegmentGroupMetadata | undefined>(
   () => segmentationStore.metadataByID[segmentationId.value]
 );
 const imageData = computed(
@@ -64,7 +67,7 @@ watchEffect(() => {
 });
 
 // set slicing mode
-const parentImageId = computed(() => metadata.value.parentImage);
+const parentImageId = computed(() => metadata.value?.parentImage);
 const { metadata: parentMetadata } = useImage(parentImageId);
 
 watchEffect(() => {
@@ -89,6 +92,8 @@ const applySegmentColoring = () => {
 
   let maxValue = 0;
 
+  if (!metadata.value) return; // segment group just deleted
+
   const { segments } = metadata.value;
   segments.order.forEach((segId) => {
     const segment = segments.byValue[segId];
diff --git a/src/composables/useCurrentImage.ts b/src/composables/useCurrentImage.ts
index add2ccea8..78498d38a 100644
--- a/src/composables/useCurrentImage.ts
+++ b/src/composables/useCurrentImage.ts
@@ -14,11 +14,8 @@ import {
 } from '@/src/store/datasets-images';
 import { useLayersStore } from '@/src/store/datasets-layers';
 import { createLPSBounds, getAxisBounds } from '@/src/utils/lps';
-import {
-  getDataSelection,
-  getImageID,
-  useDatasetStore,
-} from '@/src/store/datasets';
+import { useDatasetStore } from '@/src/store/datasets';
+import { getDataSelection, getImageID } from '@/src/utils/dataSelection';
 import { storeToRefs } from 'pinia';
 
 export interface CurrentImageContext {
diff --git a/src/io/dicom.ts b/src/io/dicom.ts
index af54476da..1dc91a36d 100644
--- a/src/io/dicom.ts
+++ b/src/io/dicom.ts
@@ -219,36 +219,6 @@ export class DICOMIO {
     return result.outputs[0].data as Image;
   }
 
-  async resample(fixed: SpatialParameters, moving: Image) {
-    await this.initialize();
-
-    const { size, spacing, origin, direction } = fixed;
-    const args = [
-      '--action',
-      'resample',
-      '0', // space for input image
-
-      '--size',
-      size.join(','),
-      '--spacing',
-      spacing.join(','),
-      '--origin',
-      origin.join(','),
-      '--direction',
-      direction.join(','),
-
-      '--memory-io',
-      '0',
-    ];
-
-    const inputs = [{ type: InterfaceTypes.Image, data: moving }];
-    const outputs = [{ type: InterfaceTypes.Image }];
-
-    const result = await this.runTask('dicom', args, inputs, outputs);
-    const image = result.outputs[0].data as Image;
-    return image;
-  }
-
   /**
    * Builds a volume for a set of files.
    * @async
diff --git a/src/io/import/common.ts b/src/io/import/common.ts
index ab9627d04..716117709 100644
--- a/src/io/import/common.ts
+++ b/src/io/import/common.ts
@@ -14,6 +14,10 @@ export interface LoadableResult extends DataResult {
   dataType: 'image' | 'dicom' | 'model';
 }
 
+export interface VolumeResult extends LoadableResult {
+  dataType: 'image' | 'dicom';
+}
+
 export interface ConfigResult extends DataResult {
   config: Config;
 }
@@ -46,6 +50,15 @@ export function isLoadableResult(
   return 'dataID' in importResult && 'dataType' in importResult;
 }
 
+export function isVolumeResult(
+  importResult: ImportResult
+): importResult is VolumeResult {
+  return (
+    isLoadableResult(importResult) &&
+    (importResult.dataType === 'image' || importResult.dataType === 'dicom')
+  );
+}
+
 export function isConfigResult(
   importResult: ImportResult
 ): importResult is ConfigResult {
diff --git a/src/io/import/importDataSources.ts b/src/io/import/importDataSources.ts
index bdcd11f96..b271b62d6 100644
--- a/src/io/import/importDataSources.ts
+++ b/src/io/import/importDataSources.ts
@@ -6,8 +6,8 @@ import {
   isConfigResult,
   ImportHandler,
   ImportResult,
-  LoadableResult,
   isLoadableResult,
+  VolumeResult,
 } from '@/src/io/import/common';
 import { DataSource, DataSourceWithFile } from '@/src/io/import/dataSource';
 import handleDicomFile from '@/src/io/import/processors/handleDicomFile';
@@ -22,7 +22,10 @@ import restoreStateFile from '@/src/io/import/processors/restoreStateFile';
 import updateFileMimeType from '@/src/io/import/processors/updateFileMimeType';
 import handleConfig from '@/src/io/import/processors/handleConfig';
 import { useDICOMStore } from '@/src/store/datasets-dicom';
-import { makeDICOMSelection, makeImageSelection } from '@/src/store/datasets';
+import {
+  makeDICOMSelection,
+  makeImageSelection,
+} from '@/src/utils/dataSelection';
 import { applyConfig } from '@/src/io/import/configJson';
 
 /**
@@ -44,17 +47,18 @@ const unhandledResource: ImportHandler = () => {
 
 function isSelectable(
   result: PipelineResult<DataSource, ImportResult>
-): result is PipelineResultSuccess<LoadableResult> {
+): result is PipelineResultSuccess<VolumeResult> {
   if (!result.ok) return false;
-
   if (result.data.length === 0) {
     return false;
   }
-
   const importResult = result.data[0];
   if (!isLoadableResult(importResult)) {
     return false;
   }
+  if (importResult.dataType === 'model') {
+    return false;
+  }
 
   return true;
 }
@@ -172,7 +176,7 @@ export type ImportDataSourcesResult = Awaited<
   ReturnType<typeof importDataSources>
 >[number];
 
-export function toDataSelection(loadable: LoadableResult) {
+export function toDataSelection(loadable: VolumeResult) {
   const { dataID, dataType } = loadable;
   if (dataType === 'dicom') {
     return makeDICOMSelection(dataID);
@@ -180,13 +184,15 @@ export function toDataSelection(loadable: LoadableResult) {
   if (dataType === 'image') {
     return makeImageSelection(dataID);
   }
-  return null;
+
+  const _exhaustiveCheck: never = dataType;
+  throw new Error(`invalid loadable type ${_exhaustiveCheck}`);
 }
 
 export function convertSuccessResultToDataSelection(
   result: ImportDataSourcesResult
 ) {
   if (!isSelectable(result)) return null;
-
-  return toDataSelection(result.data[0]);
+  const importResult = result.data[0];
+  return toDataSelection(importResult);
 }
diff --git a/src/io/import/processors/restoreStateFile.ts b/src/io/import/processors/restoreStateFile.ts
index ad6157c1c..cc577b575 100644
--- a/src/io/import/processors/restoreStateFile.ts
+++ b/src/io/import/processors/restoreStateFile.ts
@@ -21,12 +21,12 @@ import { Awaitable } from '@vueuse/core';
 import doneWithDataSource from '@/src/io/import/processors/doneWithDataSource';
 import { useDICOMStore } from '@/src/store/datasets-dicom';
 import { useViewStore } from '@/src/store/views';
+import { useDatasetStore } from '@/src/store/datasets';
 import {
   DataSelection,
   makeDICOMSelection,
   makeImageSelection,
-  useDatasetStore,
-} from '@/src/store/datasets';
+} from '@/src/utils/dataSelection';
 import {
   makeDefaultSegmentGroupName,
   useSegmentGroupStore,
diff --git a/src/io/resample/CMakeLists.txt b/src/io/resample/CMakeLists.txt
index 257ca9632..cadac1625 100644
--- a/src/io/resample/CMakeLists.txt
+++ b/src/io/resample/CMakeLists.txt
@@ -8,6 +8,7 @@ find_package(ITK REQUIRED
     WebAssemblyInterface
     ITKImageGrid
     ITKImageFunction
+    GenericLabelInterpolator
   )
 include(${ITK_USE_FILE})
 
diff --git a/src/io/resample/emscripten-build/resample.wasm b/src/io/resample/emscripten-build/resample.wasm
index 6a47271ad..1e71629d1 100755
Binary files a/src/io/resample/emscripten-build/resample.wasm and b/src/io/resample/emscripten-build/resample.wasm differ
diff --git a/src/io/resample/emscripten-build/resample.wasm.zst b/src/io/resample/emscripten-build/resample.wasm.zst
index a30a93ee9..d273785ae 100755
Binary files a/src/io/resample/emscripten-build/resample.wasm.zst and b/src/io/resample/emscripten-build/resample.wasm.zst differ
diff --git a/src/io/resample/itkWasmUtils.js b/src/io/resample/itkWasmUtils.js
index 35c1a217f..ae99ecc49 100644
--- a/src/io/resample/itkWasmUtils.js
+++ b/src/io/resample/itkWasmUtils.js
@@ -8,6 +8,7 @@ import {
 
 import itkConfig from '@/src/io/itk/itkConfig';
 
+// Splits the input image into multiple slices and processes them in parallel
 export async function runWasm(
   pipeline,
   args,
diff --git a/src/io/resample/resample.cxx b/src/io/resample/resample.cxx
index 0d754fbcd..a8a13e398 100644
--- a/src/io/resample/resample.cxx
+++ b/src/io/resample/resample.cxx
@@ -19,6 +19,7 @@
 #include "itkVectorImage.h"
 #include "itkResampleImageFilter.h"
 #include "itkLinearInterpolateImageFunction.h"
+#include "itkLabelImageGenericInterpolateImageFunction.h"
 #include "itkImageRegionSplitterSlowDimension.h"
 #include "itkExtractImageFilter.h"
 #include "itkRGBPixel.h"
@@ -53,6 +54,9 @@ int Resample(itk::wasm::Pipeline &pipeline, itk::wasm::InputImage<TImage> &input
   OutputImageType outputImage;
   pipeline.add_option("OutputImage", outputImage, "Output image")->required();
 
+  bool label = false;
+  pipeline.add_flag("-l,--label", label, "Interpolate for label image")->default_val(false);
+
   std::vector<unsigned int> outSize;
   pipeline.add_option("-z,--size", outSize, "New image size for each direction")->expected(2, 3)->delimiter(',');
 
@@ -81,6 +85,12 @@ int Resample(itk::wasm::Pipeline &pipeline, itk::wasm::InputImage<TImage> &input
 
   using ResampleFilterType = itk::ResampleImageFilter<ImageType, ImageType>;
   auto resampleFilter = ResampleFilterType::New();
+  if (label)
+  {
+    using InterpolatorType = itk::LabelImageGenericInterpolateImageFunction<ImageType, itk::LinearInterpolateImageFunction>;
+    resampleFilter->SetInterpolator(InterpolatorType::New());
+  }
+
   resampleFilter->SetInput(inImage);
 
   typename ImageType::SizeType outputSize;
diff --git a/src/io/resample/resample.ts b/src/io/resample/resample.ts
index d7842b471..711bcc734 100644
--- a/src/io/resample/resample.ts
+++ b/src/io/resample/resample.ts
@@ -1,10 +1,15 @@
 import { Image } from 'itk-wasm';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkITKHelper from '@kitware/vtk.js/Common/DataModel/ITKHelper';
+import { compareImageSpaces } from '@/src/utils/imageSpace';
 import { runWasm } from './itkWasmUtils';
 
 
-export async function resample(fixed: Image, moving: Image) {
+export async function resample(fixed: Image, moving: Image, label = false) {
+  const labelFlag = label ? ['--label'] : [];
   const { size, spacing, origin, direction } = fixed;
   const args = [
+    ...labelFlag,
     '--size',
     size.join(','),
     '--spacing',
@@ -17,3 +22,15 @@ export async function resample(fixed: Image, moving: Image) {
 
   return runWasm('resample', args, [moving]);
 }
+
+export async function ensureSameSpace(target: vtkImageData, resampleCandidate: vtkImageData, label = false) {
+  if (compareImageSpaces(target, resampleCandidate)) {
+    return resampleCandidate; // could still be different pixel dimensions
+  } 
+  const itkImage = await resample(
+    vtkITKHelper.convertVtkToItkImage(target),
+    vtkITKHelper.convertVtkToItkImage(resampleCandidate),
+    label
+  );
+  return vtkITKHelper.convertItkToVtkImage(itkImage);
+}
\ No newline at end of file
diff --git a/src/store/datasets-dicom.ts b/src/store/datasets-dicom.ts
index 00f446e95..3917c0317 100644
--- a/src/store/datasets-dicom.ts
+++ b/src/store/datasets-dicom.ts
@@ -1,4 +1,5 @@
 import vtkITKHelper from '@kitware/vtk.js/Common/DataModel/ITKHelper';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { defineStore } from 'pinia';
 import { Image } from 'itk-wasm';
 import { DataSourceWithFile } from '@/src/io/import/dataSource';
@@ -54,13 +55,16 @@ interface State {
   sliceData: Record<string, Record<string, Image>>;
 
   // volumeKey -> imageID
-  volumeToImageID: Record<string, string | undefined>;
+  volumeToImageID: Record<string, string>;
   // imageID -> volumeKey
   imageIDToVolumeKey: Record<string, string>;
 
   // volume invalidation information
   needsRebuild: Record<string, boolean>;
 
+  // Avoid recomputing image data for the same volume by checking this for existing buildVolume tasks
+  volumeImageData: Record<string, Promise<vtkImageData>>;
+
   // patientKey -> patient info
   patientInfo: Record<string, PatientInfo>;
   // patientKey -> array of studyKeys
@@ -138,11 +142,22 @@ export const getWindowLevels = (info: VolumeInfo) => {
   return widths.map((width, i) => ({ width, level: levels[i] }));
 };
 
+const constructImage = async (dicomIO: DICOMIO, volumeKey: string) => {
+  const fileStore = useFileStore();
+  const files = fileStore.getFiles(volumeKey);
+  if (!files) throw new Error('No files for volume key');
+  const image = vtkITKHelper.convertItkToVtkImage(
+    await dicomIO.buildImage(files)
+  );
+  return image;
+};
+
 export const useDICOMStore = defineStore('dicom', {
   state: (): State => ({
     sliceData: {},
     volumeToImageID: {},
     imageIDToVolumeKey: {},
+    volumeImageData: {},
     patientInfo: {},
     patientStudies: {},
     studyInfo: {},
@@ -260,8 +275,9 @@ export const useDICOMStore = defineStore('dicom', {
       }
     },
 
+    // You should probably call datasetStore.remove instead as this does not
+    // remove files/images/layers associated with the volume
     deleteVolume(volumeKey: string) {
-      const imageStore = useImageStore();
       if (volumeKey in this.volumeInfo) {
         const studyKey = this.volumeStudy[volumeKey];
         delete this.volumeInfo[volumeKey];
@@ -270,19 +286,22 @@ export const useDICOMStore = defineStore('dicom', {
 
         if (volumeKey in this.volumeToImageID) {
           const imageID = this.volumeToImageID[volumeKey]!;
-          imageStore.deleteData(imageID!);
           delete this.volumeToImageID[volumeKey];
           delete this.imageIDToVolumeKey[imageID];
         }
 
+        if (volumeKey in this.volumeImageData) {
+          delete this.volumeImageData[volumeKey];
+        }
+
         removeFromArray(this.studyVolumes[studyKey], volumeKey);
         if (this.studyVolumes[studyKey].length === 0) {
-          this.deleteStudy(studyKey);
+          this._deleteStudy(studyKey);
         }
       }
     },
 
-    deleteStudy(studyKey: string) {
+    _deleteStudy(studyKey: string) {
       if (studyKey in this.studyInfo) {
         const patientKey = this.studyPatient[studyKey];
         delete this.studyInfo[studyKey];
@@ -295,17 +314,17 @@ export const useDICOMStore = defineStore('dicom', {
 
         removeFromArray(this.patientStudies[patientKey], studyKey);
         if (this.patientStudies[patientKey].length === 0) {
-          this.deletePatient(patientKey);
+          this._deletePatient(patientKey);
         }
       }
     },
 
-    deletePatient(patientKey: string) {
+    _deletePatient(patientKey: string) {
       if (patientKey in this.patientInfo) {
         delete this.patientInfo[patientKey];
 
         [...this.patientStudies[patientKey]].forEach((studyKey) =>
-          this.deleteStudy(studyKey)
+          this._deleteStudy(studyKey)
         );
         delete this.patientStudies[patientKey];
       }
@@ -377,36 +396,39 @@ export const useDICOMStore = defineStore('dicom', {
 
     async buildVolume(volumeKey: string, forceRebuild: boolean = false) {
       const imageStore = useImageStore();
-      const dicomIO = this.$dicomIO;
 
-      const rebuild = forceRebuild || this.needsRebuild[volumeKey];
-
-      if (!rebuild && this.volumeToImageID[volumeKey]) {
-        const imageID = this.volumeToImageID[volumeKey]!;
-        return imageStore.dataIndex[imageID];
-      }
-
-      const fileStore = useFileStore();
-      const files = fileStore.getFiles(volumeKey);
-      if (!files) throw new Error('No files for volume key');
-      const image = vtkITKHelper.convertItkToVtkImage(
-        await dicomIO.buildImage(files)
-      );
+      const alreadyBuilt = volumeKey in this.volumeImageData;
+      const buildNeeded =
+        forceRebuild || this.needsRebuild[volumeKey] || !alreadyBuilt;
+      delete this.needsRebuild[volumeKey];
 
+      // wait for old buildVolume call so we can run imageStore update side effects after
+      const oldImagePromise = alreadyBuilt
+        ? [this.volumeImageData[volumeKey]]
+        : [];
+      // actually build volume or wait for existing build?
+      const newImagePromise = buildNeeded
+        ? constructImage(this.$dicomIO, volumeKey)
+        : this.volumeImageData[volumeKey];
+      // let other calls to buildVolume reuse this constructImage work
+      this.volumeImageData[volumeKey] = newImagePromise;
+      const [image] = await Promise.all([newImagePromise, ...oldImagePromise]);
+
+      // update image store
       const existingImageID = this.volumeToImageID[volumeKey];
-      if (existingImageID) {
+      const imageExists =
+        existingImageID && imageStore.dataIndex[existingImageID];
+      if (imageExists) {
+        // was a rebuild
         imageStore.updateData(existingImageID, image);
       } else {
         const info = this.volumeInfo[volumeKey];
-        const name =
-          cleanupName(info.SeriesDescription) || info.SeriesInstanceUID;
-        const imageID = imageStore.addVTKImageData(name, image);
-        this.imageIDToVolumeKey[imageID] = volumeKey;
-        this.volumeToImageID[volumeKey] = imageID;
+        const name = getDisplayName(info);
+        const newImageID = imageStore.addVTKImageData(name, image);
+        this.imageIDToVolumeKey[newImageID] = volumeKey;
+        this.volumeToImageID[volumeKey] = newImageID;
       }
 
-      delete this.needsRebuild[volumeKey];
-
       return image;
     },
   },
diff --git a/src/store/datasets-layers.ts b/src/store/datasets-layers.ts
index 54442a5d2..e8eeba475 100644
--- a/src/store/datasets-layers.ts
+++ b/src/store/datasets-layers.ts
@@ -3,17 +3,15 @@ import vtkITKHelper from '@kitware/vtk.js/Common/DataModel/ITKHelper';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import vtkBoundingBox from '@kitware/vtk.js/Common/DataModel/BoundingBox';
 import { defineStore } from 'pinia';
-import { useImageStore } from '@/src/store/datasets-images';
 import { compareImageSpaces } from '@/src/utils/imageSpace';
-import { resample } from '../io/resample/resample';
-import { useDICOMStore } from './datasets-dicom';
 import {
   DataSelection,
+  getImage,
   makeDICOMSelection,
   makeImageSelection,
   selectionEquals,
-  getImage,
-} from './datasets';
+} from '@/src/utils/dataSelection';
+import { resample } from '../io/resample/resample';
 import { useErrorMessage } from '../composables/useErrorMessage';
 import { Manifest, StateFile } from '../io/state-file/schema';
 
@@ -160,40 +158,18 @@ export const useLayersStore = defineStore('layer', () => {
       .flat()
       .find(({ id }) => id === layerID);
 
-  // --- watch for deletion --- //
-
-  const deleteSelection = (deleteKey: DataSelection) => {
+  const remove = (selectionToRemove: DataSelection) => {
     const layerStore = useLayersStore();
     // delete as parent
     layerStore
-      .getLayers(deleteKey)
-      .forEach(({ selection }) => layerStore.deleteLayer(deleteKey, selection));
+      .getLayers(selectionToRemove)
+      .forEach(({ selection }) => layerStore.deleteLayer(selection, selection));
     // delete from layer lists
     Object.keys(layerStore.parentToLayers)
       .map((key) => toDataSelectionFromKey(key as DataSelectionKey))
-      .forEach((parent) => layerStore.deleteLayer(parent, deleteKey));
+      .forEach((parent) => layerStore.deleteLayer(parent, selectionToRemove));
   };
 
-  const imageStore = useImageStore();
-  imageStore.$onAction(({ name, args }) => {
-    if (name !== 'deleteData') {
-      return;
-    }
-    const [id] = args;
-    const selection = makeImageSelection(id);
-    deleteSelection(selection);
-  });
-
-  const dicomStore = useDICOMStore();
-  dicomStore.$onAction(({ name, args }) => {
-    if (name !== 'deleteVolume') {
-      return;
-    }
-    const [volumeKey] = args;
-    const selection = makeDICOMSelection(volumeKey);
-    deleteSelection(selection);
-  });
-
   function serialize(this: _This, state: StateFile) {
     state.manifest.parentToLayers = Object.entries(this.parentToLayers).map(
       ([selectionKey, layers]) => ({
@@ -242,6 +218,7 @@ export const useLayersStore = defineStore('layer', () => {
     _addLayer,
     addLayer,
     deleteLayer,
+    remove,
     getLayers,
     getLayer,
     serialize,
diff --git a/src/store/datasets.ts b/src/store/datasets.ts
index 355bd7e17..ee70539e5 100644
--- a/src/store/datasets.ts
+++ b/src/store/datasets.ts
@@ -1,97 +1,29 @@
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { defineStore } from 'pinia';
 import { computed, ref } from 'vue';
+import {
+  DataSelection,
+  getDataSelection,
+  getImageID,
+  selectionEquals,
+} from '@/src/utils/dataSelection';
 import { useDICOMStore } from './datasets-dicom';
 import { useImageStore } from './datasets-images';
-import { useModelStore } from './datasets-models';
 import { useFileStore } from './datasets-files';
 import { StateFile } from '../io/state-file/schema';
 import { useErrorMessage } from '../composables/useErrorMessage';
+import { useLayersStore } from './datasets-layers';
 
 export const DataType = {
   Image: 'Image',
   Model: 'Model',
 };
 
-export const makeDICOMSelection = (volumeKey: string) =>
-  ({
-    type: 'dicom',
-    volumeKey,
-  } as const);
-
-export type DICOMSelection = ReturnType<typeof makeDICOMSelection>;
-
-export const makeImageSelection = (imageID: string) =>
-  ({
-    type: 'image',
-    dataID: imageID,
-  } as const);
-
-export type ImageSelection = ReturnType<typeof makeImageSelection>;
-
-export type DataSelection = DICOMSelection | ImageSelection;
-
-export const getImageID = (selection: DataSelection) => {
-  if (selection.type === 'image') return selection.dataID;
-  if (selection.type === 'dicom') {
-    // possibly undefined because image may not have been made yet
-    return useDICOMStore().volumeToImageID[selection.volumeKey];
-  }
-
-  const _exhaustiveCheck: never = selection;
-  throw new Error(`invalid selection type ${_exhaustiveCheck}`);
-};
-
-export const getImage = async (selection: DataSelection) => {
-  const images = useImageStore();
-  const dicoms = useDICOMStore();
-  if (selection.type === 'dicom') {
-    // ensure image data exists
-    await useErrorMessage('Failed to build volume', () =>
-      dicoms.buildVolume(selection.volumeKey)
-    );
-    return images.dataIndex[getImageID(selection)!];
-  }
-  // just an image that should be in dataIndex
-  return images.dataIndex[selection.dataID];
-};
-
-// Converts imageID to VolumeKey if exists, else return input imageID
-export const getDataID = (imageID: string) => {
-  const dicomStore = useDICOMStore();
-  return dicomStore.imageIDToVolumeKey[imageID] ?? imageID;
-};
-
-export const getDataSelection = (imageID: string) => {
-  const dicomStore = useDICOMStore();
-  const volumeKey = dicomStore.imageIDToVolumeKey[imageID];
-  if (volumeKey) {
-    return makeDICOMSelection(volumeKey);
-  }
-  return makeImageSelection(imageID);
-};
-
-// Pass VolumeKey or ImageID and get ImageID
-export const findImageID = (dataID: string) => {
-  const dicomStore = useDICOMStore();
-  return dicomStore.volumeToImageID[dataID] ?? dataID;
-};
-
-export function selectionEquals(s1: DataSelection, s2: DataSelection) {
-  if (s1.type === 'dicom' && s2.type === 'dicom') {
-    return s1.volumeKey === s2.volumeKey;
-  }
-  if (s1.type === 'image' && s2.type === 'image') {
-    return s1.dataID === s2.dataID;
-  }
-  return false;
-}
-
 export const useDatasetStore = defineStore('dataset', () => {
   const imageStore = useImageStore();
-  const modelStore = useModelStore();
   const dicomStore = useDICOMStore();
   const fileStore = useFileStore();
+  const layersStore = useLayersStore();
 
   // --- state --- //
 
@@ -109,8 +41,12 @@ export const useDatasetStore = defineStore('dataset', () => {
     return (primaryImageID.value && dataIndex[primaryImageID.value]) || null;
   });
 
-  const allDataIDs = computed(() => {
-    return [...imageStore.idList, ...modelStore.idList];
+  const idsAsSelections = computed(() => {
+    const volumeKeys = Object.keys(dicomStore.volumeInfo);
+    const images = imageStore.idList.filter(
+      (id) => !(id in dicomStore.imageIDToVolumeKey)
+    );
+    return [...volumeKeys, ...images].map(getDataSelection);
   });
 
   // --- actions --- //
@@ -147,45 +83,35 @@ export const useDatasetStore = defineStore('dataset', () => {
     }
   }
 
-  // --- watch for deletion --- //
-
-  imageStore.$onAction(({ name, args, after }) => {
-    if (name !== 'deleteData') {
-      return;
-    }
-    after(() => {
-      const [id] = args;
-      const sel = primarySelection.value;
-      if (sel?.type === 'image' && sel.dataID === id) {
-        primarySelection.value = null;
-      }
-      // remove file store entry
-      fileStore.remove(id);
-    });
-  });
-
-  dicomStore.$onAction(({ name, args, after }) => {
-    if (name !== 'deleteVolume') {
-      return;
+  const remove = (id: string) => {
+    const sel = getDataSelection(id);
+    if (
+      primarySelection.value &&
+      selectionEquals(sel, primarySelection.value)
+    ) {
+      primarySelection.value = null;
     }
 
-    after(() => {
-      const [volumeKey] = args;
-      const sel = primarySelection.value;
-      if (sel?.type === 'dicom' && volumeKey === sel.volumeKey) {
-        primarySelection.value = null;
+    if (sel.type === 'dicom') {
+      if (sel.volumeKey in dicomStore.volumeToImageID) {
+        imageStore.deleteData(dicomStore.volumeToImageID[sel.volumeKey]);
       }
+      dicomStore.deleteVolume(sel.volumeKey);
+    } else if (sel.type === 'image') {
+      imageStore.deleteData(id);
+    }
 
-      fileStore.remove(volumeKey);
-    });
-  });
+    fileStore.remove(id);
+    layersStore.remove(sel);
+  };
 
   return {
     primaryImageID,
     primarySelection,
     primaryDataset,
-    allDataIDs,
+    idsAsSelections,
     setPrimarySelection,
     serialize,
+    remove,
   };
 });
diff --git a/src/store/load-data.ts b/src/store/load-data.ts
index 7d72cb719..45b860d50 100644
--- a/src/store/load-data.ts
+++ b/src/store/load-data.ts
@@ -8,7 +8,9 @@ import {
 import {
   ImportResult,
   LoadableResult,
+  VolumeResult,
   isLoadableResult,
+  isVolumeResult,
 } from '@/src/io/import/common';
 import { useDICOMStore } from '@/src/store/datasets-dicom';
 import { useDatasetStore } from '@/src/store/datasets';
@@ -21,8 +23,16 @@ import { useToast } from '@/src/composables/useToast';
 import { TYPE } from 'vue-toastification';
 import { ToastID, ToastOptions } from 'vue-toastification/dist/types/types';
 import { useLayersStore } from './datasets-layers';
+import { useSegmentGroupStore } from './segmentGroups';
+import { nonNullable } from '../utils';
 
-const BASE_MODALITY_TYPES = ['CT', 'MR', 'DX', 'US'];
+// higher value priority is preferred for picking a primary selection
+const BASE_MODALITY_TYPES = {
+  CT: { priority: 3 },
+  MR: { priority: 3 },
+  US: { priority: 2 },
+  DX: { priority: 1 },
+} as const;
 
 const NotificationMessages = {
   Loading: 'Loading datasets...',
@@ -119,11 +129,40 @@ function pickBaseDicom(loadableDataSources: Array<LoadableResult>) {
   );
   // prefer some modalities as base
   const dicomStore = useDICOMStore();
-  return dicoms.find((dicomSource) => {
-    const volumeInfo = dicomStore.volumeInfo[dicomSource.dataID];
-    const modality = volumeInfo?.Modality;
-    return BASE_MODALITY_TYPES.includes(modality);
-  });
+  const baseDicomVolumes = dicoms
+    .map((dicomSource) => {
+      const volumeInfo = dicomStore.volumeInfo[dicomSource.dataID];
+      const modality = volumeInfo?.Modality as keyof typeof BASE_MODALITY_TYPES;
+      if (modality in BASE_MODALITY_TYPES)
+        return {
+          dicomSource,
+          priority: BASE_MODALITY_TYPES[modality]?.priority,
+          volumeInfo,
+        };
+      return undefined;
+    })
+    .filter(nonNullable)
+    .sort(
+      (
+        { priority: a, volumeInfo: infoA },
+        { priority: b, volumeInfo: infoB }
+      ) => {
+        const priorityDiff = a - b;
+        if (priorityDiff !== 0) return priorityDiff;
+        // same modality, then more slices preferred
+        if (!infoA.NumberOfSlices) return 1;
+        if (!infoB.NumberOfSlices) return -1;
+        return infoB.NumberOfSlices - infoA.NumberOfSlices;
+      }
+    );
+  if (baseDicomVolumes.length) return baseDicomVolumes[0].dicomSource;
+  return undefined;
+}
+
+function getStudyUID(volumeID: string) {
+  const dicomStore = useDICOMStore();
+  const studyKey = dicomStore.volumeStudy[volumeID];
+  return dicomStore.studyInfo[studyKey]?.StudyInstanceUID;
 }
 
 function pickLoadableDataSources(
@@ -142,41 +181,72 @@ function pickBaseDataSource(
   return baseDicom ?? loadableDataSources[0];
 }
 
-function getStudyUID(volumeID: string) {
-  const dicomStore = useDICOMStore();
-  const studyKey = dicomStore.volumeStudy[volumeID];
-  return dicomStore.studyInfo[studyKey].StudyInstanceUID;
+function pickOtherVolumesInStudy(
+  volumeID: string,
+  succeeded: Array<PipelineResultSuccess<ImportResult>>
+) {
+  const targetStudyUID = getStudyUID(volumeID);
+  const dicomDataSources = pickLoadableDataSources(succeeded).filter(
+    ({ dataType }) => dataType === 'dicom'
+  );
+  return dicomDataSources.filter((ds) => {
+    const sourceStudyUID = getStudyUID(ds.dataID);
+    return sourceStudyUID === targetStudyUID && ds.dataID !== volumeID;
+  }) as Array<VolumeResult>;
 }
 
+// Layers a DICOM PET on a CT if found
 function loadLayers(
-  primaryDataSource: LoadableResult,
+  primaryDataSource: VolumeResult,
   succeeded: Array<PipelineResultSuccess<ImportResult>>
 ) {
   if (primaryDataSource.dataType !== 'dicom') return;
-  const dicomDataSources = pickLoadableDataSources(succeeded).filter(
-    ({ dataType }) => dataType === 'dicom'
+  const otherVolumesInStudy = pickOtherVolumesInStudy(
+    primaryDataSource.dataID,
+    succeeded
   );
-  const studyID = getStudyUID(primaryDataSource.dataID);
-  const otherVolumesInStudy = dicomDataSources.filter((ds) => {
-    const studyUID = getStudyUID(ds.dataID);
-    return studyUID === studyID && ds.dataID !== primaryDataSource.dataID;
-  });
   const dicomStore = useDICOMStore();
   const primaryModality =
     dicomStore.volumeInfo[primaryDataSource.dataID].Modality;
+  if (primaryModality !== 'CT') return;
   // Look for one PET volume to layer with CT.  Only one as there are often multiple "White Balance" corrected PET volumes.
   const toLayer = otherVolumesInStudy.find((ds) => {
     const otherModality = dicomStore.volumeInfo[ds.dataID].Modality;
-    return primaryModality === 'CT' && otherModality === 'PT';
+    return otherModality === 'PT';
   });
   if (!toLayer) return;
 
-  const primarySelection = toDataSelection(primaryDataSource)!;
+  const primarySelection = toDataSelection(primaryDataSource);
   const layersStore = useLayersStore();
-  const layerSelection = toDataSelection(toLayer)!;
+  const layerSelection = toDataSelection(toLayer);
   layersStore.addLayer(primarySelection, layerSelection);
 }
 
+// Loads DICOM SEG modalities as Segment Groups if found
+function loadSegmentations(
+  primaryDataSource: VolumeResult,
+  succeeded: Array<PipelineResultSuccess<ImportResult>>
+) {
+  const dicomStore = useDICOMStore();
+  const otherSegVolumesInStudy = pickOtherVolumesInStudy(
+    primaryDataSource.dataID,
+    succeeded
+  ).filter((ds) => {
+    const modality = dicomStore.volumeInfo[ds.dataID].Modality;
+    if (!modality) return false;
+    return modality.trim() === 'SEG';
+  });
+
+  const segmentGroupStore = useSegmentGroupStore();
+  otherSegVolumesInStudy.forEach((ds) => {
+    const loadable = toDataSelection(ds);
+    segmentGroupStore.convertImageToLabelmap(
+      loadable,
+      toDataSelection(primaryDataSource)
+    );
+  });
+}
+
 const useLoadDataStore = defineStore('loadData', () => {
   const { startLoading, stopLoading, setError, isLoading } =
     useLoadingNotifications();
@@ -207,11 +277,12 @@ const useLoadDataStore = defineStore('loadData', () => {
 
     if (!dataStore.primarySelection && succeeded.length) {
       const primaryDataSource = pickBaseDataSource(succeeded);
-      const selection = toDataSelection(primaryDataSource);
-      if (selection) {
+      if (isVolumeResult(primaryDataSource)) {
+        const selection = toDataSelection(primaryDataSource);
         dataStore.setPrimarySelection(selection);
         loadLayers(primaryDataSource, succeeded);
-      }
+        loadSegmentations(primaryDataSource, succeeded);
+      } // then must be primaryDataSource.type === 'model'
     }
 
     if (errored.length) {
diff --git a/src/store/segmentGroups.ts b/src/store/segmentGroups.ts
index e2602545c..acd2c5320 100644
--- a/src/store/segmentGroups.ts
+++ b/src/store/segmentGroups.ts
@@ -1,17 +1,25 @@
 import { computed, reactive, ref, toRaw, watch } from 'vue';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkBoundingBox from '@kitware/vtk.js/Common/DataModel/BoundingBox';
+import type { RGBAColor } from '@kitware/vtk.js/types';
 import { defineStore } from 'pinia';
 import { useImageStore } from '@/src/store/datasets-images';
 import { join, normalize } from '@/src/utils/path';
 import { useIdStore } from '@/src/store/id';
 import { onImageDeleted } from '@/src/composables/onImageDeleted';
 import { normalizeForStore, removeFromArray } from '@/src/utils';
-import { compareImageSpaces } from '@/src/utils/imageSpace';
 import { SegmentMask } from '@/src/types/segment';
 import { DEFAULT_SEGMENT_MASKS } from '@/src/config';
 import { readImage, writeImage } from '@/src/io/readWriteImage';
-import type { RGBAColor } from '@kitware/vtk.js/types';
+import {
+  DataSelection,
+  getImage,
+  selectionEquals,
+  findImageID,
+  getImageID,
+  getDataID,
+} from '@/src/utils/dataSelection';
 import vtkLabelMap from '../vtk/LabelMap';
 import {
   StateFile,
@@ -19,13 +27,8 @@ import {
   SegmentGroupMetadata,
 } from '../io/state-file/schema';
 import { FileEntry } from '../io/types';
-import {
-  DataSelection,
-  findImageID,
-  getDataID,
-  getImageID,
-  selectionEquals,
-} from './datasets';
+import { ensureSameSpace } from '../io/resample/resample';
+import { useDICOMStore } from './datasets-dicom';
 
 const LabelmapArrayType = Uint8Array;
 export type LabelmapArrayType = Uint8Array;
@@ -203,15 +206,56 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
     delete metadataByID[id];
   }
 
+  let lastColorIndex = 0;
+  function getNextColor() {
+    const color = DEFAULT_SEGMENT_MASKS[lastColorIndex].color;
+    lastColorIndex = (lastColorIndex + 1) % DEFAULT_SEGMENT_MASKS.length;
+    return [...color];
+  }
+
+  function decodeSegments(image: DataSelection) {
+    if (image.type === 'image') {
+      return structuredClone(DEFAULT_SEGMENT_MASKS);
+    }
+
+    const dicomStore = useDICOMStore();
+    const volumeInfo = dicomStore.volumeInfo[image.volumeKey];
+    const segmentSequence = undefined; // volumeInfo.SegmentSequence;
+    if (!segmentSequence) {
+      return [
+        {
+          value: 255,
+          name: volumeInfo.SeriesDescription || 'Unknown Segment',
+          color: getNextColor(),
+        },
+      ];
+    }
+    // TODO convert Recommended Display CIELab Value (0062,000D) tag to a segment color
+    // TODO convert SegmentDescription (0062,0006) tag to a segment name
+    return [
+      {
+        value: 255,
+        name: volumeInfo.SeriesDescription || 'Unknown Segment',
+        color: [255, 0, 255, 255],
+      },
+    ];
+  }
+
   /**
    * Converts an image to a labelmap.
-   * @param imageID
-   * @param parentID
    */
-  function convertImageToLabelmap(image: DataSelection, parent: DataSelection) {
+  async function convertImageToLabelmap(
+    image: DataSelection,
+    parent: DataSelection
+  ) {
     if (selectionEquals(image, parent))
       throw new Error('Cannot convert an image to be a labelmap of itself');
 
+    // Build vtkImageData for DICOMs
+    const [childImage, parentImage] = await Promise.all(
+      [image, parent].map(getImage)
+    );
+
     const imageID = getImageID(image);
     const parentID = getImageID(parent);
 
@@ -219,25 +263,39 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
       throw new Error('Image and/or parent datasets do not exist');
 
     const imageStore = useImageStore();
-    const parentImage = imageStore.dataIndex[parentID];
-    const childImage = imageStore.dataIndex[imageID];
 
-    if (!compareImageSpaces(childImage, parentImage))
-      throw new Error('Image does not match parent image space');
+    const intersects = vtkBoundingBox.intersects(
+      parentImage.getBounds(),
+      childImage.getBounds()
+    );
+    if (!intersects) {
+      throw new Error(
+        'Segment group and parent image bounds do not intersect. So there is no overlap in physical space.'
+      );
+    }
+
+    const name = imageStore.metadata[imageID].name;
+    // Don't remove image if DICOM as user may have selected child image as primary selection by now
+    const deleteImage = image.type !== 'dicom';
+    if (deleteImage) {
+      imageStore.deleteData(imageID);
+    }
+
+    const resampled = await ensureSameSpace(parentImage, childImage, true);
+    const copyNeeded = resampled === childImage && !deleteImage;
+    const ownedMemoryImage = copyNeeded
+      ? structuredClone(resampled)
+      : resampled;
+    const labelmapImage = toLabelMap(ownedMemoryImage);
 
+    const segments = decodeSegments(image);
+    const { order, byKey } = normalizeForStore(segments, 'value');
     const segmentGroupStore = useSegmentGroupStore();
-    const labelmapImage = toLabelMap(childImage);
-    const { order, byKey } = normalizeForStore(
-      structuredClone(DEFAULT_SEGMENT_MASKS),
-      'value'
-    );
     segmentGroupStore.addLabelmap(labelmapImage, {
-      name: imageStore.metadata[imageID].name,
+      name,
       parentImage: parentID,
       segments: { order, byValue: byKey },
     });
-
-    imageStore.deleteData(imageID);
   }
 
   /**
diff --git a/src/store/tools/useAnnotationTool.ts b/src/store/tools/useAnnotationTool.ts
index 94a584219..def14ea9e 100644
--- a/src/store/tools/useAnnotationTool.ts
+++ b/src/store/tools/useAnnotationTool.ts
@@ -13,7 +13,7 @@ import { useViewStore } from '@/src/store/views';
 import { getLPSAxisFromDir } from '@/src/utils/lps';
 import { LPSAxisDir } from '@/src/types/lps';
 import { AnnotationTool, ToolID } from '@/src/types/annotation-tool';
-import { findImageID, getDataID } from '@/src/store/datasets';
+import { findImageID, getDataID } from '@/src/utils/dataSelection';
 import { useIdStore } from '@/src/store/id';
 import { useToolSelectionStore } from '@/src/store/tools/toolSelection';
 import type { IToolStore } from '@/src/store/tools/types';
diff --git a/src/utils/dataSelection.ts b/src/utils/dataSelection.ts
new file mode 100644
index 000000000..15a41b470
--- /dev/null
+++ b/src/utils/dataSelection.ts
@@ -0,0 +1,95 @@
+import { getDisplayName, useDICOMStore } from '@/src/store/datasets-dicom';
+import { useImageStore } from '@/src/store/datasets-images';
+import { useErrorMessage } from '@/src/composables/useErrorMessage';
+
+export const makeDICOMSelection = (volumeKey: string) =>
+  ({
+    type: 'dicom',
+    volumeKey,
+  } as const);
+
+export type DICOMSelection = ReturnType<typeof makeDICOMSelection>;
+
+export const makeImageSelection = (imageID: string) =>
+  ({
+    type: 'image',
+    dataID: imageID,
+  } as const);
+
+export type ImageSelection = ReturnType<typeof makeImageSelection>;
+
+export type DataSelection = DICOMSelection | ImageSelection;
+
+export const getImageID = (selection: DataSelection) => {
+  if (selection.type === 'image') return selection.dataID;
+  if (selection.type === 'dicom') {
+    // possibly undefined because image may not have been made yet
+    return useDICOMStore().volumeToImageID[selection.volumeKey];
+  }
+
+  const _exhaustiveCheck: never = selection;
+  throw new Error(`invalid selection type ${_exhaustiveCheck}`);
+};
+
+export const getImage = async (selection: DataSelection) => {
+  const images = useImageStore();
+  const dicoms = useDICOMStore();
+  if (selection.type === 'dicom') {
+    // ensure image data exists
+    await useErrorMessage('Failed to build volume', () =>
+      dicoms.buildVolume(selection.volumeKey)
+    );
+    return images.dataIndex[getImageID(selection)!];
+  }
+  // just an image that should be in dataIndex
+  return images.dataIndex[selection.dataID];
+};
+
+// Converts imageID to VolumeKey if exists, else return input imageID
+export const getDataID = (imageID: string) => {
+  const dicomStore = useDICOMStore();
+  return dicomStore.imageIDToVolumeKey[imageID] ?? imageID;
+};
+
+// @param id - VolumeKey or ImageID
+export const getDataSelection = (id: string) => {
+  const dicomStore = useDICOMStore();
+  const volumeKey =
+    dicomStore.imageIDToVolumeKey[id] ??
+    (id in dicomStore.volumeInfo ? id : undefined);
+  if (volumeKey) {
+    return makeDICOMSelection(volumeKey);
+  }
+  return makeImageSelection(id);
+};
+
+// Pass VolumeKey or ImageID and get ImageID
+export const findImageID = (dataID: string) => {
+  const dicomStore = useDICOMStore();
+  return dicomStore.volumeToImageID[dataID] ?? dataID;
+};
+
+export function selectionEquals(s1: DataSelection, s2: DataSelection) {
+  if (s1.type === 'dicom' && s2.type === 'dicom') {
+    return s1.volumeKey === s2.volumeKey;
+  }
+  if (s1.type === 'image' && s2.type === 'image') {
+    return s1.dataID === s2.dataID;
+  }
+  return false;
+}
+
+const getImageName = (imageID: string) => {
+  return useImageStore().metadata[imageID].name;
+};
+
+export const getSelectionName = (selection: DataSelection) => {
+  if (selection.type === 'image') return getImageName(selection.dataID);
+  if (selection.type === 'dicom') {
+    const imageID = getImageID(selection);
+    if (imageID) return getImageName(imageID);
+    return getDisplayName(useDICOMStore().volumeInfo[selection.volumeKey]);
+  }
+  const _exhaustiveCheck: never = selection;
+  throw new Error(`invalid selection type ${_exhaustiveCheck}`);
+};
diff --git a/tests/pageobjects/volview.page.ts b/tests/pageobjects/volview.page.ts
index 1d1df733c..690713f4c 100644
--- a/tests/pageobjects/volview.page.ts
+++ b/tests/pageobjects/volview.page.ts
@@ -83,6 +83,7 @@ class VolViewPage extends Page {
         return notificationCount >= 1;
       },
       {
+        timeout: DOWNLOAD_TIMEOUT,
         timeoutMsg: `expected notification badge to display`,
       }
     );
diff --git a/tests/specs/layers.e2e.ts b/tests/specs/layers.e2e.ts
index f1ecfc010..68724ba49 100644
--- a/tests/specs/layers.e2e.ts
+++ b/tests/specs/layers.e2e.ts
@@ -1,3 +1,4 @@
+import { DOWNLOAD_TIMEOUT } from '../../wdio.shared.conf';
 import { volViewPage } from '../pageobjects/volview.page';
 import { openUrls } from './utils';
 
@@ -21,13 +22,18 @@ describe('Add Layer button', () => {
         return menus.length >= 2;
       },
       {
-        timeout: 30000,
+        timeout: DOWNLOAD_TIMEOUT,
         timeoutMsg: `Expected 2 volumes to appear in list`,
       }
     );
 
+    // Wait for a primary selection
+    await volViewPage.waitForViews();
+    // kludge for CI (dataset not seen as layerable yet without?)
+    await browser.pause(10000);
+
     const menus = await volViewPage.datasetMenuButtons;
-    await menus[0].click();
+    await menus[1].click();
     await browser.waitUntil(
       async () => {
         const addLayerButton = await $(