public HyperSphereNeighborhoodGPL(final RandomAccessibleInterval<T> source, final OutOfBoundsFactory<T, RandomAccessibleInterval<T>> outOfBounds, final long radius) { super(source.numDimensions(), outOfBounds); this.radius = radius; }
static private final long[] toMinArray(final RandomAccessibleInterval<?> img, final int p0, final int p1) { final long[] pos = new long[img.numDimensions()]; pos[0] = p0; pos[1] = p1; return pos; }
@Override final public int numDimensions() { return source.numDimensions(); }
SubInterval(RandomAccessibleInterval<K> interval) { super(interval); long[] dims = new long[interval.numDimensions()]; long[] negOffs = new long[interval.numDimensions()]; long[] posOffs = new long[interval.numDimensions()]; for (int i = 0; i < dims.length; i++) posOffs[i] = dims[i] - 1; init(interval,negOffs, posOffs); }
public FloydSteinbergDithering( final RandomAccessibleInterval< T > img, final float ditheringThreshold ) { this.img = img; this.dim = Intervals.dimensionsAsLongArray( img ); this.tmp1 = new long[ img.numDimensions() ]; this.tmp2 = new long[ img.numDimensions() ]; this.errorDiffusionKernel = createErrorDiffusionKernel( img.numDimensions() ); this.ditheringThreshold = ditheringThreshold; }
@Override public void move(Localizable localizable) { for (int i = 0; i < source.numDimensions(); i++) { center [ i ] = center [ i ] + localizable.getLongPosition(i); } }
final public static < C extends ComplexType< C > > void complexToComplexForward( final RandomAccessibleInterval< C > data ) { for ( int d = 0; d < data.numDimensions(); ++d ) FFTMethods.complexToComplex( data, d, true ); }
/** The algorithm is defined only for 3D images */ @Override public boolean conforms() { return in().numDimensions() == 3; }
final public static < R extends RealType< R >, C extends ComplexType< C > > void realToComplex( final RandomAccessibleInterval< R > input, final RandomAccessibleInterval< C > output, final ExecutorService service ) { FFTMethods.realToComplex( input, output, 0, false, service ); for ( int d = 1; d < input.numDimensions(); ++d ) FFTMethods.complexToComplex( output, d, true, false, service ); }
@Override public boolean conforms() { // TODO this first check is too simple, but for now ok return in().numDimensions() == out().numDimensions() + 1 && in().numDimensions() > dim; }
final static protected < T > RandomAccessibleInterval< T > zeroMinN( final RandomAccessibleInterval< T > source ) { final long[] min = new long[ source.numDimensions() ]; final int n = min.length - 1; min[ n ] = source.min( n ); return Views.offset( source, min ); }
public Bandpass( final RandomAccessibleInterval< T > input, final int beginRadius, final int endRadius, ImgFactory<T> imgFactory ) { this.input = input; this.inPlace = false; this.bandPass = true; this.beginRadius = beginRadius; this.endRadius = endRadius; this.origin = new long[ input.numDimensions() ]; this.origin[ 0 ] = input.dimension( 0 ) - 1; for ( int d = 1; d < this.origin.length; ++d ) origin[ d ] = input.dimension( d ) / 2; }
@Override public void initialize() { final double[] sigmas1 = new double[in().numDimensions()]; final double[] sigmas2 = new double[in().numDimensions()]; Arrays.fill(sigmas1, sigma1); Arrays.fill(sigmas2, sigma2); op = Computers.unary(ops(), Ops.Filter.DoG.class, out(), in(), sigmas1, sigmas2, fac); }
public EllipsoidNeighborhood(final IN source, final long[] center, final long[] radiuses, final OutOfBoundsFactory<T, IN> outOfBounds) { super(source.numDimensions(), outOfBounds); if (numDimensions() < 2) { throw new IllegalArgumentException( "[EllipsoidNeighborhood] source must be at least of dimension 3."); } setSpan(radiuses); setPosition(center); updateSource(source); }
public BoundaryRandomAccess4( final RandomAccessibleInterval< T > sourceInterval ) { super( sourceInterval.randomAccess() ); n = sourceInterval.numDimensions(); min = new long[ n ]; max = new long[ n ]; sourceInterval.min( min ); sourceInterval.max( max ); type = new BoolType(); }
@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(); }
@Override public < T > NeighborhoodsAccessible< T > neighborhoodsRandomAccessible( final RandomAccessibleInterval< T > source ) { final RectangleNeighborhoodFactory< T > f = skipCenter ? RectangleNeighborhoodSkipCenterUnsafe.< T >factory() : RectangleNeighborhoodUnsafe.< T >factory(); final Interval spanInterval = createSpan( source.numDimensions() ); return new NeighborhoodsAccessible< T >( source, spanInterval, f ); }
@Override public boolean conforms() { if (in().numDimensions() == 2) { final long max_dist = in().dimension(0) * in().dimension(0) + in().dimension(1) * in().dimension(1); return ((in().numDimensions() == 2) && (max_dist <= Integer.MAX_VALUE)); } return false; }
@Override public RandomAccessibleInterval<T> calculate(RandomAccessibleInterval<T> input) { final long[] newDims = Intervals.dimensionsAsLongArray(in()); for (int i = 0; i < Math.min(scaleFactors.length, in().numDimensions()); i++) { newDims[i] = Math.round(in().dimension(i) * scaleFactors[i]); } IntervalView<T> interval = Views.interval(Views.raster(RealViews.affineReal( Views.interpolate(Views.extendMirrorSingle(input), interpolator), new Scale(scaleFactors))), new FinalInterval(newDims)); return interval; }
public void initialize(RandomAccessibleInterval<T> yk_iterated) { if (yk_prediction == null) { long[] temp = new long[yk_iterated.numDimensions()]; yk_iterated.dimensions(temp); FinalDimensions dims = new FinalDimensions(temp); yk_prediction = create.calculate(dims); xkm1_previous = create.calculate(dims); yk_prediction = create.calculate(dims); gk = create.calculate(dims); hk_vector = create.calculate(dims); } }