Biblioteca Java de código abierto para el procesamiento de imágenes

Primeros pasos con ImgLib2

La forma más fácil y recomendada de instalar ImgLib2 es a través de GitHub.

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

Creación de nuevas imágenes a través de Java

La biblioteca Java de código abierto ImgLib2 ha incluido soporte para crear una nueva imagen desde cero con solo un par de líneas de código Java. Con la biblioteca ImgLib2, puede crear diferentes tipos de imágenes, como imágenes simples, imágenes en 3D, ImgFactory y más. También puede modificar imágenes de las imágenes existentes con solo un par de líneas 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 );
        }

Duplicación de imágenes a través de la API de Java

La biblioteca ImgLib2 ha incluido funcionalidad para la duplicación de imágenes usando comandos Java. Puede hacer fácilmente una copia de la imagen existente. Puede emplear los cursores para lograr esta tarea. También puede usar el método de copia, que es un método genérico y lo bueno es que funcionará en cualquier tipo de Tipo.

	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 imágenes en parte a través de Java

La biblioteca gratuita ImgLib2 permite a los desarrolladores de software mostrar solo algunas partes de la imagen dentro de sus aplicaciones a través de un par de líneas de código Java. Las vistas son muy poderosas y puede usarlas para mostrar partes seleccionadas de las imágenes, mostrar una vista rotada y algunas otras cosas. Las vistas pueden ser RandomAccessible, Interval y, por lo tanto, pueden hacerse iterables.

Gestión de datos dispersos

La biblioteca gratuita ImgLib2 brinda a los desarrolladores de software la capacidad de trabajar con datos escasos utilizando código Java. La biblioteca ha proporcionado dos esquemas de interpolación para mostrar datos dispersos. Los usuarios pueden calcular un valor para cada ubicación en el espacio devolviendo el valor de la muestra más cercana o un valor ponderado por distancia interpolado de los k vecinos más cercanos a la ubicación muestreada.

        // 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 );
	}