@Override public long dimension( final int d ) { return counts.dimension( d ); }
@Override public long dimension( final int d ) { return counts.dimension( d ); }
@Override public boolean hasNext() { return k < op.dimension( m_projectionDim ) - 1; }
@Override public boolean hasNext() { return k < op.dimension( m_projectionDim ) - 1; }
@Override public long dimension(final int d) { return img.dimension(d); }
@Override public long dimension(final int d) { return img.dimension(d); }
/** The dimensions of the integral image are always +1 from the integrated image. */ protected static final boolean isIntegerDivision(Img<?> integralImg, Img<?> scaled) { for ( int d = 0; d < scaled.numDimensions(); ++d ) if ( 0 != (integralImg.dimension( d ) -1) % scaled.dimension( d ) ) return false; return true; }
public Bandpass( final Img<T> img, final int beginRadius, final int endRadius ) { this.img = img; this.inPlace = false; this.bandPass = true; this.beginRadius = beginRadius; this.endRadius = endRadius; this.origin = new long[ img.numDimensions() ]; this.origin[ 0 ] = img.dimension( 0 ) - 1; for ( int d = 1; d < this.origin.length; ++d ) origin[ d ] = img.dimension( d ) / 2; }
private final long inside(final long pos, final int d) { // TODO isn't this dimensions[d], without the -1? return Math.min(integralHistogram.dimension(d) -1, Math.max(0, pos)); }
static private final long[] asDimArray(final Img<?> img, final Number scale) { final long[] dim = new long[img.numDimensions()]; final double s = scale.doubleValue(); for (int i=0; i<dim.length; i++) { dim[i] = (int)((img.dimension(i) * s) + 0.5); } return dim; }
static private final long[] dimensions(final Img<?> img) { final long[] ds = new long[img.numDimensions()]; for (int d=0; d<ds.length; ++d) { ds[d] = img.dimension(d) + 1; } return ds; }
public static < T extends RealType< T > > Img< T > computeMaxProjectionPSF( final Img< T > avg ) { int minDim = -1; long minDimSize = Long.MAX_VALUE; for ( int d = 0; d < avg.numDimensions(); ++d ) if ( avg.dimension( d ) < minDimSize ) { minDimSize = avg.dimension( d ); minDim = d; } return computeProjection( avg, minDim, true ); }
public static FloatProcessor toProcessor( final Img< ? extends RealType< ? > > img ) { final FloatProcessor fp = new FloatProcessor( (int)img.dimension( 0 ), (int)img.dimension( 1 ) ); final float[] array = (float[])fp.getPixels(); final Cursor< ? extends RealType< ? > > c = img.cursor(); for ( int i = 0; i < array.length; ++ i) array[ i ] = c.next().getRealFloat(); return fp; }
public void setDownSamplingFactor( final float factor ) { newSize = new long[ input.numDimensions() ]; scaling = new float[ input.numDimensions() ]; for ( int d = 0; d < input.numDimensions(); ++d ) { newSize[ d ] = Util.round( input.dimension(d) * factor ); scaling[ d ] = 1.0f / factor; } } public void setNewSize( final long[] newSize ) { this.newSize = newSize.clone(); }
@Override public RandomAccessibleInterval< UnsignedShortType > getImage( final ViewId view ) { final long[] dim = new long[ sb.getImgs().get( view.getViewSetupId() ).numDimensions() ]; for ( int d = 0; d < dim.length; ++d ) dim[ d ] = sb.getImgs().get( view.getViewSetupId() ).dimension( d ); final Img< UnsignedShortType > img = ArrayImgs.unsignedShorts( dim ); final Cursor< FloatType > in = sb.getImgs().get( view.getViewSetupId() ).cursor(); final Cursor< UnsignedShortType > out = img.cursor(); while ( in.hasNext() ) out.next().set( Math.round( in.next().get() ) ); return img; }
private void generateByteTestImgs(int size) { if (in != null && in.dimension(0) == size) return; if (size > 1024) { assumeTrue(expensiveTestsEnabled); } in = generateByteArrayTestImg(true, size, size); out = generateByteArrayTestImg(false, size, size); }
private void placeSphereInCenter(Img<FloatType> img) { final Point center = new Point(img.numDimensions()); for (int d = 0; d < img.numDimensions(); d++) center.setPosition(img.dimension(d) / 2, d); HyperSphere<FloatType> hyperSphere = new HyperSphere<>(img, center, 2); for (final FloatType value : hyperSphere) { value.setReal(1); } }
private void placeSphereInCenter(Img<FloatType> img) { final Point center = new Point(img.numDimensions()); for (int d = 0; d < img.numDimensions(); d++) center.setPosition(img.dimension(d) / 2, d); HyperSphere<FloatType> hyperSphere = new HyperSphere<>(img, center, 30); for (final FloatType value : hyperSphere) { value.setReal(1); } } }
@Test public void testLoopLine() { // setup final Img< IntType > img = ArrayImgs.ints( 1, 1, 5 ); final RandomAccess< IntType > ra = img.randomAccess(); // process final Runnable loop = LoopUtils.createLineLoop( ra, img.dimension( 2 ), 2, () -> ra.get().set( 42 ) ); loop.run(); // test img.forEach( value -> assertEquals( 42, value.get() ) ); }