Support scaling_factor and offset for axis

packages/app/src/vis-packs/core/utils.ts

@@ -4,7 +4,9 @@ import {
   type InteractionInfo,
 } from '@h5web/lib';
 import {
+  isBigIntArray,
   isBigIntTypedArray,
+  isBoolArray,
   isIntegerType,
   isNumericType,
 } from '@h5web/shared/guards';
@@ -88,14 +90,6 @@ export function getImageInteractions(keepRatio: boolean): InteractionInfo[] {
   return keepRatio ? BASE_INTERACTIONS : INTERACTIONS_WITH_AXIAL_ZOOM;
 }
 
-function isBigIntArray(val: ArrayValue<NumericLikeType>): val is bigint[] {
-  return Array.isArray(val) && typeof val[0] === 'bigint';
-}
-
-function isBoolArray(val: ArrayValue<NumericLikeType>): val is boolean[] {
-  return Array.isArray(val) && typeof val[0] === 'boolean';
-}
-
 export function toNumArray<T extends ArrayValue<NumericLikeType> | undefined>(
   arr: T,
 ): T extends ArrayValue<NumericLikeType> ? NumArray : undefined;

packages/app/src/vis-packs/nexus/NxValuesFetcher.tsx

@@ -1,3 +1,8 @@
+import {
+  assertDefined,
+  isBigIntArray,
+  isBigIntTypedArray,
+} from '@h5web/shared/guards';
 import {
   type ComplexType,
   type NumericLikeType,
@@ -43,7 +48,21 @@ function NxValuesFetcher<T extends NumericLikeType | ComplexType>(
   const errors = useDatasetValue(signalDef.errorDataset, selection);
   const auxValues = useDatasetsValues(auxDatasets, selection);
   const auxErrors = useDatasetsValues(auxErrorDatasets, selection);
-  const axisValues = useDatasetsValues(axisDatasets);
+  const rawAxisValues = useDatasetsValues(axisDatasets);
+
+  const axisValues = rawAxisValues.map((value, i) => {
+    if (!value || isBigIntArray(value) || isBigIntTypedArray(value)) {
+      return value;
+    }
+
+    assertDefined(axisDefs[i]);
+    const { scalingFactor, offset } = axisDefs[i];
+    if (scalingFactor === undefined || offset === undefined) {
+      return value;
+    }
+
+    return value.map((v) => scalingFactor * v + offset);
+  });
 
   return render({ title, signal, errors, auxValues, auxErrors, axisValues });
 }

packages/app/src/vis-packs/nexus/hooks.ts

@@ -19,13 +19,14 @@ import {
   findTitleDataset,
   getDatasetInfo,
   getDefaultSlice,
+  getScalingInfo,
   getSilxStyle,
 } from './utils';
 
 export const useDefaultSlice = createMemo(getDefaultSlice);
 
 export function useNxData(group: GroupWithChildren): NxData {
-  const { attrValuesStore } = useDataContext();
+  const { attrValuesStore, valuesStore } = useDataContext();
 
   assertNxDataGroup(group, attrValuesStore);
   const signalDataset = findSignalDataset(group, attrValuesStore);
@@ -46,7 +47,10 @@ export function useNxData(group: GroupWithChildren): NxData {
     })),
     axisDefs: axisDatasets.map(
       (dataset) =>
-        dataset && { dataset, ...getDatasetInfo(dataset, attrValuesStore) },
+        dataset && {
+          dataset,
+          ...getAxisDef(group, dataset, attrValuesStore, valuesStore),
+        },
     ),
     defaultSlice: useDefaultSlice(group, signalDataset.shape, attrValuesStore),
     silxStyle: getSilxStyle(group, attrValuesStore),

packages/app/src/vis-packs/nexus/models.ts

@@ -28,6 +28,11 @@ export interface DatasetInfo {
   unit: string | undefined;
 }
 
+export interface ScalingInfo {
+  scalingFactor: number | undefined;
+  offset: number | undefined;
+}
+
 export interface DatasetDef<
   T extends NumericLikeType | ComplexType = NumericLikeType | ComplexType,
 > extends DatasetInfo {
@@ -38,7 +43,7 @@ type WithError<T extends DatasetDef> = T & {
   errorDataset?: Dataset<ArrayShape, NumericType>;
 };
 
-export type AxisDef = DatasetDef<NumericType>;
+export type AxisDef = DatasetDef<NumericType> & ScalingInfo;
 
 export type DefaultSlice = (number | '.')[];
 export interface SilxStyle {

packages/app/src/vis-packs/nexus/utils.test.ts

@@ -5,9 +5,27 @@ import { describe, expect, it } from 'vitest';
 import { applyDefaultSlice, guessKeepRatio } from './utils';
 
 const axisDataset = dataset('foo', intType(), [5]);
-const axisDefNoUnit = { label: 'foo', unit: undefined, dataset: axisDataset };
-const axisDefUnitX = { label: 'foo', unit: 'mm', dataset: axisDataset };
-const axisDefUnitY = { label: 'foo', unit: 'degrees', dataset: axisDataset };
+const axisDefNoUnit = {
+  label: 'foo',
+  unit: undefined,
+  dataset: axisDataset,
+  scalingFactor: undefined,
+  offset: undefined,
+};
+const axisDefUnitX = {
+  label: 'foo',
+  unit: 'mm',
+  dataset: axisDataset,
+  scalingFactor: undefined,
+  offset: undefined,
+};
+const axisDefUnitY = {
+  label: 'foo',
+  unit: 'degrees',
+  dataset: axisDataset,
+  scalingFactor: undefined,
+  offset: undefined,
+};
 
 describe('guessKeepRatio', () => {
   it('should return `cover` if units of both axes are provided and equal', () => {

packages/app/src/vis-packs/nexus/utils.ts

@@ -4,6 +4,7 @@ import {
   assertArrayShape,
   assertDataset,
   assertDefined,
+  assertNum,
   assertNumericLikeOrComplexType,
   assertNumericType,
   assertScalarShape,
@@ -26,12 +27,13 @@ import {
 } from '@h5web/shared/hdf5-models';
 import { getChildEntity } from '@h5web/shared/hdf5-utils';
 
-import { type AttrValuesStore } from '../../providers/models';
+import { type AttrValuesStore, type ValuesStore } from '../../providers/models';
 import { hasAttribute } from '../../utils';
 import {
   type AxisDef,
   type DatasetInfo,
   type DefaultSlice,
+  type ScalingInfo,
   type SilxStyle,
 } from './models';
 
@@ -130,6 +132,38 @@ export function findAuxErrorDataset(
   return dataset;
 }
 
+export function findScalingFactorDataset(
+  group: GroupWithChildren,
+  datasetName: string,
+): Dataset<ScalarShape, NumericType> | undefined {
+  const dataset = getChildEntity(group, `${datasetName}_scaling_factor`);
+
+  if (!dataset) {
+    return undefined;
+  }
+
+  assertDataset(dataset);
+  assertScalarShape(dataset);
+  assertNumericType(dataset);
+  return dataset;
+}
+
+export function findOffsetDataset(
+  group: GroupWithChildren,
+  datasetName: string,
+): Dataset<ScalarShape, NumericType> | undefined {
+  const dataset = getChildEntity(group, `${datasetName}_offset`);
+
+  if (!dataset) {
+    return undefined;
+  }
+
+  assertDataset(dataset);
+  assertScalarShape(dataset);
+  assertNumericType(dataset);
+  return dataset;
+}
+
 export function findAssociatedDatasets(
   group: GroupWithChildren,
   type: 'axes' | 'auxiliary_signals',
@@ -312,6 +346,41 @@ export function getSilxStyle(
   }
 }
 
+function getNumericValue(
+  dataset: Dataset<ScalarShape, NumericType> | undefined,
+  valuesStore: ValuesStore,
+): number | undefined {
+  if (dataset === undefined) {
+    return undefined;
+  }
+
+  const value = valuesStore.get({ dataset });
+  assertNum(value);
+  return value;
+}
+
+export function getAxisDef(
+  group: GroupWithChildren,
+  dataset: Dataset,
+  attrValuesStore: AttrValuesStore,
+  valuesStore: ValuesStore,
+): ScalingInfo {
+  const scalingFactor = getNumericValue(
+    findScalingFactorDataset(group, dataset.name),
+    valuesStore,
+  );
+  const offset = getNumericValue(
+    findOffsetDataset(group, dataset.name),
+    valuesStore,
+  );
+
+  return {
+    scalingFactor,
+    offset,
+    ...getDatasetInfo(dataset, attrValuesStore),
+  };
+}
+
 export function getDatasetInfo(
   dataset: Dataset,
   attrValuesStore: AttrValuesStore,

packages/shared/src/guards.ts

@@ -148,6 +148,14 @@ export function isComplexArray(val: unknown): val is H5WebComplex[] {
   return Array.isArray(val) && isComplex(val[0]);
 }
 
+export function isBigIntArray(val: unknown): val is bigint[] {
+  return Array.isArray(val) && typeof val[0] === 'bigint';
+}
+
+export function isBoolArray(val: unknown): val is boolean[] {
+  return Array.isArray(val) && typeof val[0] === 'boolean';
+}
+
 export function isTypedArray(val: unknown): val is TypedArray {
   return (
     val instanceof Int8Array ||