added dummy-implementation of prefetch for underlying images that are not CellImgs assuming a 128x128x64 blocksize

Author: StephanPreibisch

src/main/java/net/preibisch/bigstitcher/spark/util/ViewUtil.java

@@ -50,6 +50,7 @@
 import net.imglib2.util.Util;
 import net.imglib2.view.IntervalView;
 import net.imglib2.view.MixedTransformView;
+import util.Grid;
 
 public class ViewUtil
 {
@@ -200,72 +201,120 @@ public static String viewIdToString(final ViewId viewId) {
 			transformToSource = null;
 		}
 
-		// TODO: this fails for the AllenOMEZarrLoader because the RandomAccessibleInterval< ? > img is .view().slice( 4, 0 ).slice( 3, 0 );
+		// this failed for the AllenOMEZarrLoader because the RandomAccessibleInterval< ? > img is .view().slice( 4, 0 ).slice( 3, 0 );
+		// TODO: I added some copy of the code below that assumes a 128x128x64 blocksize, this should be fixed. But better this than a non-working code ...
 		if ( ! ( rai instanceof AbstractCellImg ) )
 		{
-			throw new IllegalArgumentException( "TODO. Handling source types other than CellImg is not implemented yet, rai is=" + rai.getClass().getName() );
-		}
+			// use some random blocksize and fetch for all
+			final List<long[][]> grid = Grid.create( new FinalInterval( img ).dimensionsAsLongArray(), new int[] { 128, 128, 64 } );
 
-		// Brute force search for overlapping cells:
-		//
-		// For each grid cell, estimate its bounding box in world space and test
-		// for intersection with fusedBlock
-		//
-		// TODO: BigVolumeViewer has a more sophisticated method for
-		//       intersecting the View Frustum with the source grid and
-		//       determining overlapping cells. This is similar and could be
-		//       re-used here to make the search more efficient. It should
-		//       provide more accurate results because it uses non-axis aligned
-		//       planes for intersection. See class FindRequiredBlocks.
-		//
-		// TODO: The following works for the hyperslice views currently produced by ZarrImageLoader
-		//       (from https://github.com/bigdataviewer/bigdataviewer-omezarr)
-		//       However, for the general case, the logic should be inverted:
-		//       Project the "fused" bounding box into source coordinates (see
-		//       above), because that is well-defined.
-		//       In contrast, the code below performs a projection onto the
-		//       "fused" hyper-slice, which can lead to non-required blocks
-		//       being loaded.
-
-		// iterate all cells (intervals) in grid
-		final CellGrid grid = ( ( AbstractCellImg< ?, ?, ?, ? > ) rai ).getCellGrid();
-
-		final int n = grid.numDimensions();
-		final long[] gridPos = new long[ n ];
-		final BoundingBox cellBBox = new BoundingBox( n );
-		final long[] cellMin = cellBBox.corner1;
-		final long[] cellMax = cellBBox.corner2;
-
-		final BoundingBox projectedCellBBox;
-		final Interval projectedCellInterval;
-		final int m = img.numDimensions(); // should be always ==3
-		projectedCellBBox = new BoundingBox( m );
-		projectedCellInterval = FinalInterval.wrap( projectedCellBBox.corner1, projectedCellBBox.corner2 );
-
-		final IntervalIterator gridIter = new LocalizingIntervalIterator( grid.getGridDimensions() );
-		while( gridIter.hasNext() )
-		{
-			gridIter.fwd();
-			gridIter.localize( gridPos );
-			grid.getCellInterval( gridPos, cellMin, cellMax );
+			final int n = img.numDimensions();
+			final BoundingBox cellBBox = new BoundingBox( n );
+			final long[] cellMin = cellBBox.corner1;
+			final long[] cellMax = cellBBox.corner2;
 
-			if ( transformToSource == null )
+			final BoundingBox projectedCellBBox;
+			final Interval projectedCellInterval;
+			final int m = img.numDimensions(); // should be always ==3
+			projectedCellBBox = new BoundingBox( m );
+			projectedCellInterval = FinalInterval.wrap( projectedCellBBox.corner1, projectedCellBBox.corner2 );
+
+			for ( final long[][] block : grid )
 			{
-				expand( cellBBox, expand, projectedCellBBox );
+				final long[] offset = block[ 0 ];
+				final long[] size = block[ 1 ];
+
+				for ( int d = 0; d < n; ++d )
+				{
+					cellMin[ d ] = offset[ d ];
+					cellMax[ d ] = cellMin[ d ] + size[ d ] - 1;
+				}
+
+				if ( transformToSource == null )
+				{
+					expand( cellBBox, expand, projectedCellBBox );
+				}
+				else
+				{
+					transform( transformToSource, projectedCellBBox, cellBBox );
+					expand( projectedCellBBox, expand );
+				}
+
+				final Interval bounds = Intervals.smallestContainingInterval(
+						imgToWorld.estimateBounds( projectedCellInterval ) );
+
+				if ( overlaps( bounds, fusedBlock ) )
+				{
+					System.out.println( Arrays.toString( offset ) + ", " + Arrays.toString( size ) );
+
+					prefetch.add( new PrefetchPixel<>( rai, cellMin.clone() ) );
+				}
 			}
-			else
+
+			//throw new IllegalArgumentException( "TODO. Handling source types other than CellImg is not implemented yet, rai is=" + rai.getClass().getName() );
+		}
+		else
+		{
+			// Brute force search for overlapping cells:
+			//
+			// For each grid cell, estimate its bounding box in world space and test
+			// for intersection with fusedBlock
+			//
+			// TODO: BigVolumeViewer has a more sophisticated method for
+			//       intersecting the View Frustum with the source grid and
+			//       determining overlapping cells. This is similar and could be
+			//       re-used here to make the search more efficient. It should
+			//       provide more accurate results because it uses non-axis aligned
+			//       planes for intersection. See class FindRequiredBlocks.
+			//
+			// TODO: The following works for the hyperslice views currently produced by ZarrImageLoader
+			//       (from https://github.com/bigdataviewer/bigdataviewer-omezarr)
+			//       However, for the general case, the logic should be inverted:
+			//       Project the "fused" bounding box into source coordinates (see
+			//       above), because that is well-defined.
+			//       In contrast, the code below performs a projection onto the
+			//       "fused" hyper-slice, which can lead to non-required blocks
+			//       being loaded.
+	
+			// iterate all cells (intervals) in grid
+			final CellGrid grid = ( ( AbstractCellImg< ?, ?, ?, ? > ) rai ).getCellGrid();
+	
+			final int n = grid.numDimensions();
+			final long[] gridPos = new long[ n ];
+			final BoundingBox cellBBox = new BoundingBox( n );
+			final long[] cellMin = cellBBox.corner1;
+			final long[] cellMax = cellBBox.corner2;
+	
+			final BoundingBox projectedCellBBox;
+			final Interval projectedCellInterval;
+			final int m = img.numDimensions(); // should be always ==3
+			projectedCellBBox = new BoundingBox( m );
+			projectedCellInterval = FinalInterval.wrap( projectedCellBBox.corner1, projectedCellBBox.corner2 );
+	
+			final IntervalIterator gridIter = new LocalizingIntervalIterator( grid.getGridDimensions() );
+			while( gridIter.hasNext() )
 			{
-				transform( transformToSource, projectedCellBBox, cellBBox );
-				expand( projectedCellBBox, expand );
+				gridIter.fwd();
+				gridIter.localize( gridPos );
+				grid.getCellInterval( gridPos, cellMin, cellMax );
+	
+				if ( transformToSource == null )
+				{
+					expand( cellBBox, expand, projectedCellBBox );
+				}
+				else
+				{
+					transform( transformToSource, projectedCellBBox, cellBBox );
+					expand( projectedCellBBox, expand );
+				}
+	
+				final Interval bounds = Intervals.smallestContainingInterval(
+						imgToWorld.estimateBounds( projectedCellInterval ) );
+	
+				if ( overlaps( bounds, fusedBlock ) )
+					prefetch.add( new PrefetchPixel<>( rai, cellMin.clone() ) );
 			}
-
-			final Interval bounds = Intervals.smallestContainingInterval(
-					imgToWorld.estimateBounds( projectedCellInterval ) );
-
-			if ( overlaps( bounds, fusedBlock ) )
-				prefetch.add( new PrefetchPixel<>( rai, cellMin.clone() ) );
 		}
-
 //		prefetch.forEach( System.out::println );
 		return prefetch;
 	}