net.imagej.Dataset Java Examples

@Override
public Dataset open(final Location source, final SCIFIOConfig config)
	throws IOException
{
	final ImgOpener imageOpener = new ImgOpener(getContext());
	try {
		// TODO openImgs we are only using the first image index in the
		// SCIFIOConfig.imgOpenerGetRange - so this image index corresponds to the
		// first ImgPlus in the list returned by the ImgOpener. See
		// https://github.com/scifio/scifio/issues/259

		final SCIFIOImgPlus<?> imgPlus = imageOpener.openImgs(source, config).get(
			0);

		@SuppressWarnings({ "rawtypes", "unchecked" })
		final Dataset dataset = datasetService.create((ImgPlus) imgPlus);

		final ImageMetadata imageMeta = imgPlus.getImageMetadata();
		updateDataset(dataset, imageMeta);
		return dataset;
	}
	catch (final ImgIOException exc) {
		throw new IOException(exc);
	}
}
 

@Override
public void run() {
    final Dataset cube;
    try {
        File cubeFile = ResourceLoader.createFile( getClass(), "/cored_cube_var2_8bit.tif" );

        cube = datasetIO.open( cubeFile.getAbsolutePath() );
    }
    catch (IOException exc) {
        log.error( exc );
        return;
    }

    Volume v = (Volume) sciView.addVolume( cube, new float[] { 1, 1, 1 } );
    v.setPixelToWorldRatio(0.1f);// FIXME
    v.setName( "Volume Render Demo" );
    v.setDirty(true);
    v.setNeedsUpdate(true);

    List<SourceAndConverter<UnsignedByteType>> sources = (List<SourceAndConverter<UnsignedByteType>>) v.getMetadata().get("sources");

    BdvFunctions.show(sources.get(0).getSpimSource(), new BdvOptions().frameTitle("slice of " + v.getName()));

    sciView.setActiveNode(v);
    sciView.centerOnNode( sciView.getActiveNode() );
}
 

@Override
public Metadata save(final Dataset dataset, final Location destination,
	final SCIFIOConfig config) throws IOException
{
	@SuppressWarnings("rawtypes")
	final ImgPlus img = dataset.getImgPlus();
	final Metadata metadata;
	final ImgSaver imageSaver = new ImgSaver(getContext());
	try {
		metadata = imageSaver.saveImg(destination, img, config);
	}
	catch (ImgIOException | IncompatibleTypeException exc) {
		throw new IOException(exc);
	}
	final String name = destination.getName();
	dataset.setName(name);
	dataset.setDirty(false);
	return metadata;
}
 

@Test
public void testFileToDatasetConverter() {
	final ConvertService convertService = c.service(ConvertService.class);
	File imageFile = new File("image&pixelType=uint8&axes=X,Y,Z&lengths=256,128,32.fake");
	
	Converter<?, ?> handler = convertService.getHandler(imageFile, Dataset.class);
	// Make sure we got the right converter back
	assertSame(FileToDatasetConverter.class, handler.getClass());
	
	// Test handler capabilities
	assertTrue(handler.canConvert(imageFile, Dataset.class));
	assertFalse(handler.canConvert(null, Dataset.class));

	// Make sure we can convert with ConvertService
	assertTrue(convertService.supports(imageFile, Dataset.class));

	// Convert and check dimensions
	Dataset dataset = convertService.convert(imageFile, Dataset.class);
	assertEquals(256, dataset.dimension(0));
	assertEquals(128, dataset.dimension(1));
	assertEquals(32, dataset.dimension(2));
}
 

/**
 * The {@link DatasetService#create} methods make a best guess for populating
 * {@link Dataset} information. But this can be incorrect/over-aggressive,
 * e.g. in the case of RGBMerged state.
 * <p>
 * If we have access to the {@link Metadata} instance backing a
 * {@code Dataset}, we can use it to more accurately populate these settings.
 * </p>
 *
 * @param dataset Dataset instance to update.
 * @param imageMeta Metadata instance to query for updated information.
 */
private void updateDataset(final Dataset dataset,
	final ImageMetadata imageMeta)
{
	// If the original image had some level of merged channels, we should set
	// RGBmerged to true for the sake of backwards compatibility.
	// See https://github.com/imagej/imagej-legacy/issues/104

	// Look for Axes.CHANNEL in the planar axis list. If found, set RGBMerged to
	// true.
	boolean rgbMerged = false;

	for (final CalibratedAxis axis : imageMeta.getAxesPlanar()) {
		if (axis.type().equals(Axes.CHANNEL)) rgbMerged = true;
	}

	dataset.setRGBMerged(rgbMerged);
}
 

@Test
public void testFileToDatasetConverter() {
	final ConvertService convertService = c.service(ConvertService.class);
	String imagePath = "image&pixelType=uint8&axes=X,Y,Z&lengths=256,128,32.fake";
	
	Converter<?, ?> handler = convertService.getHandler(imagePath, Dataset.class);
	// Make sure we got the right converter back
	assertSame(StringToDatasetConverter.class, handler.getClass());
	
	// Test handler capabilities
	assertTrue(handler.canConvert(imagePath, Dataset.class));
	assertFalse(handler.canConvert(null, Dataset.class));

	// Make sure we can convert with ConvertService
	assertTrue(convertService.supports(imagePath, Dataset.class));

	// Convert and check dimensions
	Dataset dataset = convertService.convert(imagePath, Dataset.class);
	assertEquals(256, dataset.dimension(0));
	assertEquals(128, dataset.dimension(1));
	assertEquals(32, dataset.dimension(2));
}
 

@Override
public Dataset open(final Location source) throws IOException {
	final SCIFIOConfig config = new SCIFIOConfig();
	config.imgOpenerSetIndex(0);
	// skip min/max computation
	config.imgOpenerSetComputeMinMax(false);
	// prefer planar array structure, for ImageJ1 and ImgSaver compatibility
	config.imgOpenerSetImgModes(ImgMode.PLANAR);
	return open(source, config);
}
 

@Override
public List<net.imagej.Dataset> openAll(final Location source)
	throws IOException
{
	final SCIFIOConfig config = new SCIFIOConfig();
	config.imgOpenerSetImgModes(ImgMode.PLANAR);
	return openAll(source, config);
}
 

@Override
public List<net.imagej.Dataset> openAll(final Location source,
	final SCIFIOConfig config) throws IOException
{
	final ArrayList<Dataset> datasetList = new ArrayList<>();

	final ImgOpener imageOpener = new ImgOpener(getContext());
	try {
		final List<SCIFIOImgPlus<?>> openImgs = imageOpener.openImgs(source,
			config);
		for (int imgId = 0; imgId != openImgs.size(); imgId++) {

			final SCIFIOImgPlus<?> imgPlus = openImgs.get(imgId);

			@SuppressWarnings({ "rawtypes", "unchecked" })
			final Dataset dataset = datasetService.create((ImgPlus) imgPlus);

			final ImageMetadata imageMeta = imgPlus.getImageMetadata();
			updateDataset(dataset, imageMeta);
			datasetList.add(dataset);
		}

	}
	catch (final ImgIOException exc) {
		throw new IOException(exc);
	}
	return datasetList;
}
 

@SuppressWarnings("unchecked")
@Override
public <T> T convert(final Object src, final Class<T> dest) {
	final File file = (File) src;
	Dataset data = null;
	try {
		data = io.open(file.getAbsolutePath());
	} catch (IOException e) {
		log.error("Error loading file", e);
	}
	return (T) data;
}
 

@Override
public void run() {
	final Dataset dataset = dataset();
	try {
		datasetIOService.save(dataset, new FileLocation(outputFile.getAbsolutePath()));
	}
	catch (final IOException exc) {
		log.error(exc);
		uiService.showDialog(exc.getMessage(), "Error Saving Image",
			DialogPrompt.MessageType.ERROR_MESSAGE);
		return;
	}

	display.setName(dataset.getName());
}
 

/**
 * Add a Dataset to the scene as a volume. Voxel resolution and name are extracted from the Dataset itself
 * @param image
 * @return a Node corresponding to the Volume
 */
public Node addVolume( Dataset image ) {

    float[] voxelDims = new float[image.numDimensions()];
    for( int d = 0; d < voxelDims.length; d++ ) {
        double inValue = image.axis(d).averageScale(0, 1);
        if( image.axis(d).unit() == null )
            voxelDims[d] = (float) inValue;
        else
            voxelDims[d] = (float) unitService.value( inValue, image.axis(d).unit(), axis(d).unit() );
    }

    return addVolume( image, voxelDims );
}
 

@Override
public void run() {
    final Dataset cube;
    try {
        File cubeFile = ResourceLoader.createFile( getClass(), "/cored_cube_var2_8bit.tif" );

        cube = datasetIO.open( cubeFile.getAbsolutePath() );
    }
    catch (IOException exc) {
        log.error( exc );
        return;
    }

    Volume v = (Volume) sciView.addVolume( cube, new float[] { 1, 1, 1 } );
    v.setPixelToWorldRatio(0.05f);
    v.setName( "Volume Render Demo" );
    v.setDirty(true);
    v.setNeedsUpdate(true);

    if (iso) {
        int isoLevel = 1;

        @SuppressWarnings("unchecked")
        Img<UnsignedByteType> cubeImg = ( Img<UnsignedByteType> ) cube.getImgPlus().getImg();

        Img<BitType> bitImg = ( Img<BitType> ) ops.threshold().apply( cubeImg, new UnsignedByteType( isoLevel ) );

        Mesh m = ops.geom().marchingCubes( bitImg, isoLevel, new BitTypeVertexInterpolator() );

        graphics.scenery.Mesh isoSurfaceMesh = MeshConverter.toScenery(m,false);
        v.addChild(isoSurfaceMesh);

        isoSurfaceMesh.setName( "Volume Render Demo Isosurface" );
    }

    sciView.setActiveNode(v);
    sciView.centerOnNode( sciView.getActiveNode() );
}
 

@Override
public PNGImageNotebookOutput convert(Object object) {

    Dataset source = (Dataset) object;

    String base64Image = (String) ijnb.RAIToPNG((Img) source, //
            source.dimensionIndex(Axes.X),
            source.dimensionIndex(Axes.Y),
            source.dimensionIndex(Axes.CHANNEL),
            ImageJNotebookService.ValueScaling.AUTO);

    return new PNGImageNotebookOutput(base64Image);
}
 

@Override
public Dataset open(final String source) throws IOException {
	return datasetIOService.open(resolve(source, "source"));
}
 

@Override
public Class<Dataset> getDataType() {
	return Dataset.class;
}
 

@Override
public void save(final Dataset dataset, final String destination)
	throws IOException
{
	datasetIOService.save(dataset, resolve(destination, "destination"));
}
 

public Metadata save(final Dataset dataset, final String destination,
	final SCIFIOConfig config) throws IOException
{
	return save(dataset, resolve(destination), config);
}
 

@Override
public Metadata save(final Dataset dataset, final Location destination)
	throws IOException
{
	return save(dataset, destination, new SCIFIOConfig());
}
 

@Override
public Metadata save(final Dataset dataset, final String destination)
	throws IOException
{
	return save(dataset, resolve(destination), new SCIFIOConfig());
}
 

@Override
public List<Dataset> openAll(final String source, final SCIFIOConfig config)
	throws IOException
{
	return openAll(resolve(source), config);
}
 

@Override
public List<Dataset> openAll(final String source) throws IOException {
	return openAll(resolve(source));
}
 

@Override
public Class<Dataset> getInputType() {
    return Dataset.class;
}
 

@Override
public Dataset open(final String source, final SCIFIOConfig config)
	throws IOException
{
	return open(resolve(source), config);
}
 

@Override
public Dataset open(final String source) throws IOException {
	return open(resolve(source));
}
 

/**
 * A integrated test for the workflow using IOResource:<br/>
 * <li>upload file</li>
 * <li>get IDs</li>
 * <li>get ID</li>
 * <li>remove ID</li>
 * <li>retrieve file</li>
 */
@Test
public void ioResource() {
	try {
		// Test upload image
		final String imgID = uploadFile("imgs/about4.tif");
		assertTrue(objectService.contains(imgID));

		// Test upload table
		final String tableID = uploadFile("texts/table.csv");
		assertTrue(objectService.contains(tableID));

		// Test getIDs
		final String secondImg = uploadFile("imgs/about4.tif");
		assertTrue(objectService.contains(secondImg));
		assertTrue(!imgID.equals(secondImg));
		final List<String> ids = Arrays.asList(getIDs());
		assertTrue(ids.contains(imgID));
		assertTrue(ids.contains(secondImg));
		assertTrue(ids.contains(tableID));

		// Test getID
		assertEquals(getObject(imgID).getStatusInfo(), Status.OK);
		assertEquals(getObject(secondImg).getStatusInfo(), Status.OK);
		assertEquals(getObject(tableID).getStatusInfo(), Status.OK);

		// Test removeID
		assertEquals(Status.OK, removeID(secondImg).getStatusInfo());
		assertEquals(Status.NOT_FOUND, retrieveFile(secondImg, "fmt")
			.getStatusInfo());

		// Test retrieve image
		final File downloaded = retrieveFile(imgID, "tiff").readEntity(
			File.class);
		final Dataset ds = ctx.service(DatasetIOService.class).open(downloaded
			.getAbsolutePath());
		final Iterator<?> expectedItr = ((Iterable<?>) objectService.find(imgID)
			.getObject()).iterator();
		final Iterator<?> actualItr = ds.iterator();
		while (expectedItr.hasNext()) {
			assertTrue(actualItr.hasNext());
			assertEquals(expectedItr.next(), actualItr.next());
		}
		assertTrue(!actualItr.hasNext());

		// Test retrieve table
		final File downloadTable = retrieveFile(tableID, "csv").readEntity(
			File.class);
		final String secondTable = uploadFile("secondTable.csv",
			new FileInputStream(downloadTable));
		assertEquals(objectService.find(tableID).getObject(), objectService.find(
			secondTable).getObject());
	}
	catch (IOException exc) {
		fail(exc.getMessage());
	}
}
 

protected void initOutputFile() {
	final Dataset dataset = dataset();
	if (dataset == null) return;
	outputFile = new File(dataset.getSource());
}
 

private Dataset dataset() {
	return imageDisplayService.getActiveDataset(display);
}
 

public void setDataset(final Dataset d) {
	dataset = d;
}
 

public Dataset getDataset() {
	return dataset;
}