Java Code Examples for net.imglib2.Point#setPosition()

@SuppressWarnings({"rawtypes", "unchecked"})
private void fillAt(final double x, final double y, final long fill)
{
	final ViewerState viewerState   = viewer.getState();

	// TODO should this check happen outside?
	if (!isVisible.getAsBoolean())
	{
		LOG.info("Selected source is not visible -- will not fill");
		return;
	}

	final int               level          = 0;
	final AffineTransform3D labelTransform = new AffineTransform3D();
	// TODO What to do for time series?
	final int               time           = 0;
	source.getSourceTransform(time, level, labelTransform);

	final RealPoint rp = setCoordinates(x, y, viewer, labelTransform);
	final Point     p  = new Point(rp.numDimensions());
	for (int d = 0; d < p.numDimensions(); ++d)
	{
		p.setPosition(Math.round(rp.getDoublePosition(d)), d);
	}

	LOG.debug("Filling source {} with label {} at {}", source, fill, p);
	try
	{
		fill(time, level, fill, p, assignment);
	} catch (final MaskInUse e)
	{
		LOG.info(e.getMessage());
	}

}
 

/**
 * utility that places a sphere in the center of the image
 * 
 * @param img
 */
private void placeSphereInCenter(final Img<FloatType> img) {

	final Point center = new Point(img.numDimensions());

	for (int d = 0; d < img.numDimensions(); d++)
		center.setPosition(img.dimension(d) / 2, d);

	final HyperSphere<FloatType> hyperSphere = new HyperSphere<>(img, center,
		2);

	for (final FloatType value : hyperSphere) {
		value.setReal(1);
	}
}
 

@SuppressWarnings({"unchecked", "rawtypes"})
public void restrictTo(final double x, final double y)
{
	final Source<?>   currentSource = sourceInfo.currentSourceProperty().get();
	final ViewerState viewerState   = viewer.getState();
	if (currentSource == null)
	{
		LOG.info("No current source selected -- will not fill");
		return;
	}

	final SourceState<?, ?> currentSourceState = sourceInfo.getState(currentSource);

	if (!currentSourceState.isVisibleProperty().get())
	{
		LOG.info("Selected source is not visible -- will not fill");
		return;
	}

	if (!(currentSource instanceof MaskedSource<?, ?>))
	{
		LOG.info("Selected source is not painting-enabled -- will not fill");
		return;
	}

	if (maskForLabel == null)
	{
		LOG.info("Cannot generate boolean mask for this source -- will not fill");
		return;
	}

	final MaskedSource<?, ?> source = (MaskedSource<?, ?>) currentSource;

	final Type<?> t = source.getDataType();

	if (!(t instanceof LabelMultisetType) && !(t instanceof IntegerType<?>))
	{
		LOG.info("Data type is not integer type or LabelMultisetType -- will not fill");
		return;
	}

	final AffineTransform3D screenScaleTransform = new AffineTransform3D();
	viewer.getRenderUnit().getScreenScaleTransform(0, screenScaleTransform);
	final int level, time;
	synchronized (viewerState)
	{
		level = viewerState.getBestMipMapLevel(screenScaleTransform, sourceInfo.currentSourceIndexInVisibleSources().get());
		time = viewerState.getTimepoint();
	}
	final AffineTransform3D labelTransform = new AffineTransform3D();
	source.getSourceTransform(time, level, labelTransform);

	final RealPoint rp = setCoordinates(x, y, viewer, labelTransform);
	final Point     p  = new Point(rp.numDimensions());
	for (int d = 0; d < p.numDimensions(); ++d)
	{
		p.setPosition(Math.round(rp.getDoublePosition(d)), d);
	}

	try
	{
		if (source.getDataType() instanceof LabelMultisetType)
		{
			restrictToLabelMultisetType((MaskedSource) source, time, level, p, requestRepaint);
		}
		else
		{
			restrictTo((MaskedSource) source, time, level, p, requestRepaint);
		}
	} catch (final MaskInUse e)
	{
		LOG.info("Mask already in use -- will not paint: {}", e.getMessage());
	}

}
 

protected void createNormalizationImageSemiNonCirculant(Interval fastFFTInterval) {

		// k is the window size (valid image region)
		final int length = k.numDimensions();

		final long[] n = new long[length];
		final long[] nFFT = new long[length];

		// n is the valid image size plus the extended region
		// also referred to as object space size
		for (int d = 0; d < length; d++) {
			n[d] = k.dimension(d) + l.dimension(d) - 1;
		}

		// nFFT is the size of n after (potentially) extending further
		// to a fast FFT size
		for (int d = 0; d < length; d++) {
			nFFT[d] = fastFFTInterval.dimension(d);
		}

		FinalDimensions fd = new FinalDimensions(nFFT);

		// create the normalization image
		normalization = create.calculate(fd);

		// size of the measurement window
		final Point size = new Point(length);
		final long[] sizel = new long[length];

		for (int d = 0; d < length; d++) {
			size.setPosition(k.dimension(d), d);
			sizel[d] = k.dimension(d);
		}

		// starting point of the measurement window when it is centered in fft space
		final Point start = new Point(length);
		final long[] startl = new long[length];
		final long[] endl = new long[length];

		for (int d = 0; d < length; d++) {
			start.setPosition((nFFT[d] - k.dimension(d)) / 2, d);
			startl[d] = (nFFT[d] - k.dimension(d)) / 2;
			endl[d] = startl[d] + sizel[d] - 1;
		}

		// size of the object space
		final Point maskSize = new Point(length);
		final long[] maskSizel = new long[length];

		for (int d = 0; d < length; d++) {
			maskSize.setPosition(Math.min(n[d], nFFT[d]), d);
			maskSizel[d] = Math.min(n[d], nFFT[d]);
		}

		// starting point of the object space within the fft space
		final Point maskStart = new Point(length);
		final long[] maskStartl = new long[length];

		for (int d = 0; d < length; d++) {
			maskStart.setPosition((Math.max(0, nFFT[d] - n[d]) / 2), d);
			maskStartl[d] = (Math.max(0, nFFT[d] - n[d]) / 2);
		}

		final RandomAccessibleInterval<O> temp = Views.interval(normalization,
			new FinalInterval(startl, endl));
		final Cursor<O> normCursor = Views.iterable(temp).cursor();

		// draw a cube the size of the measurement space
		while (normCursor.hasNext()) {
			normCursor.fwd();
			normCursor.get().setReal(1.0);
		}

		final Img<O> tempImg = create.calculate(fd);

		// 3. correlate psf with the output of step 2.
		correlater.compute(normalization, tempImg);

		normalization = tempImg;

		final Cursor<O> cursorN = normalization.cursor();

		while (cursorN.hasNext()) {
			cursorN.fwd();

			if (cursorN.get().getRealFloat() <= 1e-3f) {
				cursorN.get().setReal(1.0f);

			}
		}
	}
 

/** tests fft based convolve */
@Test
public void testCreateAndConvolvePoints() {

	final int xSize = 128;
	final int ySize = 128;
	final int zSize = 128;

	int[] size = new int[] { xSize, ySize, zSize };

	Img<DoubleType> phantom = ops.create().img(size);

	RandomAccess<DoubleType> randomAccess = phantom.randomAccess();

	randomAccess.setPosition(new long[] { xSize / 2, ySize / 2, zSize / 2 });
	randomAccess.get().setReal(255.0);

	randomAccess.setPosition(new long[] { xSize / 4, ySize / 4, zSize / 4 });
	randomAccess.get().setReal(255.0);

	Point location = new Point(phantom.numDimensions());
	location.setPosition(new long[] { 3 * xSize / 4, 3 * ySize / 4, 3 * zSize /
		4 });

	HyperSphere<DoubleType> hyperSphere = new HyperSphere<>(phantom, location,
		5);

	for (DoubleType value : hyperSphere) {
		value.setReal(16);
	}

	// create psf using the gaussian kernel op (alternatively PSF could be an
	// input to the script)
	RandomAccessibleInterval<DoubleType> psf = ops.create().kernelGauss(
		new double[] { 5, 5, 5 }, new DoubleType());

	RandomAccessibleInterval<DoubleType> convolved = ops.create().img(size);

	// convolve psf with phantom
	convolved = ops.filter().convolve(convolved, phantom, psf);

	DoubleType sum = new DoubleType();
	DoubleType max = new DoubleType();
	DoubleType min = new DoubleType();

	ops.stats().sum(sum, Views.iterable(convolved));
	ops.stats().max(max, Views.iterable(convolved));
	ops.stats().min(min, Views.iterable(convolved));

	assertEquals(sum.getRealDouble(), 8750.000184601617, 0.0);
	assertEquals(max.getRealDouble(), 3.154534101486206, 0.0);
	assertEquals(min.getRealDouble(), -2.9776862220387557E-7, 0.0);
}
 

private void placeSphereInCenter(Img<FloatType> img) {

		final Point center = new Point(img.numDimensions());

		for (int d = 0; d < img.numDimensions(); d++)
			center.setPosition(img.dimension(d) / 2, d);

		HyperSphere<FloatType> hyperSphere = new HyperSphere<>(img, center, 30);

		for (final FloatType value : hyperSphere) {
			value.setReal(1);
		}
	}
 

private void placeSphereInCenter(Img<FloatType> img) {

		final Point center = new Point(img.numDimensions());

		for (int d = 0; d < img.numDimensions(); d++)
			center.setPosition(img.dimension(d) / 2, d);

		HyperSphere<FloatType> hyperSphere = new HyperSphere<>(img, center, 2);

		for (final FloatType value : hyperSphere) {
			value.setReal(1);
		}
	}