Libreria Java open source per l'elaborazione delle immagini

Iniziare con ImgLib2

Il modo più semplice e consigliato per installare ImgLib2 è tramite GitHub.

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

Creazione di nuove immagini tramite Java

La libreria Java open source ImgLib2 ha incluso il supporto per la creazione di una nuova immagine da zero con solo un paio di righe di codice Java. Usando la libreria ImgLib2, puoi creare diversi tipi di immagini come immagini semplici, immagini 3D, ImgFactory e altro. Puoi anche modificare le immagini delle immagini esistenti con solo un paio di righe di codice.

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

Duplicazione delle immagini tramite API Java

La libreria ImgLib2 include funzionalità per la duplicazione delle immagini utilizzando i comandi Java. Puoi facilmente fare una copia dell'immagine esistente. Puoi utilizzare i Cursori per svolgere questa attività. Puoi anche usare il metodo di copia che è un metodo generico e la cosa grandiosa è che funzionerà su qualsiasi tipo di 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;
	}

Visualizza le immagini in parte tramite Java

La libreria gratuita ImgLib2 consente agli sviluppatori di software di visualizzare solo alcune parti dell'immagine all'interno delle loro app tramite un paio di righe di codice Java. Le viste sono molto potenti e puoi usarle per visualizzare parti selezionate delle immagini, visualizzare una vista ruotata e poche altre cose. Le viste possono essere RandomAccessible, Interval e possono quindi essere rese iterabili.

Gestione dei dati scarsi

La libreria gratuita ImgLib2 offre agli sviluppatori di software la possibilità di lavorare con dati sparsi utilizzando il codice Java. La libreria ha fornito due schemi di interpolazione per la visualizzazione di dati sparsi. Gli utenti possono calcolare un valore per ogni posizione nello spazio restituendo il valore del campione più vicino o un valore interpolato e ponderato per la distanza dei k vicini più vicini alla posizione campionata.

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