No solution for the bounding problem but here is another approch : could you
prevent the apparition of unecessary (invisible) objects (on the basis of their
position in space for instance) ? I've done this a couple of times (for my madpipe
macro for instance) and it can cut down drastically your number of objects. Of
course it may not be feasible in your case.
Another solution I'm using a lot these days is to export systematically
procedure-generated objects like this to an inc file so that I can play with them
without having to parse things again and again. Also,  I can remove objects
directly from the inc file. With a recursion macro, you could store each recursion
level objects in their own file.

Gilles Tran

Ken wrote:

> Greetings Advanced Users !
>
>   I have a scene rendering that has been going now for 24 hours. It has
> several levels of recursion and has deeply nested CSG operations. To
> decrease the rendering time I added manual bounding to the differencing
> objects. This gave me a decent increase of rendering time at 1 level of
> recursion when I was testing to see if manual bounding would help.
>
>   However since I bumped the recursion level up to a depth of 5 my
> render time has decreased to a point of being unacceptable and I am
> likely to stop my current session and just give up on it. I calculate
> at it's current rendering rate of 4 hours per line with 412 lines to
> go it will take 69 days to finish. My question then is should I turn
> automatic bounding off when manual bounding has been used in the scene
> file or will the manual bounding simply override any automatic bounding
> that would normally occur ?
>
>   In my current bounding scheme I have the objects that are subtracting
> from the original shape bounded individually and I have also bounded the
> shape that is being differenced. Another question would be is when to bound
> a shape in an operation for optimum performance. There are often several
> ways of adding bounding and I am not sure when or where it should be
> applied. Will manual bounding at the wrong place hurt the process when
> a certain number of csg operations if reached as opposed to being an aid
> in a simple operation ?
>  I would be more than happy to post the source for anyone willing to look
> at it but it is a bit lengthy to add to this post without first seeing an
> interest in it.
>
> A skeleton example of the bounding scheme I am currently using is:
>
> // the cutting objects
> #declare Diff_shape =
>
> intersection {
>       object { obj1 }
>       object { obj2 }
>   bounded_by {
>       object { obj3 }
>              }
> // bound the cutting shape
> #declare Diff_Shape_bound = object { Diff_Shape }
>
> // The shape being cut
> #declare Diff_Obj = object { obj4 }
>
> // A bounding shape for the shape being cut
> #declare Diff_Obj_Bound = object { Diff_Obj }
>
> Then I have a complicated recursive while loop to difference the Diff_obj.
>
> // The differencing operation
> #declare Final_Shape =
> difference {
> Loop stuff
>     object { Diff_Obj }
>      union {
>     object { Diff_Shape }
> bounded_by {
>     object { Diff_Shape_bound }
>            }
> #end loop stuff      }
>
> // And finaly bound the entire object after the difference operation.
>     object { Final_Shape
> bounded_by {
>     object { Diff_Obj_Bound }
>            }
>
> Is this complicating things overly much ? It really seemed to help when I used
> lower recursion depths but when going higher it has basicaly stalled out.
>
> --
> Ken Tyler
>
> See my 700+ Povray and 3D Rendering and Raytracing Links at:
> http://home.pacbell.net/tylereng/index.html

Post a reply to this message