realizing FFT

so... I just whanted to realize FFT algorithm in a simple way avoiding the greatest Sample-Based Architecture but... is there any way for faster memory allocation?
for example the code below makes buffer for image and then draws the image from that buffer (only 100x100 pixels) but one cycle of buffer creation takes about 5 sec. so it will be impossible to create 1000x1000 pixel buffer or large. What is the problem or this aproach is impossible to realize?

function prepare()
calculated = 0
a=1
mt = {}
N = 100
M = 100
for i=0,N do
mt[i] = {}
for j=0,M do
mt[i][j] = {0,0,0}
end
end

end;

function cheat()
if calculated==0 then
for i=0,N do
for j=0,M do
mt[i][j][1], mt[i][j][2], mt[i][j][3] = get_sample_map(i/N,j/M,TEST)

end
end
calculated=1
end
return 1

end;

function get_sample(x, y)
cheat()
i=math.ceil(x*(N-1))
j=math.ceil(y*(M-1))
return mt[i][j][1], mt[i][j][2], mt[i][j][3], 1
end;

ok... thanks for the link Sphinx. It is really impossible this way then. may be there is some possibility for direct acсessing memory of the input map and using some external prepared c++ library? I read somewhere that there are some kind of possible c++ extensions.

get_sample_map is something like readonly buffer already, isn't it?
Ok, We'll wait for better times Hope FilterForge will be something like NI Reaktor but for pictures. It is a huge lack of interesting and usuable software in 2d graphical industry nowdays. I wanted to realize Fast Fourier transform because with just one dot so many interesting structures can be created and it is a large field of experiments. For example here is a picture of black dot IFFt distored with Flexify2 filter.

cool image, gmur

Unfortunately, from my understanding, the three techniques I mention rely on the fundamental nature of bitmaps to function, mostly the ability to compare points in the image in a systemic manner, and thus have no equivalent in sample-based rendering. Distance Transform is a good example, it's closely mathematically related to a Gaussian Blur, which can't be achieved in sample-based rendering (to my knowledge).

Please, feel free to correct me if I'm wrong.

Quote
They share some properties in the way they can be optimized by multi-pass processing, and the fact that both must assume a minimum sample distance or sample step size (with a bitmap this distance is simply one pixel).

Yeah, that's basically what I meant. I'm not nearly as proficient in these thing as I may like.
I'd actually forgotten that the restriction is not absolute, but it does essentially make it unusable.

The main problem seems to be that a lot of the research into interesting graphical techniques can't really be generalized in an efficient manner to FF's rendering engine.

Quote
Bitmap-based Scripting component is currently in our plans. Actually it has been being in the plans since we started the development of FF scripting. =)

The version 4 release will have this Bitmap-based Scripting component?