1. Producten
  2.   Afbeelding
  3.   Java
  4.   ImgLib2
 
  

Open Source Java-bibliotheek voor beeldverwerking

Een universele, multidimensionale beeldverwerkings-API die nieuwe afbeeldingen maakt, bestaande afbeeldingen wijzigt, werkt met schaarse gegevens en bestaande afbeeldingen dupliceert met behulp van de gratis Java-API.

De open source ImgLib2-bibliotheek geeft softwareontwikkelaars de mogelijkheid om afbeeldingen in hun Java-apps te maken en te manipuleren. De bibliotheek biedt een interface-gestuurd ontwerp waarmee gebruikers gemakkelijk numerieke en niet-numerieke gegevenstypen kunnen gebruiken in hun eigen applicaties.

De ImgLib2 is een universele, multidimensionale beeldverwerkingsbibliotheek die ondersteuning biedt voor verschillende belangrijke functies met betrekking tot beeldverwerking, zoals het maken van nieuwe afbeeldingen, het wijzigen van bestaande afbeeldingen, het openen en lezen van bestaande afbeeldingen, het werken met schaarse gegevens, het dupliceren van bestaande afbeeldingen, Generiek kopiëren van afbeeldingsgegevens, een bol tekenen, ondersteuning voor interpolatie en nog veel meer.

De bibliotheek is zeer gebruiksvriendelijk en vermijdt onnodige complexiteit, zodat ontwikkelaars zich kunnen concentreren op de essentie van het algoritme tijdens het ontwikkelen van hun projecten. Het mooie van de bibliotheek is dat deze dimensie-onafhankelijk is en gebruikers in staat stelt hun code uit te drukken op een manier die kan worden toegepast op veeldimensionale gegevens. De bibliotheekwerking is niet beperkt tot afbeeldingen, er zijn alleen voorbeelden die ook aan RNA-sequenties werken.

Previous Next

Aan de slag met ImgLib2

De gemakkelijkste en aanbevolen manier om ImgLib2 te installeren is via GitHub.

Installeer ImgLib2 via GitHub

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

Nieuwe afbeeldingen maken via Java

De open source Java-bibliotheek ImgLib2 biedt ondersteuning voor het maken van een geheel nieuwe afbeelding met slechts een paar regels Java-code. Met behulp van de ImgLib2-bibliotheek kunt u verschillende soorten afbeeldingen maken, zoals eenvoudige afbeeldingen, 3D-afbeeldingen, ImgFactory en meer. U kunt ook afbeeldingen van de bestaande afbeeldingen wijzigen met slechts een paar regels code.

Create New Images via Java9


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

Beeldduplicatie via Java API

De ImgLib2-bibliotheek heeft functionaliteit voor het dupliceren van afbeeldingen met behulp van Java-opdrachten. U kunt eenvoudig een kopie maken van de bestaande afbeelding. U kunt cursors gebruiken om deze taak uit te voeren. Je kunt ook de kopieermethode gebruiken, wat een generieke methode is en het mooie is dat het op elk type werkt.

Duplicaat Image via JavaAPI


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

Afbeeldingen bekijken Deels via Java

Met de gratis ImgLib2-bibliotheek kunnen softwareontwikkelaars slechts enkele delen van de afbeelding in hun apps weergeven via een paar regels Java-code. Weergaven zijn erg krachtig en u kunt ze gebruiken om geselecteerde delen van de afbeeldingen weer te geven, een geroteerde weergave weer te geven en enkele andere dingen. Weergaven kunnen RandomAccessible, Interval zijn en kunnen daarom Iterable worden gemaakt.

Spaarzaam gegevensbeheer

De gratis ImgLib2-bibliotheek geeft softwareontwikkelaars de mogelijkheid om met schaarse gegevens te werken met behulp van Java-code. De bibliotheek heeft twee interpolatieschema's verschaft voor het weergeven van schaarse gegevens. Gebruikers kunnen een waarde berekenen voor elke locatie in de ruimte door de waarde van de dichtstbijzijnde steekproef of een geïnterpoleerde, op afstand gewogen waarde van de k dichtstbijzijnde buren van de bemonsterde locatie te retourneren.

Werk met Sparse Data binnen Java App


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