POV-Ray

The Persistence of Vision Raytracer (POV-Ray).

This is the legacy Bug Tracking System for the POV-Ray project. Bugs listed here are being migrated to our github issue tracker. Please refer to that for new reports or updates to existing ones on this system.

IDCategoryTask TypeReported InPriority  descSeveritySummaryStatusProgressDue In Version
289Light sourcePossible Bug3.70 RC7Very LowLowarea_illumination with light fading and scattering medi...Tracked on GitHub
0%
Task Description

with reference to http://bugs.povray.org/task/46

still some issue with area illumination and light fading when interacting with media

seems light fade is not taken into account with scattering media.
emission and absorption media seem to work fine.
occurs with all scattering types.

#version 3.7;

global_settings {
 ambient_light 0
 assumed_gamma 1
}

camera {
  location <0, 3, -5>
  look_at <0, 2, 0>
}


#declare Light = 3; // light 1 = individual lights
                   // light 2 = standard area light
                   // light 3 = area light with area illumination

#declare Fade = 1; // light fading: 1 on, 0 off

#declare Media = 1; // media 1 = scattering
                    // media 2 = emission
                    // media 3 = absorption

#declare Type = 1; // scattering media type


#switch(Light)
 #case(1)

  #declare Ls = light_source {
    0
    1/7
    #if(Fade) fade_distance 2 fade_power 2 #end
  }

  union {
   object { Ls }
   object { Ls translate .5*x }
   object { Ls translate x }
   object { Ls translate 1.5*x }
   object { Ls translate -.5*x }
   object { Ls translate -x }
   object { Ls translate -1.5*x }
   translate y
  }

 #break
 #case(2)

  light_source{
    y
    1
    area_light 3*x, z, 7, 1
    #if(Fade) fade_distance 2 fade_power 2 #end
  }

 #break
 #case(3)

  light_source{
    y
    1
    area_light 3*x, z, 7, 1
    #if(Fade) fade_distance 2 fade_power 2 #end
    area_illumination on
  }

 #break

#end


cylinder { <0, .01, 0>, <0, 5, 0>, 2 pigment { rgbt 1 } hollow no_shadow
 interior {
  media {
   #if(Media = 1) scattering {Type, 30 } #end
   #if(Media = 2) emission 2 #end
   #if(Media = 3) absorption 2 #end
    density { cylindrical turbulence 1.5 scale <1, .14, 1> }
  }
 }
 scale <.15, 1, .4> translate 4*z
}

plane { y,0 pigment { rgb .7 } }
plane { -z,-7 pigment { gradient y color_map { [.5 rgb 1][.5 rgb 0] } } }
union {
 sphere { 0,.05 }
 sphere { .5*x,.05 }
 sphere { x,.05 }
 sphere { 1.5*x,.05 }
 sphere { -.5*x,.05 }
 sphere { -x,.05 }
 sphere { -1.5*x,.05 }
 translate y
  hollow pigment { rgbt 1 } interior { media { emission 10 } }
}
292Geometric PrimitivesUnimp. Feature/TODO3.70 RC7Very LowLowArbitrary containing object for isosurfacesTracked on GitHub
0%
Task Description

A low priority thought for the future: isosurface now only allows contained_by to be a sphere or a box. It would be more intuitive to allow the same objects that are allowed in clipped_by and bounded_by (although it probably needs to be finite). It would enable allow much faster rendering in many cases:

1) There are a lot of cases when the sphere or a box are very bad in bounding - if an object has a hole, a torus may be better, and in many cases, cylindrical bounding would help a lot.
2) Sometimes, having a too large contained_by object includes far-away parts of the iso-function, and expose large gradients that you want to avoid. If a bounding object is better, you can decrease the max_gradient and speed up the render.
3) The isosurface is usually much more expensive to calculate than any normal bounding object, so it’s an improvement even if the intesection test is not as fast as bounding box.
4) A typical case: if you use texture-like functions to make the surface realistically rough, you know almost exactly what the bounding object is - it can be the original unmodified object.
5) For isosurface terrains, a preprocessing macro could create a rough mesh-like bounding object to contain the “mountains”, thus making everything faster.
6) In case you want clipping, having the contained_by set to the same object probably avoits calculating too many intersections.

The main modification is probably that the intersections of bounding objects can be split into more than one interval - but it’s probably worth it, the isosurfaces are usually a speed bottleneck.

293User interfacePossible Bug3.70 RC7Very LowLowPOV-Ray Shown Twice in Windows TaskbarTracked on GitHub
0%
Task Description

When rendering for some time, it occasionally happens that POV-Ray appears twice in the Windows taskbar. One button is the normal one, the other one does not open any window when clicked on and reads something like “99% complete” (see attached image), like the render window’s title, but obviously unrelated to it (probably the title the render window had shortly before?). After stopping the render, the odd taskbar button remains there until POV-Ray is closed.

  • Observed under Windows XP
  • POV-Ray 3.7.0.RC7.msvc10-sse2.win32
  • When applications are summarized into groups in the taskbar by Windows, the odd POV-Ray button is attached to the Windows Explorer group
  • Run with render priority set to “high”

Is this a Bug in Windows or in POV-Ray?

295User interfaceDefinite Bug3.70 RC7Very LowLowMinor GUI BugsTracked on GitHub
0%
Task Description

Here are two low-priority bugs in POV-Ray’s GUI, observed by me under Windows XP, which should be easy to fix I think:

  • In the “Insert” menu, there are sub-menus (e.g. “Radiosity and Photons”) in which there are menu seperators at the end of the popped-up menu bar.
  • The progress bar in the top-right corner of the editor window seems to be too large for the window (203px) and therefore clipped. As a result, progress seems to be 100% when it is not yet, e.g. at 90% progress. (Have not measured exactly.)

Both bugs are not severe at all, but it would be nice if they could be fixed.
By the way, a second progress bar could be added to visualize the number of frames already rendered in an animation.

299Parser/SDLFeature Request3.70 RC7Very LowLowObject Properties FeatureTracked on GitHub
0%
Task Description

Up to POV-Ray 3.7 RC7 it has not been possible so far to declare custom properties for POV-Ray’s objects, which would be especially useful for complex objects defined in include files.

Currently, if you want to have an object (e.g. a car) with certain variable parameters (e.g. colour, wheel rotation, ...) defined in an include file and the parameters set by a scene file which uses the include file, you have to choose one of the following approaches:

1. use a macro

#macro car(colour, wheelrot, ...)
  ...
#end

or, 2. check parameters declared before, e.g.

#declare car =
union {
  
  #ifdef (colour)
    #local colour_internal = colour;
  #else
    #local colour_internal = default_colour;
  #end
  
}

The resulting object would be used in the following way:

  #include "car.inc" // include file once
  object {
    car(rgb <1,0,0>, 0, ...) // macro approach
  }
  // other approach
  #declare colour = rgb <1,0,0>;
  #declare wheelrot = 0;
  ...
  #include "car.inc" // include file every time you want to have a car object instance
  object {
    car
  }

Needless to say, both approaches are not quite optimal.

  • The macro approach needs only one #include directive and name conflicts will (hopefully) not be a problem. However, one would have to look up the parameter order of the macro in the include file, in the worst case every time the macro is used.
  • The other approach needs as many #include directives as car objects shall be instantiated, there can arise name conflicts with other inculde files used in the scene, and a (potentially long) list of parameters has to be declared before each #include. On the other hand, with this approach for any value it is clear which information it gives, e.g. #declare colour = rgb <1,0,0> can easily be read as ‘set car colour to “red”‘.

My suggestion would be creating an SDL feature to

  • declare which properties a certain object can have
  • set these properties inside the object statement in which the object is used.

One step up could be to even declare object classes along with them.

This could look like this:

// include file code
class car { // alternatively (without classes) use #declare car = object { ...
  property colour = rgb <1,0,0>; // with default colour
  
  union {
    ...
  }
}

// scene file code
car { // alternatively (without classes) use object { car ... }
  colour rgb <0,0,1>
}

Note that this solution makes the declarations much more concise and easy-to-read. Especially in scenes with many includes and animation scenes where objects’ properties have to be manipulated according to sometimes complex functions, this would be very useful. Please also consider that such user-defined objects can have dozens of properties.

301OtherDefinite Bug3.70 RC7Very LowLowFallback to default image size causes wrong values to b...Tracked on GitHub
50%
Task Description

When resolution is not specified (neither via POVRAY.INI nor via QUICKRES.INI nor via command line or custom .ini file), random values are displayed for image resolution in the Image Output Options message output. (The actual render will be performed at the default size of 160×120 pixels though.)

302OtherPossible Bug3.70 RC7Very LowLowconfusing error message when .ini file cannot be parsedTracked on GitHub
0%
Task Description

When a command-line parameter in an .ini file cannot be parsed (such as “+a.3”), POV-Ray reports a “Problem with setting”, quoting the command line, rather than indicating that the problem occurred in an .ini file. This leads the user to think that the problem is with the command line itself, unnecessarily confusing him.

309Parser/SDLDefinite Bug3.70 RC7Very LowLowWarning Message MissingTracked on GitHub
0%
3.71 release Task Description

Draw_Vistas, Light_Buffer, and Vista_Buffer (plus associated switches) do not issue warning when used, even tho code has been disabled.

310EditorFeature Request3.70 RC7Very LowLowEditor should remember bookmarksTracked on GitHub
0%
Task Description

Now the editor remembers only the cursor positions of the loaded files when starting a new PR session. It would be more friendly to remember whether the window was split or not, as well as the bookmarks.

311User interfacePossible Bug3.70 releaseVery LowLowElepsed time error on very long rendersTracked on GitHub
0%
3.71 release Task Description

On a very long render, around day 24, the elapsed time display becomes incorrect, showing 4294967272d 4294967272h 4294967272m 4294967272s.

Found on Windows 7 64 bits and reproduced on Windows 7 32 bits.
NOT reported on other platforms.

319Texture/Material/FinishFeature Request3.70 releaseVery LowLowAdd interior to #default directiveTracked on GitHub
0%
Task Description

When working with predefined materials, it would be useful to have something like:

#if (!Use_photons)
  #default { interior { caustics 1 } }
#end

#include "my_predefined_materials.inc"

Default medias or IORs could also be useful.

321OtherDefinite Bug3.70 releaseVery LowLowbounding threshold inconsistencyTracked on GitHub
90%
Task Description

User reported documentation inconsistency. Investigation led to the discovery of a bug in the setting of the current default value.

~source/frontend/renderfrontend.cpp reports the value “3” while ~source/backend/scene/scene.cpp sets a default value of “1”

Before for addressing this issue, are there any thoughts as to what the default value should be?

326OtherDefinite Bug3.70 releaseVery LowLowrestricted setting ignored in 3.7Tracked on GitHub
0%
Task Description

Due to a typo in the conf file parser (introduced, I think, in refactoring after 3.6), the restricted setting is ignored, and access checks aren’t performed.

Fixing this reveals some other issues:

  • %INSTALLDIR%/../../etc is incompletely canonicalized to /usr/local/share/../etc, not /usr/local/etc
  • read+write paths are added to the read list only, so writing is impossible

See attached patch.

Relatedly, I think it would be nice to add a new replacement token %CONFDIR% instead of %INSTALLDIR%/../../etc.

Also, there’s a realpath function that could simplify path handling, though I’m not sure if it’s available on all platforms.

327Parser/SDLFeature Request3.70 releaseVery LowLowSupport for non-ASCII characters in filename stringsTracked on GitHub
0%
Task Description

pov 3.7 Can not identify the Chinese.I give the texture map filename in chinese,it turns out parse error.

333User interfaceFeature Request3.70 releaseVery LowLowMake text in "about" alt+b dialog selectable with the m...Tracked on GitHub
0%
Task Description

When you press alt+b or access the “about” dialog in the Help menu it displays some text including software version number and list of contributors.

It would be nice to be able to select and copy this text using this mouse. Sometimes in the newsgroup I have to tell people what version of POVray I am using, and typing the version number can be a pain.

334Texture/Material/FinishFeature Request3.70 releaseVery LowLowHLS colorsTracked on GitHub
0%
Task Description

It would be nice to be able to specify colors in HLS as well as RGB.

Currently, you can use a macor to convert individual colors. But this does not work in color_maps where you want smooth gradations/interpolations between two or several colors.

335Parser/SDLPossible Bug3.70 releaseVery LowLowmacro works in variable but not in arrayTracked on GitHub
0%
Task Description

This doesn’t work:

#declare pavement_object = array[2]
{

object {trash_can_macro()	scale 3/4			translate -x * 1/2},
object {potted_plant_macro(_CT_rand2)	scale 3/4	scale 3/2	translate -x * 1/2}

}

This does work:

#declare trash_can_object = object {trash_can_macro()};
#declare potted_plant_object = object {potted_plant_macro(_CT_rand2)};
#declare pavement_object = array[2]
{

object {trash_can_object	scale 3/4			translate -x * 1/2},
object {potted_plant_object	scale 3/4	scale 3/2	translate -x * 1/2}

}

Logically, I cannot see a reason for this to be so.

42OtherDefinite Bug3.70 beta 32Very LowMediumcommand line parameters are not parsed properly on UnixTracked on GitHub
0%
Task Description

POV-Ray does not follow common practice on command-line handling; for instance:

povray +i"My File"

entered on a Unix shell would be passed to POV-Ray as

povray
+iMy File

(each line representing a distinct parameter here), which POV-Ray would further dissect, interpreting it as

povray
+iMy
File

To achieve the desired effect, one would actually have to quote the string twice:

povray +i"'My File'"

which the shell would translate to

povray
+i'My File'

which POV-Ray would interpret as

povray
+iMy File

In both cases, this is obviously not what a Unix user would expect.

The further dissecting of individual command-line parameters may have had its valid roots in the peculiarities of DOS’ command-line handling, but to my knowledge all major contemporary operating systems follow a concept akin to Unix, passing a list of parameters instead of a monolithic command line, and burdening the respective command shells with the task of dissecting command lines into parameters.

Therefore I suggest to disable this anachronistic feature in favor of contemporary standards; a compiler flag might be used to allow for easy re-enabling of the feature, for compiling POV-Ray on exotic targets.

- edit -

It has been pointed out that the described behaviour differs from 3.6, so I’m promoting this to a bug and changing the title.

50Runtime errorPossible Bug3.70 beta 32Very LowMediumFrequent segfaults with photon scenesTracked on GitHub
0%
Task Description

I observe frequent segfaults with POV-Ray 3.7 betas when rendering scenes using photons:

  • Debian Linux 4.0r5 “etch” for AMD64
  • AMD Phenom X4 9650 2.3GHz, 6 GB RAM
  • POV-Ray compiled with Intel icpc 11.0

Segfaults are sporadic but frequent (occurring in roughly 50% of all photon renders).

60Geometric PrimitivesDefinite Bug3.70 beta 34Very LowMediumArtifacts using prism in CSGTracked on GitHub
0%
Future release Task Description

Using prisms in intersecion or difference CSG objects may cause artifacts in POV-Ray 3.6.2 as well as 3.7.0.beta.34, as demonstrated by the following code:


camera {
  right    -x
  up        y*image_height/image_width
  location  <-24,19,12>
  look_at   <0,0,0>
}

light_source { <100,200,100> color rgb 1 }

plane { y, -2 pigment { color rgb 1 } }


#declare KeyValue = 1.366; // pick any you like

difference {
  prism {
    linear_sweep -0.5,0.5, 4
    
    <-3,20-17>,
    <-3,KeyValue>,
    <-6,-3>,
    <-0,-5>
  }
  intersection {
    cylinder { <-7,-0.51,1>, <-7, 0.51,1>, 4.0 }
    plane { z, KeyValue }
  }
  pigment { color rgb 0.5 } 
}

Apparently the surface of the other object becomes visible when it exactly coincides with a vertex of the prism; probably there is a failure of the inside() test for such values.

75Geometric PrimitivesUnimp. Feature/TODO3.70 beta 34Very LowMediumReplace POV_MALLOC with std::vector in shape codeTracked on GitHub
30%
Future release Task Description

In the files bezier.cpp, fpmetric.cpp, fractal.cpp, hfield.cpp, isosurf.cpp, lathe.cpp, poly.cpp, polygon.cpp, prism.cpp, sor.cpp, and sphsweep.cpp the use of POV_MALLOC can be replaced by std::vector quite easily because the containing class already is a C++ class. As this is a low hanging fruit for continued code cleanup, it should be done sooner rather than later.

81Geometric PrimitivesDefinite Bug3.62Very LowMediumsphere_sweep generating artifactsTracked on GitHub
0%
Task Description

I’m running POV-Ray for (64 bit) Windows v3.62 on (64 bit) Windows Vista

This pov file:


#include "colors.inc"
#include "metals.inc"

light_source { <6, 9, -21> color White }
camera { location <0, 0, -3> look_at <0, 0, 0> }

sphere_sweep {
                cubic_spline
                6
                <-2.0, 0, 0> 0.05

                <0.000,0,0> 0.2
                <0.025,0,0> 0.2
                <0.050,0,0> 0.2
                <0.075,0,0> 0.2

                <3.0,0,0> 0.2
                pigment { color White }
}

Produces two strange artifacts: A disk at the center of the sweep, and a faint “halo” or veil which shows as 4 faint hyperbolas centered around the origin.

I have tried tweaking tolerance (for no other reason than I saw that someone else was tweaking it to solve a problem) but this does not seem to change things.

For a look at MY result when I run this, view this image:

riventree.comarchivebugdatapovrayspheresweepartifacts.jpg

Alain reports the same behavior in the latest version: “It’s still there with the latest version: 3.7 beta 35a.” This MAY move the status to “confirmed”, but I can’t do that

Someone else says that changing the scale (!) “solves” the problem by moving the disk and the halo offscreen, but that sounds like a bad idea to me.

-Jeff Evarts, first-time POVRay bug reporter

181BackendUnimp. Feature/TODO3.70 beta 40Very LowMediumUnimplemented, altered or missing features to document ...Tracked on GitHub
0%
Task Description

This is a list of unimplemented features and things to fix with respect to 3.7 vs 3.6 compatibility. They either need to be fixed in code, or failing that, to be documented prior to release.


Create_INI works differently from 3.6. Prior versions of POV-Ray would write all options to the file, even if they were not supplied by the user (non-supplied options would take the default value). Currently in 3.7, only supplied options are written, because the front-end does not send unused options to the back-end. The proper fix for this would be to have a set of defines that establish the defaults all in one place (currently we rely on hard-coded values scattered around the code), and for the Output_INI_Option() function to look up and use the default when not supplied. As this is not likely to be done before 3.7 release, we need to document it as a temporary situation.

The following messages are marked as ‘currently not supported by code’ in povmsgid.h. We need to check where this comment is correct and if so the docs need to be updated to indicate this (for items that are already documented). Some items may be re-implemented later, and some may never be:

  • kPOVAttrib_TestAbort
  • kPOVAttrib_TestAbortCount
  • kPOVAttrib_VideoMode
  • kPOVAttrib_Palette
  • kPOVAttrib_DisplayGammaType
  • kPOVAttrib_FieldRender
  • kPOVAttrib_OddField
  • kPOVAttrib_AntialiasGammaType
  • kPOVAttrib_LightBuffer
  • kPOVAttrib_VistaBuffer
  • kPOVAttrib_DrawVistas

This bug should be edited to add/remove items as time goes by.

251Parser/SDLPossible Bug3.70 RC6Very LowMediumScene / include files of >2GB size may cause problemsTracked on GitHub
0%
3.71 release Task Description

Code inspection shows that we’re still using fseek() and ftell() in various places (including text file input), which can’t handle file positions of 2GB and beyond (except on 64-bit linux machines); those calls need to be examined and (where appropriate) replaced with the fseek64() macro we’re already defining (but currently not using), and a to-be-defined ftell64() macro.

One potential (untested) error scenario would be a scene file calling a macro that is defined at the end of a > 2GB long include file.

273OtherDefinite Bug3.70 RC6Very LowMediumNo automatic backup files from inc filesTracked on GitHub
0%
Task Description

If enabled, POVray always created backups of pov and inc files once per session.
Now using 3.7 RC6 only pov file backups are created but not from inc files.

278BackendFeature Request3.70 RC7Very LowMediumImplement Lens Flare RenderingTracked on GitHub
0%
Task Description

Currently POV-Ray does not support rendering lens flare effects, however, they can be simulated using a macro (include file) by Chris Colefax.

I would like to suggest adding a feature to POV-Ray to support lens effects “natively” since

  • as far as I know the macro has been designed for POV-Ray 3.1 so with each new POV-Ray version it gets more likely that this macro does not work properly any more
  • the macro does not work when rendering with radiosity, probably because the macro creates the lens effect by using a pigment with a high ambient value (which is ignored by POV-Ray 3.7’s radiosity algorithm).

Additionally, the macro is not quite easy to employ because

  • it needs to know the exact camera parameters (location etc.) and defines an own camera itself so any important camera information has to be stored if the effect has to work as expected
  • it does not (actually cannot) take into account that objects may (partially) hide the lens effect
  • reflections and refractions (of light sources) cannot be combined with it properly - the user would have to calculate both the point where the reflected/refracted light source can be observed and the shape it then has due to distortion, and in more complex scenes such computations are nearly impossible in SDL.

I would suggest integrating such a lens flare rendering feature with the “looks like” mechanism you already have for light sources. Several parameters that can currently be set for the macro - including effect brightness and intensity, lens options and whether to create a flare at all - could be set for the light source.

Then POV-Ray could store the location and colour of each ray that finally intersected the “looks like” object of a light source and, having finished the main rendering, from that data compute a partially transparent “lens flare layer” eventually mixed into the rendered image. By this, the above mentioned problems could be avoided:

  • an object fully or partially intersecting a light source’s “looks like” object would also reduce the number of pixels used to create a flare - and therefore reduce that flare until fully hiding it
  • the same goes for reflected and/or refracted versions of the “looks like” object
  • the camera’s location and other properties would be used automatically
  • and finally, as a feature supported by POV-Ray itself, there would be neither compatibility issues nor problems like the effect not fitting together with radiosity.

Do not get me wrong, I would not expect POV-Ray to really calculate intersections that naturally happen in a camera lens, causing lens flares. Effects looking appropriate can actually be created just in 2D space (as some graphics programs do support) so the work to be done would, as far as I have any overview, be:

  • storing, as mentioned above, the relevant data for pixels showing “looks like” objects
  • calculating a lens flare from that data after the render has finished
  • overlaying the rendered image with the newly created lens effect.
328User interfaceDefinite Bug3.70 releaseVery LowMediumAscii char '=' in filenames causes command line parsing...Tracked on GitHub
0%
Task Description

The following command fails with parsing error:
povray +OqXfFbD0Vg5XjZgi5sOefkvdF_oCGrZ1ChVhrQw==.png +IqXfFbD0Vg5XjZgi5sOefkvdF_oCGrZ1ChVhrQw==.pov +W1000 +H1000

The following command succeeds:
povray +OqXfFbD0Vg5XjZgi5sOefkvdF_oCGrZ1ChVhrQw.png +IqXfFbD0Vg5XjZgi5sOefkvdF_oCGrZ1ChVhrQw.pov +W1000 +H1000

Any option that gets a filename as parameter will fail if it contains ‘=’.

It is a regression, as it worked fine with 3.6.

227Refactoring/CleanupUnimp. Feature/TODO3.70 RC3Very LowHighFixed Vector LimitationsTracked on GitHub
0%
Task Description

See this documentation entry for more details.

306Subsurface ScatteringDefinite Bug3.70 RC7Very LowHighfinish subsurface block before global_settings subsurfa...Tracked on GitHub
0%
3.71 release Task Description

The following scene causes a crash:

sphere {
  <0,0,0>, 1
  finish { subsurface { translucency 1.0 } }
}

global_settings {
  subsurface { }
}
324Geometric PrimitivesDefinite Bug3.70 releaseVery LowHigh3.7 mesh2 rendering artifact, regression from 3.6Tracked on GitHub
0%
Task Description

Povray 3.7 has rendering artifact in meshes with polygons that meet at shallow angles. Please see the attached file.

The part of concern is the mesh2, which produces the partly-transparent faces of a shallow pyramid. The file result-3_6.png shows the output of povray-3.6, and the file result-3_7.png shows the output of povray-3.7. In 3.7, you can see a thin light-colored margin all around the base of the pyramid, especially thick under the top cylinder. In 3.6, this artifact is absent. For comparison purposes, I have inserted a “#version 3.6;” directive at the top of the file so that the output images are as close to each other as possible. However, the artifact is still present in 3.7 without this directive.

The attached scene file is only a small part of a much larger scene, where this artifact shows up in numerous very obvious places, where it doesn’t in 3.6. I have hunted in the documentation and online for ways to solve this problem, but haven’t found anything. Because of this, I am forced to stay with 3.6 for production use, which is quite unfortunate since I’d like to take advantage of the new features of 3.7.

86Parser/SDLFeature RequestNot applicableDeferVery LowAdd support for more RNG typesTracked on GitHub
0%
Future release Task Description

The current 32-bit linear congruential generator used as RNG in POV-Ray is sometimes quite limited for some purposes and in a few cases its poor quality shows up (as has been demonstrated more than once in the newsgroup). Thus it would be nice if POV-Ray offered additional, higher-quality random number generators, besides the current one (which should probably remain for backwards compatibility). These RNGs could include algorithms like the Mersenne Twister and the ISAAC RNG, both of which have very decent quality and have an enormous periods (while at the same time being very fast).

After a long discussion, the following syntax for specifying the RNG type and seed (which may be larger than 32 bits) has been suggested:

seed(<value>) | seed(<type>, <value> [, <values>])

For example:

#declare Seed1 = seed(123); // Use the current RNG, with seed 123
#declare Seed2 = seed(1, 123); // Identical to the previous one
#declare Seed3 = seed(2, 456, 789, 123); // Use RNG algorithm #2,
                                         // with a large seed (96 bits specified here)

A C++ implementation of the ISAAC RNG can be found at http://warp.povusers.org/IsaacRand.zip

87Geometric PrimitivesFeature RequestNot applicableDeferVery LowAdd new feature: Reference objectTracked on GitHub
0%
Future release Task Description

When you instantiate an object several times, eg:

object { MyObj translate -x*10 }
object { MyObj translate x*10 }

POV-Ray will copy that object in memory, at least for most types of objects. Not for all of them, though. Most famously if MyObj is a mesh, it won’t be copied, but only a reference to the original will be used, thus saving memory. (There are a few other primitives which also don’t cause a copy, such as bicubic_patch and blob, but those are naturally not so popular as mesh, so it’s a less known fact.)

AFAIK the reason why referencing (rather than copying) is not used for all types of objects is rather complicated, and mostly related to how transformations are applied to these objects. For example if the object being instantiated is a union, the translates above will be (AFAIK) applied to the individual members of the union rather than to the union object itself.

Copying, however, can be quite detrimental in some situations. For example if you have a huge union, and you want to instantiate it many times, the memory usage will be that many times larger (compared to just one instance). This is sometimes something which the user would not want, even if it made the rendering slightly slower as a consequence. (In other words, better to be able to render the scene in the first place, rather than running out of memory.)

Redesigning POV-Ray so that all objects would be referenced rather than copied would probably be a huge job, and in some cases a questionable one. There probably are situations where the current method really produces faster rendering times, so redesigning POV-Ray so that it would always reference instead of copy, could make some scenes render slower.

So this got me thinking about an alternative approach: How hard would it be to create a special object which sole purpose is to act as a reference to another object, without copying it? This special reference object would act as any regular object, would have its own transformation matrix and all that data related to objects, but its sole purpose is to simply be a “wrapper” which references an existing object. It could be, for example, like this:

object_ref { MyObj translate -x*10 }
object_ref { MyObj translate x*10 }

The end result would be exactly identical as earlier, but the difference is that now MyObj behaves in the same way as a mesh (in the sense that it’s not instantiated twice, but only once, even though it appears twice in the scene), regardless of what MyObj is.

In some cases this might render slightly slower than the first version (because POV-Ray has to apply the transformations of the object_ref first, after which it applies whatever transformations are inside MyObj), but that’s not the point here. The point is to save memory if MyObj is large.

An object_ref would behave like any other object, so you could do things like:

#declare MyObjRef = object_ref { MyObj };

object { MyObjRef translate -x*10 }
object { MyObjRef translate x*10 }

(The only thing being instantiated (and copied) here is the “MyObjRef” object, not the object it’s referring to, so that actual object is still stored in memory only once.)

In some situations it might even be so that referenced objects actually render faster than if the objects were copied because references increase data locality, lessening cache misses.

I believe this could be a rather useful feature and should be seriously considered, unless there are some major obstacles in implementing it.

99Refactoring/CleanupUnimp. Feature/TODO3.70 beta 36DeferVery LowRefactor engine (front- & back-end) code for Unicode su...Tracked on GitHub
0%
Future release Task Description

Front- & Back-end code should be refactored for full Unicode support in scene files and strings.

129Parser/SDLFeature Request3.70 beta 37aDeferVery LowHash arraysTracked on GitHub
0%
Future release Task Description

Currently, array items may only be referenced by their index number (an integer). It would be nice to also be able to assign string values as array indexes, as in other scripting languages.

133Geometric PrimitivesFeature Request3.70 beta 37aDeferVery LowSubdivision supportTracked on GitHub
0%
Future release Task Description

Someone built a version of Povray with internal support for automatic subdivision of meshes. See:

http://www.cise.ufl.edu/~xwu/Pov-Sub/

Would like to see this feature added natively to Povray.

237User interfaceDefinite Bug3.70 RC3DeferVery LowGlitch in displaying rendered pixels and percentageTracked on GitHub
0%
Task Description

When rendering in multiple passes (radiosity in my case), the elapsed pixels and percentage, written to terminal
are first displayed like this:
Rendered 126202 of 360000 pixels (35%)
Then on the second stage the output text becomes shorter and you see
Rendered 25344 of 360000 pixels (7%)%)
The contents of the previous status are not erased, so the longer text persists (note the duplicate percentage sign and closing parenthesis). Such a glitch could have more drastic effect in rare cases.

I’m running
Version 3.7.0.RC3 (g++ 4.6.2 x86_64-unknown-linux-gnu)
compiled for the Arch Linux package.

242OtherFeature RequestAllDeferVery LowAlgorithm to fix the so-called shadow line artifactTracked on GitHub
0%
Task Description

The so-called shadow line artifact (http://wiki.povray.org/content/Knowledgebase:The_Shadow_Line_Artifact) which affects objects with a ‘normal’ statement as well as smooth meshes and heightfields can be really annoying sometimes. Currently the only way to remove it is to make the object shadowless, which isn’t a good solution except in very special cases.

This algorithm could remove the artifact: If the actual normal vector of the object points away from the light source (its dot-product with the light vector is negative) but the perturbed normal points towards it (dot-product positive), then ignore the first shadow-test intersection with the object itself.

There are alternative ways of implementing an equivalent functionality:

- Don’t check the condition (if it’s too difficult to check due to how the code is designed) but always ignore the first intersection with the objects itself. This will work properly with closed surfaces but not with open ones, so it might need to be a feature for the user to turn on with a keyword (similar to eg. ‘double_illuminate’).

- Alternatively, don’t ignore the first intersection, but instead ignore the “opposite side” of the object’s surface (again, possibly only if a keyword has been specified). In other words, if we are rendering the outer side of the object, ignore its inner side when shadow-testing, and vice-versa.

- Perhaps simply add a feature to make surfaces one-sided (similarly to how they can be made so in OpenGL and similar scanline rendering systems). In other words, the inner side of a surface is completely ignored everywhere, making the object virtually invisible from the inside. The advantage of this feature would be that it can have uses other than simply removing the shadow line artifact.

272OtherFeature Request3.70 RC6DeferVery LowMinor change, significant speedup in cubic polynomial s...Tracked on GitHub
0%
3.71 release Task Description

While familiarizing myself with the code, I found some small changes in the solve_cubic function that lead to a significant speedup.

In my experience, “pow” is by far the slowest function in math.h and replacing it with simpler functions usually makes a tremendous impact on the speed (it’s an order of magnitude slower than sqrt/exp/cbrt/log).

solve_cubic has a “pow” function that can be replaced by cbrt (cubic root), which is standard in ISO-C99 and should be available on all systems. Separate benchmarks of solve_cubic function show this change almost doubles the speed and does not lower the accuracy. As solve_cubic is part of the solution of quartic equation, this improves the speed for many primitives. Testing with a scene containing many torus intersection tests (attached below) I still observed almost 10% speedup (Intel, 4 threads, 2 hyperthreaded cores, antialiasing on, 600×600: from 91 to 84 seconds). And this is for a torus, where a lot of time is spent in the solve_quartic and cubic solver is only called once! Similar speedup should be expected for prism, ovus, sor and blob.

I do believe the cubic solver can be done without trigonometry, but that would mean changing the algorithm, introducing new bugs and requiring a lot of testing. However, the trigonometric evaluation can still be simplified (3% speedup in full torus benchmark).

These changes don’t affect the algorithm at all, they are mathematically identical to the existing code, so the changes can be applied immediately. I also included other changes just as suggestions. Every change is commented and marked with [SC 2.2013].

This sadly does not speedup the sturm solver, which uses bisection and regula-falsi and looks very optimized already.

The test scene I used has a lot of torus intersections from various directions (shadow rays, main rays, transmitted rays).

300OtherFeature Request3.70 RC7DeferVery LowReference Documentation SupportTracked on GitHub
0%
Task Description

As emerged as an idea during the discussion of FS#299, an SDL / POV-Ray editor feature would be useful that allows API documentation via formal comments, e.g. in include files:

/**
 * Creates a car object.
 * @param a
 *        description of param a
 * ...
 */
#macro car(a,b,c)
  ...
#end

In addition to the ability of (auto-)generating a documentation file from such comments, an editor window feature would be convenient that allows popup display of a macro’s (object’s / parameter’s / ...) documentation section.

303OtherDefinite Bug3.70 RC7DeferVery Lowwrong bit depth reported for OpenEXR file formatTracked on GitHub
0%
Task Description

When using OpenEXR output file format, POV-Ray erroneously reports it as “24 bpp EXR” in the message output, while in fact it generates a 3×16 = 48 bpp file.

6Subsurface ScatteringUnimp. Feature/TODO3.70 beta 32DeferLowIntegrate Subsurface Scattering with PhotonsTracked on GitHub
0%
Future release Task Description

Subsurface scattering must be made photon-aware.

8RadiosityUnimp. Feature/TODO3.70 beta 32DeferLowImprove Radiosity "Cross-Talk" Rejection in CornersTracked on GitHub
0%
Future release Task Description

Near concave edges, radiosity samples may be re-used at a longer distance away from the edge than towards the edge; there is code in place to ensure this, but it only works properly where two surfaces meet roughly rectangularly, while failing near the junction of three surfaces or non-rectangular edges, potentially causing “cross-talk”.

It should be investigated how the algorithm can be improved or replaced to better cope with non-trivial geometry.

25AnimationDefinite Bug3.70 beta 32DeferLowPause sometimes fails when rendering animationTracked on GitHub
90%
Task Description

There is an issue where the pause button in POVWIN will sometimes not work during an animation (primarily where the frame rate is high), and furthermore, POVWIN can then get into a state where it’s not possible to use the pause until it is re-started.

Newsgroup report.

58Parser/SDLUnimp. Feature/TODO3.70 beta 32DeferLowallow SDL code to detect optional featuresTracked on GitHub
0%
Task Description

Some features are optional in custom builds of POV-Ray (I’m thinking about OpenEXR in particular); it would be nice to have a syntax for an SDL script to check for support of such features, so it may take some fallback action if the feature is not supported.

85OtherFeature RequestNot applicableDeferLowAspect ratio issuesTracked on GitHub
0%
Future release Task Description

Background

When rendering an image, there are actually three aspect ratios involved:

1) The aspect ratio of the camera, set with the up and right vectors.

2) The aspect ratio of the rendered image, set with the +W and +H parameters.

3) The aspect ratio of the pixels in the intended target medium. While this is very often 1:1, it’s definitely not always so (anamorphic images are common in some media, such as DVDs).

The aspect ratio of the camera does not (and arguably should not, although some people might disagree) define the aspect ratio of the image resolution, but the aspect ratio of the image as shown on the final medium. In other words, it defines how the image should be displayed, not what the resolution of the image should be.

This of course means that the aspect ratio of the target medium pixels has to be taken into account when specifying the image resolution. If the target medium pixels are not 1:1 (eg. when rendering for a medium with non-square pixels, or when rendering an anamorphic image eg. for a DVD), the proper resolution has to be specified so that the aspect ratio of the displayed image remains the same as the one specified in the camera block.

This isn’t generally a problem. It usually goes like “my screen is physically 4:3, so I design my scene for that aspect ratio, but the resolution of my screen is mxn which is not 4:3, but that doesn’t matter; I just render with +Wm +Hn and I get a correct image for my screen”.

However, problems start when someone renders an image using an image aspect ratio / pixel aspect ratio combination which does not match the camera aspect ratio. By far the most common situation is rendering a scene with a 4:3 camera for a screen with square pixels but with a non-4:3 resolution (most typically 16:9 or 16:10 nowadays). The image will be horizontally
stretched.

In a few cases the effect is the reverse: The scene (and thus the camera) has been designed for some less-typical aspect ratio, eg. a cinematic 2.4:1 aspect ratio, but then someone renders the image with a 4:3 resolution. The resulting image will be horizontally squeezed.

In a few cases this is actually the correct and desired behavior, ie. when you are really rendering the image in an anamorphic format (eg. for a DVD). However, often it’s an inadverted mistake.

Some people argue that this default behavior should be changed. However, there are also good arguments why it should not be changed. Some argue that POV-Ray should have more features (at the SDL level, at the command-line level or both) to control this behavior.

There are several possible situations, which is why this issue is so complicated. These situations may include:

- The scene author doesn’t really care what aspect ratio is used to render the image, even if it means that additional parts of the scenery become visible or parts are cropped away when using a different aspect ratio than what he used.

In this case the choice of camera aspect ratio should be up to the person who renders the image, and thus selectable on the command-line. However, he should have an easy choice of how changing the aspect ratio affects the image: Should it extend the viewing range, or should it crop part of it, compared to the original?

And this, of course, while still making it possible to render for an anamorphic format.

- The author wants to support different aspect ratios, but he wants to control precisely how it affects the composition of the image. Maybe he never wants anything cropped away within certain limits, but instead the image should always be extended in whichever direction is necessary due to the aspect ratio. Or maybe he wants to allow cropping the image, but only up to a certain point. Or whatever.

In this case the choice of camera aspect ratio should be up to the author, and thus selectable in the scene file, while still allowing some changes from the command-line.

- The author designed his scene for a precise aspect ratio and nothing else, and doesn’t want the image to be rendered in any other aspect ratio. Maybe he used some very peculiar aspect ratio (eg. something like 1:2, ie. twice as tall as wide) for artistic composition reasons, and wants the image rendered with that aspect ratio, period.

Perhaps the author should be able to completely forbid the change of camera aspect ratio in the command-line.

Of course anamorphic rendering should still be supported for targets with a different pixel aspect ratio.

Possible solution

This solution does not necessarily address all the problems described above perfectly, but could be a good starting point for more ideas:

Add a way to specify in the camera block minimum and maximum limits for the horizontal and vertical viewing angles (and if any of them is unspecified, it’s unlimited). Of course for this to be useful in any way, there should also be a way to change the camera and pixel aspect ratios from the command line.

The idea with this is that the author of the scene can use these angle limits to define a rectangular “protected zone” at the center of the view, using the minimum angle limits. In other words, no matter how the camera aspect ratio is modified, the horizontal and/or vertical viewing angles will never get smaller than these minimum angles. This ensures that the image will never be cropped beyond a certain limit, only extended either horizontally or vertically to ensure that the “protected zone” always remains fully visible regardless of what aspect ratio is used.

The maximum angles can be used for the reverse: They ensure that no scenery beyond a certain point will ever become visible, no matter what aspect ratio is used. This can be used to make sure that unmodelled parts of the scene never come into view. Thus the image will always be cropped to ensure this, depending on the aspect ratio.

I’m not completely sure what should be done if both minimum and maximum angles are specified, and the user specifies an aspect ratio which would break these limits. An error message could be a possibility. At least it would be a way for the author to make sure his scene is never rendered using an aspect ratio he doesn’t want. He can use these angle limits to give some leeway how much the aspect ratio can change, to an extent, or he could even force a specific aspect ratio and nothing else (by specifying that both the minimum and maximum angles are the same).

So in short:

- Add a “minimum/maximum horizontal/vertical angles” feature to the camera block. These can be used to define a “protected zone” in the image which must not be breached by command-line options.

- Add a command-line syntax to change the camera aspect ratio (which automatically obeys the “protected zone” settings). Could perhaps give an error message if the command-line options break the limits in the scene camera.

- Add a command-line syntax to specify a pixel aspect ratio other than 1:1. This can be used to render anamorphic versions of the image on purpose (iow. not by mistake).

This can probably be made backwards-compatible in that if none of these new features are used, the behavior could be the same as currently (or at least similar).

91Texture/Material/FinishFeature Request3.70 beta 36DeferLowSlope pattern applied to object is not transformed afte...Tracked on GitHub
0%
Future release Task Description

There is an big issue with the slope pattern: when the object it is applied to is instanced (again) with a transformation (in particular a rotation, as a translation would not impact.. but a shear might), the colours of the surfaces are changed.

  
object { p translate -5*x }
object { p rotate 220*y+20*x    translate 3*x }       

Nobody would expect the object to be different in appearance.
If slope {} is replaced with wood, all is fine. (as for others textures, i guess)

IMHO, the slope vector need to be adjusted for the later transformation(s) (so as to compensate the issue of using the Perturbed Normal vector).

This should not impact the AOI/FACING (experimental) patterns, as AOI definition is pretty clear about duplicating & transform if you think about it a bit, as well as FACING: for these two, it is expected to either use the ray(current point of view) or a fixed 3D point as reference. At the limit, discussion about moving the 3D point of FACING might also be opened to interpretation.

AOI/FACING are in task #19

243Geometric PrimitivesUnimp. Feature/TODOAllDeferLowSphere sweep behaves wrong when scaledTracked on GitHub
0%
Future release Task Description

The sphere_sweep renders well when specified directly, but when it is scaled, its bounding box is calculated incorrectly, which clips the object so it almost disappears.

The effect is present for all three types of splines.

I’m attaching a test scene and the rendering result. The saving of the object with #declare has no effect, I just wanted to show both transformed and untransformed version.

I don’t think this issue is related to other artifacts occuring with sphere_sweep, as it is obviously an issue of the internal bounding box.

245OtherFeature RequestAllDeferLowPOVMS message queue can fill up with GB of data for ver...Tracked on GitHub
0%
Future release Task Description

With very fast renders and very large output files, the message queue can fill up because the producers are not limited by IO, while the consumer performance is limited by disk IO. Consequently, the message queue can fill up to exhaust all available memory. The solution is to build in some better control of pending output data in the message queue on the producer side. This will also pave the way for message communication over slow links (i.e. a network).

264PhotonsUnimp. Feature/TODO3.70 RC6DeferLowImprove precision of photon direction informationTracked on GitHub
0%
Task Description

In the photons map, the direction of each photon is stored as separate latitude & longitude angles (encoded in one byte each), causing the longitudinal direction component’s precision to be unnecessarily high for directions close to the “poles” (Y axis); in addition, encoded value -128 is never used. For better overall precision as well as precision homogenity, the following scheme could be used instead:

  • Encode the latitude (-pi/2 to +pi/2) into LatCount=226 distinct values (= 256*sqrt(pi)/2) rounded to the next even number) from 0 to LatCount-1 using
latCode = (int)((LatCount-1) * (lat/M_PI + 0.5) + 0.5)
  • For each latitude code, define a specific number of encodable longitude values, LngCount[latCode] = approx. cos(lat)*pi*65536/(2*LatCount); this can be a pre-computed table, and may need slight tweaking for optimum use of the code space. Encode the longitude (-pi to +pi) into a value from 0 to (LngCount[lat]-1) using
LC = LngCount[latCode];
lngCode = (int)(LC * (lng/(2*M_PI) + 0.5) + 0.5) % LC;
  • Besides LngCount[latCode], also store the sum of LngCount[i] with i < latCode as LatBase[latCode]; encode the direction as
dirCode = LatBase[latCode] + lngCode;
  • For decoding, a simple lookup from a precomputed list of directions could be used (2^15 entries, i.e. one hemisphere, will suffice). To conserve space, direction vectors could be scaled by (2^N-1) and stored as (N+1)-bit signed integer triples rather than floating point values; due to the limited precision of the lat/long information, 8 bits per coordinate might be enough, giving a table size of 96k. A full double-precision table would require 786k instead.
281Geometric PrimitivesFeature Request3.70 RC7DeferLowBug in rendering of Bézier patchesTracked on GitHub
0%
Future release Task Description

In version 3.7.0.RC7.msvc10.win64, there is a bug in rendering Bézier patches in which four points (along one edge) are all the same point.

The rendering can be seen here:
http://i.imgur.com/eq2UIXR.png
[Edit: See attachment for the rendering]

As you can see, there is a visible unwanted artifact in the corner of each patch. The two patches shown are essentially the same, except with the 4×4 matrix of vertices transposed (just to demonstrate that simply transposing it didn’t fix it).

Expected rendering is a smooth surface without the artifact.

Below is the code used to render the above example.

#version 3.7;

global_settings { assumed_gamma 1.0 }

camera {

  location <45, 31, -10>
  look_at <40, 21, 200>
  right x*image_width/image_height

}

light_source {

  <660, 300, -525>
  color rgb 1

}

Example 1: First point in each row is the same point
bicubic_patch {
type 1 flatness 0.001
u_steps 4 v_steps 4
<32.2168, -23.78125, 0>, <34.4968, -23.78125, 0>, <35.2168, -23.78125, -0.72>, <35.2168, -23.78125, -3>,
<32.2168, -23.78125, 0>, <34.4968, -22.10256, 0>, <35.2168, -21.57244, -0.72>, <35.2168, -21.57244, -3>,
<32.2168, -23.78125, 0>, <33.9709, -21.55577, 0>, <34.52483, -20.85299, -0.72>, <34.52483, -20.85299, -3>,
<32.2168, -23.78125, 0>, <32.30556, -21.50298, 0>, <32.33359, -20.78352, -0.72>, <32.33359, -20.78352, -3>
rotate 180*x scale 1.4
translate ←5, 0, 0>
pigment { color <1, 0, 0> }
}
Example 2: First row is all the same point
bicubic_patch {

  type 1 flatness 0.001
  u_steps 4 v_steps 4
  <32.2168, -23.78125, 0>, <32.2168, -23.78125, 0>, <32.2168, -23.78125, 0>, <32.2168, -23.78125, 0>,
  <34.4968, -23.78125, 0>, <34.4968, -22.10256, 0>, <33.9709, -21.55577, 0>, <32.30556, -21.50298, 0>,
  <35.2168, -23.78125, -0.72>, <35.2168, -21.57244, -0.72>, <34.52483, -20.85299, -0.72>, <32.33359, -20.78352, -0.72>,
  <35.2168, -23.78125, -3>, <35.2168, -21.57244, -3>, <34.52483, -20.85299, -3>, <32.33359, -20.78352, -3>
  rotate 180*x
  scale 1.4
  pigment { color <1, 1, 0> }

}

Showing tasks 51 - 100 of 103 Page 2 of 3 - 1 - 2 - 3 -

Available keyboard shortcuts

Tasklist

Task Details

Task Editing