@SuppressWarnings( "unchecked" ) @Override public Cursor< LabelingType< L > > cursor( final Interval interval ) { if ( this.sourceInterval instanceof SubIntervalIterable ) return ( ( SubIntervalIterable< LabelingType< L > > ) this.sourceInterval ).cursor( interval ); else return Views.interval( this.sourceInterval, interval ).cursor(); }
@SuppressWarnings( "unchecked" ) @Override public Cursor< T > localizingCursor( final Interval interval ) { if ( this.sourceInterval instanceof SubIntervalIterable ) return ( ( SubIntervalIterable< T > ) this.sourceInterval ).localizingCursor( interval ); else return Views.interval( this.sourceInterval, interval ) .localizingCursor(); }
@Test public void addDimensionMinMaxTest() { Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 10, 10 }, new DoubleType()); int max = 20; int min = 0; IntervalView<DoubleType> il2 = Views.addDimension(img, min, max); IntervalView<DoubleType> opr = ops.transform().addDimensionView(img, min, max); assertEquals(il2.numDimensions(), opr.numDimensions(), 0.0); for (int i = 0; i < il2.numDimensions(); i++) { assertEquals(il2.dimension(i), opr.dimension(i), 0.0); } } }
@Test public void testIntervalRotateInterval() { final Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 20, 10 }, new DoubleType()); final IntervalView<DoubleType> il2 = Views.rotate((RandomAccessibleInterval<DoubleType>) img, 1, 0); final IntervalView<DoubleType> opr = ops.transform().rotateView((RandomAccessibleInterval<DoubleType>) img, 1, 0); assertEquals(img.min(1), il2.min(0)); assertEquals(img.max(1), il2.max(0)); assertEquals(img.min(0), -il2.max(1)); assertEquals(img.max(0), -il2.min(1)); for (int i = 0; i < il2.numDimensions(); i++) { assertEquals(il2.max(i), opr.max(i)); assertEquals(il2.min(i), opr.min(i)); } } }
@Test public void testOptimizable() { // Testing Cursor assertTrue( ( Views.interval( img, intervalFast ).cursor() instanceof ArraySubIntervalCursor ) ); // Testing Localizing Cursor assertTrue( ( Views.interval( img, intervalFast ).localizingCursor() instanceof AbstractArrayLocalizingCursor ) ); // Testing Cursor assertFalse( ( Views.interval( img, intervalFastPart ).cursor() instanceof ArraySubIntervalCursor ) ); // Testing Localizing Cursor assertFalse( ( Views.interval( img, intervalFastPart ).localizingCursor() instanceof AbstractArrayLocalizingCursor ) ); // Testing Cursor assertTrue( ( Views.interval( img, intervalShifted ).cursor() instanceof ArraySubIntervalCursor ) ); // Testing Localizing Cursor assertTrue( ( Views.interval( img, intervalShifted ).localizingCursor() instanceof AbstractArrayLocalizingCursor ) ); }
/** * Test the op with a 3x3 square with a hole in the middle. The square is in * the middle of a 5x5 img */ @Test public void testOutlineSquare() throws Exception { // SETUP final Img<BitType> img = ArrayImgs.bits(5, 5); final IntervalView<BitType> square = Views.offsetInterval(img, new long[] { 1, 1 }, new long[] { 3, 3 }); square.cursor().forEachRemaining(BitType::setOne); final RandomAccess<BitType> access = square.randomAccess(); access.setPosition(new long[] { 1, 1 }); access.get().setZero(); // EXECUTION final Img<BitType> result = (Img<BitType>) ops.morphology().outline(img, Boolean.TRUE); // VERIFY assertEquals("Wrong number of foreground elements in interval", 8, countForeground(result)); final IntervalView<BitType> resultSquare = Views.offsetInterval(result, new long[] { 1, 1 }, new long[] { 3, 3 }); assertEquals("Wrong number of foreground elements in object", 8, countForeground(resultSquare)); assertPositionBackground(result, new long[] { 2, 2 }); }
@Test public void defaultIntervalTest() { Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[]{10, 10}, new DoubleType()); MersenneTwisterFast r = new MersenneTwisterFast(SEED); for (DoubleType d : img) { d.set(r.nextDouble()); } Cursor<DoubleType> il2 = Views.interval(img, img).localizingCursor(); RandomAccess<DoubleType> opr = ops.transform().intervalView(img, img).randomAccess(); while (il2.hasNext()) { DoubleType e = il2.next(); opr.setPosition(il2); assertEquals(e.get(), opr.get().get(), 1e-10); } }
@Override public Void call() { final Cursor< T > dogCursor = dogIterable.localizingCursor(); final RandomAccess< T > tmpAccess = tmpInterval.randomAccess(); dogCursor.jumpFwd( fromIndex ); for ( int i = 0; i < thisTaskSize; ++i ) { final T o = dogCursor.next(); tmpAccess.setPosition( dogCursor ); o.sub( tmpAccess.get() ); } return null; } } ) );
visit( ( ( IntervalView< T > ) randomAccessible ).getSource() );
final int w = xAxis >= 0 ? (int) image.dimension(xAxis) : 1; final int h = yAxis >= 0 ? (int) image.dimension(yAxis) : 1; final int c = cAxis >= 0 ? (int) image.dimension(cAxis) : 1; final ARGBScreenImage target = new ARGBScreenImage(w, h); final ArrayList<Converter<T, ARGBType>> converters = new ArrayList<>(c); min = image.firstElement().getMinValue(); max = image.firstElement().getMaxValue(); } else {
final VolatileViewData< T, V > sourceData = wrapAsVolatileViewData( view.getSource(), queue, hints ); return new VolatileViewData<>( new IntervalView<>( sourceData.getImg(), view ), sourceData.getCacheControl(), sourceData.getType(),
@Test public void IntervalHyperSliceTest() { final Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 10, 10, 10 }, new DoubleType()); final IntervalView<DoubleType> il2 = Views.hyperSlice((RandomAccessibleInterval<DoubleType>) img, 1, 8); final IntervalView<DoubleType> opr = ops.transform().hyperSliceView(img, 1, 8); for (int i = 0; i < ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource() .getMatrix().length; i++) { for (int j = 0; j < ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource() .getMatrix()[i].length; j++) { assertEquals( ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource().getMatrix()[i][j], ((MixedTransformView<DoubleType>) opr.getSource()).getTransformToSource().getMatrix()[i][j], 1e-10); } } assertEquals(img.numDimensions() - 1, opr.numDimensions()); } }
final int numTasks = Math.max( Math.min( ( int ) shrink( source, borderSize ).dimension( splitDim ), numThreads * 20 ), 1 );
/** * Define an interval on a RandomAccessible. It is the callers * responsibility to ensure that the source RandomAccessible is defined in * the specified interval. * * @param randomAccessible * the source * @param interval * interval boundaries. * @return a RandomAccessibleInterval */ public static < T > IntervalView< T > interval( final RandomAccessible< T > randomAccessible, final Interval interval ) { return new IntervalView<>( randomAccessible, interval ); }
@Benchmark public void copy_pairedView() { Views.interval( Views.pair( in, out ), out ).forEach( p -> p.getA().set( p.getB() ) ); }
@Test public void defaultPermuteCoordinatesInverseTest() { Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[]{2, 2}, new DoubleType()); Cursor<DoubleType> c = img.cursor(); MersenneTwisterFast r = new MersenneTwisterFast(SEED); while (c.hasNext()) { c.next().set(r.nextDouble()); } Cursor<DoubleType> il2 = Views.permuteCoordinatesInverse(img, new int[]{0, 1}).cursor(); RandomAccess<DoubleType> opr = ops.transform().permuteCoordinatesInverseView(img, new int[]{0, 1}).randomAccess(); while (il2.hasNext()) { il2.next(); opr.setPosition(il2); assertEquals(il2.get().get(), opr.get().get(), 1e-10); } }
@Test public void intervalMinMaxTest() { Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[]{10, 10}, new DoubleType()); MersenneTwisterFast r = new MersenneTwisterFast(SEED); for (DoubleType d : img) { d.set(r.nextDouble()); } Cursor<DoubleType> il2 = Views.interval(img, new long[]{1, 1}, new long[]{8,9}).localizingCursor(); RandomAccess<DoubleType> opr = ops.transform().intervalView(img, new long[]{1, 1}, new long[]{8,9}).randomAccess(); while (il2.hasNext()) { DoubleType e = il2.next(); opr.setPosition(il2); assertEquals(e.get(), opr.get().get(), 1e-10); } } }
/** * Test whether the correct cursors are created. */ @Test public void testOptimizable() { // Testing Cursor assertTrue( ( Views.interval( img, intervalSinglePlaneShifted ).cursor() instanceof PlanarPlaneSubsetCursor ) ); // Testing Localizing Cursor assertTrue( ( Views.interval( img, intervalSinglePlaneShifted ).localizingCursor() instanceof PlanarPlaneSubsetLocalizingCursor ) ); // Testing Cursor assertTrue( ( Views.interval( img, intervalSinglePlaneFull ).cursor() instanceof PlanarPlaneSubsetCursor ) ); // Testing Localizing Cursor assertTrue( ( Views.interval( img, intervalSinglePlaneFull ).localizingCursor() instanceof PlanarPlaneSubsetLocalizingCursor ) ); // Testing Cursor assertFalse( ( Views.interval( img, intervalFastPart ).cursor() instanceof PlanarPlaneSubsetCursor ) ); // Testing Localizing Cursor assertFalse( ( Views.interval( img, intervalFastPart ).localizingCursor() instanceof PlanarPlaneSubsetLocalizingCursor ) ); }
@Override public void run() { final IntervalView< T > intervalView = Views.offset( largeSource, offset ); final Cursor< T > cursor = create.cursor(); cursor.jumpFwd( chunk.getStartPosition() ); final RandomAccess< T > randomAccess = intervalView.randomAccess(); for ( long step = 0; step < chunk.getLoopSize(); step++ ) { cursor.fwd(); randomAccess.setPosition( cursor ); cursor.get().set( randomAccess.get() ); } } };
visit( ( ( IntervalView< T > ) randomAccessible ).getSource() );