Hello,

I am interested in using POV-Ray in a distributed computing environment, in
which I may have many compute nodes available for rendering.  One requirement
for this project is that an image rendered in a single pass should match exactly
an image that is rendered in pieces with Partial Output and then properly
reassembled.

I have been trying to verify this behavior on a fairly large file with many
thousands of elements (frames of this video: https://youtu.be/Pa149iuBPGw , a
spinning glassy earth globe with thousands of spherical markers), by rendering
one frame in a Single-Pass, and again in 4 Quadrants and then merging
(Merged-Quadrant).  I was surprised to see small differences distributed
throughout the image.  I thought it might be my particular file, which has many
glassy elements with reflection and refraction.  But then I tried the same test
on some standard images from the POV-Ray distribution.  There were no problems
with biscuit.pov.  But I found a lot of problems with benchmark.pov.

Here is my setup.  I am running POV-Ray on Windows.  This example does not use
AntiAliasing, just to keep the render times shorter.  I'm using a small 16:9
image size (480x270) for these small tests. Here are the 4 commands to render
the 4 quadrants:

pvengine.exe /RENDER benchmark.pov Width=480 Height=270 DISPLAY=off -A
Start_Column=1 Start_Row=1 End_Column=240 End_Row=135 /EXIT

pvengine.exe /RENDER benchmark.pov Width=480 Height=270 DISPLAY=off -A
Start_Column=241 Start_Row=1 End_Column=480 End_Row=135 /EXIT

pvengine.exe /RENDER benchmark.pov Width=480 Height=270 DISPLAY=off -A
Start_Column=1 Start_Row=136 End_Column=240 End_Row=270 /EXIT

pvengine.exe /RENDER benchmark.pov Width=480 Height=270 DISPLAY=off -A
Start_Column=241 Start_Row=136 End_Column=480 End_Row=270 /EXIT

which I then reassembled into a single image in Photoshop.  Here is the command
to render the Single-Pass reference:

pvengine.exe /RENDER benchmark.pov Width=480 Height=270 DISPLAY=off -A /EXIT

Here is the Single-Pass reference image:
https://www.dropbox.com/s/mep5qzw7rj73sld/SinglePass.png?dl=0

Here is the Merged-Quadrant image:
https://www.dropbox.com/s/baz4z8r2my15ayy/MergedQuadrants.png?dl=0

And here is the difference map, amplified:
https://www.dropbox.com/s/jxbk6xzgzgz0q05/Difference.png?dl=0

In isolation, the Merged-Quadrant image looks just fine.  But it does not match
the Single-Pass image well at all.  This would be very important in frames of an
animation where some frames might be rendered by a powerful machine in
Single-Pass mode, and others might be rendered by weaker machines in
Merged-Quadrant mode -- frame-to-frame differences would jump out as
crawling/sparkly artifacts in the animation.

I have run the same experiment with AntiAliasing on, and the results are similar
(but even trickier, because new problems occur at the quadrant edges, requiring
a "guard ring" of extra pixels to be rendered to make sure that all the pixels
that are actually used in the final merged image have all 8 neighbors.)

I note that benchmark.pov uses a lot of fancy features like radiosity, photons,
etc.  But my original globe-with-markers image doesn't use any of those fancy
features.  Just lots of glassy spheres and CSG. I can provide the .pov file for
that if it would help -- it's a big, computer-generated file, so I thought it
would be best to report the problem using benchmark.pov which is familiar and
much shorter.

Would this be considered a bug?  Or an out-of-scope usage of the Partial Output
feature -- perhaps this kind of matching was never a requirement for Partial
Output?  Or something else?

Thank you,
Lloyd

Post a reply to this message