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 ]; }
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 ); }
@Override public void applyInverse( final Positionable source, final Localizable target ) { assert source.numDimensions() >= numTargetDimensions; assert target.numDimensions() >= numTargetDimensions; for ( int d = 0; d < numTargetDimensions; ++d ) source.setPosition( target.getLongPosition( d ) - translation[ d ], d ); }
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 ); }
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; }
@Override public void apply( final RealLocalizable source, final RealPositionable target ) { assert source.numDimensions() >= 3 && target.numDimensions() >= 3: "3d affine transformations can be applied to 3d coordinates only."; /* source and target may be the same vector, so do not write into target before done with source */ final double s0 = source.getDoublePosition( 0 ); final double s1 = source.getDoublePosition( 1 ); final double s2 = source.getDoublePosition( 2 ); target.setPosition( s0 * a.m00 + s1 * a.m01 + s2 * a.m02 + a.m03, 0 ); target.setPosition( s0 * a.m10 + s1 * a.m11 + s2 * a.m12 + a.m13, 1 ); target.setPosition( s0 * a.m20 + s1 * a.m21 + s2 * a.m22 + a.m23, 2 ); }
@Override public void setPosition( final Localizable position ) { for ( int d = 0; d < sd; ++d ) tmpLong[ d ] = position.getLongPosition( d ); for ( int s = 0; s < sliceAccesses.length; ++s ) sliceAccesses[ s ].setPosition( tmpLong ); slice = position.getIntPosition( sd ); }
final static public void indexToPosition( long index, final Dimensions dimensions, final Positionable position ) { final int maxDim = dimensions.numDimensions() - 1; for ( int d = 0; d < maxDim; ++d ) { final long j = index / dimensions.dimension( d ); position.setPosition( index - j * dimensions.dimension( d ), d ); index = j; } position.setPosition( index, maxDim ); }
/** * {@inheritDoc} */ @Override protected void initRegionGrowing( I srcImg ) { srcCur = srcImg.localizingCursor(); srcRA = srcImg.randomAccess(); }
@Override public void move(Localizable localizable) { for (int i = 0; i < source.numDimensions(); i++) { center [ i ] = center [ i ] + localizable.getLongPosition(i); } }
@Override public void move( final Localizable distance ) { for ( int s = 0; s < sliceAccesses.length; ++s ) for ( int d = 0; d < sd; ++d ) sliceAccesses[ s ].move( distance.getLongPosition( d ), d ); slice += distance.getIntPosition( sd ); }
@Override public void realMin( final RealPositionable min ) { for ( int d = 0; d < n; ++d ) min.setPosition( structuringElementBoundingBox.realMin( d ), d ); }
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 ); }
@Override public void applyInverse( final RealPositionable source, final RealLocalizable target ) { assert source.numDimensions() >= 2 && target.numDimensions() >= 2: "2d affine transformations can be applied to 2d coordinates only."; /* source and target may be the same vector, so do not write into source before done with target */ final double t0 = target.getDoublePosition( 0 ); final double t1 = target.getDoublePosition( 1 ); source.setPosition( t0 * inverse.a.m00 + t1 * inverse.a.m01 + inverse.a.m02, 0 ); source.setPosition( t0 * inverse.a.m10 + t1 * inverse.a.m11 + inverse.a.m12, 1 ); }
@Override public void apply( final Localizable source, final Positionable target ) { assert source.numDimensions() >= numTargetDimensions; assert target.numDimensions() >= numTargetDimensions; for ( int d = 0; d < numTargetDimensions; ++d ) target.setPosition( source.getLongPosition( component[ d ] ), d ); }
final static public void indexToPosition( long index, final Dimensions dimensions, final Positionable position ) { final int maxDim = dimensions.numDimensions() - 1; for ( int d = 0; d < maxDim; ++d ) { final long j = index / dimensions.dimension( d ); position.setPosition( index - j * dimensions.dimension( d ), d ); index = j; } position.setPosition( index, maxDim ); }
@Override public void realMin( final RealPositionable min ) { for ( int d = 0; d < n; ++d ) min.setPosition( structuringElementBoundingBox.realMin( d ), d ); }
@Override public void apply( final RealLocalizable source, final RealPositionable target ) { assert source.numDimensions() >= s.length && target.numDimensions() >= s.length : "Input dimensions too small."; for ( int d = 0; d < s.length; ++d ) target.setPosition( source.getDoublePosition( d ) * s[ d ], d ); }
@Override public void apply( final Localizable source, final Positionable target ) { assert source.numDimensions() >= numSourceDimensions; assert target.numDimensions() >= numTargetDimensions; for ( int d = 0; d < numTargetDimensions; ++d ) target.setPosition( zero[ d ] ? ( int ) translation[ d ] : source.getLongPosition( component[ d ] ), d ); }