@vitessce/vit-s 4.0.4 → 4.0.6

package/src/data-hooks-multilevel.js

@@ -10,6 +10,7 @@ import {
   useObsLocationsMultiLevel,
   useObsSetsMultiLevel,
   useObsLabelsMultiLevel,
+  useObsColorsMultiLevel,
 } from './data-hooks-multilevel-utils.js';
 
 
@@ -319,3 +320,34 @@ export function useSegmentationMultiObsSets(
   );
   return [indicesData, indicesDataStatus, indicesDataErrors];
 }
+
+/**
+ * Wrapper around useObsColorsMultiLevel.
+ * @param {object} coordinationScopes
+ * @param {object} coordinationScopesBy
+ * @param {object} loaders
+ * @param {string} dataset
+ * @returns {array} [data, status, errors]
+ */
+export function useSegmentationMultiObsColors(
+  coordinationScopes, coordinationScopesBy, loaders, dataset,
+) {
+  const obsTypeCoordination = useComplexCoordinationSecondary(
+    [
+      CoordinationType.OBS_TYPE,
+    ],
+    coordinationScopes,
+    coordinationScopesBy,
+    CoordinationType.SEGMENTATION_LAYER,
+    CoordinationType.SEGMENTATION_CHANNEL,
+  );
+  const matchOnObj = useMemo(() => obsTypeCoordination[0],
+    // imageCoordination reference changes each render,
+    // use coordinationScopes and coordinationScopesBy which are
+    // indirect dependencies here.
+    [coordinationScopes, coordinationScopesBy]);
+  const [colorsData, colorsDataStatus, colorsDataErrors] = useObsColorsMultiLevel(
+    loaders, dataset, false, matchOnObj, 2,
+  );
+  return [colorsData, colorsDataStatus, colorsDataErrors];
+}

package/src/hooks.js

@@ -5,6 +5,7 @@ import { debounce, every } from 'lodash-es';
 import { extent } from 'd3-array';
 import { useQuery } from '@tanstack/react-query';
 import { capitalize } from '@vitessce/utils';
+import { getObsIndexMap } from '@vitessce/sets-utils';
 import { STATUS, AsyncFunctionType } from '@vitessce/constants-internal';
 import { VITESSCE_CONTAINER } from './classNames.js';
 import { useGridResize, useEmitGridResize } from './state/hooks.js';
@@ -258,6 +259,10 @@ export function useUint8FeatureSelection(expressionData) {
   }, [expressionData]);
 }
 
+// Marks an instance index that equals the matrix row index, so that no
+// per-observation mapping needs to be built.
+const IDENTITY_MAPPING = 'identity';
+
 export function useExpressionValueGetter(
   { instanceObsIndex, matrixObsIndex, expressionData },
 ) {
@@ -267,18 +272,32 @@ export function useExpressionValueGetter(
   // we need a way to look up an obsFeatureMatrix obsIndex index
   // given an obsEmbedding obsIndex index.
   const toMatrixIndexMap = useMemo(() => {
-    if (instanceObsIndex && matrixObsIndex) {
-      const matrixIndexMap = new Map(matrixObsIndex.map((key, i) => ([key, i])));
-      return instanceObsIndex.map(key => matrixIndexMap.get(key));
+    if (!instanceObsIndex || !matrixObsIndex) {
+      return null;
     }
-    return null;
+    if (instanceObsIndex === matrixObsIndex) {
+      // The same array (the usual case when both come from one data source)
+      // is already aligned by position.
+      return IDENTITY_MAPPING;
+    }
+    // The map is shared with other consumers of this index via getObsIndexMap.
+    const matrixIndexMap = getObsIndexMap(matrixObsIndex);
+    const mapping = new Int32Array(instanceObsIndex.length);
+    for (let i = 0; i < instanceObsIndex.length; i += 1) {
+      const rowIndex = matrixIndexMap.get(instanceObsIndex[i]);
+      mapping[i] = rowIndex === undefined ? -1 : rowIndex;
+    }
+    return mapping;
   }, [instanceObsIndex, matrixObsIndex]);
 
   // Set up a getter function for gene expression values, to be used
   // by the DeckGL layer to obtain values for instanced attributes.
   const getExpressionValue = useCallback((entry, { index: instanceIndex }) => {
     if (toMatrixIndexMap && expressionData && expressionData[0]) {
-      const rowIndex = toMatrixIndexMap[instanceIndex];
+      const rowIndex = toMatrixIndexMap === IDENTITY_MAPPING
+        ? instanceIndex
+        : toMatrixIndexMap[instanceIndex];
+      // An observation absent from the matrix (-1) reads as undefined, as before.
       const val = expressionData[0][rowIndex];
       return val;
     }

package/src/hooks.test.jsx

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useExpressionValueGetter } from './hooks.js';
+
+describe('useExpressionValueGetter', () => {
+  const expressionData = [new Uint8Array([10, 20, 30])];
+
+  it('reads by position when the instance and matrix indices are the same array', () => {
+    const obsIndex = ['a', 'b', 'c'];
+    const { result } = renderHook(() => useExpressionValueGetter({
+      instanceObsIndex: obsIndex, matrixObsIndex: obsIndex, expressionData,
+    }));
+    expect(result.current(null, { index: 0 })).toEqual(10);
+    expect(result.current(null, { index: 2 })).toEqual(30);
+  });
+
+  it('maps through observation IDs when the indices differ', () => {
+    const { result } = renderHook(() => useExpressionValueGetter({
+      instanceObsIndex: ['c', 'unknown', 'a'],
+      matrixObsIndex: ['a', 'b', 'c'],
+      expressionData,
+    }));
+    expect(result.current(null, { index: 0 })).toEqual(30);
+    // An observation absent from the matrix reads as undefined, as before.
+    expect(result.current(null, { index: 1 })).toEqual(undefined);
+    expect(result.current(null, { index: 2 })).toEqual(10);
+  });
+
+  it('returns 0 without indices or without data', () => {
+    const { result: noIndices } = renderHook(() => useExpressionValueGetter({
+      instanceObsIndex: null, matrixObsIndex: ['a'], expressionData,
+    }));
+    expect(noIndices.current(null, { index: 0 })).toEqual(0);
+    const { result: noData } = renderHook(() => useExpressionValueGetter({
+      instanceObsIndex: ['a'], matrixObsIndex: ['a'], expressionData: null,
+    }));
+    expect(noData.current(null, { index: 0 })).toEqual(0);
+  });
+});

package/src/index.js

@@ -93,6 +93,7 @@ export {
   useSegmentationMultiObsFeatureMatrixIndices,
   useSegmentationMultiObsLocations,
   useSegmentationMultiObsSets,
+  useSegmentationMultiObsColors,
 } from './data-hooks-multilevel.js';
 export {
   useHasLoader,