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 InPrioritySeveritySummaryStatusProgressDue In Version  desc
287Light sourceDefinite Bug3.70 RC7Very LowLowarea_illumination shadow calculationTracked on GitHub
50%
Future release Task Description

not sure if this is something needing further work or an intended effect.

Shadows from and area light with area_illumination on seem to follow the same shadow calculation as a standard area light by giving more weight to lights near the center of the array. I would assume the shadows would be calculated similarly to individual lights in the same pattern as the array by evenly distributing the amount of shadow equally for each light. But this is not what I see.

The code sample below when rendered with scene 1 will show shadows grouped near the center from the area light with area_illumination. If scene 1 is commented out and scene 2 is uncommented then rendered, you will see evenly distributed shadows from individual lights. Area lighting with area_illumination I would assume should give a result identical to scene 2. If scene 1 is rendered with area_illumination off, the shadow calculation is exactly the same as with area_illumination on.

example images rendered on win32 XP

#version 3.7;

global_settings {
 ambient_light 0
 assumed_gamma 1
}

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

background { rgb <.3, .5, .8> }
plane { y,0 pigment { rgb .7 } }
torus { 1.5,.1 rotate 90*x translate 4*z pigment { rgb .2 } }
plane { -z,-7 pigment { rgb .7 } }

/*
// scene 1
light_source{
  y
  1
  area_light 3*x, z, 7, 1
  area_illumination on
}
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 } }
}
// end scene 1
*/


// scene 2
#declare Light = light_source {
  0
  1/7
  looks_like { sphere { 0,.05 hollow pigment { rgbt 1 } interior { media { emission 10 } } } }
}

union {
 object { Light }
 object { Light translate .5*x }
 object { Light translate x }
 object { Light translate 1.5*x }
 object { Light translate -.5*x }
 object { Light translate -x }
 object { Light translate -1.5*x }
 translate y
}
// end scene 2

282Image formatFeature RequestNot applicableDeferLowUnrendered region should be transparent, not blackTracked on GitHub
0%
Future release Task Description

When rendering only a region of a file, using the command-line options +sc/+sr/+ec/+er, the area of the image that is excluded comes out as black in the final PNG.

Expected behaviour is for it to be transparent.

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> }

}

275Light sourceDefinite Bug3.70 RC7Very LowLowcircular area lights exhibit anisotropyTracked on GitHub
50%
Future release Task Description

circular area lights exhibit some anisotropy, being brighter along the diagonals than on average, as can be demonstrated with the following scene:

//+w800 +h800
#version 3.7;
global_settings{assumed_gamma 1}
plane{-z,-10 pigment{rgb 1} finish{ambient 0 brilliance 0}}
disc{0,z,10000,0.5}
camera{orthographic location z look_at 10*z up y*12 right x*12}
light_source{-10*z rgb 10 area_light 10*x 10*y 257 257 adaptive 4 circular}
248Parser/SDLFeature RequestNot applicableVery LowLowImplement mechanism to compute direction of a splineTracked on GitHub
0%
Future release Task Description

The SDL currently provides no way to compute the exact direction of a spline at a given location, even though mathematically this is a piece of cake: The first-order derivative of any spline section gives you the “speed” as a vector function, and is trivial to compute for polynomial splines (which are behind all spline types that POV-Ray supports); the normalized “speed” vector, in turn, gives the “pure” direction.

For exact direction/speed computations, I propose to extend the SDL invocation syntax as follows to allow for evaluating a spline’s derivative:

    SPLINE_INVOCATION:
        SPLINE_IDENTIFIER ( FLOAT [, SPLINE_TYPE] [, FLOAT] )

or

    SPLINE_INVOCATION:
        SPLINE_IDENTIFIER ( FLOAT [, FLOAT] [, SPLINE_TYPE] )

where the second FLOAT will specify the order of derivative to evaluate (defaulting to 0). In order to compute the position, direction, and acceleration of an object traveling along a certain spline, one could then for instance use:

    #declare S        = spline { ... }
    #declare Pos      = S(Time);
    #declare VSpeed   = S(Time,1);
    #declare VAccel   = S(Time,2);
    #declare Dir      = vnormalize(VSpeed);
    #declare Speed    = vlength(VSpeed);
    #declare AccelDir = vnormalize(VAccel);
    #declare GForce   = vlength(VAccel) / 9.81;

Alternatively, a mechanism may be devised to create a spline representing another spline’s derivative; however, it would be debatable whether the syntax should be parameter-like (being an added information that could be overridden again when creating other splines from such a derived spline), or operation-like (converting the spline), and in the latter case how it should affect spline type (and consequently control points); so the spline invocation parameter approach might be more straightforward, with less potential surprises for the user.

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).

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.

222Geometric PrimitivesDefinite Bug3.70 RC3Very LowLowincorrect render of CSG merge with radiosityTracked on GitHub
0%
Future release Task Description

The problem arises when I am trying to trace a radiosity scene without conventional lighting that has a GSG merge object. There are a coincident surfaces, but these surfaces are first merged, then the texture applied. The texture is a simple solig color non-transfluent pigment, default normal, default finish etc..

Problem consists when adding antialiasing, changing resolution, changing camera view-point etc.; when I replace merge with union, the problem disappeared.

The scene was checked on two different machines with different versions of POV-Ray:

  1. Gentoo Linux, kernel 2.6.39-r3, i686 Intel(R) Xeon(TM) CPU 2.80GHz GenuineIntel, 2G RAM (this is Dell PowerEdge 2650 server with 2 dual-core Intel Xeon MP processors); Persistence of Vision™ Ray Tracer Version 3.7.0.RC3 (i686-pc-linux-gnu-g++ 4.5.3 @ i686-pc-linux-gnu)
  2. Gentoo Linux, kernel 2.6.37-r4, x86_64 AMD Athlon™ X2 Dual Core Processor BE-2350, 2G RAM (non-branded machine); Persistence of Vision™ Ray Tracer Version 3.6.1 (x86_64-pc-linux-gnu-g++ 4.4.4 @ x86_64-pc-linux-gnu)

(scene has been adapted slightly to be rendered with 3.6, the adaptation was to change “emission” with “ambient” and replace gamma “srgb” with “2.2”)

Both machines generate similar images.

The attachment is an archive containing sources of minimal scenes with these problems, and sample pictures I generated from them on my machines.

196Subsurface ScatteringDefinite Bug3.70 RC3Very LowLowMore SSLT CaveatsTracked on GitHub
90%
Future release Task Description

when a prism is differenced with a primitive (cylinder in this case) if sslt is used it causes a seq fault. Reference distribution file logo.inc and the Povray_Logo_Prism definition.

183Texture/Material/FinishPossible Bug3.70 beta 40Very LowLowcutaway_textures broken with child unionsTracked on GitHub
50%
Future release Task Description

When using cutaway_textures in a CSG object that has union children, results are not as expected; instead, surfaces in the union children that have no explicit texture will be rendered with the default texture instead. This is not the case for e.g. difference children.

Example:

#default { texture { pigment { rgb 1 } } }

camera {
  right x*image_width/image_height
  location  <0,1.5,-4>
  look_at   <0,1,0>
}

light_source { <500,500,-500> color rgb 1 }

#declare U = union {
  sphere { <0,-0.1,-1>, 0.3 }
  sphere { <0, 0.1,-1>, 0.3 pigment { color red 1 } }
}

intersection {
  sphere { <0,0,0>, 1 pigment { color green 1 } }
  object { U }
  cutaway_textures
  rotate y*90
}

When declaring U as an intersection instead, the results are as expected, with the surface of the first sphere in U being rendered with the texture defined in the outer intersection.

172Image formatUnimp. Feature/TODO3.70 beta 39Very LowLowRe-implement progressive image outputTracked on GitHub
0%
Future release Task Description

With previous versions of POV-Ray, it was possible to turn off display output, but still assess the output during render by viewing the output file as it was progressively generated. This allowed e.g. to run a long render on a remote machine as a background process, and check the output from time to time via FTP or similar.

142Texture/Material/FinishFeature Request3.70 beta 37aVery LowLowcamera_view pigment from MegaPOVTracked on GitHub
0%
Future release Task Description

I probably don’t have to explain why the camera_view pigment in MegaPOV was important, but I will list some reasons anyway:

1) post-processing could be performed in-scene
2) new types of focal blur effects could be created
3) feedback fractals were possible

I’m sure there are many others, as this is one of those features that has undetermined potential!

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.

131OtherFeature Request3.70 beta 37aVery LowLowAbility to change the order of editor tabs by dragging ...Tracked on GitHub
0%
Future release Task Description

See Notepad++ or EditPad Lite for examples.

It would be nice to be able to drag tabs in the editor window to change their order, so as to group opened files together by relevance for instance.

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.

127Parser/SDLFeature Request3.70 beta 37aVery LowLowExpandable arraysTracked on GitHub
0%
Future release Task Description

Currently, arrays are of a fixed size. You can’t add or remove items to/from an array. I think it would like arrays to be expandable with no fixed and pre-determined size.

115Texture/Material/FinishFeature Request3.70 beta 37aVery LowLowMore cutaway_texturesTracked on GitHub
0%
Future release Task Description

Think this is still a problem. See the attached scene file. Find the WindowFrameSegment declaration for more info. The scene as-is shows the problem (SOME portions of the difference inherit the color of the room) the window opening is scaled larger to show that they AREN’T touching. The problem goes away when (in WindowFrameSegment) the 1st occurrence of the applied texture is commented out and the 2nd occurrence is uncommented, and cutaway_textures is commented out.

108Parser/SDLFeature Request3.70 beta 37Very LowLowmotion_blur feature similar to Megapov versionTracked on GitHub
0%
Future release Task Description

motion_blur which is a simple and effective feature to use in Megapov to simulate motion blur of, e.g. bird wings, propellers or running animals, would be a neat addition to version 3.7 and later.

In Megapov, the feature requires a line of code in the global_settings{} e.g.: motion_blur 10, 2
and a declaration for the moving object. e.g.:

motion_blur {
  type 0
  object{MyObject  material{MyMaterial rotate x*clock*2}}
  rotate x*clock*10
}

type represents several types of pre-defined motions.

Thanks,

Thomas

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.

98Refactoring/CleanupUnimp. Feature/TODO3.70 beta 36DeferMediumRefactor Windows UI code for Unicode supportTracked on GitHub
50%
Future release Task Description

Windows UI code should be refactored to use _TCHAR throughout instead of char, as well as the corresponding string function macros, to head for Unicode support.

96Texture/Material/FinishFeature RequestNot applicableVery LowLowUser-defined warpsTracked on GitHub
0%
Future release Task Description

User-defined warps would be nice to have, something along the lines of:

warp {
  function { MyFnX(x,y,z) } // function to compute pattern-space x-coordinate from object-space <x,y,z> coordinate
  function { MyFnY(x,y,z) } // ditto for pattern-space y coordinate
  function { MyFnZ(x,y,z) } // ditto for pattern-space z coordinate
}

// a displacement warp:
warp {
  function { x + MyFnX(x,y,z) }
  function { y + MyFnY(x,y,z) }
  function { z + MyFnZ(x,y,z) }
}
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

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.

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

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).

79Source codeFeature Request3.70 beta 35aVery LowLowFull-Featured Test-Scene to check the correctness of po...Tracked on GitHub
0%
Future release Task Description

Hi,

it would be nice if there exists a test scene (not a benchmark) which has a high coverage of povray source and can be used as correctness validation of povray. It schould be produce an image which can be compared to a golden reference image.

It may be also possible to create a regression test suite which does automatic comparision of the render results.

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.

65Parser/SDLFeature Request3.70 beta 34Very LowLowAdd support for vectors with functionsTracked on GitHub
0%
Future release Task Description

Being able to have functions operate on vectors would be pretty nice to have.

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.

44RadiosityFeature RequestAllVery LowLowImprove Normals Handling in RadiosityTracked on GitHub
0%
Future release Task Description

Currently, radiosity does not make use of the fact that pertubed normals would theoretically just require a different weighting of already-sampled rays, leading to the following issues:

  • Honoring normal pertubations in radiosity leads to an increased number of samples, slowing down sample cache lookup.
  • The increased number of samples is generated from a proportionally higher number of sample rays, slowing down pretrace even further.
  • Low-amplitude pertubations tend to be smoothed out; “reviving” these is only possible by increasing the general sample density.
  • Handling of multi-layered textures with different normal pertubations is currently poorly implemented.

As a solution, I propose to store for each radiosity sample not only the resulting illumination for a perfectly unpertubed normal, but from the same set of sample rays also compute the illumination for an additional set of about a dozen standardized pertubed-normal directions, and interpolate among these when computing the radiosity-based illumination for a particular point that has a pertubed normal.

For backwards compatibility, this method of dealing with pertubed normals in radiosity might be activated by a different value for the “normal” statement in the radiosity block, say, “normal 2”.

28FrontendFeature Request3.70 beta 32Very LowLow#debug message not displayed.Tracked on GitHub
0%
Future release Task Description

The #debug message stream is only being flushed when it hits a newline character,
instead of after each #debug statement. This means that some final strings don’t show up.

#debug "This line prints,\n but this line doesn't."
27OtherFeature Request3.70 beta 32Very LowLowAdd texture support to background statementTracked on GitHub
0%
Future release Task Description

Adding full texture statement support to the background statement (with a scale of 1/1) aligned with the image_map direction of an image would allow i.e. specifying an image as background easily.

26Geometric PrimitivesDefinite Bug3.61Very LowLowArtifacts rendering a cloth which has two-side texturesTracked on GitHub
0%
Future release Task Description

Dear PovRay maintainers and developers, congratulations for your great RayTracer!

We think that we have found a bug while we were rendering a piece of cloth.

In this piece of cloth were defined two textures, one for one side and one for the another side:

  texture { mesh_tex0_0 }
  interior_texture { mesh_tex0_1 }
  • Please: Look at line 77414 of the attached file “test.pov” to see

these definitions in their original context.

We have found some artifacts in the final rendering, in concrete near some wrinkles,
please, look at the attached file “render_artifacts.tga”, I have painted a big green arrow
near the artifacts, maybe you’ll need to do a zoom to see them more accurately.

They are as though the texture of the other side was painted in the incorrect side.

Fortunately, we have a patch to fix this bug (thanks to Denis Steinemann, he made the
implementation for PovRay 3.5, so I have adapted these changes to release 3.6.1)

Although we have found this bug in the Windows and Linux 3.6.1 releases,
the patch was generated in Linux (using the source code release of “povray-3.6.1”).

To apply this patch, inside the parent folder of the directory “povray-3.6.1” execute:

            patch -p0 < other_side_artifacts.patch

And the “povray-3.6.1” will be patched and you will get a console output like this:

 patching file povray-3.6.1/source/lighting.cpp
 patching file povray-3.6.1/source/mesh.cpp
 patching file povray-3.6.1/source/render.cpp

We don’t know if this “hack” is enough smart to apply in the next release,
but we think that it fixes the bug (the artifacts dissapear).

Best regards and thank you very much for your great RayTracer!

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.

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.

4Subsurface ScatteringUnimp. Feature/TODO3.70 beta 32Very LowLowIntegrate Subsurface Scattering with standard lighting ...Tracked on GitHub
90%
Future release Task Description

Subsurface Scattering still uses its own rudimentary code to compute illumination from classic light sources; this must be changed to use the standard light source & shadow handling code, to add support for non-trivial light sources (e.g. spotlights, cylindrical lights, area lights), partially-transparent shadowing objects etc.

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.

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.

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 { }
}
296Geometric PrimitivesDefinite Bug3.70 RC7DeferMediummax gradient computation is not thread safe (isosurface...Tracked on GitHub
0%
3.71 release Task Description

It appears as a side effect of investigation of #294: the code in isosurf.cpp, inside
bool IsoSurface::Function_Find_Root_R(ISO_ThreadData& itd, const ISO_Pair* EP1, const ISO_Pair* EP2, DBL dt, DBL t21, DBL len, DBL& maxg)

	if(gradient < temp)
		gradient = temp;

is not thread-safe (The code is used at render time, there is a data race between < and = operation, as gradient is stored in the global object and accessed in write mode by the cited code)

It is only important if the gradient is initially undervaluated (otherwise, all is fine, no write-access)

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).

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.

206OtherPossible Bug3.70 RC3Very LowLow"Cannot open file" error when text output files specifi...Tracked on GitHub
50%
3.71 release Task Description

I created an INI file which specifies the Input_File_Name, Output_File_Name, and also the Render_File and the remaining four text outputs as double-quoted absolute paths on my disk. When I run the render, I get the following output:

Preset INI file is ‘C:\USERS\TPREAL\DOCUMENTS\POV-RAY\V3.7\INI\QUICKRES.INI’, section is ‘[512×384, No AA]’.
Preset source file is ‘D:\Ruby\POV-Rb\ini\20110521_004037_Noix.ini’.
Rendering with 2 threads.
-
Cannot open file.
Render failed
-
CPU time used: kernel 0.06 seconds, user 0.02 seconds, total 0.08 seconds.
Elapsed time 0.52 seconds.

And the render does not start. The five text output files are not even created, and where the output image should be, there is a file with extension pov-state. The render works as it should only when I remove all five lines defining the five text output files. The paths I specify for the files are correct (paths exist and files do not, no white-spaces or anything), read/write restrictions are disabled in POV-Ray. This used to work in 3.6 and does not work now in 3.7 RC3. The error happens no matter if I run the render using GUI or command line.

(Also please note that the error message is really not useful here, it does not say which file it failed to open, and not even if it was an attempt to open for read or for write.)

I’d be really glad if you could correct this as it’s a critical functionality for me. I’m generating the POV-Ray code automatically and I need to parse the text output automatically to return the status to the generator.

118Light sourceFeature Request3.70 beta 37aVery LowLowMore efficient handling of fading lightsTracked on GitHub
0%
3.71 release Task Description

Currently, fading light sources are used for lighting and shadow
calculations even when so far away as to no longer have any effect
on the outcome. The proposed solution is to add a new keyword
fade_cutoff_distance which tells povray to ignore the light
source when alluminating a point at larger distance.

A sample implementation is provided in the attached files. These
changes are still based on beta 34 as sources for the current beta
are not yet available, and starting to merge changes to beta 35
only at this time didn’t seem worth the effort. Also, please
disregard, changes in the CVS header comments (I also use
CVS locally for managing source files).

Further considerations regarding this feature:

- For special effects this feature can also be used if the light
source does not actually use fading. On the other hand, cutting
the light at some distances can be considered an extreme form
of fading which may justify the keyword name anyhow.

- Depending on how  FS#46  is implemented, the test for cutoff may
then be needed at another location as well.

- The default value currently is 0 (or *no* cutoff distance). For
#version 3.7 of higher, the default could be chosen automatically
based on the light source intensity and adc_bailout, although it
may then need to be overriden by the user for extreme pigments.

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.

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.

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.

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.

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.

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.

Showing tasks 1 - 50 of 103 Page 1 of 31 - 2 - 3 -

Available keyboard shortcuts

Tasklist

Task Details

Task Editing