roflmaostc / fftresampling.jl

A package for FFT based interpolations of N-dimensional arrays.

Felix Wechsler

I'm currently working on computational optics topics such as 3D printing with light or wave propagation. Feel free to visit my webpage for more information.

A lot of my work is implemented in Julia Lang. I mainly use Arch Linux + AwesomeWM + Vim.

Published Code

• DeconvOptim.jl for performant data deconvolution
• Scalable Angular Spectrum for optical wave propagation.
• SwissVAMyKnife.jl to solve optimizations around Tomographic Volumetric Additive Manufacturing
• WaveOpticsPropagation.jl for differentiable wave optical propagation

Julia Lang

Some of my smaller packages:

• ABCDMatrixOptics.jl to trace Geometrical and Gaussian beams with matrices
• DiffImageRotation.jl for CUDA, differentiable image rotation
• FourierTools.jl to efficiently work with Fourier space
• IndexFunArrays to create arrays according to index specific behaviour
• NDTools.jl to manage N dimensional data
• Noise.jl to degrade data quality
• PtyLab.jl to reconstruct Ptychography datasets
• RadonKA.jl for (exponential/attenuated) Radon transforms

Outdated:

• PhysicalOptics.jl to simulate wave optics

Python

• orpheuscc to manage event registrations of the Orpheus e.V. Written in Python + Django
• Naive implementation of energy minimization with graph cuts.

OCaml

• PONGCaml simple and easy pong game written in OCaml
• Solved almost all 99 OCaml problems

Toy projects

• aiornot.fun: A quiz to test your knowledge whether you're able to idenfity an AI paper or non AI paper.

fftresampling.jl's Issues

Feature request: slow sinc interpolation at unevenly spaced points

Would be nice to have this work for arbitrary points, also multi-dimensional. I have this piece of code lying around:

# take an array ϕ defined at equispaced points and evaluate its
# Fourier interpolant at points xint
function fourier_interpolate(ϕ,xint)
    Y = fftshift(fft(ϕ))
    half_size = floor.(size(ϕ)./2)
    yval = zeros(size(xint))
    x = [[x[i] for x in xint] for i in 1:3]
    for k = 1:size(ϕ)[3], j = 1:size(ϕ)[2], i = 1:size(ϕ)[1]
	yval += Y[i,j,k]*exp.(im*2*pi*
			      ((i-1 - half_size[1]).*x[1] .+
			       (j-1 - half_size[2]).*x[2] .+
			       (k-1 - half_size[3]).*x[3]))
    end
    return real.(yval ./length(ϕ))
end

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Efficiently handle the case when the input size is the same as the size of the array to be resample

It should directly return the input array (or a copy?) back.

Complex Signals

So far we are only sure that interpolation of real signals works correctly.
For complex signals we can consider splitting the signal in real and imaginary part and apply the real signal routine to each of them independently.

Todo

• check the current functions for purely complex signal
• check the current functions for complex signals