Is it possible to fake blur via images?

Question

I'm using libGDX for an android game; as far as I can tell, it doesn't have an API for blurring.

Reading on Wikipedia, it seems like blur is formed by setting each pixels RGB values to the average of all adjacent values. Which doesn't seem easily possible in libGDX -- setting pixel data.

So my question is simple:

Is it possible to fake (a decent) blur using only images?

I can potentially overlay multiple (in number, transparency, type) images; but can I create a convincing blur like this?

I'm tempted to say "no," but maybe someone else has achieved something similar. For clarity, I want a set of 1+ generic images I can render on top of ANY image to generate a blur-like effect.

You suggest overlaying transparent images over one another. If you slightly offset them, you're going to be averaging the pixels, achieving blur — Jeff, Oct 20 '11 at 02:30
@Jeff I updated my question to be clear. I'm not talking about rendering the images slightly offset; I'm talking about generic images I can render on top of ANY image output to blur it. — ashes999, Oct 20 '11 at 02:37
@ashes999, if you're looking for a "magic image" that can be overlaid on things to make them appear blurry, that doesn't exist. Alpha-blending (overlaying) isn't remotely the same thing as blurring, sorry. — Nathan Reed, Oct 20 '11 at 02:51
That "magic image" you're looking for is the current to-be-displayed image. — Martin Sojka, Oct 20 '11 at 14:21
UPDATED ANSWER: this will probably help you http://manuelbua.github.com/libgdx-contribs/ — Mikle Pankratov, Mar 04 '13 at 07:19

Nathan Reed · Answer 1 · 2011-10-20T02:50:01.050

If you're able to additively blend images and multiply them by a constant while doing so, then you can do a blur. Instead of averaging the pixels in a neighborhood, you'd average several copies of the image displaced by a small number of pixels from each other. Or more generally, you could do a Gaussian blur or whatever kind of blur, by controlling the weights - that is, multiplying each displaced copy of the image by a constant as it's being added onto the rest.

Algorithmically, it would look something like this:

clear output_image to 0
foreach offset, weight in filter_kernel:
    output_image += input_image * weight, shifted by offset

You'd use the same offsets and weights as in the standard way of doing a blur. There are plenty of articles on the Web on how to generate the weights for a Gaussian blur, for instance.

+1 nice answer. In my case, I don't have additive ability. – ashes999 Oct 20 '11 at 02:57 — ashes999, Oct 20 '11 at 02:57

score 0 · Answer 2 · answered Oct 20 '11 at 14:13

Blurring can be an expensive operation, perhaps a different approach could work, e.g.:

Store multiple copies of the image blurred in several different directions (e.g. multiples of 45 degrees), then display the closest matching image at runtime. This will offer the highest performance, at the cost of memory usage.
Scale the image down and then back to full-size with anti-aliasing/smoothing. Often this can be done with graphics hardware with very little performance impact.

It won't work, because it has to be dynamic, i.e. I can't know the exact setup of the screen ahead of time. — ashes999, Oct 20 '11 at 15:43

Is it possible to fake blur via images?

2 Answers2