Java Code Examples for net.imglib2.util.Intervals#minAsLongArray()

private ShapeKey<T> createShapeKey(
		final CellGrid grid,
		final long index,
		final int scaleLevel,
		final SceneUpdateParameters sceneUpdateParameters)
{
	final Interval blockInterval = Grids.getCellInterval(grid, index);
	return new ShapeKey<>(
			identifier,
			scaleLevel,
			sceneUpdateParameters.simplificationIterations,
			sceneUpdateParameters.smoothingLambda,
			sceneUpdateParameters.smoothingIterations,
			sceneUpdateParameters.minLabelRatio,
			Intervals.minAsLongArray(blockInterval),
			Intervals.maxAsLongArray(blockInterval)
		);
}
 

/**
 * Add 0s before axis minimum.
 * 
 * @param input Input RAI
 * @return An extended and cropped version of input
 */
private <T extends RealType<T>> RandomAccessibleInterval<T> addLeadingZeros(
	RandomAccessibleInterval<T> input)
{
	final long[] min = Intervals.minAsLongArray(input);
	final long[] max = Intervals.maxAsLongArray(input);

	for (int i = 0; i < max.length; i++) {
		min[i]--;
	}

	final T realZero = Util.getTypeFromInterval(input).copy();
	realZero.setZero();

	final ExtendedRandomAccessibleInterval<T, RandomAccessibleInterval<T>> extendedImg = Views.extendValue(input,
		realZero);
	final IntervalView<T> offsetInterval = Views.interval(extendedImg,
		min, max);
	
	return Views.zeroMin(offsetInterval);
}
 

/**
 * Removes leading 0s from integral image after composite creation.
 *
 * @param input Input RAI (can be a RAI of Composite)
 * @return An extended and cropped version of input
 */
private <T> RandomAccessibleInterval<T> removeLeadingZeros(
	final RandomAccessibleInterval<T> input)
{
	// Remove 0s from integralImg by shifting its interval by +1
	final long[] min = Intervals.minAsLongArray(input);
	final long[] max = Intervals.maxAsLongArray(input);

	for (int d = 0; d < input.numDimensions(); ++d) {
		int correctedSpan = getShape().getSpan() - 1;
		min[d] += (1 + correctedSpan);
		max[d] -= correctedSpan;
	}

	// Define the Interval on the infinite random accessibles
	final FinalInterval interval = new FinalInterval(min, max);

	final RandomAccessibleInterval<T> extendedImg = Views.offsetInterval(Views
		.extendBorder(input), interval);
	return extendedImg;
}
 

private static <V> RandomAccessibleInterval<V> trim(
	final RandomAccessibleInterval<V> image, final int[] blockSize)
{
	final long[] min = Intervals.minAsLongArray(image);
	final long[] max = Intervals.maxAsLongArray(image);
	for (int d = 0; d < blockSize.length; d++) {
		final long trimSize = image.dimension(d) % blockSize[d];
		final long half = trimSize / 2;
		min[d] += half;
		max[d] -= trimSize - half;
	}
	return Views.interval(image, min, max);
}
 

private < T > List< RandomAccessibleInterval< T > > createIntervals( final RandomAccessibleInterval< T > source, final long divider, final int axis )
{
	final long[] min = Intervals.minAsLongArray( source );
	final long[] max = Intervals.maxAsLongArray( source );
	final long[] min1 = min.clone();
	final long[] min2 = min.clone();
	final long[] max1 = max.clone();
	final long[] max2 = max.clone();
	max1[ axis ] = divider;
	min2[ axis ] = divider + 1;
	final IntervalView< T > interval1 = Views.interval( source, min1, max1 );
	final IntervalView< T > interval2 = Views.interval( source, min2, max2 );

	return Arrays.asList( interval1, interval2 );
}
 

/**
 * Converts the given plane information using the current metadata to a format
 * usable by the wrapped reader, stored in the "lastPlane"... variables.
 */
private void updateLastPlaneInfo(final int imageIndex, final int lutLength,
	final Interval bounds)
{
	final long[] min = Intervals.minAsLongArray(bounds);
	final long[] max = Intervals.maxAsLongArray(bounds);

	final int cIndex = getMetadata().get(imageIndex).getAxisIndex(Axes.CHANNEL);
	min[cIndex] = min[cIndex] / lutLength;
	max[cIndex] = max[cIndex] / lutLength;
	lastPlaneBounds = new FinalInterval(min, max);
}
 

/**
 * @return The minimums of this plane relative to the origin image
 */
default long[] getMin() {
	return Intervals.minAsLongArray(getBounds());
}