"alphaQuad" <alp### [at] earthlinknet> wrote:
>
> look foward with FOV of 90
> camera {
> >   location <0,0,0>
> >   direction <0,0,0.5>
>     angle 90
> > }
>
> CAMERA
>
> the right vector is used to set angle.
> if you input 40 degrees, right needs to be length of 1 or fov is not 40
>
> I determined this with the docs and my planetarium work
>
> The default aspect is 1.333333
> this can get real confusing on a monitor with a physical aspect of 1.33333
> but viewing a resolution of 1.25 i.e. 1280x1024, circles are not round.
>
> Examples
>
> camera {
>   up y
>   right x*image_width/image_height
>   angle 40
>
>   location -z*100
>   look_at <0,0,0>
> }
> not actually 40 degrees determined by stellar angles unless right has a length
> of 1.
>
> OR full scripted control of camera matrix, such as targeting a known point
> and vcross-ing a camera matrix. This would allow scripted control of a camera
> z-roll.  Leaves right with a length of 1. Can still be done 10 other ways, but
> if you intend to invert matrix, you'd end up with something close to this:
>
> camera { perspective
>   location campos
>   right <cameramatrix[0],cameramatrix[1],cameramatrix[2]>
>   up <cameramatrix[4],cameramatrix[5],cameramatrix[6]>*
> (image_height/image_width)
>   direction <cameramatrix[8],cameramatrix[9],cameramatrix[10]>*
> (image_height/image_width)
>   angle camang
> }

I understand what you are saying in terms of controlling the camera's field of
view with angle and controlling with a camera matrix transform, but the field
of view of the camera is only a means to an end for me. What I really want to
quantify, is the width of a single pixel in an image of a known resolution. So
from what it seems to me, is that I can use the direction vector to contol the
"focal length" of the camera, and the right/up vectors to create the
appropriate field of view. Now the thing I am having trouble understanding is
how to convert this image plane into width and height of the image in Povray
standard units. From this I should be able to use the resolution to calculate
how big a pixel is in terms of these "Povray units." Does this make sense?
Does the right and up vector actually control the size of this image plane? If
so then I should be able to set
camera {
location = <0,0,0>
right = 1*x
up = (img_height/img_width)*y
direction = 0.5*z
}
This , in theory would give me an image plane with dimensions 1 units x 0.75
units for an aspect ratio of 1.333. From here then, I should be able to divide
the width (1unit) by 640 and get the "pixel width" of each pixel in the image.
Does it work this way, or am I completely missing the mark?

Thanks for all your help,
~Carl

Post a reply to this message