Java UnsignedByteType类代码示例

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
public static GenericTexture convertToGenericTexture( Dataset d ) {
    long width = d.getWidth();
    long height = d.getHeight();

    GLVector dims = new GLVector( width, height, 1 );
    int nChannels = 3;

    ByteBuffer bb = BufferUtils.BufferUtils.allocateByte((int) (width * height * nChannels));

    System.out.println("Size:" + width + " " +  height + " " + nChannels);

    Cursor cur = d.cursor();
    while( cur.hasNext() ) {
        cur.fwd();
        int val = ((UnsignedByteType) cur.get()).get();
        //System.out.println( (byte)val );
        bb.put( (byte) val );
        //bb.put((byte)(Math.random()*255));
    }
    bb.flip();

    return new GenericTexture("neverUsed", dims, nChannels, GLTypeEnum.UnsignedByte, bb, true, true, false);
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
public KnossosUnsignedByteImageLoader(
		final KnossosConfig config,
		final String urlFormat,
		final VolatileGlobalCellCache cache )
{
	super(
			config,
			urlFormat,
			new UnsignedByteType(),
			new VolatileUnsignedByteType(),
			new KnossosUnsignedByteVolatileArrayLoader(
					config.baseUrl,
					urlFormat,
					config.experimentName,
					config.format ),
			cache );
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
public H5UnsignedByteSetupImageLoader(
		final IHDF5Reader reader,
		final String dataset,
		final int setupId,
		final int[] blockDimension,
		final double[] resolution,
		final VolatileGlobalCellCache cache ) throws IOException
{
	super(
			reader,
			dataset,
			setupId,
			blockDimension,
			resolution,
			readOffset( reader, dataset ),
			new UnsignedByteType(),
			new VolatileUnsignedByteType(),
			new H5ByteArrayLoader( reader, dataset ),
			cache );
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的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.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
static private final <R extends IntegerType<R> & NativeType<R>> R chooseBestType(final int nBits) {
	
	if (nBits < 9) return (R)(Object) new UnsignedByteType();
	else if (nBits< 13) return (R)(Object) new Unsigned12BitType();
	else if (nBits < 17) return (R)(Object) new UnsignedShortType();
	else if (nBits < 33) return (R)(Object) new UnsignedIntType();
	else if (nBits < 65) return (R)(Object) new LongType();
	else throw new IllegalArgumentException("Cannot do an histogram of " + nBits + " bits.");
	/*
	switch (nBits) {
		case 8:
			return (R) new UnsignedByteType();
		case 12:
			return (R) new Unsigned12BitType();
		case 16:
			return (R) new UnsignedShortType();
		case 32:
			return (R) new UnsignedIntType();
		case 64:
			return (R) new LongType();
		default:
			return (R) new UnsignedAnyBitType(nBits);
	}
	*/
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
/**
 * Tests a PredicateCursor by checking if all visited values are "true".
 * @throws MissingPreconditionException
 */
@Test
public void predicateCursorTest() throws MissingPreconditionException {
	// load a 3D test image
	RandomAccessibleInterval<UnsignedByteType> img = positiveCorrelationImageCh1;
	long[] roiOffset = createRoiOffset(img);
	long[] roiSize = createRoiSize(img);
	long[] dim = new long[ img.numDimensions() ];
	img.dimensions(dim);
	RandomAccessibleInterval<BitType> mask = MaskFactory.createMask(dim,
			roiOffset, roiSize);

	// create cursor to walk an image with respect to a mask
	final Predicate<BitType> predicate = new MaskPredicate();
	Cursor<BitType> roiCursor
		= new PredicateCursor<BitType>(
				Views.iterable(mask).localizingCursor(), predicate);

	// test if all visited voxels are "true"
	while (roiCursor.hasNext()) {
		roiCursor.fwd();
		assertTrue(roiCursor.get().get());
	}
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的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.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
@Test
public void testDefaultASCII() {
	// character set used in DefaultASCII, could be updated if necessary
	final String CHARS = "#O*o+-,. ";
	final int len = CHARS.length();
	final int width = 10;
	final int offset = 47;
	final byte[] array = new byte[width * len];
	for (int i = 0; i < len; i++) {
		for (int j = 0; j < width; j++) {
			array[i * width + j] = (byte) (offset + i * width + j);
		}
	}
	final Img<UnsignedByteType> img = ArrayImgs.unsignedBytes(array, width,
		len);
	final String ascii = (String) ops.run(DefaultASCII.class, img);
	for (int i = 0; i < len; i++) {
		for (int j = 0; j < width; j++) {
			assertTrue(ascii.charAt(i * (width + 1) + j) == CHARS.charAt(i));
		}
		assertTrue(ascii.charAt(i * (width + 1) + width) == '\n');
	}
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
static public final void main(String[] args) {
	
	new ImageJ();
	
	try {
		String src = "http://imagej.nih.gov/ij/images/bat-cochlea-volume.zip";
		//String src = "/home/albert/Desktop/t2/bat-cochlea-volume.tif";	
		Img<UnsignedByteType> img = ImgLib.open(src);
		
		Img<UnsignedByteType> s = new SliceXY<UnsignedByteType>(img, 23);

		ImgLib.wrap(s, "23").show();
		ImgLib.wrap(img, "bat").show();

	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
public void convert( final Img< UnsignedByteType > in,  final Img< ARGBType > out )
	{
		final CompositeXYProjector< UnsignedByteType > projector = new CompositeXYProjector< UnsignedByteType >( in, out, ChannelARGBConverter.converterListRGBA, 2 );
		projector.setComposite( true );
//		projector.setComposite( 0, false );
//		projector.setComposite( 1, true );
//		projector.setComposite( 2, false );
		for ( int iteration = 0; iteration < 10; ++iteration )
		{
			final long start = System.currentTimeMillis();
			for ( int i = 0; i < 10; ++i )
				projector.map();
			final long end = System.currentTimeMillis();
			System.out.println( ( end - start ) + " ms (iteration " + iteration + ")" );
		}
	}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
@Test
public void copyRAINoOutputTest() {
	@SuppressWarnings("unchecked")
	final RandomAccessibleInterval<UnsignedByteType> output =
		(RandomAccessibleInterval<UnsignedByteType>) ops.run(CopyRAI.class,
			input);

	final Cursor<UnsignedByteType> inc = input.localizingCursor();
	final RandomAccess<UnsignedByteType> outRA = output.randomAccess();

	while (inc.hasNext()) {
		inc.fwd();
		outRA.setPosition(inc);
		assertEquals(inc.get().get(), outRA.get().get());
	}
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void copyRAIDifferentSizeTest() {

	// create a copy op
	final UnaryHybridCF<IntervalView<UnsignedByteType>, RandomAccessibleInterval<UnsignedByteType>> copy =
		(UnaryHybridCF) Hybrids.unaryCF(ops, CopyRAI.class,
			RandomAccessibleInterval.class, IntervalView.class);

	assertNotNull(copy);

	final Img<UnsignedByteType> out = ops.create().img(new FinalDimensions(
		size2), new UnsignedByteType());

	// copy view to output and assert that is equal to the mean of the view
	copy.compute(view, out);
	assertEquals(ops.stats().mean(out).getRealDouble(), 100.0, delta);

	// also try with a planar image
	final Img<UnsignedByteType> outFromPlanar = ops.create().img(
		new FinalDimensions(size2), new UnsignedByteType());

	copy.compute(viewPlanar, outFromPlanar);
	assertEquals(ops.stats().mean(outFromPlanar).getRealDouble(), 100.0, delta);

}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的package包/类
@Before
public void initImg() {
	in = generateUnsignedByteArrayTestImg(false, 10, 10, 10);

	final RandomAccess<UnsignedByteType> randomAccess = in.randomAccess();

	// at each x,y,z fill with x+y
	for (int x = 0; x < 10; x++) {
		for (int y = 0; y < 10; y++) {
			for (int z = 0; z < 10; z++) {
				randomAccess.setPosition(new long[] { x, y, z });
				randomAccess.get().setReal(x + y);
			}
		}
	}

	out1 = generateUnsignedByteArrayTestImg(false, 10, 10);
	out2 = generateUnsignedByteArrayTestImg(false, 10, 10);

	op = Computers.unary(ops, Ops.Stats.Sum.class, UnsignedByteType.class,
		out1);
}
 

import net.imglib2.type.numeric.integer.UnsignedByteType; //导入依赖的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.type.numeric.integer.UnsignedByteType; //导入依赖的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;
}