Pyramids by matrix

Pyramids by matrix
http://www.filterforge.com/filters/5419.html

Hey Matt!

Ahh, finally you published this!

Guys you should take a look at the guts of this one - it shows how to achieve correct depth perspective transformations/distortions...

Hey all,

I'd like to fill in some more details about the implementation...

I'll try to describe the process in which we arrived at our final solution.

First of all, we considered the problem of finding the inverse transformation of the offset module. That is, how can we get back to the original image after it has been transformed by an offset?

Specifically we looked at the case when the image was rescaled uniformly using vertical and horizontal gradients.

We found that the offset module performed a transformation according to this formula:

y = x + 2*x*p

where x is the input coordinate, y is the output coordinate and p is the percentage parameter. We assumed that x was in the range -0.5..0.5.

If the offset module is represented as a function f and its source sampler as a function g, then it means that the returned value can be computed as

f(x) = g(x + 2*x*p).

Now let us assume that as second offset module h(x), is able to reverse the transformation of the first offset, according to the formula

h(x) = f(x - 2*x*u(p)),

where u is an unknown function.

If this module reverses the transformation of f, then clearly h(x) = g(x).

Thus we have the following recurrence equation:

g(x) = f(x - 2*x*u(p)) <=>
g(x/(1 - 2*u(p)) = f(x) <=>
g(x/(1 - 2*u(p)) = g(x + 2*x*p) =>

x/(1 - 2*u(p)) = x + 2*x*p =>
u(p) = p/(1 + 2*p)

Hence, by adjusting the percentage of the second offset according to u(p), we can reverse the first offset operation.

By further experiments we figured out how to reverse a an offset that used repeated gradients for zooming out.

In this case, if we have n repetitions (and percentage = 100%), then the reverse transformation could be done using the following formula:

u(p, n) = p*n/(1 + 2*p*n)

Now, the tricky part was to find a formula that allowed us to linearly interpolate between the zoomed out and the zoomed in version of the image and thus create a perspective effect. This part wasn't done completely analytically, but rather by noticing that by adjusting the bias and the maximum parameters of a bias curve, this would create a correct perspective for a certain value of n.

The bias curve would have a maximum determined by u(p, n) and a bias value determined by a formula that we derived through curve fitting.

Finally, working out how to actually compute these formulas in FF also required some thinking.

Basically we had to figure out a way to compute the value of

u(n) = n / (1 + 2*n).

We found that a bias curve could be used to perform exact divisions, assuming that it was adjusted as follows:

Bias = 98.02
Start = 1.00
End = 1.00
Minimum = 1.00
Maximum = 100

This proved to be very useful, but still we had some problems with overflow and so we were forced to rewrite the formula using partial fraction decomposition:

u(n) = 0.5 - 0.5/(1 + 2*n)

This however successfully solved our problem and we managed to finally get the correct perspective transformation that we were looking for!

Well, indeed, there is some fascinating stuff in the guts of this one.

For instance, I had no idea you could shrink something down to a dot and blow it back up (internally) without loss of detail. So, I guess that, apart from a few effects, all internal calculation in FF is purely mathematical with floating point precision?

Sorry matrix. I just realized that adding reflection to uberzev's snippet has nothing to do with your excellent perspective filter.

Quote
uberzev wrote: The only issue I have is the the blurriness of the presets. Otherwise great job.

Yep, I was a bit unsure whether to include it or not. I think I wasn't very satisfied with the antialiasing of the previews. Will the previews be updated if I upload it again with different AA settings?

Quote
matrix wrote: Will the previews be updated if I upload it again with different AA settings?

----Yes. You can update filters any time with changes, it just takes another day or two until the *new* version is posted in the online library is all.

jffe

I think it's good to try to find a balance between your creative and analytical skills. Sort of not to make one of the brain halves feel left out.

Anyway, I've managed to simplify the perspective part of the filter quite a bit (partly thanks to ThreeDees fraction snippet), so if you downloaded the previous version you probably want to update it.

Sounds like an interesting challenge. If you were to do this programmatically, then there are two methods that are frequently used: scanline rendering and ray tracing. In both cases you need to be able to represent the vertices of the box and the position of the light source in 3D (assuming that you want it to be shaded).

Now, suppose that we can somehow represent 3D coordinates in FF and that we can perform the correct 3D -> 2D projection. What is left is basically to compute the depth values of each plane of the box and to clip these planes to the projected polygons (this would be similar to the scanline rendering approach). I think that could be quite feasible.

If we were to go for the ray-tracing solution instead, then we would rather need some way of representing the ray and to test whether or not it intersects the 3D object. That is, depending on which side of the box we hit, we will return the appropriate depth value.

Moreover, if we have the depth values, we could use the built-in shader of FF and the current perspective tranformation to add light and texture.

Well, I could start by trying to figure out if there is a good way to represent 3D coordinates and how one should go about projective transformations...

Maybe you can use this for something TD...Spinning Wall..
http://www.filterforge.com/forum/read...ssage46025
basically the same as the perspective frame but a gradient...
Also a cube here
http://www.filterforge.com/forum/read...10&TID=747

Hi CFandM,

That's the basic idea, but with mathematically correct perspective. I'm doing this sort of step-by-step, but the real objective is a box of adjustable x, y and z dimensions that is fully rotatable around x and y axis, in proper perspective. (Going for that technical achievement award, whatever the prize was, a Yugo or something...) No, seriously speaking, I want to end up with a "packaging" filter where you could map an image to a box and rotate the thing. May be too much to ask for, but hey, if you don't aim high...

Very nice job on the v1.1 update Matrix.

One (very minor) suggestion I have is to remove the 'Set Alpha' and just plug everything into the 'Threshold'. (Make the 'High' input the image and the 'Low' input a transparent color ['A' slider in the color picker])

Oh and this is too cool...

Excellent work!!!

Wow!!! Talk about a detailed mathmatical approach!!!

I just plug the line thingy into the node thingy..... ..... LMAO.....