Java ByteArray类代码示例

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
@Override
public void click( final int x, final int y )
{
	if ( filledPixelsOverlay.visible() )
	{
		synchronized ( viewer )
		{
			viewer.setCursor( Cursor.getPredefinedCursor( Cursor.WAIT_CURSOR ) );

			final Point p = new Point( x, y );

			final ArrayImg< ByteType, ByteArray > img = wrapBufferedImage( filledPixelsOverlay.img );

			final ByteType extension = new ByteType( ( byte ) 1 );

			final long t0 = System.currentTimeMillis();
			final ArrayRandomAccess< ByteType > ra = img.randomAccess();
			ra.setPosition( p );
			FloodFill.fill( Views.extendValue( img, extension ), Views.extendValue( img, extension ), p, extension.copy(), extension.copy(), new DiamondShape( 1 ), filter );
			final long t1 = System.currentTimeMillis();
			System.out.println( "Filling took " + ( t1 - t0 ) + " ms" );
			viewer.setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR ) );
			viewer.getDisplay().repaint();
		}
	}
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
@SuppressWarnings( "unchecked" )
public static BigWarpImageStackImageLoader< UnsignedByteType, ByteArray > createUnsignedByteInstance( final ImagePlus imp, int[] ids )
{
	return new BigWarpImageStackImageLoader< UnsignedByteType, ByteArray >( new UnsignedByteType(), imp, ids )
	{
		@Override
		protected ByteArray wrapPixels( final Object array )
		{
			return new ByteArray( ( byte[] ) array );
		}

		@Override
		protected void linkType( final PlanarImg< UnsignedByteType, ByteArray > img )
		{
			img.setLinkedType( new UnsignedByteType( img ) );
		}
	};
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
private static final Img<?> createImg(final BufferedImage bi) {
	final long[] dims = new long[]{bi.getWidth(), bi.getHeight()};
	switch (bi.getType()) {
	case BufferedImage.TYPE_BYTE_GRAY:
	case BufferedImage.TYPE_BYTE_INDEXED:
		ByteArray ba = new ByteArray(((DataBufferByte)bi.getRaster().getDataBuffer()).getData());
		ArrayImg<UnsignedByteType, ByteArray> b = new ArrayImg<UnsignedByteType, ByteArray>(ba, dims, new Fraction());
		b.setLinkedType(new UnsignedByteType(b));
		return b;
	case BufferedImage.TYPE_USHORT_GRAY:
		ShortArray sa = new ShortArray(((DataBufferShort)bi.getRaster().getDataBuffer()).getData());
		ArrayImg<UnsignedShortType, ShortArray> s = new ArrayImg<UnsignedShortType, ShortArray>(sa, dims, new Fraction());
		s.setLinkedType(new UnsignedShortType(s));
		return s;
	case BufferedImage.TYPE_INT_RGB:
	case BufferedImage.TYPE_INT_ARGB:
		IntArray ia = new IntArray(((DataBufferInt)bi.getRaster().getDataBuffer()).getData());
		ArrayImg<ARGBType, IntArray> i = new ArrayImg<ARGBType, IntArray>(ia, dims, new Fraction());
		i.setLinkedType(new ARGBType(i));
		return i;
	}
	throw new UnsupportedOperationException("Cannot wrap images of type " + bi.getType());
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
private CellImg<UnsignedByteType, ByteArray> createCellImage() {
	final UnsignedByteType type = new UnsignedByteType();
	final int cellSize = ( int ) Math.pow( Integer.MAX_VALUE / type.getEntitiesPerPixel().getRatio(), 1.0 / numDimensions );

	// test whether there were rounding errors and cellSize is actually too big
	long t = 1;
	for ( int d = 0; d < numDimensions; ++d )
		t *= cellSize;
	t *= type.getEntitiesPerPixel().getNumerator();
	t /= type.getEntitiesPerPixel().getDenominator();
	if ( t > Integer.MAX_VALUE )
		throw new RuntimeException( "there were rounding errors and cellSize is actually too big" );

	@SuppressWarnings( "unchecked" )
	final
	CellImg<UnsignedByteType, ByteArray> cellContainer = ( CellImg<UnsignedByteType, ByteArray> ) createImage( dimensions, new CellImgFactory< UnsignedByteType >( cellSize ) );
	return cellContainer;
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
public static void main0( final String[] args )
{
	ImageJ.main( args );
	final ArrayImg< UnsignedByteType, ByteArray > img = ArrayImgs.unsignedBytes( 19, 19, 19 );
	final ArrayRandomAccess< UnsignedByteType > ra = img.randomAccess();
	ra.setPosition( new long[] { 9, 9, 9 } );
	ra.get().set( 255 );

	final int[] radiuses = new int[] { 2, 3, 5 };
	for ( final int radius : radiuses )
	{
		final List< Shape > strelStd = StructuringElements.diamond( radius, img.numDimensions(), false );
		final Img< UnsignedByteType > std = Dilation.dilate( img, strelStd, 1 );
		final List< Shape > strelOpt = StructuringElements.diamond( radius, img.numDimensions(), true );
		final Img< UnsignedByteType > opt = Dilation.dilate( img, strelOpt, 1 );

		ImageJFunctions.show( std, "Std " + radius );
		ImageJFunctions.show( opt, "Opt " + radius );
	}
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
public static void openAndClose() {
	final ArrayImg<UnsignedByteType, ByteArray> img = ArrayImgs.unsignedBytes(new long[] { 50, 50 });
	final Random ran = new Random();
	for (final UnsignedByteType pixel : img) {
		if (ran.nextDouble() > 0.95)
			pixel.set(255);
	}

	final Shape strel = new HyperSphereShape(3);
	final Img< UnsignedByteType > open = Opening.open( img, strel, 4 );
	final Img< UnsignedByteType > closed = Closing.close( img, strel, 4 );

	new ImageJ();
	ImageJFunctions.show(img);
	ImageJFunctions.show(open);
	ImageJFunctions.show(closed);
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
public static void standardErode() {
	final ArrayImg<UnsignedByteType, ByteArray> img = ArrayImgs.unsignedBytes(new long[] { 10, 9 });
	for (final UnsignedByteType pixel : img) {
		pixel.set(255);
	}
	final ArrayRandomAccess<UnsignedByteType> ra = img.randomAccess();
	ra.setPosition(new int[] { 1, 4 });
	ra.get().set(0);

	final Shape strel = new CenteredRectangleShape(new int[] { 3, 2 }, false);
	// final Shape strel = new HyperSphereShape(radius)
	final Img< UnsignedByteType > full = Erosion.erodeFull( img, strel, 4 );
	final Img< UnsignedByteType > std = Erosion.erode( img, strel, 4 );

	new ImageJ();
	ImageJFunctions.show(img);
	ImageJFunctions.show(full);
	ImageJFunctions.show(std);
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
public static void standardDilate() {
	final ArrayImg<UnsignedByteType, ByteArray> img = ArrayImgs.unsignedBytes(new long[] { 3, 9 });
	final ArrayRandomAccess<UnsignedByteType> ra = img.randomAccess();
	ra.setPosition(new int[] { 1, 4 });
	ra.get().set(255);

	final Shape strel = new CenteredRectangleShape(new int[] { 5, 2 }, true);
	// final Shape strel = new HyperSphereShape(radius)
	final Img< UnsignedByteType > full = Dilation.dilateFull( img, strel, new UnsignedByteType( 0 ), 4 );
	final Img< UnsignedByteType > std = Dilation.dilate( img, strel, new UnsignedByteType( 0 ), 4 );

	new ImageJ();
	ImageJFunctions.show(img);
	ImageJFunctions.show(full);
	ImageJFunctions.show(std);
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
public ArrayImg<ByteType, ByteArray> generateKnownByteArrayTestImgLarge() {
	final long[] dims = new long[] { 3, 3 };
	final byte[] array = new byte[9];

	array[0] = (byte) 40;
	array[1] = (byte) 40;
	array[2] = (byte) 20;

	array[3] = (byte) 40;
	array[4] = (byte) 40;
	array[5] = (byte) 20;

	array[6] = (byte) 20;
	array[7] = (byte) 20;
	array[8] = (byte) 100;

	return ArrayImgs.bytes(array, dims);
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
/**
 * @param dim a long array with the desired dimensions of the image
 * @param constValue constant image value
 * @return an {@link Img} of {@link UnsignedByteType} filled with a constant
 *         value.
 */
public Img<UnsignedByteType> getConstantUnsignedByteImg(final long[] dim,
	final int constValue)
{
	final ArrayImg<UnsignedByteType, ByteArray> img = ArrayImgs.unsignedBytes(
		dim);

	final UnsignedByteType type = img.firstElement();
	if (constValue < type.getMinValue() || constValue >= type.getMaxValue()) {
		throw new IllegalArgumentException("Can't create image for constant [" +
			constValue + "]");
	}

	final ArrayCursor<UnsignedByteType> cursor = img.cursor();
	while (cursor.hasNext()) {
		cursor.next().set(constValue);
	}

	return img;
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
private void testXYZCropping(int t) {

		Img<ByteType> inSequence = ArrayImgs.bytes(20, 20, 21, t);
		ArrayImg<ByteType, ByteArray> outSequence = ArrayImgs.bytes(20, 20, 21, t);

		// fill array img with values (plane position = value in px);
		for (final Cursor<ByteType> cur = inSequence.cursor(); cur.hasNext();) {
			cur.fwd();
			cur.get().set((byte) cur.getIntPosition(2));
		}

		// selected interval XYZ
		final int[] xyAxis = new int[] { 0, 1, 2 };

		ops.run(SliceRAI2RAI.class, outSequence, inSequence, new DummyOp(), xyAxis);

		for (final Cursor<ByteType> cur = outSequence.cursor(); cur.hasNext();) {
			cur.fwd();
			assertEquals(cur.getIntPosition(2), cur.get().getRealDouble(), 0);
		}
	}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
public ArrayImg<ByteType, ByteArray> generateKnownByteArrayTestImg() {
	final long[] dims = new long[] { 3, 3 };
	final byte[] array = new byte[9];

	array[0] = (byte) 4;
	array[1] = (byte) 4;
	array[2] = (byte) 2;

	array[3] = (byte) 4;
	array[4] = (byte) 4;
	array[5] = (byte) 2;

	array[6] = (byte) 2;
	array[7] = (byte) 2;
	array[8] = (byte) 6;

	return ArrayImgs.bytes(array, dims);
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
public ArrayImg<ByteType, ByteArray> generateKnownByteArrayTestImg() {
	final long[] dims = new long[] { 3, 3 };
	final byte[] array = new byte[9];

	array[0] = (byte) 1;
	array[1] = (byte) 2;
	array[2] = (byte) 3;

	array[3] = (byte) 4;
	array[4] = (byte) 5;
	array[5] = (byte) 6;

	array[6] = (byte) 7;
	array[7] = (byte) 8;
	array[8] = (byte) 9;

	return ArrayImgs.bytes(array, dims);
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
public static ImageStackImageLoader< UnsignedByteType, ByteArray > createUnsignedByteInstance( final ImagePlus imp )
{
	return new ImageStackImageLoader< UnsignedByteType, ByteArray >( new UnsignedByteType(), imp )
	{
		@Override
		protected ByteArray wrapPixels( final Object array )
		{
			return new ByteArray( ( byte[] ) array );
		}

		@Override
		protected void linkType( final PlanarImg< UnsignedByteType, ByteArray > img )
		{
			img.setLinkedType( new UnsignedByteType( img ) );
		}
	};
}
 

import net.imglib2.img.basictypeaccess.array.ByteArray; //导入依赖的package包/类
@Test
public void testCacheAllToggle() throws FormatException, IOException {
	final SCIFIOCellCache<ByteArray> cache1 = makeCache(128l * 128l);
	final SCIFIOCell<ByteArray> cell =
		cache1.load(0, new int[] { 128, 128 }, new long[] { 0l, 0l });

	// Enable caching non-dirty data
	cs.cacheAll(true);

	// Should be able to cache even though the cell isn't dirty
	assertEquals(CacheResult.SUCCESS, cs.cache(cache1.toString(), 0, cell));

	// Verify the cell was cached
	assertEquals(cell, cs.retrieve(cache1.toString(), 0));

	enableCells(false, cell);
}