Reslice mapper representation

.gitignore

@@ -21,3 +21,7 @@
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
+
+
+# AI assistant memory
+memories/

src/core/ResliceRepresentation.tsx

@@ -0,0 +1,148 @@
+import vtkImageResliceMapper, {
+  vtkImageResliceMapper as IvtkImageResliceMapper,
+} from '@kitware/vtk.js/Rendering/Core/ImageResliceMapper';
+import { SlabTypes } from '@kitware/vtk.js/Rendering/Core/ImageResliceMapper/Constants';
+import { forwardRef, PropsWithChildren, useRef } from 'react';
+import useComparableEffect from '../utils/useComparableEffect';
+import SliceRepresentation, {
+  SliceRepresentationProps,
+} from './SliceRepresentation';
+
+export interface ResliceRepresentationProps extends SliceRepresentationProps {
+  /**
+   * Slice plane
+   */
+  slicePlane?: any;
+
+  /**
+   * Optional slice polydata
+   */
+  slicePolyData?: any;
+
+  /**
+   * Slab type
+   */
+  slabType?: number;
+
+  /**
+   * Slab thickness
+   */
+  slabThickness?: number;
+
+  /**
+   * Slab trapezoid integration
+   */
+  slabTrapezoidIntegration?: boolean;
+}
+
+export default forwardRef(function ResliceRepresentation(
+  props: PropsWithChildren<ResliceRepresentationProps>,
+  fwdRef
+) {
+  const {
+    slicePlane,
+    slicePolyData,
+    slabType = SlabTypes.MEAN,
+    slabThickness = 0.0,
+    slabTrapezoidIntegration = false,
+    mapperInstance: providedMapper,
+    ...sliceProps
+  } = props;
+
+  // Create reslice mapper once and reuse it across renders.
+  const internalMapperRef = useRef<IvtkImageResliceMapper | null>(null);
+  if (!internalMapperRef.current) {
+    internalMapperRef.current = vtkImageResliceMapper.newInstance();
+  }
+  const mapperInstance = (providedMapper ||
+    internalMapperRef.current) as IvtkImageResliceMapper;
+
+  // Handle reslice-specific mapper updates
+  useComparableEffect(
+    () => {
+      if (!providedMapper && mapperInstance) {
+        trackModified(true);
+        mapperInstance.setSlicePlane(slicePlane);
+      }
+    },
+    [slicePlane, providedMapper],
+    ([cur, prevMapped], [prev, prevProvided]) =>
+      cur === prev && prevMapped === prevProvided
+  );
+
+  useComparableEffect(
+    () => {
+      if (!providedMapper && mapperInstance) {
+        trackModified(true);
+        mapperInstance.setSlicePolyData(slicePolyData);
+      }
+    },
+    [slicePolyData, providedMapper],
+    ([cur, prevMapped], [prev, prevProvided]) =>
+      cur === prev && prevMapped === prevProvided
+  );
+
+  useComparableEffect(
+    () => {
+      if (!providedMapper && mapperInstance) {
+        trackModified(true);
+        if (
+          slabType != null &&
+          slabType >= SlabTypes.MIN &&
+          slabType <= SlabTypes.SUM
+        ) {
+          mapperInstance.setSlabType(slabType);
+        }
+      }
+    },
+    [slabType, providedMapper],
+    ([cur, prevMapped], [prev, prevProvided]) =>
+      cur === prev && prevMapped === prevProvided
+  );
+
+  useComparableEffect(
+    () => {
+      if (!providedMapper && mapperInstance) {
+        trackModified(true);
+        if (slabThickness != null) {
+          mapperInstance.setSlabThickness(slabThickness);
+        }
+      }
+    },
+    [slabThickness, providedMapper],
+    ([cur, prevMapped], [prev, prevProvided]) =>
+      cur === prev && prevMapped === prevProvided
+  );
+
+  useComparableEffect(
+    () => {
+      if (!providedMapper && mapperInstance) {
+        trackModified(true);
+        if (slabTrapezoidIntegration != null) {
+          mapperInstance.setSlabTrapezoidIntegration(
+            slabTrapezoidIntegration ? 1 : 0
+          );
+        }
+      }
+    },
+    [slabTrapezoidIntegration, providedMapper],
+    ([cur, prevMapped], [prev, prevProvided]) =>
+      cur === prev && prevMapped === prevProvided
+  );
+
+  function trackModified(changed: boolean) {
+    if (changed) {
+      // Trigger render
+    }
+  }
+
+  return (
+    <SliceRepresentation
+      {...sliceProps}
+      mapperInstance={mapperInstance as any}
+      ref={fwdRef}
+    >
+      {props.children}
+    </SliceRepresentation>
+  );
+});

src/core/ShareDataSet.tsx

@@ -160,12 +160,19 @@ export function RegisterDataSet(props: RegisterDataSetProps) {
 
   // --- //
 
+  // Store the connection function so it can be evaluated lazily when
+  // dataAvailable fires (i.e. after the async data load completes).
+  const connRef = useRef<(() => unknown) | null>(null);
+
   const downstream = useMemo<IDownstream>(
     () => ({
       setInputData(obj) {
         share.register(id, obj);
       },
       setInputConnection(conn) {
+        // Persist the port function; don't evaluate it yet — the upstream
+        // algorithm may not have data until an async operation completes.
+        connRef.current = conn;
         downstream.setInputData(conn());
       },
     }),
@@ -175,10 +182,14 @@ export function RegisterDataSet(props: RegisterDataSetProps) {
   const mockRepresentation = useMemo<IRepresentation>(
     () => ({
       dataChanged() {
+        // Re-evaluate the connection to capture the latest output.
+        if (connRef.current) share.register(id, connRef.current());
         share.dispatchDataChanged(id);
         dataChangedEvent.current.dispatchEvent();
       },
       dataAvailable() {
+        // Re-evaluate the connection NOW, when the data is actually ready.
+        if (connRef.current) share.register(id, connRef.current());
         share.dispatchDataAvailable(id);
         dataAvailableEvent.current.dispatchEvent();
       },
@@ -226,3 +237,8 @@ export function UseDataSet(props: UseDataSetProps) {
 
   return null;
 }
+
+/**
+ * ShareDataSet is an alias for UseDataSet for backwards compatibility
+ */
+export const ShareDataSet = UseDataSet;

src/index.ts

@@ -32,8 +32,11 @@ export { default as PolyData } from './core/PolyData';
 export type { PolyDataProps } from './core/PolyData';
 export { default as Reader } from './core/Reader';
 export type { ReaderProps } from './core/Reader';
+export { default as ResliceRepresentation } from './core/ResliceRepresentation';
+export type { ResliceRepresentationProps } from './core/ResliceRepresentation';
 export {
   RegisterDataSet,
+  ShareDataSet,
   ShareDataSetRoot,
   UseDataSet,
 } from './core/ShareDataSet';