@Override public void evaluate(long[] coordinate, SubInterval<T> interval, ComplexType<?> output) { double sum = 0; long numElem = 0; Cursor<RealType<?>> cursor = null; // DOES NOT COMPILE HERE //cursor = interval.cursor(); // probably need RegionIndexIterator idea instead while (cursor.hasNext()) { sum += cursor.get().getRealDouble(); numElem++; } if (numElem == 0) output.setReal(0); else output.setReal(sum/numElem); }
@Override public void compute( final Composite< T > tensor, final Composite< U > evs ) { evs.get( 0 ).setReal( tensor.get( 0 ).getRealDouble() ); } }
@Override public C compute(T input1, V input2, C output) { output.setReal(input1.getRealDouble()); output.setImaginary(input2.getRealDouble()); return output; }
@Override public O compute(I z, O output) { output.setReal(z.getRealDouble()); output.setImaginary(z.getImaginaryDouble()); return output; }
@Override public O compute(I z, O output) { output.setReal(z.getRealDouble()); output.setImaginary(z.getImaginaryDouble()); return output; }
@Override public C compute(T input1, V input2, C output) { output.setReal(input1.getRealDouble()); output.setImaginary(input2.getRealDouble()); return output; }
@Override public void compute( final Composite< T > tensor, final Composite< U > evs ) { final double x11 = tensor.get( 0 ).getRealDouble(); final double x12 = tensor.get( 1 ).getRealDouble(); final double x22 = tensor.get( 2 ).getRealDouble(); final double sum = x11 + x22; final double diff = x11 - x22; final double sqrt = Math.sqrt( 4 * x12 * x12 + diff * diff ); evs.get( 0 ).setReal( 0.5 * ( sum + sqrt ) ); evs.get( 1 ).setReal( 0.5 * ( sum - sqrt ) ); } }
@Override public void compute( final Composite< T > tensor, final Composite< U > evs ) { m.setData( tensor ); ed.computeValuesOnly( m ); ed.getEigenvalues( this.evs, emptyOptional ); for ( int d = 0; d < this.evs.length; ++d ) evs.get( d ).setReal( this.evs[ d ] ); }
@Override public void compute( final Composite< T > tensor, final Composite< U > evs ) { m.setData( tensor ); ed.computeValuesOnly( this.m ); ed.getEigenvalues( this.evs, emptyOptional ); for ( int d = 0; d < this.evs.length; ++d ) evs.get( d ).setReal( this.evs[ d ] ); }
cursor.get().setReal(val);
exponent += -x * x / 2d / sigmas[0] / sigmas[0]; c.get().setReal(mantissa * Math.exp(exponent));
@Override public void compute(long[] point, O output) { accessor.setPosition(point); output.setReal(accessor.get().getRealDouble()); output.setImaginary(accessor.get().getImaginaryDouble()); }
@Override public void compute(long[] point, O output) { accessor.setPosition(point); output.setReal(accessor.get().getRealDouble()); output.setImaginary(accessor.get().getImaginaryDouble()); }
cursor.get().setReal( GaussExp * Math.cos(freqPart) );
@Override public RandomAccessibleInterval<T> calculate(double[][] input) { final long[] dims = { input.length, input[0].length }; final RandomAccessibleInterval<T> rai = createOp.calculate(new FinalInterval( dims)); final Cursor<T> cursor = Views.iterable(rai).cursor(); for (int j = 0; j < input.length; j++) { for (int k = 0; k < input[j].length; k++) { cursor.fwd(); cursor.get().setReal(input[j][k]); } } return rai; } }
@Override public RandomAccessibleInterval<T> calculate(double[] input) { final double[] sigmaPixels = new double[input.length]; final long[] dims = new long[input.length]; final double[][] kernelArrays = new double[input.length][]; for (int d = 0; d < input.length; d++) { sigmaPixels[d] = input[d]; dims[d] = Math.max(3, (2 * (int) (3 * sigmaPixels[d] + 0.5) + 1)); kernelArrays[d] = Util.createGaussianKernel1DDouble(sigmaPixels[d], true); } final RandomAccessibleInterval<T> out = createOp.calculate(new FinalInterval( dims)); final Cursor<T> cursor = Views.iterable(out).cursor(); while (cursor.hasNext()) { cursor.fwd(); double result = 1.0f; for (int d = 0; d < input.length; d++) { result *= kernelArrays[d][cursor.getIntPosition(d)]; } cursor.get().setReal(result); } return out; }
@Override public RandomAccessibleInterval<T> calculate() { long[] dim = new long[4]; dim[0] = 3; dim[1] = 1; for (int k = 2; k < dim.length; k++) { dim[k] = 1; } dim[dim.length - 1] = 2; RandomAccessibleInterval<T> output = createOp.calculate(new FinalInterval(dim)); final Cursor<T> cursor = Views.iterable(output).cursor(); int i = 0; while (cursor.hasNext()) { cursor.fwd(); cursor.get().setReal(values[i]); i++; } return output; }
/** * Conditionally assigns pixels in the output region. */ public void assign() { final RandomAccess<U> accessor = img.randomAccess(); final V output = function.createOutput(); INPUT input = null; while (iter.hasNext()) { input = iter.next(input); boolean proceed = (condition == null) || (condition.isTrue(input)); if (proceed) { function.compute(input, output); accessor.setPosition(iter.getCurrentPoint()); accessor.get().setReal(output.getRealDouble()); accessor.get().setImaginary(output.getImaginaryDouble()); // FIXME // Note - for real datasets this imaginary assignment may waste cpu // cycles. Perhaps it can get optimized away by the JIT. But maybe not // since the type is not really known because this class is really // constructed from a raw type. We'd need to test how the JIT handles // this situation. Note that in past incarnations this class used // assigner classes. The complex version set R & I but the real // version just set R. We could adopt that approach once again. } } } }
/** * Conditionally assigns pixels in the output region. */ public void assign() { final RandomAccess<U> accessor = img.randomAccess(); final V output = function.createOutput(); INPUT input = null; while (iter.hasNext()) { input = iter.next(input); boolean proceed = (condition == null) || (condition.isTrue(input)); if (proceed) { function.compute(input, output); accessor.setPosition(iter.getCurrentPoint()); accessor.get().setReal(output.getRealDouble()); accessor.get().setImaginary(output.getImaginaryDouble()); // FIXME // Note - for real datasets this imaginary assignment may waste cpu // cycles. Perhaps it can get optimized away by the JIT. But maybe not // since the type is not really known because this class is really // constructed from a raw type. We'd need to test how the JIT handles // this situation. Note that in past incarnations this class used // assigner classes. The complex version set R & I but the real // version just set R. We could adopt that approach once again. } } } }
sumI += temp.getRealDouble(); output.setReal(sumR); output.setImaginary(sumI);