Java Interval.numDimensions方法代码示例

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包/类
/**
 * 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包/类
@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包/类
/**
 * 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包/类
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包/类
/**
 * Finds intersection points of the line and the minimum and maximum bounds of
 * the interval.
 *
 * @param line parametric equation of a line <b>a<sub>0</sub></b> + <b>v</b>
 *          as a (point, vector) pair.
 * @param interval an interval with integer coordinates. The method assumes that the
 *          first three dimensions are x, y and z.
 * @return scalar values (t<sub>1</sub>, t<sub>2</sub>) for intersection
 *         points (<b>a<sub>0</sub></b> + <em>t<sub>1</sub></em> <b>v</b>,
 *         <b>a<sub>0</sub></b> + <em>t<sub>2</sub></em> <b>v</b>).
 *         {@link Optional#empty()} if the line doesn't intersect the stack.
 */
@Override
public Optional<ValuePair<DoubleType, DoubleType>> calculate(
	final ValuePair<Tuple3d, Vector3d> line, final Interval interval)
{
	final Vector3d direction = new Vector3d(line.b);
	final Point3d origin = new Point3d(line.a);
	if (!validCoordinates(direction) || !validCoordinates(origin)) {
		throw new IllegalArgumentException(
			"Direction or origin has non-finite coordinates");
	}
	if (direction.length() == 0.0) {
		throw new IllegalArgumentException("Direction has zero length");
	}
	direction.normalize();
	final int d = interval.numDimensions();
	final long[] minBounds = new long[d];
	interval.min(minBounds);
	final long[] maxBounds = new long[d];
	interval.max(maxBounds);

	final ValuePair<DoubleType, DoubleType> pair = findIntervalIntersections(
		origin, direction, minBounds, maxBounds);
	if (pair == null) {
		return Optional.empty();
	}
	if (reverseScalars(pair)) {
		// Swap t-values so that the first is the intersection where the line
		// enters the interval.
		final double tmp = pair.a.get();
		pair.a.set(pair.b.get());
		pair.b.set(tmp);
	}
	return Optional.of(pair);
}
 

import net.imglib2.Interval; //导入方法依赖的package包/类
public static List< RealLocalizable > getTileMins(List<Interval> intervals)
{
	final List<RealLocalizable> mins = new ArrayList<>();
	for(Interval iv : intervals)
	{
		RealPoint min = new RealPoint( iv.numDimensions() );
		iv.min( min );
		mins.add( min );
	}
	return mins;
}
 

import net.imglib2.Interval; //导入方法依赖的package包/类
/**
 * create SpimData containing Views at each Interval
 * @param intervals list of intervals
 * @return generated SpimData
 */
public SpimData generateSpimData(final List<Interval> intervals)
{
	final List<RealLocalizable> mins = new ArrayList<>();
	for(Interval iv : intervals)
	{
		RealPoint min = new RealPoint( iv.numDimensions() );
		iv.min( min );
		mins.add( min );
	}
	return generateSpimData( intervals, mins );
}
 

import net.imglib2.Interval; //导入方法依赖的package包/类
/**
 * split the given Interval into nSplits intervals along the largest dimension
 * @param interval input interval
 * @param nSplits how may splits
 * @return list of intervals input was split into
 */
public static List<Interval> splitAlongLargestDimension(Interval interval, long nSplits){
	
	List<Interval> res = new ArrayList<Interval>();
	
	long[] min = new long[interval.numDimensions()];
	long[] max = new long[interval.numDimensions()];
	interval.min(min);
	interval.max(max);
	
	int splitDim = 0;
	for (int i = 0; i< interval.numDimensions(); i++){
		if (interval.dimension(i) > interval.dimension(splitDim)) splitDim = i;
	}

	// there could be more splits than actual dimension entries
	nSplits = Math.min( nSplits, interval.dimension(splitDim) );

	long chunkSize = interval.dimension(splitDim) / nSplits;
	long maxSplitDim = max[splitDim];
	
	for (int i = 0; i<nSplits; i++){
		if (i != 0){
			min[splitDim] += chunkSize;	
		}
		max[splitDim] = min[splitDim] + chunkSize - 1;
		if (i == nSplits -1){
			max[splitDim] = maxSplitDim;
		}
		res.add(new FinalInterval(min, max));
	}
		
	return res;
}
 

import net.imglib2.Interval; //导入方法依赖的package包/类
public static < T extends NumericType< T > & NativeType< T > > ImagePlus copyToImageStack( final RealRandomAccessible< T > rai, final Interval itvl )
{
	final long[] dimensions = new long[ itvl.numDimensions() ];
	itvl.dimensions( dimensions );

	// create the image plus image
	final T t = rai.realRandomAccess().get();
	final ImagePlusImgFactory< T > factory = new ImagePlusImgFactory< T >();
	final ImagePlusImg< T, ? > target = factory.create( itvl, t );

	double k = 0;
	final long N = dimensions[ 0 ] * dimensions[ 1 ] * dimensions[ 2 ];

	final net.imglib2.Cursor< T > c = target.cursor();
	final RealRandomAccess< T > ra = rai.realRandomAccess();
	while ( c.hasNext() )
	{
		c.fwd();
		ra.setPosition( c );
		c.get().set( ra.get() );

		if ( k % 10000 == 0 )
		{
			IJ.showProgress( k / N );
		}
		k++;
	}

	IJ.showProgress( 1.1 );
	try
	{
		return target.getImagePlus();
	}
	catch ( final ImgLibException e )
	{
		e.printStackTrace();
	}

	return null;
}
 

import net.imglib2.Interval; //导入方法依赖的package包/类
public static void show( final String[] args ) throws ImgIOException
{
	ImageJ.main( args );
	final File file = new File( "/Users/tinevez/Desktop/iconas/Data/Uneven.tif" );
	final SCIFIOImgPlus img = new ImgOpener().openImgs( file.getAbsolutePath() ).get( 0 );

	final Shape strel = new HyperSphereShape( 5 );

	/*
	 * To new Img
	 */

	ImageJFunctions.show( img, "Source" );

	final Img topHat = TopHat.topHat( img, strel, 1 );
	ImageJFunctions.show( topHat, "WhiteTopHatToNewImg" );


	/*
	 * In place
	 */

	final Interval interval = FinalInterval.createMinSize( new long[] { 30, 50, 88, 32 } );
	final Img copy = img.copy();
	TopHat.topHatInPlace( copy, interval, strel, 1 );
	ImageJFunctions.show( copy, "WhiteTopHatInPlace" );

	/*
	 * To target
	 */

	final Img img2 = img.factory().create( interval, new UnsignedByteType() );
	final long[] translation = new long[ interval.numDimensions() ];
	interval.min( translation );
	final IntervalView translate = Views.translate( img2, translation );
	TopHat.topHat( img, translate, strel, 1 );
	ImageJFunctions.show( img2, "WhiteTopHatToTarget" );

}
 

import net.imglib2.Interval; //导入方法依赖的package包/类
public SlicesIICursor(final RandomAccessibleInterval<T> src, final Interval fixedAxes, final Interval slice) {
	super(fixedAxes);

	this.src = src;
	this.tmpPosition = new long[fixedAxes.numDimensions()];
	this.sliceDims = new long[slice.numDimensions()];
	this.sliceOffset = new long[slice.numDimensions()];

	slice.dimensions(sliceDims);
	slice.min(sliceOffset);
}
 

import net.imglib2.Interval; //导入方法依赖的package包/类
private static final boolean isEmpty(final Interval interval) {
	final int n = interval.numDimensions();
	for (int d = 0; d < n; ++d)
		if (interval.min(d) > interval.max(d))
			return true;
	return false;
}