When we move to a signal, which is now of course pulsed or
flutter shuttered like this, we might have a signal like this.
Of course, the output we know is convolution of this to this one,
and this is also a sinc function.
And of course,
the big thing here is it is actually preserving all of the high frequencies.
It's not going down into the low frequencies.
By basically being able to do this, we actually now are able to get rid of
modeling all of the low frequencies and high frequencies are there.
And this is my sinc function.
Again, I would get this by trying to compute the discrete Fourier transform
of an image in this process.
Recall again, that convolution has a lot to do with Fourier transforms, when we
looked at all of our signal processing stuff in one of the earlier lectures.
Here are the two signals next to each other.
Full open shutter, sinc function looks like this.
And of course, our flutter shutter, or a pulse shutter like this,
the since function looks like this,
never gets to some of the low frequencies always basically.
And again you can see this that there is a lot more low frequency
information here.
And because of the sharp lines and stuff like that,
here we are actually seeing a lot more of the high frequencies.
Simply, again, we flutter shuttered or pulsed our sense,
our, our shutter to be able to get this image.
We are interest in, of course, is the inversion, right?
We are trying to invert this, being able to go from this to an original image.
Of course, we can do this by doing inverse Fourier transforms.
And again, in this case, we can now look at the inverse filters for doing these
types of things, and of course we look at the two different sine functions.
The thing that is, and this is something I'm going to refer you to back
to some of the literature on signal processing.
This kind of a filter is unstable, while a signal like this is much more stable
because again it's only kind of capturing the high or
low frequencies in this instance.
And we can represent this much better to be able to kind of do the inversion to
compute our signals.
And that's the basic idea here is that trying to do an inverse
discrete Fourier transform, this kind actually would be much more suitable for
our reconstruction.
Let's look at the examples.
In this case I'm going to basically show short exposure, long exposure and
coded exposure.
For a long, short exposure, of course, no light.
We get a ray thing, but of course we get a nice, crisp image.
Long exposure, we get a lot of blurriness.
Coded exposure we get blurriness with a lot more
high frequency information still there.
And of course, we can de-blur this using the approach I kind of talked about, and
this is what we would get, much crisper image.
If we were to de-blurring this with a variety of different approaches,
we might still get some incompleteness.
But in this case by doing it the method I was doing with discrete Fourier
transforms and stuff like that, we will get more bars.
By the way, just to compare, this is the ground truth image that we would have
had if we actually had captured it correctly.
And this one looks pretty good.
There's a little bit of noise, and a little bit of banding going on, but
much better than this.
And that's the basic idea of this flutter shutter camera.
Being able to kind of use this knowledge to be able to now reconstruct an image
that knows how the variations happen.
Again, we know the code, we know the output, we can deconvolve
with the knowledge itself to help us figure out how to actually generate
a reconstruction that's much more true to what the original image would be.
Same idea as what we looked at for
coded aperture, except this time of course it's a coded shutter.
Let's see some examples produced by these authors and their paper.
Here is an example using this camera here, of basically looking at a car.
Of course, if this car is moving fast,
you cannot actually see the license plate, which is here.
But, of course, if we had a flutter shutter camera, you should be able to
reconstruct from this and actually get the license plate number.
Another example of the same thing again, somebody says I want more detail here.
This is the original image, but
if I had a flutter shutter camera, I should be able to generate more.
Another example with the cars again, this is the orig image, image.
Let's just focus in in there.
And actually, the whole car image can be regenerated.
And if you notice, we can actually now start looking up, and
start even reading some of the numbers and additional detail.
Another input image, we can rectify the cropped image here and
again create a de-blurred result, much more crisper.