Biblioteca Java de código aberto para processamento de imagens

Introdução ao ImgLib2

A maneira mais fácil e recomendada de instalar o ImgLib2 é via GitHub.

go get -u github.com/imglib/imglib2.git 

Criando novas imagens via Java

A biblioteca Java de código aberto ImgLib2 incluiu suporte para criar uma nova imagem do zero com apenas algumas linhas de código Java. Usando a biblioteca ImgLib2, você pode criar diferentes tipos de imagens, como imagens simples, imagens 3D, ImgFactory e muito mais. Você também pode modificar imagens das imagens existentes com apenas algumas linhas de código.

        public Example1c()
        {
            // create the ImgFactory based on cells (cellsize = 5x5x5...x5) that will
            // instantiate the Img
            final ImgFactory< FloatType > imgFactory = new CellImgFactory<>( new FloatType(), 5 );
            // create an 3d-Img with dimensions 20x30x40 (here cellsize is 5x5x5)Ø
            final Img< FloatType > img1 = imgFactory.create( 20, 30, 40 );
            // create another image with the same size. Note that the input provides the size for the new image as it implements the Interval interface
            final Img< FloatType > img2 = imgFactory.create( img1 );
            // display both (but they are empty)
            ImageJFunctions.show( img1 );
            ImageJFunctions.show( img2 );
        }

Duplicação de imagem via API Java

A biblioteca ImgLib2 incluiu funcionalidade para duplicação de imagem usando comandos Java. Você pode facilmente fazer uma cópia da imagem existente. Você pode empregar cursores para realizar essa tarefa. Você também pode usar o método copy que é um método genérico e o melhor é que funcionará em qualquer tipo de Type.

	public DuplicateImage() throws ImgIOException
	{
		// open with SCIFIO as a FloatType
		Img< FloatType > img = IO.openImgs( "DrosophilaWing.tif", new FloatType() ).get( 0 );
		// copy the image, as it is a generic method it also works with FloatType
		Img< FloatType > duplicate = copyImage( img );
		// display the copy
		ImageJFunctions.show( duplicate );
	}
        // Generic, type-agnostic method to create an identical copy of an Img
	public < T extends Type< T > > Img< T > copyImage( final Img< T > input )
	{
		// create a new Image with the same properties
		Img< T > output = input.factory().create( input );
		// create a cursor for both images
		Cursor< T > cursorInput = input.cursor();
		Cursor< T > cursorOutput = output.cursor();
		// iterate over the input
		while ( cursorInput.hasNext())
		{
			// move both cursors forward by one pixel
			cursorInput.fwd();
			cursorOutput.fwd();
			// set the value of this pixel of the output image to the same as the input,
			// every Type supports T.set( T type )
			cursorOutput.get().set( cursorInput.get() );
		}
		// return the copy
		return output;
	}

Ver imagens parcialmente via Java

A biblioteca ImgLib2 gratuita permite que os desenvolvedores de software exibam apenas algumas partes da imagem dentro de seus aplicativos por meio de algumas linhas de código Java. As visualizações são muito poderosas e você pode usá-las para exibir partes selecionadas das imagens, exibir uma visualização girada e algumas outras coisas. As visualizações podem ser RandomAccessible, Interval e, portanto, podem ser Iterable.

Gerenciamento de dados esparsos

A biblioteca gratuita ImgLib2 oferece aos desenvolvedores de software a capacidade de trabalhar com dados esparsos usando código Java. A biblioteca forneceu dois esquemas de interpolação para exibir dados esparsos. Os usuários podem calcular um valor para cada local no espaço retornando o valor da amostra mais próxima ou um valor interpolado e ponderado pela distância dos k vizinhos mais próximos do local amostrado.

        // Working with sparse data
	public SparseExample()
	{
		// the interval in which to create random points
		FinalInterval interval = new FinalInterval( new long[] { 375, 200 } );
		// create an IterableRealInterval
		IterableRealInterval< FloatType > realInterval = createRandomPoints( interval, 250 );
		// using nearest neighbor search we will be able to return a value an any position in space
		NearestNeighborSearch< FloatType > search =
			new NearestNeighborSearchOnKDTree<>(
				new KDTree<>( realInterval ) );
		// make it into RealRandomAccessible using nearest neighbor search
		RealRandomAccessible< FloatType > realRandomAccessible =
			Views.interpolate( search, new NearestNeighborSearchInterpolatorFactory< FloatType >() );
		// convert it into a RandomAccessible which can be displayed
		RandomAccessible< FloatType > randomAccessible = Views.raster( realRandomAccessible );
		// set the initial interval as area to view
		RandomAccessibleInterval< FloatType > view = Views.interval( randomAccessible, interval );
		// display the view
		ImageJFunctions.show( view );
		// compute a gauss on it
		Img< FloatType > convolved = new ArrayImgFactory<>( new FloatType() ).create( interval );
		Gauss.inFloat( new double[] { 3, 3 }, view, interval, convolved,
			new Point( view.numDimensions() ), convolved.factory() );
		// display the view
		ImageJFunctions.show( convolved );
	}