From 3c20960fa32523c692c9ac12bbef6ff6045f4d11 Mon Sep 17 00:00:00 2001
From: Forrest <forrest.li@kitware.com>
Date: Tue, 7 Nov 2023 14:44:31 -0500
Subject: [PATCH] refactor: rename labelmaps to segment groups

---
 src/components/AnnotationsModule.vue          |  14 +-
 ...pControls.vue => SegmentGroupControls.vue} | 100 ++++++-----
 src/components/SegmentList.vue                |  24 +--
 src/components/VtkTwoView.vue                 |  10 +-
 src/composables/useSceneBuilder.ts            |   4 +-
 src/config.ts                                 |   4 +-
 src/constants.ts                              |   7 -
 src/io/import/processors/restoreStateFile.ts  |   6 +-
 src/io/state-file/index.ts                    |   6 +-
 src/io/state-file/schema.ts                   |  10 +-
 ...datasets-labelmaps.ts => segmentGroups.ts} | 158 +++++++++---------
 src/store/tools/index.ts                      |   2 +-
 src/store/tools/paint.ts                      |  42 ++---
 src/types/{labelmap.ts => segment.ts}         |   2 +-
 src/vtk/LabelMap/index.d.ts                   |   6 +-
 15 files changed, 197 insertions(+), 198 deletions(-)
 rename src/components/{LabelmapControls.vue => SegmentGroupControls.vue} (59%)
 rename src/store/{datasets-labelmaps.ts => segmentGroups.ts} (74%)
 rename src/types/{labelmap.ts => segment.ts} (75%)

diff --git a/src/components/AnnotationsModule.vue b/src/components/AnnotationsModule.vue
index 22c0d3283..b85f0456c 100644
--- a/src/components/AnnotationsModule.vue
+++ b/src/components/AnnotationsModule.vue
@@ -4,13 +4,13 @@ import { storeToRefs } from 'pinia';
 import { AnnotationToolType, Tools } from '@/src/store/tools/types';
 import { useToolStore } from '@/src/store/tools';
 import MeasurementsToolList from './MeasurementsToolList.vue';
-import LabelmapControls from './LabelmapControls.vue';
+import SegmentGroupControls from './SegmentGroupControls.vue';
 import ToolControls from './ToolControls.vue';
 import MeasurementRulerDetails from './MeasurementRulerDetails.vue';
 
 const Tabs = {
   Measurements: 'measurements',
-  Labelmaps: 'labelmaps',
+  SegmentGroups: 'segmentGroups',
 };
 
 const MeasurementTools = [
@@ -33,12 +33,12 @@ const MeasurementToolTypes = new Set<string>(
   MeasurementTools.map(({ type }) => type)
 );
 
-const tab = ref('measurements');
+const tab = ref(Tabs.Measurements);
 const { currentTool } = storeToRefs(useToolStore());
 
 function autoFocusTab() {
   if (currentTool.value === Tools.Paint) {
-    tab.value = Tabs.Labelmaps;
+    tab.value = Tabs.SegmentGroups;
   } else if (MeasurementToolTypes.has(currentTool.value)) {
     tab.value = Tabs.Measurements;
   }
@@ -59,14 +59,14 @@ watch(
     <v-divider thickness="4" />
     <v-tabs v-model="tab" align-tabs="center" density="compact" class="my-1">
       <v-tab value="measurements" class="tab-header">Measurements</v-tab>
-      <v-tab value="labelmaps" class="tab-header">Labelmaps</v-tab>
+      <v-tab value="segmentGroups" class="tab-header">Segment Groups</v-tab>
     </v-tabs>
     <v-window v-model="tab">
       <v-window-item value="measurements">
         <measurements-tool-list :tools="MeasurementTools" />
       </v-window-item>
-      <v-window-item value="labelmaps">
-        <labelmap-controls />
+      <v-window-item value="segmentGroups">
+        <segment-group-controls />
       </v-window-item>
     </v-window>
   </div>
diff --git a/src/components/LabelmapControls.vue b/src/components/SegmentGroupControls.vue
similarity index 59%
rename from src/components/LabelmapControls.vue
rename to src/components/SegmentGroupControls.vue
index d7f2f470b..6e86d08ec 100644
--- a/src/components/LabelmapControls.vue
+++ b/src/components/SegmentGroupControls.vue
@@ -1,59 +1,60 @@
 <script setup lang="ts">
 import SegmentList from '@/src/components/SegmentList.vue';
 import { useCurrentImage } from '@/src/composables/useCurrentImage';
-import { useLabelmapStore } from '@/src/store/datasets-labelmaps';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import { usePaintToolStore } from '@/src/store/tools/paint';
 import { Maybe } from '@/src/types';
 import { reactive, ref, computed, watch, toRaw } from 'vue';
 
-const UNNAMED_LABELMAP_NAME = 'Unnamed Labelmap';
+const UNNAMED_GROUP_NAME = 'Unnamed Segment Group';
 
-const labelmapStore = useLabelmapStore();
+const segmentGroupStore = useSegmentGroupStore();
 const { currentImageID } = useCurrentImage();
 
-const currentLabelmaps = computed(() => {
+const currentSegmentGroups = computed(() => {
   if (!currentImageID.value) return [];
-  if (!(currentImageID.value in labelmapStore.orderByParent)) return [];
-  return labelmapStore.orderByParent[currentImageID.value].map((id) => {
+  const { orderByParent, metadataByID } = segmentGroupStore;
+  if (!(currentImageID.value in orderByParent)) return [];
+  return orderByParent[currentImageID.value].map((id) => {
     return {
       id,
-      name: labelmapStore.labelmapMetadata[id].name,
+      name: metadataByID[id].name,
     };
   });
 });
 
 const paintStore = usePaintToolStore();
-const selectedLabelmapID = computed({
-  get: () => paintStore.activeLabelmapID,
+const currentSegmentGroupID = computed({
+  get: () => paintStore.activeSegmentGroupID,
   set: (id) => paintStore.setActiveLabelmap(id),
 });
 
-// clear selection if we delete the labelmaps
-watch(currentLabelmaps, () => {
-  const selection = selectedLabelmapID.value;
-  if (selection && !(selection in labelmapStore.dataIndex)) {
-    selectedLabelmapID.value = null;
+// clear selection if we delete the active segment group
+watch(currentSegmentGroups, () => {
+  const selection = currentSegmentGroupID.value;
+  if (selection && !(selection in segmentGroupStore.dataIndex)) {
+    currentSegmentGroupID.value = null;
   }
 });
 
-function deleteLabelmap(id: string) {
-  labelmapStore.removeLabelmap(id);
+function deleteGroup(id: string) {
+  segmentGroupStore.removeGroup(id);
 }
 
 // --- editing state --- //
 
-const editingLabelmapID = ref<Maybe<string>>(null);
+const editingGroupID = ref<Maybe<string>>(null);
 const editState = reactive({ name: '' });
 const editDialog = ref(false);
 
 const editingMetadata = computed(() => {
-  if (!editingLabelmapID.value) return null;
-  return labelmapStore.labelmapMetadata[editingLabelmapID.value];
+  if (!editingGroupID.value) return null;
+  return segmentGroupStore.metadataByID[editingGroupID.value];
 });
 
 const existingNames = computed(() => {
   return new Set(
-    Object.values(labelmapStore.labelmapMetadata).map((meta) => meta.name)
+    Object.values(segmentGroupStore.metadataByID).map((meta) => meta.name)
   );
 });
 
@@ -71,7 +72,7 @@ function uniqueNameRule(name: string) {
 
 function startEditing(id: string) {
   editDialog.value = true;
-  editingLabelmapID.value = id;
+  editingGroupID.value = id;
   if (editingMetadata.value) {
     editState.name = editingMetadata.value.name;
   }
@@ -81,30 +82,31 @@ function stopEditing(commit: boolean) {
   if (editingNameConflict.value) return;
 
   editDialog.value = false;
-  if (editingLabelmapID.value && commit)
-    labelmapStore.updateMetadata(editingLabelmapID.value, {
-      name: editState.name || UNNAMED_LABELMAP_NAME,
+  if (editingGroupID.value && commit)
+    segmentGroupStore.updateMetadata(editingGroupID.value, {
+      name: editState.name || UNNAMED_GROUP_NAME,
     });
-  editingLabelmapID.value = null;
+  editingGroupID.value = null;
 }
 
 // --- //
 
-function createLabelmap() {
+function createSegmentGroup() {
   if (!currentImageID.value)
     throw new Error('Cannot create a labelmap without a base image');
 
-  const id = labelmapStore.newLabelmapFromImage(currentImageID.value);
+  const id = segmentGroupStore.newLabelmapFromImage(currentImageID.value);
   if (!id) throw new Error('Could not create a new labelmap');
 
   // copy segments from current labelmap
-  if (selectedLabelmapID.value) {
-    const metadata = labelmapStore.labelmapMetadata[selectedLabelmapID.value];
+  if (currentSegmentGroupID.value) {
+    const metadata =
+      segmentGroupStore.metadataByID[currentSegmentGroupID.value];
     const copied = structuredClone(toRaw(metadata.segments));
-    labelmapStore.updateMetadata(id, { segments: copied });
+    segmentGroupStore.updateMetadata(id, { segments: copied });
   }
 
-  selectedLabelmapID.value = id;
+  currentSegmentGroupID.value = id;
 
   startEditing(id);
 }
@@ -116,41 +118,38 @@ function createLabelmap() {
       variant="tonal"
       color="secondary"
       class="mb-4"
-      @click.stop="createLabelmap"
+      @click.stop="createSegmentGroup"
     >
-      <v-icon class="mr-1">mdi-plus</v-icon> New Labelmap
+      <v-icon class="mr-1">mdi-plus</v-icon> New Segment Group
     </v-btn>
     <div class="text-grey text-subtitle-2">Segment Groups</div>
     <v-divider />
     <v-radio-group
-      v-model="selectedLabelmapID"
+      v-model="currentSegmentGroupID"
       hide-details
       density="comfortable"
       class="my-1 segment-group-list"
     >
       <v-radio
-        v-for="labelmap in currentLabelmaps"
-        :key="labelmap.id"
-        :value="labelmap.id"
+        v-for="group in currentSegmentGroups"
+        :key="group.id"
+        :value="group.id"
       >
         <template #label>
-          <div
-            class="d-flex flex-row align-center w-100"
-            :title="labelmap.name"
-          >
-            <span class="labelmap-name">{{ labelmap.name }}</span>
+          <div class="d-flex flex-row align-center w-100" :title="group.name">
+            <span class="group-name">{{ group.name }}</span>
             <v-spacer />
             <v-btn
               icon="mdi-pencil"
               size="x-small"
               variant="flat"
-              @click.stop="startEditing(labelmap.id)"
+              @click.stop="startEditing(group.id)"
             ></v-btn>
             <v-btn
               icon="mdi-delete"
               size="x-small"
               variant="flat"
-              @click.stop="deleteLabelmap(labelmap.id)"
+              @click.stop="deleteGroup(group.id)"
             ></v-btn>
           </div>
         </template>
@@ -159,14 +158,17 @@ function createLabelmap() {
     <v-divider />
   </div>
   <div v-else class="text-center text-caption">No selected image</div>
-  <segment-list v-if="selectedLabelmapID" :labelmap-id="selectedLabelmapID" />
+  <segment-list
+    v-if="currentSegmentGroupID"
+    :group-id="currentSegmentGroupID"
+  />
 
   <v-dialog v-model="editDialog" max-width="400px">
     <v-card>
       <v-card-text>
         <v-text-field
           v-model="editState.name"
-          :placeholder="UNNAMED_LABELMAP_NAME"
+          :placeholder="UNNAMED_GROUP_NAME"
           :rules="[uniqueNameRule]"
           @keydown.stop.enter="stopEditing(true)"
         />
@@ -188,11 +190,7 @@ function createLabelmap() {
   overflow-y: auto;
 }
 
-.labelmap-select > .v-input__append {
-  margin-left: 8px;
-}
-
-.labelmap-name {
+.group-name {
   word-wrap: none;
   white-space: nowrap;
   overflow: hidden;
diff --git a/src/components/SegmentList.vue b/src/components/SegmentList.vue
index 4b2685bef..b3a945a2b 100644
--- a/src/components/SegmentList.vue
+++ b/src/components/SegmentList.vue
@@ -3,33 +3,33 @@ import EditableChipList from '@/src/components/EditableChipList.vue';
 import SegmentEditor from '@/src/components/SegmentEditor.vue';
 import IsolatedDialog from '@/src/components/IsolatedDialog.vue';
 import {
-  useLabelmapStore,
+  useSegmentGroupStore,
   makeDefaultSegmentName,
-} from '@/src/store/datasets-labelmaps';
+} from '@/src/store/segmentGroups';
 import { Maybe } from '@/src/types';
 import { hexaToRGBA, rgbaToHexa } from '@/src/utils/color';
 import { reactive, ref, toRefs, computed, watch } from 'vue';
-import { LabelMapSegment } from '@/src/types/labelmap';
+import { SegmentMask } from '@/src/types/segment';
 import { usePaintToolStore } from '@/src/store/tools/paint';
 
 const props = defineProps({
-  labelmapId: {
+  groupId: {
     required: true,
     type: String,
   },
 });
 
-const { labelmapId } = toRefs(props);
+const { groupId } = toRefs(props);
 
-const labelmapStore = useLabelmapStore();
+const segmentGroupStore = useSegmentGroupStore();
 const paintStore = usePaintToolStore();
 
-const segments = computed<LabelMapSegment[]>(() => {
-  return labelmapStore.segmentsByLabelmapID[labelmapId.value] ?? [];
+const segments = computed<SegmentMask[]>(() => {
+  return segmentGroupStore.segmentByGroupID[groupId.value] ?? [];
 });
 
 function addNewSegment() {
-  labelmapStore.addSegment(labelmapId.value);
+  segmentGroupStore.addSegment(groupId.value);
 }
 
 // --- selection --- //
@@ -68,7 +68,7 @@ const editDialog = ref(false);
 
 const editingSegment = computed(() => {
   if (editingSegmentValue.value == null) return null;
-  return labelmapStore.getSegment(labelmapId.value, editingSegmentValue.value);
+  return segmentGroupStore.getSegment(groupId.value, editingSegmentValue.value);
 });
 
 function startEditing(value: number) {
@@ -81,7 +81,7 @@ function startEditing(value: number) {
 
 function stopEditing(commit: boolean) {
   if (editingSegmentValue.value && commit)
-    labelmapStore.updateSegment(labelmapId.value, editingSegmentValue.value, {
+    segmentGroupStore.updateSegment(groupId.value, editingSegmentValue.value, {
       name: editState.name ?? makeDefaultSegmentName(editingSegmentValue.value),
       color: hexaToRGBA(editState.color),
     });
@@ -90,7 +90,7 @@ function stopEditing(commit: boolean) {
 }
 
 function deleteSegment(value: number) {
-  labelmapStore.deleteSegment(labelmapId.value, value);
+  segmentGroupStore.deleteSegment(groupId.value, value);
 }
 
 function deleteEditingSegment() {
diff --git a/src/components/VtkTwoView.vue b/src/components/VtkTwoView.vue
index bea571070..9921f7ea9 100644
--- a/src/components/VtkTwoView.vue
+++ b/src/components/VtkTwoView.vue
@@ -223,7 +223,7 @@ import PolygonTool from './tools/polygon/PolygonTool.vue';
 import PaintTool from './tools/paint/PaintTool.vue';
 import { useSceneBuilder } from '../composables/useSceneBuilder';
 import { useDICOMStore } from '../store/datasets-dicom';
-import { useLabelmapStore } from '../store/datasets-labelmaps';
+import { useSegmentGroupStore } from '../store/segmentGroups';
 import vtkLabelMapSliceRepProxy from '../vtk/LabelMapSliceRepProxy';
 import { usePaintToolStore } from '../store/tools/paint';
 import useWindowingStore from '../store/view-configs/windowing';
@@ -572,10 +572,10 @@ export default defineComponent({
 
     // --- scene setup --- //
 
-    const labelmapStore = useLabelmapStore();
+    const segmentGroupStore = useSegmentGroupStore();
 
-    const labelmapIDs = computed(() =>
-      curImageID.value ? labelmapStore.orderByParent[curImageID.value] : []
+    const segmentGroupIDs = computed(() =>
+      curImageID.value ? segmentGroupStore.orderByParent[curImageID.value] : []
     );
 
     const layerIDs = computed(() => currentLayers.value.map(({ id }) => id));
@@ -586,7 +586,7 @@ export default defineComponent({
       vtkIJKSliceRepresentationProxy
     >(viewID, {
       baseImage: curImageID,
-      labelmaps: labelmapIDs,
+      labelmaps: segmentGroupIDs,
       layers: layerIDs,
     });
 
diff --git a/src/composables/useSceneBuilder.ts b/src/composables/useSceneBuilder.ts
index d3d02838c..71b1dd991 100644
--- a/src/composables/useSceneBuilder.ts
+++ b/src/composables/useSceneBuilder.ts
@@ -35,8 +35,8 @@ export function useSceneBuilder<
   });
 
   const labelmapReps = computed(() => {
-    const labelmapIDs = sceneIDs.labelmaps?.value ?? [];
-    return labelmapIDs
+    const ids = sceneIDs.labelmaps?.value ?? [];
+    return ids
       .map((id) =>
         viewStore.getDataRepresentationForView<LabelMapType>(id, viewID.value)
       )
diff --git a/src/config.ts b/src/config.ts
index 66bfa3bf1..323acaff6 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -3,7 +3,7 @@ import MRIPROSTATExThumbnail from '@/src/assets/samples/MRI-PROSTATEx.jpg';
 import MRAHeadThumbnail from '@/src/assets/samples/MRA-Head_and_Neck.jpg';
 import CTAHeadThumbnail from '@/src/assets/samples/CTA-Head_and_Neck.jpg';
 import USFetusThumbnail from '@/src/assets/samples/3DUS-Fetus.jpg';
-import { LabelMapSegment } from '@/src/types/labelmap';
+import { SegmentMask } from '@/src/types/segment';
 import { Layout, LayoutDirection } from './types/layout';
 import { ViewSpec } from './types/views';
 import { SampleDataset } from './types';
@@ -158,7 +158,7 @@ export const Layouts: Record<string, Layout> = [
   return { ...layouts, [layout.name]: layout };
 }, {});
 
-export const DEFAULT_LABELMAP_SEGMENTS: LabelMapSegment[] = [
+export const DEFAULT_SEGMENT_MASKS: SegmentMask[] = [
   {
     value: 1,
     name: 'Tissue',
diff --git a/src/constants.ts b/src/constants.ts
index 2d2771a27..301d1cd57 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -45,13 +45,6 @@ export const VTKThreeViewWidgetManager: InjectionKey<
 export const ToolContainer: InjectionKey<Ref<Maybe<HTMLElement>>> =
   Symbol('ToolContainer');
 
-export const DataTypes = {
-  Image: 'Image',
-  Labelmap: 'Labelmap',
-  Dicom: 'DICOM',
-  Model: 'Model',
-};
-
 export const Messages = {
   WebGLLost: {
     title: 'Viewer Error',
diff --git a/src/io/import/processors/restoreStateFile.ts b/src/io/import/processors/restoreStateFile.ts
index 161b24087..840b3120c 100644
--- a/src/io/import/processors/restoreStateFile.ts
+++ b/src/io/import/processors/restoreStateFile.ts
@@ -26,7 +26,7 @@ import {
   makeImageSelection,
   useDatasetStore,
 } from '@/src/store/datasets';
-import { useLabelmapStore } from '@/src/store/datasets-labelmaps';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import { useToolStore } from '@/src/store/tools';
 import { useLayersStore } from '@/src/store/datasets-layers';
 import { extractFilesFromZip } from '@/src/io/zip';
@@ -266,14 +266,14 @@ const restoreStateFile: ImportHandler = async (
     useViewStore().deserialize(manifest.views, stateIDToStoreID);
 
     // Restore the labelmaps
-    const labelmapIDMap = await useLabelmapStore().deserialize(
+    const segmentGroupIDMap = await useSegmentGroupStore().deserialize(
       manifest,
       restOfStateFile,
       stateIDToStoreID
     );
 
     // Restore the tools
-    useToolStore().deserialize(manifest, labelmapIDMap, stateIDToStoreID);
+    useToolStore().deserialize(manifest, segmentGroupIDMap, stateIDToStoreID);
 
     useLayersStore().deserialize(manifest, stateIDToStoreID);
 
diff --git a/src/io/state-file/index.ts b/src/io/state-file/index.ts
index d706f44e5..eaab18c88 100644
--- a/src/io/state-file/index.ts
+++ b/src/io/state-file/index.ts
@@ -1,6 +1,6 @@
 import JSZip from 'jszip';
 import { useDatasetStore } from '@/src/store/datasets';
-import { useLabelmapStore } from '@/src/store/datasets-labelmaps';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import { useLayersStore } from '@/src/store/datasets-layers';
 import { useToolStore } from '@/src/store/tools';
 import { Tools } from '@/src/store/tools/types';
@@ -17,7 +17,7 @@ export const MANIFEST_VERSION = '3.0.0';
 export async function serialize() {
   const datasetStore = useDatasetStore();
   const viewStore = useViewStore();
-  const labelStore = useLabelmapStore();
+  const labelStore = useSegmentGroupStore();
   const toolStore = useToolStore();
   const layersStore = useLayersStore();
 
@@ -32,7 +32,7 @@ export async function serialize() {
         position: [0, 0, 0],
       },
       paint: {
-        activeLabelmapID: null,
+        activeSegmentGroupID: null,
         activeSegment: null,
         brushSize: 8,
         labelmapOpacity: 1,
diff --git a/src/io/state-file/schema.ts b/src/io/state-file/schema.ts
index fdf591d24..53877bfc6 100644
--- a/src/io/state-file/schema.ts
+++ b/src/io/state-file/schema.ts
@@ -239,25 +239,25 @@ export type View = z.infer<typeof View>;
 
 const RGBAColor = z.tuple([z.number(), z.number(), z.number(), z.number()]);
 
-const LabelMapSegment = z.object({
+const SegmentMask = z.object({
   value: z.number(),
   name: z.string(),
   color: RGBAColor,
 });
 
-export const LabelMapMetadata = z.object({
+export const SegmentGroupMetadata = z.object({
   name: z.string(),
   parentImage: z.string(),
   segments: z.object({
     order: z.number().array(),
-    byValue: z.record(z.string(), LabelMapSegment),
+    byValue: z.record(z.string(), SegmentMask),
   }),
 });
 
 export const LabelMap = z.object({
   id: z.string(),
   path: z.string(),
-  metadata: LabelMapMetadata,
+  metadata: SegmentGroupMetadata,
 });
 
 export type LabelMap = z.infer<typeof LabelMap>;
@@ -317,7 +317,7 @@ export type Crosshairs = z.infer<typeof Crosshairs>;
 const ToolsEnumNative = z.nativeEnum(ToolsEnum);
 
 const Paint = z.object({
-  activeLabelmapID: z.string().nullable(),
+  activeSegmentGroupID: z.string().nullable(),
   activeSegment: z.number().nullish(),
   brushSize: z.number(),
   labelmapOpacity: z.number(),
diff --git a/src/store/datasets-labelmaps.ts b/src/store/segmentGroups.ts
similarity index 74%
rename from src/store/datasets-labelmaps.ts
rename to src/store/segmentGroups.ts
index c2ae4486c..4cd1b225f 100644
--- a/src/store/datasets-labelmaps.ts
+++ b/src/store/segmentGroups.ts
@@ -8,11 +8,15 @@ 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 { LabelMapSegment } from '@/src/types/labelmap';
-import { DEFAULT_LABELMAP_SEGMENTS } from '@/src/config';
+import { SegmentMask } from '@/src/types/segment';
+import { DEFAULT_SEGMENT_MASKS } from '@/src/config';
 import { RGBAColor } from '@kitware/vtk.js/types';
 import vtkLabelMap from '../vtk/LabelMap';
-import { StateFile, Manifest, LabelMapMetadata } from '../io/state-file/schema';
+import {
+  StateFile,
+  Manifest,
+  SegmentGroupMetadata,
+} from '../io/state-file/schema';
 import { vtiReader, vtiWriter } from '../io/vtk/async';
 import { FileEntry } from '../io/types';
 import {
@@ -29,15 +33,15 @@ export type LabelmapArrayType = Uint8Array;
 export const LABELMAP_BACKGROUND_VALUE = 0;
 export const DEFAULT_SEGMENT_COLOR: RGBAColor = [255, 0, 0, 255];
 export const makeDefaultSegmentName = (value: number) => `Segment ${value}`;
-export const makeDefaultLabelmapName = (baseName: string, index: number) =>
-  `Labelmap ${index} for ${baseName}`;
+export const makeDefaultSegmentGroupName = (baseName: string, index: number) =>
+  `Segment Group ${index} for ${baseName}`;
 
-export interface LabelMapMetadata {
+export interface SegmentGroupMetadata {
   name: string;
   parentImage: string;
   segments: {
     order: number[];
-    byValue: Record<number, LabelMapSegment>;
+    byValue: Record<number, SegmentMask>;
   };
 }
 
@@ -75,34 +79,34 @@ export function toLabelMap(imageData: vtkImageData) {
   return labelmap;
 }
 
-export const useLabelmapStore = defineStore('labelmap', () => {
-  type _This = ReturnType<typeof useLabelmapStore>;
+export const useSegmentGroupStore = defineStore('segmentGroup', () => {
+  type _This = ReturnType<typeof useSegmentGroupStore>;
 
   const dataIndex = reactive<Record<string, vtkLabelMap>>(Object.create(null));
-  const labelmapMetadata = reactive<Record<string, LabelMapMetadata>>(
+  const metadataByID = reactive<Record<string, SegmentGroupMetadata>>(
     Object.create(null)
   );
   const orderByParent = ref<Record<string, string[]>>(Object.create(null));
 
   /**
    * Gets the metadata for a labelmap.
-   * @param labelmapID
+   * @param segmentGroupID
    * @param segmentValue
    */
-  function getMetadata(labelmapID: string) {
-    if (!(labelmapID in labelmapMetadata))
+  function getMetadata(segmentGroupID: string) {
+    if (!(segmentGroupID in metadataByID))
       throw new Error('No such labelmap ID');
-    return labelmapMetadata[labelmapID];
+    return metadataByID[segmentGroupID];
   }
 
   /**
    * Gets a segment.
-   * @param labelmapID
+   * @param segmentGroupID
    * @param segmentValue
    * @returns
    */
-  function getSegment(labelmapID: string, segmentValue: number) {
-    const metadata = getMetadata(labelmapID);
+  function getSegment(segmentGroupID: string, segmentValue: number) {
+    const metadata = getMetadata(segmentGroupID);
     if (!(segmentValue in metadata.segments.byValue))
       throw new Error('No such segment');
     return metadata.segments.byValue[segmentValue];
@@ -112,15 +116,15 @@ export const useLabelmapStore = defineStore('labelmap', () => {
    * Validates that a segment does not violate constraints.
    *
    * Assumes that the given segment is not yet part of the labelmap segments.
-   * @param labelmapID
+   * @param segmentGroupID
    * @param segment
    */
-  function validateSegment(labelmapID: string, segment: LabelMapSegment) {
+  function validateSegment(segmentGroupID: string, segment: SegmentMask) {
     return (
       // cannot be zero (background)
       segment.value !== 0 &&
       // cannot already exist
-      !(segment.value in getMetadata(labelmapID).segments.byValue)
+      !(segment.value in getMetadata(segmentGroupID).segments.byValue)
     );
   }
 
@@ -130,12 +134,12 @@ export const useLabelmapStore = defineStore('labelmap', () => {
   function addLabelmap(
     this: _This,
     labelmap: vtkLabelMap,
-    metadata: LabelMapMetadata
+    metadata: SegmentGroupMetadata
   ) {
     const id = useIdStore().nextId();
 
     dataIndex[id] = labelmap;
-    labelmapMetadata[id] = metadata;
+    metadataByID[id] = metadata;
     orderByParent.value[metadata.parentImage] ??= [];
     orderByParent.value[metadata.parentImage].push(id);
 
@@ -168,19 +172,19 @@ export const useLabelmapStore = defineStore('labelmap', () => {
     const labelmap = createLabelmapFromImage(imageData);
 
     const { order, byKey } = normalizeForStore(
-      structuredClone(DEFAULT_LABELMAP_SEGMENTS),
+      structuredClone(DEFAULT_SEGMENT_MASKS),
       'value'
     );
 
     // pick a unique name
     let name = '';
     const existingNames = new Set(
-      Object.values(labelmapMetadata).map((meta) => meta.name)
+      Object.values(metadataByID).map((meta) => meta.name)
     );
     do {
       const nameIndex = nextDefaultIndex[parentID] ?? 1;
       nextDefaultIndex[parentID] = nameIndex + 1;
-      name = makeDefaultLabelmapName(baseName, nameIndex);
+      name = makeDefaultSegmentGroupName(baseName, nameIndex);
     } while (existingNames.has(name));
 
     return addLabelmap.call(this, labelmap, {
@@ -193,12 +197,12 @@ export const useLabelmapStore = defineStore('labelmap', () => {
   /**
    * Deletes a labelmap.
    */
-  function removeLabelmap(id: string) {
+  function removeGroup(id: string) {
     if (!(id in dataIndex)) return;
-    const { parentImage } = labelmapMetadata[id];
+    const { parentImage } = metadataByID[id];
     removeFromArray(orderByParent.value[parentImage], id);
     delete dataIndex[id];
-    delete labelmapMetadata[id];
+    delete metadataByID[id];
   }
 
   /**
@@ -223,13 +227,13 @@ export const useLabelmapStore = defineStore('labelmap', () => {
     if (!compareImageSpaces(childImage, parentImage))
       throw new Error('Image does not match parent image space');
 
-    const labelmapStore = useLabelmapStore();
+    const segmentGroupStore = useSegmentGroupStore();
     const labelmapImage = toLabelMap(childImage);
     const { order, byKey } = normalizeForStore(
-      structuredClone(DEFAULT_LABELMAP_SEGMENTS),
+      structuredClone(DEFAULT_SEGMENT_MASKS),
       'value'
     );
-    labelmapStore.addLabelmap(labelmapImage, {
+    segmentGroupStore.addLabelmap(labelmapImage, {
       name: imageStore.metadata[imageID].name,
       parentImage: parentID,
       segments: { order, byValue: byKey },
@@ -240,15 +244,15 @@ export const useLabelmapStore = defineStore('labelmap', () => {
 
   /**
    * Updates a labelmap's metadata
-   * @param labelmapID
+   * @param segmentGroupID
    * @param metadata
    */
   function updateMetadata(
-    labelmapID: string,
-    metadata: Partial<LabelMapMetadata>
+    segmentGroupID: string,
+    metadata: Partial<SegmentGroupMetadata>
   ) {
-    labelmapMetadata[labelmapID] = {
-      ...getMetadata(labelmapID),
+    metadataByID[segmentGroupID] = {
+      ...getMetadata(segmentGroupID),
       ...metadata,
     };
   }
@@ -257,10 +261,10 @@ export const useLabelmapStore = defineStore('labelmap', () => {
    * Creates a new default segment with an unallocated value.
    *
    * The value picked is the smallest unused value greater than 0.
-   * @param labelmapID
+   * @param segmentGroupID
    */
-  function createNewSegment(labelmapID: string): LabelMapSegment {
-    const { segments } = getMetadata(labelmapID);
+  function createNewSegment(segmentGroupID: string): SegmentMask {
+    const { segments } = getMetadata(segmentGroupID);
 
     let value = 1;
     for (; value <= segments.order.length; value++) {
@@ -279,13 +283,14 @@ export const useLabelmapStore = defineStore('labelmap', () => {
    *
    * If no segment is provided, a default one is provided.
    * Duplicate segment values throw an error.
-   * @param labelmapID
+   * @param segmentGroupID
    * @param segment
    */
-  function addSegment(labelmapID: string, segment?: LabelMapSegment) {
-    const metadata = getMetadata(labelmapID);
-    const seg = segment ?? createNewSegment(labelmapID);
-    if (!validateSegment(labelmapID, seg)) throw new Error('Invalid segment');
+  function addSegment(segmentGroupID: string, segment?: SegmentMask) {
+    const metadata = getMetadata(segmentGroupID);
+    const seg = segment ?? createNewSegment(segmentGroupID);
+    if (!validateSegment(segmentGroupID, seg))
+      throw new Error('Invalid segment');
     metadata.segments.byValue[seg.value] = seg;
     metadata.segments.order.push(seg.value);
   }
@@ -294,17 +299,17 @@ export const useLabelmapStore = defineStore('labelmap', () => {
    * Updates a segment's properties.
    *
    * Does not allow updating the segment value.
-   * @param labelmapID
+   * @param segmentGroupID
    * @param segmentValue
    * @param segmentUpdate
    */
   function updateSegment(
-    labelmapID: string,
+    segmentGroupID: string,
     segmentValue: number,
-    segmentUpdate: Partial<Omit<LabelMapSegment, 'value'>>
+    segmentUpdate: Partial<Omit<SegmentMask, 'value'>>
   ) {
-    const metadata = getMetadata(labelmapID);
-    const segment = getSegment(labelmapID, segmentValue);
+    const metadata = getMetadata(segmentGroupID);
+    const segment = getSegment(segmentGroupID, segmentValue);
     metadata.segments.byValue[segmentValue] = {
       ...segment,
       ...segmentUpdate,
@@ -313,15 +318,15 @@ export const useLabelmapStore = defineStore('labelmap', () => {
 
   /**
    * Deletes a segment from a labelmap.
-   * @param labelmapID
+   * @param segmentGroupID
    * @param segmentValue
    */
-  function deleteSegment(labelmapID: string, segmentValue: number) {
-    const { segments } = getMetadata(labelmapID);
+  function deleteSegment(segmentGroupID: string, segmentValue: number) {
+    const { segments } = getMetadata(segmentGroupID);
     removeFromArray(segments.order, segmentValue);
     delete segments.byValue[segmentValue];
 
-    dataIndex[labelmapID].replaceLabelValue(
+    dataIndex[segmentGroupID].replaceLabelValue(
       segmentValue,
       LABELMAP_BACKGROUND_VALUE
     );
@@ -338,9 +343,9 @@ export const useLabelmapStore = defineStore('labelmap', () => {
 
     const parents = Object.keys(orderByParent.value);
     const serialized = parents.flatMap((parentID) => {
-      const labelmapIDs = orderByParent.value[parentID];
-      return labelmapIDs.map((id) => {
-        const metadata = labelmapMetadata[id];
+      const segmentGroupIDs = orderByParent.value[parentID];
+      return segmentGroupIDs.map((id) => {
+        const metadata = metadataByID[id];
         return {
           id,
           path: `labels/${id}.vti`,
@@ -374,7 +379,7 @@ export const useLabelmapStore = defineStore('labelmap', () => {
   ) {
     const { labelMaps } = manifest;
 
-    const labelmapIDMap: Record<string, string> = {};
+    const segmentGroupIDMap: Record<string, string> = {};
 
     // First restore the data, then restore the store.
     // This preserves ordering from orderByParent.
@@ -406,32 +411,33 @@ export const useLabelmapStore = defineStore('labelmap', () => {
       metadata.parentImage = parentImage;
 
       const newID = newLabelmapIDs[index];
-      labelmapIDMap[labelMap.id] = newID;
+      segmentGroupIDMap[labelMap.id] = newID;
 
-      labelmapMetadata[newID] = metadata;
+      metadataByID[newID] = metadata;
       orderByParent.value[parentImage] ??= [];
       orderByParent.value[parentImage].push(newID);
     });
 
-    return labelmapIDMap;
+    return segmentGroupIDMap;
   }
 
   // --- sync segments --- //
 
-  const segmentsByLabelmapID = computed(() => {
-    return Object.entries(labelmapMetadata).reduce<
-      Record<string, LabelMapSegment[]>
-    >((acc, [id, metadata]) => {
-      const {
-        segments: { order, byValue },
-      } = metadata;
-      const segments = order.map((value) => byValue[value]);
-      return { ...acc, [id]: segments };
-    }, {});
+  const segmentByGroupID = computed(() => {
+    return Object.entries(metadataByID).reduce<Record<string, SegmentMask[]>>(
+      (acc, [id, metadata]) => {
+        const {
+          segments: { order, byValue },
+        } = metadata;
+        const segments = order.map((value) => byValue[value]);
+        return { ...acc, [id]: segments };
+      },
+      {}
+    );
   });
 
   watch(
-    segmentsByLabelmapID,
+    segmentByGroupID,
     (segsByID) => {
       Object.entries(segsByID).forEach(([id, segments]) => {
         // ensure segments are not proxies
@@ -445,8 +451,8 @@ export const useLabelmapStore = defineStore('labelmap', () => {
 
   onImageDeleted((deleted) => {
     deleted.forEach((parentID) => {
-      orderByParent.value[parentID].forEach((labelmapID) => {
-        removeLabelmap(labelmapID);
+      orderByParent.value[parentID].forEach((segmentGroupID) => {
+        removeGroup(segmentGroupID);
       });
     });
   });
@@ -455,12 +461,12 @@ export const useLabelmapStore = defineStore('labelmap', () => {
 
   return {
     dataIndex,
-    labelmapMetadata,
+    metadataByID,
     orderByParent,
-    segmentsByLabelmapID,
+    segmentByGroupID,
     addLabelmap,
     newLabelmapFromImage,
-    removeLabelmap,
+    removeGroup,
     convertImageToLabelmap,
     updateMetadata,
     addSegment,
diff --git a/src/store/tools/index.ts b/src/store/tools/index.ts
index 1ee395be9..ccf52f3d0 100644
--- a/src/store/tools/index.ts
+++ b/src/store/tools/index.ts
@@ -90,7 +90,7 @@ export const useToolStore = defineStore('tool', {
     },
     deserialize(
       manifest: Manifest,
-      labelmapIDMap: Record<string, string>,
+      segmentGroupIDMap: Record<string, string>,
       dataIDMap: Record<string, string>
     ) {
       const { tools } = manifest;
diff --git a/src/store/tools/paint.ts b/src/store/tools/paint.ts
index c0f77d590..431d96f5e 100644
--- a/src/store/tools/paint.ts
+++ b/src/store/tools/paint.ts
@@ -7,7 +7,7 @@ import { defineStore } from 'pinia';
 import { Maybe } from '@/src/types';
 import { PaintMode } from '@/src/core/tools/paint';
 import { Tools } from './types';
-import { useLabelmapStore } from '../datasets-labelmaps';
+import { useSegmentGroupStore } from '../segmentGroups';
 
 const DEFAULT_BRUSH_SIZE = 4;
 
@@ -15,7 +15,7 @@ export const usePaintToolStore = defineStore('paint', () => {
   type _This = ReturnType<typeof usePaintToolStore>;
 
   const activeMode = ref(PaintMode.CirclePaint);
-  const activeLabelmapID = ref<string | null>(null);
+  const activeSegmentGroupID = ref<string | null>(null);
   const activeSegment = ref<Maybe<number>>(null);
   const brushSize = ref(DEFAULT_BRUSH_SIZE);
   const strokePoints = ref<vec3[]>([]);
@@ -29,9 +29,9 @@ export const usePaintToolStore = defineStore('paint', () => {
   }
 
   const activeLabelmap = computed(() => {
-    if (!activeLabelmapID.value) return null;
-    const labelmapStore = useLabelmapStore();
-    return labelmapStore.dataIndex[activeLabelmapID.value] ?? null;
+    if (!activeSegmentGroupID.value) return null;
+    const segmentGroupStore = useSegmentGroupStore();
+    return segmentGroupStore.dataIndex[activeSegmentGroupID.value] ?? null;
   });
 
   // --- actions --- //
@@ -48,8 +48,8 @@ export const usePaintToolStore = defineStore('paint', () => {
   /**
    * Sets the active labelmap.
    */
-  function setActiveLabelmap(labelmapID: string | null) {
-    activeLabelmapID.value = labelmapID;
+  function setActiveLabelmap(segmentGroupID: string | null) {
+    activeSegmentGroupID.value = segmentGroupID;
   }
 
   /**
@@ -63,12 +63,13 @@ export const usePaintToolStore = defineStore('paint', () => {
       return;
     }
 
-    const labelmapStore = useLabelmapStore();
-    const labelmaps = labelmapStore.orderByParent[imageID];
+    const segmentGroupStore = useSegmentGroupStore();
+    const labelmaps = segmentGroupStore.orderByParent[imageID];
     if (labelmaps?.length) {
-      activeLabelmapID.value = labelmaps[0];
+      activeSegmentGroupID.value = labelmaps[0];
     } else {
-      activeLabelmapID.value = labelmapStore.newLabelmapFromImage(imageID);
+      activeSegmentGroupID.value =
+        segmentGroupStore.newLabelmapFromImage(imageID);
     }
   }
 
@@ -80,12 +81,12 @@ export const usePaintToolStore = defineStore('paint', () => {
    */
   function setActiveSegment(this: _This, segValue: Maybe<number>) {
     if (segValue) {
-      if (!activeLabelmapID.value)
+      if (!activeSegmentGroupID.value)
         throw new Error('Cannot set active segment without a labelmap');
 
-      const labelmapStore = useLabelmapStore();
+      const segmentGroupStore = useSegmentGroupStore();
       const { segments } =
-        labelmapStore.labelmapMetadata[activeLabelmapID.value];
+        segmentGroupStore.metadataByID[activeSegmentGroupID.value];
 
       if (!(segValue in segments.byValue))
         throw new Error('Segment is not available for the active labelmap');
@@ -170,14 +171,14 @@ export const usePaintToolStore = defineStore('paint', () => {
   }
 
   function deactivateTool() {
-    activeLabelmapID.value = null;
+    activeSegmentGroupID.value = null;
     isActive.value = false;
   }
 
   function serialize(state: StateFile) {
     const { paint } = state.manifest.tools;
 
-    paint.activeLabelmapID = activeLabelmapID.value;
+    paint.activeSegmentGroupID = activeSegmentGroupID.value;
     paint.brushSize = brushSize.value;
     paint.activeSegment = activeSegment.value;
     paint.labelmapOpacity = labelmapOpacity.value;
@@ -186,7 +187,7 @@ export const usePaintToolStore = defineStore('paint', () => {
   function deserialize(
     this: _This,
     manifest: Manifest,
-    labelmapIDMap: Record<string, string>
+    segmentGroupIDMap: Record<string, string>
   ) {
     const { paint } = manifest.tools;
     setBrushSize.call(this, paint.brushSize);
@@ -194,8 +195,9 @@ export const usePaintToolStore = defineStore('paint', () => {
     setLabelmapOpacity.call(this, paint.labelmapOpacity);
     isActive.value = manifest.tools.current === Tools.Paint;
 
-    if (paint.activeLabelmapID !== null) {
-      activeLabelmapID.value = labelmapIDMap[paint.activeLabelmapID];
+    if (paint.activeSegmentGroupID !== null) {
+      activeSegmentGroupID.value =
+        segmentGroupIDMap[paint.activeSegmentGroupID];
     }
   }
 
@@ -214,7 +216,7 @@ export const usePaintToolStore = defineStore('paint', () => {
   return {
     // state
     activeMode,
-    activeLabelmapID,
+    activeSegmentGroupID,
     activeSegment,
     brushSize,
     strokePoints,
diff --git a/src/types/labelmap.ts b/src/types/segment.ts
similarity index 75%
rename from src/types/labelmap.ts
rename to src/types/segment.ts
index 657c705fd..dacfb9074 100644
--- a/src/types/labelmap.ts
+++ b/src/types/segment.ts
@@ -1,6 +1,6 @@
 import { RGBAColor } from '@kitware/vtk.js/types';
 
-export interface LabelMapSegment {
+export interface SegmentMask {
   value: number;
   name: string;
   color: RGBAColor;
diff --git a/src/vtk/LabelMap/index.d.ts b/src/vtk/LabelMap/index.d.ts
index 9e3c239b8..df8c3c378 100644
--- a/src/vtk/LabelMap/index.d.ts
+++ b/src/vtk/LabelMap/index.d.ts
@@ -1,4 +1,4 @@
-import { LabelMapSegment } from '@/src/types/labelmap';
+import { SegmentMask } from '@/src/types/segment';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type { Vector4 } from '@kitware/vtk.js/types';
 
@@ -7,12 +7,12 @@ export interface vtkLabelMap extends vtkImageData {
    * Sets the segments of the labelmap.
    * @param segments
    */
-  setSegments(segments: LabelMapSegment[]): boolean;
+  setSegments(segments: SegmentMask[]): boolean;
 
   /**
    * Gets the segments of the labelmap.
    */
-  getSegments(): LabelMapSegment[];
+  getSegments(): SegmentMask[];
 
   /**
    * Replaces a labelmap value with another value.