Open-Source-Java-Bibliothek für die Bildverarbeitung

Erste Schritte mit ImgLib2

Der einfachste und empfohlene Weg, ImgLib2 zu installieren, ist über GitHub.

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

Erstellen neuer Bilder über Java

Die Open-Source-Java-Bibliothek ImgLib2 bietet Unterstützung für die Erstellung eines neuen Bildes von Grund auf mit nur ein paar Zeilen Java-Code. Mit der ImgLib2-Bibliothek können Sie verschiedene Arten von Bildern erstellen, z. B. einfache Bilder, 3D-Bilder, ImgFactory und mehr. Sie können auch Bilder der vorhandenen Bilder mit nur wenigen Codezeilen ändern.

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

Bildvervielfältigung über Java-API

Die ImgLib2-Bibliothek enthält Funktionen zum Duplizieren von Bildern mithilfe von Java-Befehlen. Sie können ganz einfach eine Kopie des vorhandenen Bildes erstellen. Sie können Cursor verwenden, um diese Aufgabe zu erfüllen. Sie können auch die Kopiermethode verwenden, die eine generische Methode ist, und das Tolle daran ist, dass sie mit jeder Art von Type funktioniert.

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

Bilder ansehen Teilweise über Java

Die kostenlose ImgLib2-Bibliothek ermöglicht es Softwareentwicklern, nur einige Teile des Bildes in ihren Apps über ein paar Zeilen Java-Code anzuzeigen. Ansichten sind sehr leistungsfähig und Sie können sie verwenden, um ausgewählte Teile der Bilder anzuzeigen, eine gedrehte Ansicht anzuzeigen und einige andere Dinge. Ansichten können RandomAccessible, Interval sein und können daher Iterable gemacht werden.

Sparse-Datenverwaltung

Die kostenlose ImgLib2-Bibliothek gibt Softwareentwicklern die Möglichkeit, mit spärlichen Daten unter Verwendung von Java-Code zu arbeiten. Die Bibliothek hat zwei Interpolationsschemata zum Anzeigen von Daten mit geringer Dichte bereitgestellt. Benutzer können einen Wert für jeden Ort im Raum berechnen, indem sie entweder den Wert der nächstgelegenen Stichprobe oder einen interpolierten, entfernungsgewichteten Wert der k nächsten Nachbarn der Stichprobe zurückgeben.

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