Bibliothèque Java Open Source pour le traitement d'images

Premiers pas avec ImgLib2

Le moyen le plus simple et recommandé d'installer ImgLib2 est via GitHub.

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

Création de nouvelles images via Java

La bibliothèque Java open source ImgLib2 a inclus la prise en charge de la création d'une nouvelle image à partir de zéro avec seulement quelques lignes de code Java. En utilisant la bibliothèque ImgLib2, vous pouvez créer différents types d'images telles que des images simples, des images 3D, ImgFactory et plus encore. Vous pouvez également modifier les images des images existantes avec seulement quelques lignes de code.

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

Duplication d'images via l'API Java

La bibliothèque ImgLib2 a inclus des fonctionnalités pour la duplication d'images à l'aide de commandes Java. Vous pouvez facilement faire une copie de l'image existante. Vous pouvez utiliser des curseurs pour accomplir cette tâche. Vous pouvez également utiliser la méthode de copie qui est une méthode générique et la grande chose est qu'elle fonctionnera sur n'importe quel type 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;
	}

Afficher les images en partie via Java

La bibliothèque gratuite ImgLib2 permet aux développeurs de logiciels d'afficher uniquement certaines parties de l'image dans leurs applications via quelques lignes de code Java. Les vues sont très puissantes et vous pouvez les utiliser pour afficher des parties sélectionnées des images, afficher une vue pivotée et quelques autres choses. Les vues peuvent être RandomAccessible, Interval, et peuvent donc être rendues Iterable.

Gestion des données fragmentées

La bibliothèque gratuite ImgLib2 donne aux développeurs de logiciels la possibilité de travailler avec des données éparses à l'aide de code Java. La bibliothèque a fourni deux schémas d'interpolation pour afficher des données éparses. Les utilisateurs peuvent calculer une valeur pour chaque emplacement dans l'espace en renvoyant soit la valeur de l'échantillon le plus proche, soit une valeur interpolée et pondérée en fonction de la distance des k voisins les plus proches de l'emplacement échantillonné.

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