Java Interval类代码示例

import net.imglib2.Interval; //导入依赖的package包/类
/**
 * Constructs an instance of {@link LineGrid}.
 *
 * @param interval a integer interval. The method assumes that the first three
 *          dimensions are x, y and z.
 * @param <I> type of the interval.
 */
public <I extends Interval> LineGrid(final I interval) {
	final boolean emptyDims = dims.apply(interval).anyMatch(i -> i == 0);
	if (interval.numDimensions() < 3 || emptyDims) {
		throw new IllegalArgumentException(
			"Interval must have at least three dimensions");
	}
	final double planeSize = findPlaneSize(interval);
	final double t = planeSize * 0.5;
	final Point3d centroid = findCentroid(interval);
	xy = new LinePlane(XY, planeSize, new Vector3d(0, 0, -t), centroid);
	xz = new LinePlane(XZ, planeSize, new Vector3d(0, -t, 0), centroid);
	yz = new LinePlane(YZ, planeSize, new Vector3d(-t, 0, 0), centroid);
	setRandomGenerator(new Random());
	setRotation(new NoopRotation(), new AxisAngle4d());
}
 

import net.imglib2.Interval; //导入依赖的package包/类
public static List<TranslationGet> getTileTranslations(List<Interval> intervals)
{
	final List< TranslationGet > tr = new ArrayList<>();
	for(Interval iv : intervals)
	{
		double[] min = new double[iv.numDimensions()];
		iv.realMin( min );

		if (iv.numDimensions() == 2)
			tr.add( new Translation2D( min ) );
		else
			tr.add( new Translation3D( min ) );

	}
	return tr;		
	
}
 

import net.imglib2.Interval; //导入依赖的package包/类
public static void main(String[] args)
{
	Interval start = new FinalInterval( new long[] {0,0,0},  new long[] {100, 100, 1});
	List<Interval> res = generateTileList( start, 3, 3, 0.2 );
	for (Interval i : res){
		System.out.println("(" + Long.toString( i.min( 0 )) + "," + Long.toString( i.min( 1 )) + ")");
	}
	
	final AffineTransform3D m = new AffineTransform3D();
	double scale = 300;
	m.set( scale, 0.0f, 0.0f, 0.0f, 
		   0.0f, scale, 0.0f, 0.0f,
		   0.0f, 0.0f, scale, 0.0f );
	
	FractalSpimDataGenerator fsdg = new FractalSpimDataGenerator(3);
	fsdg.addFractal( m );
	
	BigDataViewer.open(  fsdg.generateSpimData( res ), "", null, null );
	
	/*
	new ImageJ();
	RandomAccessibleInterval< LongType > rai = new FractalSpimDataGenerator( new AffineTransform2D() ).getImage( res.get( 0 ) );
	ImageJFunctions.show( rai );
	*/
}
 

import net.imglib2.Interval; //导入依赖的package包/类
/**
 * RealRandomAccess that computes a blending function for a certain {@link Interval}
 * 
 * @param interval - the interval it is defined on (return zero outside of it)
 * @param border - how many pixels to skip before starting blending (on each side of each dimension)
 * @param blending - how many pixels to compute the blending function on (on each side of each dimension)
 */
public BlendingRealRandomAccess(
		final Interval interval,
		final float[] border,
		final float[] blending )
{
	this.interval = interval;
	this.n = interval.numDimensions();
	this.l = new float[ n ];
	this.border = border;
	this.blending = blending;
	this.v = new FloatType();
	
	this.min = new int[ n ];
	this.dimMinus1 = new int[ n ];
	
	for ( int d = 0; d < n; ++d )
	{
		this.min[ d ] = (int)interval.min( d );
		this.dimMinus1[ d ] = (int)interval.max( d ) - min[ d ];
	}
}
 

import net.imglib2.Interval; //导入依赖的package包/类
public static FinalInterval getSubInterval( Interval interval, int d, long start, long end )
{
	int nd = interval.numDimensions();
	long[] min = new long[ nd ];
	long[] max = new long[ nd ];
	for( int i = 0; i < nd; i++ )
	{
		if( i == d )
		{
			min[ i ] = start;
			max[ i ] = end - 1;
		}
		else
		{
			min[ i ] = interval.min( i );
			max[ i ] = interval.max( i );
		}
	}
	return new FinalInterval( min, max );
}
 

import net.imglib2.Interval; //导入依赖的package包/类
public static void main( final String[] args ) throws ImgIOException
	{
		final String fn = "/home/tobias/workspace/data/DrosophilaWing.tif";
		final int span = 3;

		final ArrayImgFactory< FloatType > factory = new ArrayImgFactory< FloatType >();
		final FloatType type = new FloatType();
		final Img< FloatType > imgInput = new ImgOpener().openImg( fn, factory, type );
		final Img< FloatType > imgOutput = factory.create( imgInput, type );

		final Interval computationInterval = Intervals.expand( imgInput, -span );
		final RandomAccessibleInterval< FloatType > input = Views.interval( imgInput, computationInterval );
		final RandomAccessibleInterval< FloatType > output = Views.interval( imgOutput, computationInterval );

		minFilter( input, output, new RectangleShape( span, false ) );
//		minFilter( input, output, new HyperSphereShape( span ) );

		ImageJFunctions.show( imgInput, "input" );
		ImageJFunctions.show( imgOutput, "min filtered" );
	}
 

import net.imglib2.Interval; //导入依赖的package包/类
@Override
public RandomAccessibleInterval<T> calculate(final RandomAccessibleInterval<T> input, final Interval interval) {
	boolean oneSizedDims = false;

	if (dropSingleDimensions) {
		for (int d = 0; d < interval.numDimensions(); d++) {
			if (interval.dimension(d) == 1) {
				oneSizedDims = true;
				break;
			}
		}
	}

	if (Intervals.equals(input, interval) && !oneSizedDims)
		return input;
	if (!Intervals.contains(input, interval))
		throw new RuntimeException("Intervals don't match!");
	IntervalView<T> res = Views.offsetInterval(input, interval);
	return oneSizedDims ? Views.dropSingletonDimensions(res) : res;
}
 

import net.imglib2.Interval; //导入依赖的package包/类
@OpMethod(op = net.imagej.ops.deconvolve.RichardsonLucyC.class)
public <
	I extends RealType<I>, O extends RealType<O>, K extends RealType<K>, C extends ComplexType<C>>
	RandomAccessibleInterval<O> richardsonLucy(
		final RandomAccessibleInterval<O> out,
		final RandomAccessibleInterval<I> in1,
		final RandomAccessibleInterval<K> in2,
		final RandomAccessibleInterval<C> fftInput,
		final RandomAccessibleInterval<C> fftKernel, final int maxIterations,
		final Interval imgConvolutionInterval)
{
	@SuppressWarnings("unchecked")
	final RandomAccessibleInterval<O> result =
		(RandomAccessibleInterval<O>) ops().run(
			net.imagej.ops.deconvolve.RichardsonLucyC.class, out, in1, in2,
			fftInput, fftKernel, maxIterations, imgConvolutionInterval);
	return result;
}
 

import net.imglib2.Interval; //导入依赖的package包/类
@OpMethod(
	op = net.imagej.ops.deconvolve.NonCirculantNormalizationFactor.class)
public <O extends RealType<O>> RandomAccessibleInterval<O>
	normalizationFactor(final RandomAccessibleInterval<O> arg,
		final Dimensions k, final Dimensions l,
		final RandomAccessibleInterval<O> fftInput,
		final RandomAccessibleInterval<O> fftKernel,
		final Interval imgConvolutionInterval)
{
	@SuppressWarnings("unchecked")
	final RandomAccessibleInterval<O> result =
		(RandomAccessibleInterval<O>) ops().run(
			net.imagej.ops.deconvolve.NonCirculantNormalizationFactor.class, arg, k,
			l, fftInput, fftKernel, imgConvolutionInterval);
	return result;
}
 

import net.imglib2.Interval; //导入依赖的package包/类
/**
 * Computes the min coordinate and the size of an {@link Interval} after
 * padding with a list of {@link Shape}s in a series morphology operations.
 * 
 * @param source the interval to be applied with some morphology operation
 * @param shapes the list of Shapes for padding
 * @return a size-2 array storing the min coordinate and the size of the
 *         padded interval
 */
public static final long[][] computeMinSize(final Interval source,
	final List<Shape> shapes)
{

	final int numDims = source.numDimensions();
	final long[] min = new long[numDims];
	final long[] size = new long[numDims];

	for (int i = 0; i < numDims; i++) {
		min[i] = source.min(i);
		size[i] = source.dimension(i);
	}

	for (final Shape shape : shapes) {
		final Neighborhood<BitType> nh = MorphologyUtils.getNeighborhood(shape,
			source);
		for (int i = 0; i < numDims; i++) {
			min[i] += nh.min(i);
			size[i] += nh.dimension(i) - 1;
		}
	}

	return new long[][] { min, size };
}
 

import net.imglib2.Interval; //导入依赖的package包/类
@Override
public void compute(final RandomAccessibleInterval<T> in1,
	final List<Shape> in2, final IterableInterval<T> out)
{
	final long[][] minSize = Morphologies.computeMinSize(in1, in2);
	final Interval interval = new FinalInterval(minSize[1]);
	Img<T> upstream = imgCreator.calculate(interval);
	Img<T> downstream = imgCreator.calculate(interval);
	Img<T> tmp;

	erodeComputer.compute(in1, in2.get(0), Views.translate(downstream,
		minSize[0]));
	for (int i = 1; i < in2.size(); i++) {
		// Ping-ponging intermediate results between upstream and downstream to
		// avoid repetitively creating new Imgs.
		tmp = downstream;
		downstream = upstream;
		upstream = tmp;
		erodeComputer.compute(Views.interval(Views.extendValue(upstream, maxVal),
			interval), in2.get(i), downstream);
	}
	if (isFull) copyImg.compute(downstream, out);
	else copyImg.compute(Views.interval(Views.translate(downstream,
		minSize[0]), out), out);
}
 

import net.imglib2.Interval; //导入依赖的package包/类
@Override
public void compute(final RandomAccessibleInterval<T> in1,
	final List<Shape> in2, final IterableInterval<T> out)
{
	final long[][] minSize = Morphologies.computeMinSize(in1, in2);
	final Interval interval = new FinalInterval(minSize[1]);
	Img<T> upstream = imgCreator.calculate(interval);
	Img<T> downstream = imgCreator.calculate(interval);
	Img<T> tmp;

	dilateComputer.compute(in1, in2.get(0), Views.translate(downstream,
		minSize[0]));
	for (int i = 1; i < in2.size(); i++) {
		// Ping-ponging intermediate results between upstream and downstream to
		// avoid repetitively creating new Imgs.
		tmp = downstream;
		downstream = upstream;
		upstream = tmp;
		dilateComputer.compute(upstream, in2.get(i), downstream);
	}
	if (isFull) copyImg.compute(downstream, out);
	else copyImg.compute(Views.interval(Views.translate(downstream,
		minSize[0]), out), out);
}
 

import net.imglib2.Interval; //导入依赖的package包/类
private static Interval initIntervals(final Interval src, final int[] axesOfInterest) {

		final long[] dimensionsToIterate = new long[src.numDimensions()];
		src.dimensions(dimensionsToIterate);

		// determine axis to iterate
		for (int i = 0; i < src.numDimensions(); i++) {
			for (int j = 0; j < axesOfInterest.length; j++) {

				if (axesOfInterest[j] == i) {
					dimensionsToIterate[i] = 1;
					break;
				}
			}
		}

		return new FinalInterval(dimensionsToIterate);
	}
 

import net.imglib2.Interval; //导入依赖的package包/类
/**
 * Adjusts the given {@link Img} to match the bounds of the specified
 * {@link Interval}.
 * 
 * @param img An image whose min/max bounds might need adjustment.
 * @param minMax An {@link Interval} whose min/max bounds to use when
 *          adjusting the image. If the provided {@code minMax} object is not
 *          an {@link Interval}, no adjustment is performed.
 * @return A wrapped version of the input {@link Img} with bounds adjusted to
 *         match the provided {@link Interval}, if any; or the input image
 *         itself if no adjustment was needed/possible.
 */
public static <T extends Type<T>> Img<T> adjustMinMax(final Img<T> img,
	final Object minMax)
{
	if (!(minMax instanceof Interval)) return img;
	final Interval interval = (Interval) minMax;

	final long[] min = new long[interval.numDimensions()];
	interval.min(min);
	for (int d = 0; d < min.length; d++) {
		if (min[d] != 0) {
			return ImgView.wrap(Views.translate(img, min), img.factory());
		}
	}
	return img;
}
 

import net.imglib2.Interval; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static <C extends CalibratedAxis> void copyTypedSpace(
	final Interval inInterval, final CalibratedSpace<C> in,
	final CalibratedSpace<C> out)
{

	int offset = 0;
	for (int d = 0; d < in.numDimensions(); d++) {
		if (inInterval != null && inInterval.dimension(d) == 1) {
			offset++;
		}
		else {
			out.setAxis((C) in.axis(d).copy(), d - offset);
		}
	}
}