@Override public CompositeView<T, RealComposite<T>> calculate(RandomAccessible<T> input) { return Views.collapseReal(input, numChannels); }
@Override public CompositeIntervalView<T, RealComposite<T>> calculate(RandomAccessibleInterval<T> input) { return Views.collapseReal(input); }
@Override public CompositeIntervalView<T, RealComposite<T>> calculate(RandomAccessibleInterval<T> input) { List<RandomAccessibleInterval<T>> derivatives = new ArrayList<>(); for (int i = 0; i < derivativeFunctions.length; i++) { RandomAccessibleInterval<T> derivative = derivativeFunctions[i].calculate(input); derivatives.add(derivative); } RandomAccessibleInterval<T> stacked = Views.stack(derivatives); return Views.collapseReal(stacked); } }
/** * Compose a list of same {@link Interval} and same {@link RealType} A * {@link RandomAccessibleInterval RandomAccessibleIntervals} into a * {@link RandomAccessibleInterval} of some target {@link Type} B using a * {@link Converter} from {@link Composite} of A to B. * * @param components * @param composer * @param targetType * @return */ final static public < A extends RealType< A >, B extends Type< B > > RandomAccessibleInterval< B > composeReal( final List< RandomAccessibleInterval< A > > components, final Converter< RealComposite< A >, B > composer, final B targetType ) { return convert( Views.collapseReal( Views.stack( components ) ), composer, targetType ); }
/** * Compose a list of same {@link Interval} and same {@link RealType} A * {@link RandomAccessibleInterval RandomAccessibleIntervals} into a * {@link RandomAccessibleInterval} of some target {@link Type} B using a * {@link Converter} from {@link Composite} of A to B. * * @param components * @param composer * @param targetType * @return */ final static public < A extends RealType< A >, B extends Type< B > > RandomAccessibleInterval< B > composeReal( final List< RandomAccessibleInterval< A > > components, final Converter< RealComposite< A >, B > composer, final B targetType ) { return convert( Views.collapseReal( Views.stack( components ) ), composer, targetType ); }
@Override public CompositeIntervalView<T, RealComposite<T>> calculate(RandomAccessibleInterval<T> input) { List<RandomAccessibleInterval<T>> derivatives = new ArrayList<>(); for (int i = 0; i < derivativeComputers.length; i++) { RandomAccessibleInterval<T> derivative = createRAI.calculate(input); derivativeComputers[i].compute(input, derivative); for (int j = 0; j < derivativeComputers.length; j++) { RandomAccessibleInterval<T> out = createRAI.calculate(input); derivativeComputers[j].compute(derivative, out); derivatives.add(out); } } RandomAccessibleInterval<T> stackedDerivatives = Views.stack(derivatives); return Views.collapseReal(stackedDerivatives); }
public LinearIntensityMap( final RandomAccessibleInterval< T > source, final InterpolatorFactory< RealComposite< T >, RandomAccessible< RealComposite< T > > > interpolatorFactory ) { this.interpolatorFactory = interpolatorFactory; final CompositeIntervalView< T, RealComposite< T > > collapsedSource = Views.collapseReal( source ); dimensions = new FinalInterval( collapsedSource ); final double[] shift = new double[ dimensions.numDimensions() ]; for ( int d = 0; d < shift.length; ++d ) shift[ d ] = 0.5; translation = new Translation( shift ); final RandomAccessible< RealComposite< T > > extendedCollapsedSource = Views.extendBorder( collapsedSource ); coefficients = Views.interpolate( extendedCollapsedSource, interpolatorFactory ); }
private static < T extends RealType< T >, U extends RealType< U > > void transformAlongDimension( final RandomAccessible< T > source, final RandomAccessibleInterval< U > target, final Distance d, final int dim ) { final int lastDim = target.numDimensions() - 1; final long size = target.dimension( dim ); final RealComposite< DoubleType > tmp = Views.collapseReal( createAppropriateOneDimensionalImage( size, new DoubleType() ) ).randomAccess().get(); // do not permute if we already work on last dimension final Cursor< RealComposite< T > > s = Views.flatIterable( Views.collapseReal( dim == lastDim ? Views.interval( source, target ) : Views.permute( Views.interval( source, target ), dim, lastDim ) ) ).cursor(); final Cursor< RealComposite< U > > t = Views.flatIterable( Views.collapseReal( dim == lastDim ? target : Views.permute( target, dim, lastDim ) ) ).cursor(); final RealComposite< LongType > lowerBoundDistanceIndex = Views.collapseReal( createAppropriateOneDimensionalImage( size, new LongType() ) ).randomAccess().get(); final RealComposite< DoubleType > envelopeIntersectLocation = Views.collapseReal( createAppropriateOneDimensionalImage( size + 1, new DoubleType() ) ).randomAccess().get(); while ( s.hasNext() ) { final RealComposite< T > sourceComp = s.next(); final RealComposite< U > targetComp = t.next(); for ( long i = 0; i < size; ++i ) { tmp.get( i ).set( sourceComp.get( i ).getRealDouble() ); } transformSingleColumn( tmp, targetComp, lowerBoundDistanceIndex, envelopeIntersectLocation, d, dim, size ); } }
private static < T extends RealType< T >, U extends ComplexType< U > > RandomAccessibleInterval< U > calculateEigenValuesImpl( final RandomAccessibleInterval< T > tensor, final RandomAccessibleInterval< U > eigenvalues, final EigenValues< T, U > ev ) { final Cursor< RealComposite< T > > m = Views.iterable( Views.collapseReal( tensor ) ).cursor(); final Cursor< NumericComposite< U > > e = Views.iterable( Views.collapseNumeric( eigenvalues ) ).cursor(); while ( m.hasNext() ) ev.compute( m.next(), e.next() ); return eigenvalues; }
private static < T extends RealType< T >, U extends RealType< U > > void transformL1AlongDimension( final RandomAccessible< T > source, final RandomAccessibleInterval< U > target, final int dim, final double weight ) { final int lastDim = target.numDimensions() - 1; final long size = target.dimension( dim ); final RealComposite< DoubleType > tmp = Views.collapseReal( createAppropriateOneDimensionalImage( size, new DoubleType() ) ).randomAccess().get(); // do not permute if we already work on last dimension final Cursor< RealComposite< T > > s = Views.flatIterable( Views.collapseReal( dim == lastDim ? Views.interval( source, target ) : Views.permute( Views.interval( source, target ), dim, lastDim ) ) ).cursor(); final Cursor< RealComposite< U > > t = Views.flatIterable( Views.collapseReal( dim == lastDim ? target : Views.permute( target, dim, lastDim ) ) ).cursor(); while ( s.hasNext() ) { final RealComposite< T > sourceComp = s.next(); final RealComposite< U > targetComp = t.next(); for ( long i = 0; i < size; ++i ) { tmp.get( i ).set( sourceComp.get( i ).getRealDouble() ); } transformL1SingleColumn( tmp, targetComp, weight, size ); } }
@Test public void defaultCollapseRealTest() { Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 10, 10 }, new DoubleType()); CompositeIntervalView<DoubleType, RealComposite<DoubleType>> il2 = Views .collapseReal((RandomAccessibleInterval<DoubleType>) img); CompositeIntervalView<DoubleType, RealComposite<DoubleType>> opr = ops.transform() .collapseRealView((RandomAccessibleInterval<DoubleType>) img); assertEquals(il2.numDimensions(), opr.numDimensions()); CompositeView<DoubleType, RealComposite<DoubleType>> il2_2 = Views .collapseReal((RandomAccessible<DoubleType>) img, 1); CompositeView<DoubleType, RealComposite<DoubleType>> opr_2 = ops.transform() .collapseRealView((RandomAccessible<DoubleType>) img, 1); assertEquals(il2_2.numDimensions(), opr_2.numDimensions()); }