public IntersectionInterval( final Interval i1, final Interval i2 ) { super( i1.numDimensions() ); this.i1 = i1; this.i2 = i2; assert ( i1.numDimensions() == i2.numDimensions() ); }
public UnionInterval( final Interval i1, final Interval i2 ) { super( i1.numDimensions() ); this.i1 = i1; this.i2 = i2; assert ( i1.numDimensions() == i2.numDimensions() ); }
public static int[] getImgSizeInt( final Interval img ) { final int[] dim = new int[ img.numDimensions() ]; for ( int d = 0; d < img.numDimensions(); ++d ) dim[ d ] = (int)img.dimension( d ); return dim; }
/** * Tests weather two intervals have equal dimensions (same size) */ public static boolean equalDimensions( final Interval a, final Interval b ) { if ( a.numDimensions() != b.numDimensions() ) return false; for ( int d = 0; d < a.numDimensions(); ++d ) if ( a.dimension( d ) != b.dimension( d ) ) return false; return true; }
/** * Tests weather two intervals have equal dimensions (same size) */ public static boolean equalDimensions( final Interval a, final Interval b ) { if ( a.numDimensions() != b.numDimensions() ) return false; for ( int d = 0; d < a.numDimensions(); ++d ) if ( a.dimension( d ) != b.dimension( d ) ) return false; return true; }
/** * Get the size of the Y-dimension. If it is a one-dimensional source, return 1. * * @param interval * @return 1 if only-dimensional, else the size */ protected static int getDimension1Size( final Interval interval ) { if ( interval.numDimensions() == 1 ) return 1; return ( int ) interval.dimension( 1 ); }
/** * Tests weather two intervals are equal in their min / max */ public static boolean equals( final Interval a, final Interval b ) { if ( a.numDimensions() != b.numDimensions() ) return false; for ( int d = 0; d < a.numDimensions(); ++d ) if ( a.min( d ) != b.min( d ) || a.max( d ) != b.max( d ) ) return false; return true; }
@Override public int compare( Interval o1, Interval o2 ) { for ( int d = 0; d < Math.min( o1.numDimensions(), o2.numDimensions() ); d++ ) { if ( o1.min( d ) == o2.min( d ) ) continue; return ( int ) o1.min( d ) - ( int ) o2.min( d ); } return 0; } });
@Override public int compare( Interval o1, Interval o2 ) { for ( int d = 0; d < Math.min( o1.numDimensions(), o2.numDimensions() ); d++ ) { if ( o1.min( d ) == o2.min( d ) ) continue; return ( int ) o1.min( d ) - ( int ) o2.min( d ); } return 0; } });
public Labeling< T > create( final Interval interval ) { final long[] dim = new long[ interval.numDimensions() ]; interval.dimensions( dim ); return create( dim ); } }
public BoundingBox( final Interval interval ) { this.n = interval.numDimensions(); this.corner1 = new long[ n ]; this.corner2 = new long[ n ]; interval.min( corner1 ); interval.max( corner2 ); }
private final static synchronized int getNumIterationSteps( int[] selectedDims, Interval interval ) { long[] dims = new long[ interval.numDimensions() ]; interval.dimensions( dims ); int[] unselectedDims = getUnselectedDimIndices( selectedDims, dims.length ); int steps = 1; for ( int i = 0; i < unselectedDims.length; i++ ) { steps *= dims[ unselectedDims[ i ] ]; } return steps; }
/** * Creates a {@link AbstractInterval} from another {@link Interval} * * @param interval * - another {@link Interval} */ public AbstractInterval( final Interval interval ) { this( interval.numDimensions() ); interval.min( min ); interval.max( max ); }
private Interval shiftInterval( Interval interval, long[] offset ) { long[] min = new long[ offset.length ]; long[] max = new long[ offset.length ]; for ( int d = 0; d < interval.numDimensions(); d++ ) { min[ d ] = interval.min( d ) - offset[ d ]; max[ d ] = min[ d ] + interval.dimension( d ) - 1; } return new FinalInterval( min, max ); }
private Interval shiftInterval( Interval interval, long[] offset ) { long[] min = new long[ offset.length ]; long[] max = new long[ offset.length ]; for ( int d = 0; d < interval.numDimensions(); d++ ) { min[ d ] = interval.min( d ) - offset[ d ]; max[ d ] = min[ d ] + interval.dimension( d ) - 1; } return new FinalInterval( min, max ); }
static public IntervalIterator create( final Interval interval ) { final int n = interval.numDimensions(); for ( int d = 0; d < n; ++d ) if ( interval.min( d ) != 0 ) return new IntervalIterator( interval ); return new ZeroMinIntervalIterator( interval ); }
public < F extends Interval & RandomAccessible< T > > AbstractOutOfBoundsValue( final F f ) { super( f.numDimensions() ); this.sampler = f.randomAccess(); dimension = new long[ n ]; f.dimensions( dimension ); min = new long[ n ]; f.min( min ); max = new long[ n ]; f.max( max ); dimIsOutOfBounds = new boolean[ n ]; }
@Override final public RandomAccess< T > randomAccess( final Interval interval ) { assert source.numDimensions() == interval.numDimensions(); if ( Intervals.contains( source, interval ) ) { return source.randomAccess( interval ); } return randomAccess(); }
public static void indexToPositionForInterval( long index, final Interval interval, final Positionable position ) { final int maxDim = interval.numDimensions() - 1; for ( int d = 0; d < maxDim; ++d ) { final long dim = interval.dimension( d ); final long j = index / dim; position.setPosition( index - j * dim + interval.min( d ), d ); index = j; } position.setPosition( index + interval.min( maxDim ), maxDim ); }
public static long positionToIndexForInterval( final Localizable position, final Interval interval ) { final int maxDim = interval.numDimensions() - 1; long i = position.getLongPosition( maxDim ) - interval.min( maxDim ); for ( int d = maxDim - 1; d >= 0; --d ) i = i * interval.dimension( d ) + position.getLongPosition( d ) - interval.min( d ); return i; }