/** * @deprecated Use * {@link #realToComplex(RandomAccessible, Interval, ImgFactory, ExecutorService)} * instead. */ @Deprecated final public static < R extends RealType< R >, C extends ComplexType< C > > Img< C > realToComplex( final RandomAccessible< R > input, Interval inputInterval, final ImgFactory< C > factory, final C type, final ExecutorService service ) { return realToComplex( input, inputInterval, factory.imgFactory( type ), service ); }
/** * This inverse FFT can be only done in place, if desired. All parameters need to be set using the set() methods of this class. * * @param fftImage - the input as {@link Img} * @param type - a Type instance for the output */ public InverseFourierTransform( final Img<S> fftImage, final T type ) throws IncompatibleTypeException { this( fftImage, fftImage.factory().imgFactory( type ), type, Rearrangement.REARRANGE_QUADRANTS, true, false, null, null ); }
public FourierTransform( final Img<T> input, final S complexType ) throws IncompatibleTypeException { this ( input, input.factory().imgFactory( complexType ), complexType, PreProcessing.EXTEND_MIRROR_FADING, Rearrangement.REARRANGE_QUADRANTS, FFTOptimization.SPEED, 0.25f, 0.25f, 12 ); }
/** * @deprecated Use * {@link #complexToReal(RandomAccessible, Interval,Interval, ImgFactory, ExecutorService)} * instead. */ @Deprecated final public static < C extends ComplexType< C >, R extends RealType< R > > Img< R > complexToReal( final RandomAccessible< C > input, Interval inputInterval, final Interval outputDimensions, final ImgFactory< R > factory, final R type, final ExecutorService service ) { return complexToReal( input, inputInterval, outputDimensions, factory.imgFactory( type ), service ); }
/** * @deprecated * @see #openImgs(Reader, ImgFactory, SCIFIOConfig) */ @Deprecated public <T extends RealType<T>> List<SCIFIOImgPlus<T>> openImgs( Reader reader, final T type, final ImgFactory<T> imgFactory, final SCIFIOConfig config) throws ImgIOException { return openImgs(reader, imgFactory.imgFactory(type), config); }
/** * This inverse FFT can be only done in place, if desired. All parameters need to be set using the set() methods of this class. * * @param fftImage - the input as {@link Img} * @param type - a Type instance for the output */ public InverseFourierTransform( final Img<S> fftImage, final T type ) throws IncompatibleTypeException { this( fftImage, fftImage.factory().imgFactory( type ), type, Rearrangement.REARRANGE_QUADRANTS, true, false, null, null ); }
/** * @deprecated * @see #openImgs(Reader, ImgFactory, SCIFIOConfig) */ @Deprecated public static <T extends RealType<T> & NativeType<T>> List<SCIFIOImgPlus<T>> openImgs(final Reader reader, final T type, final ImgFactory<T> imgFactory, final SCIFIOConfig config) { return openImgs(reader, imgFactory.imgFactory(type), config); }
/** * @deprecated * @see #openImgs(String, ImgFactory) */ @Deprecated public static <T extends RealType<T> & NativeType<T>> List<SCIFIOImgPlus<T>> openImgs(final String source, final ImgFactory<T> imgFactory, final T type) { return openImgs(source, imgFactory.imgFactory(type)); }
/** * @deprecated * @see #openImgs(Reader, ImgFactory, SCIFIOConfig) */ @Deprecated public static <T extends RealType<T> & NativeType<T>> List<SCIFIOImgPlus<T>> openImgs(final Reader reader, final T type, final ImgFactory<T> imgFactory, final SCIFIOConfig config) { return openImgs(reader, imgFactory.imgFactory(type), config); }
/** * @deprecated * @see #openImgs(String, ImgFactory) */ @Deprecated public static <T extends RealType<T> & NativeType<T>> List<SCIFIOImgPlus<T>> openImgs(final String source, final ImgFactory<T> imgFactory, final T type) { return openImgs(source, imgFactory.imgFactory(type)); }
/** * @deprecated * @see #openImgs(String, ImgFactory) */ @Deprecated public <T extends RealType<T> & NativeType<T>> List<SCIFIOImgPlus<T>> openImgs(final String source, final ImgFactory<T> imgFactory, final T type) throws ImgIOException { return openImgs(source, imgFactory.imgFactory(type)); }
public FourierTransform( final Img<T> input, final S complexType, final Rearrangement rearrangement ) throws IncompatibleTypeException { this ( input, input.factory().imgFactory( complexType ), complexType ); setRearrangement( rearrangement ); }
public FourierTransform( final Img<T> input, final S complexType, final OutOfBoundsFactory<T, RandomAccessibleInterval<T>> outOfBounds ) throws IncompatibleTypeException { this ( input, input.factory().imgFactory( complexType ), complexType ); this.outOfBounds = outOfBounds; setPreProcessing( PreProcessing.USE_GIVEN_OUTOFBOUNDSSTRATEGY ); }
public FourierTransform( final Img<T> input, final S complexType, final Rearrangement rearrangement ) throws IncompatibleTypeException { this ( input, input.factory().imgFactory( complexType ), complexType ); setRearrangement( rearrangement ); }
public FourierTransform( final Img<T> input, final S complexType, final FFTOptimization fftOptimization ) throws IncompatibleTypeException { this ( input, input.factory().imgFactory( complexType ), complexType ); setFFTOptimization( fftOptimization ); }
@Override public ImgFactory<T> factory() { try { return source.factory().imgFactory(type.createVariable()); } catch (final IncompatibleTypeException e) { e.printStackTrace(); } return null; }
@Override public Img< O > createEmptyOutput( Img< I > in ) { try { return in.factory().imgFactory( m_outType ).create( in, m_outType ); } catch ( IncompatibleTypeException e ) { return new ArrayImgFactory< O >().create( in, m_outType ); } }
/** * This inverse FFT can be only done in place, if desired. * * @param fftImage - the input as {@link Img} * @param forwardTransform - the ForwardTransform ({@link FourierTransform}) which still has all parameters * @param type - a Type instance for the output */ public InverseFourierTransform( final Img<S> fftImage, final FourierTransform<?,?> forwardTransform, final T type ) throws IncompatibleTypeException { this ( fftImage, fftImage.factory().imgFactory( type ), type, forwardTransform.getRearrangement(), true, true, forwardTransform.getFFTInputSize(), forwardTransform.getFFTInputOffset() ); }
/** * Computes a convolution in Fourier space. * * @param image - the input {@link Img} to be convolved * @param kernel - the kernel {@link Img} for the convolution operation * @throws IncompatibleTypeException if the factory of the input {@link Img}<T> is not compatible with the {@link ComplexFloatType} (it needs to be a {@link NativeType}) */ public FourierConvolution( final Img<T> image, final Img<S> kernel ) throws IncompatibleTypeException { this( image, kernel, image.factory(), kernel.factory(), image.factory().imgFactory( new ComplexFloatType() ) ); }
/** * This inverse FFT can be only done in place, if desired. * * @param fftImage - the input as {@link Img} * @param forwardTransform - the ForwardTransform ({@link FourierTransform}) which still has all parameters */ public InverseFourierTransform( final Img<S> fftImage, final FourierTransform<T,?> forwardTransform ) throws IncompatibleTypeException { this ( fftImage, fftImage.factory().imgFactory( forwardTransform.getImageType() ), forwardTransform.getImageType(), forwardTransform.getRearrangement(), true, true, forwardTransform.getFFTInputSize(), forwardTransform.getFFTInputOffset() ); }