Is there a way to do fast (to render...) and smooth (to the eyes...) blurred
reflection using average normal or other method ?
I use this way to do :
http://www.students.tut.fi/~warp/povQandT/languageQandT.html (Search for
"Blurred")
It's a good method but I find it slow to render (on My Athlon XP2500+...)
Thanks

Post a reply to this message

_Light_Beam_ <s.f### [at] tiscalifr> wrote:
> Is there a way to do fast (to render...) and smooth (to the eyes...) blurred
> reflection using average normal or other method ?

  No.

  I don't know of any technique in any rendering system which would give
a perfect result very fast.

  An alternative method for calculating reflections is using reflection
maps. The reflection map can be depth-blurred, which results in a
blurred reflection effect when used in a reflection. This is very fast
(it can be done in real-time). The problem with reflection maps is that
they don't give geometrically correct reflections for objects which are
close to the reflection object (reflection maps work like the rest of the
scene was very far away from the reflecting object).

  In raytracing you can get geometrically accurate reflections, but
then you need to supersample (ie. shoot many rays) to approximate
blurred reflection.

-- 
#macro N(D)#if(D>99)cylinder{M()#local D=div(D,104);M().5,2pigment{rgb M()}}
N(D)#end#end#macro M()<mod(D,13)-6mod(div(D,13)8)-3,10>#end blob{
N(11117333955)N(4254934330)N(3900569407)N(7382340)N(3358)N(970)}//  - Warp -

Post a reply to this message

In article <3f71bc95@news.povray.org>,
 "_Light_Beam_" <s.f### [at] tiscalifr> wrote:

> Is there a way to do fast (to render...) and smooth (to the eyes...) blurred
> reflection using average normal or other method ?
> I use this way to do :
> http://www.students.tut.fi/~warp/povQandT/languageQandT.html (Search for
> "Blurred")
> It's a good method but I find it slow to render (on My Athlon XP2500+...)

There are several ways that method could be made faster, but not without 
patching POV. And that is about as fast as you can get without patching 
POV, though you could optimize it for specific cases.

-- 
Christopher James Huff <cja### [at] earthlinknet>
http://home.earthlink.net/~cjameshuff/
POV-Ray TAG: chr### [at] tagpovrayorg
http://tag.povray.org/

Post a reply to this message

What's the difference between using the blurred reflection code in _Light_Beam_'s link
and rendering
an animation with a single texture level on the object, and averaging the output
images?

The image at http://www.chris-j.co.uk/blurs.jpg shows blurred refraction more than
blurred
reflection (the surface is also slightly reflective, as can be seen on the bottom side
of the
sphere), but also shows the dramatic speedup when an averaged animation is used rather
than multiple
layers of texture. Making an animation with 8 (rather than 80) blur samples looks
different from the
multiple-layered image with 8 samples, suggesting that the method does produce
different-looking
results, but it seems (at least in this scene) that the animation method is gives a
much faster (if
less accurate) result.

http://www.chris-j.co.uk/blurs2.jpg shows the result of the T_Silver_3C pigment and
finish with an
80-frame-averaged animation, and unscaled (as opposed to x1000, as in the code
referenced above)
bumps 0.3. The innacuracies caused by using too few frames in the average are just
about visable
here.

I'm sure this method must have been thought of before - is there any reason why it
should be
inferior in accuracy than using multiple layers of texture?

-Chris

Post a reply to this message

In article <3f7dd3f1@news.povray.org>,
 "Chris Johnson" <chr### [at] chris-jcouk> wrote:

> What's the difference between using the blurred reflection code in 
> _Light_Beam_'s link and rendering an animation with a single texture 
> level on the object, and averaging the output images?

Well, that method will trace many single paths. The paths do not split 
with this method. It could possibly be used to get good results with 
fewer rays. With the usual method, most of the rays are at a fairly deep 
recursion, and don't contribute as much. The primary problem that makes 
blurred reflection slow is the exponential explosion of rays traced when 
you get multiple levels of reflection.

What you propose is similar to another raytracing algorithm I've read 
about where a single path is always traced. When a surface with 
reflection and transparency is encountered, where a conventional 
raytracer would split into two rays, just one of the paths is chosen. To 
get the pixel color, many of these samples are added together. If you 
have deep recursion and/or large numbers of samples, this can greatly 
reduce the total number of rays traced.


> I'm sure this method must have been thought of before - is there any 
> reason why it should be inferior in accuracy than using multiple 
> layers of texture?

It is inferior in accuracy, but mainly due to the fact that images have 
limited precision. You should be able to get good results in most cases, 
with fewer rays cast than in a simplistic "cast a bunch of rays" blur 
algorithm, but a smarter version of that algorithm might do even better. 
The main problem is that it is a bit awkward and inefficient to render 
whole frames and then process them together.

-- 
Christopher James Huff <cja### [at] earthlinknet>
http://home.earthlink.net/~cjameshuff/
POV-Ray TAG: chr### [at] tagpovrayorg
http://tag.povray.org/

Post a reply to this message