wasting some round tuits, as some seems to have a good supply of them,
I added in hgpovray a new camera type: grid.

#declare Camera_0 = camera {  /*ultra_wide_angle*/ angle 10      // front view
                            location  <0.0 , 2.0 ,-40.0>
                            right     x*image_width/image_height
                            look_at   <0.0 , 2.0 , 0.0>}
#declare Camera_1 = camera {/*ultra_wide_angle*/ angle 10   // diagonal view
                            location  <20.0 , 20.0 ,-20.0>
                            right     x*image_width/image_height
                            look_at   <1.0 , 2.0 , 0.0>}
#declare Camera_2 = camera {  /*ultra_wide_angle*/ angle 10  //right side view
                            location  <40.0 , 2.0 , 0.0>
                            right     x*image_width/image_height
                            look_at   <0.0 , 2.0 , 0.0>}
#declare Camera_3 = camera {  /*ultra_wide_angle*/ angle 10        // top view
                            location  <0.0 , 40.0 ,0.0>
                            right     x*image_width/image_height
                            look_at   <0.0 , 1.0 , 0.0>}
camera{ grid 2 Camera_2 Camera_0 Camera_1 Camera_3}

Followed by the number of camera per side, and then that squared number of camera
identifiers, to make a grid of the various view directly for the rendered image.

Post a reply to this message

Attachments:
Download 'grid.png' (212 KB)

Preview of image 'grid.png'

Am 2016-07-06 12:58, also sprach Le_Forgeron:
> wasting some round tuits,

Wow. Pretty slick.

Didn't warp have something similar years ago? I recall an anim of 
spaceship on a spline from 4 angles at once.

And because I'm a dork, I'll add
"yeah, but you should support video wipe" (position the dividers between 
cameras). :)


-- 
dik

Post a reply to this message

That, sir, is wicked cool and very useful and convenient.
An excellent job!   :)

Post a reply to this message

Le 06/07/2016 22:42, dick balaska a écrit :
> Am 2016-07-06 12:58, also sprach Le_Forgeron:
>> wasting some round tuits,
> 
> Wow. Pretty slick.
> 
> Didn't warp have something similar years ago? I recall an anim of spaceship on a
spline from 4 angles at once.
> 

Any link ?

> And because I'm a dork, I'll add
> "yeah, but you should support video wipe" (position the dividers between cameras).
:)
> 
> 
Give a man a fish, and he will ask for a comfortable table and seat, with a fresh
bottle of white wine and a dedicated team of waitresses, free of charge.

"You can position the dividers anywhere, as long as it's 1/n and you have n*n
cameras".
(in the mood of Ford :"you can have the car in any colour you want, as long as it is
black.")

More seriously, if you can come up with a simple and clear syntax to describes a
layout of rectangles that have the same ratio than the final picture, I might consider
another extension.
But beware, HTML tried that with table, and that turns in a nightmare and ambiguous
descriptions (some engines render differently some complex tables).

Post a reply to this message

On 7/7/2016 6:58 AM, Le_Forgeron wrote:
> Le 06/07/2016 22:42, dick balaska a écrit :
>> >Am 2016-07-06 12:58, also sprach Le_Forgeron:
>>> >>wasting some round tuits,
>> >
>> >Wow. Pretty slick.
>> >
>> >Didn't warp have something similar years ago? I recall an anim of spaceship on a
spline from 4 angles at once.
>> >
> Any link ?
>

IIRC It was using megapov and quite a while ago.
I cannot find a link.

-- 

Regards
     Stephen

Post a reply to this message

Am 06.07.2016 um 18:58 schrieb Le_Forgeron:

> camera{ grid 2 Camera_2 Camera_0 Camera_1 Camera_3}
> 
> Followed by the number of camera per side, and then that squared number of camera
identifiers, to make a grid
> of the various view directly for the rendered image.

Why not provide two parameters, so that we can have arbitrary arrays of
NxM cameras?

That, btw, would obviously provide a reasonably simple way to generate
side-by-side stereographic images.

Post a reply to this message

Le 07/07/2016 15:31, clipka a écrit :
> Am 06.07.2016 um 18:58 schrieb Le_Forgeron:
> 
>> camera{ grid 2 Camera_2 Camera_0 Camera_1 Camera_3}
>>
>> Followed by the number of camera per side, and then that squared number of camera
identifiers, to make a grid
>> of the various view directly for the rendered image.
> 
> Why not provide two parameters, so that we can have arbitrary arrays of
> NxM cameras?
> 
> That, btw, would obviously provide a reasonably simple way to generate
> side-by-side stereographic images.
> 

Because I did not mess with image_height & image_width, which could be used in
(sub)camera computation.

And I already have side-by-side stereographic camera

http://wiki.povray.org/content/User:Le_Forgeron#Stereoscopic_camera

Post a reply to this message

Am 07.07.2016 um 16:05 schrieb Le_Forgeron:
> Le 07/07/2016 15:31, clipka a écrit :
>> Am 06.07.2016 um 18:58 schrieb Le_Forgeron:
>>
>>> camera{ grid 2 Camera_2 Camera_0 Camera_1 Camera_3}
>>>
>>> Followed by the number of camera per side, and then that squared number of camera
identifiers, to make a grid
>>> of the various view directly for the rendered image.
>>
>> Why not provide two parameters, so that we can have arbitrary arrays of
>> NxM cameras?
>>
>> That, btw, would obviously provide a reasonably simple way to generate
>> side-by-side stereographic images.
>>
> 
> Because I did not mess with image_height & image_width, which could be used in
(sub)camera computation.

They could be used to compute the aspect ratio, but they also could be
used to compute other stuff, so they're "broken" anyway if interpreted
as a per-camera value.

Also, if you develop a scene using a grid camera, you presumably know
what grid size you're using, so you can apply correction factors to
account for the mismatch between camera aspect ratio and image aspect ratio.

Post a reply to this message

Le 08/07/2016 13:41, clipka a écrit :
> Am 07.07.2016 um 16:05 schrieb Le_Forgeron:
>> Le 07/07/2016 15:31, clipka a écrit :
>>> Am 06.07.2016 um 18:58 schrieb Le_Forgeron:
>>>
>>>> camera{ grid 2 Camera_2 Camera_0 Camera_1 Camera_3}
>>>>
>>>> Followed by the number of camera per side, and then that squared number of camera
identifiers, to make a grid
>>>> of the various view directly for the rendered image.
>>>
>>> Why not provide two parameters, so that we can have arbitrary arrays of
>>> NxM cameras?
>>>
>>> That, btw, would obviously provide a reasonably simple way to generate
>>> side-by-side stereographic images.
>>>
>>
>> Because I did not mess with image_height & image_width, which could be used in
(sub)camera computation.
> 
> They could be used to compute the aspect ratio, but they also could be
> used to compute other stuff, so they're "broken" anyway if interpreted
> as a per-camera value.
> 
> Also, if you develop a scene using a grid camera, you presumably know
> what grid size you're using, so you can apply correction factors to
> account for the mismatch between camera aspect ratio and image aspect ratio.
> 


ok... Granted evolution. Just do not blame me when the aspect ratio are not correct.

Instead of 2 paramaters, the parameter is now a vector, interpreted as 2D-vector.


#declare Camera_0 = camera {  /*ultra_wide_angle*/ angle 10      // front view
                            location  <0.0 , 2.0 ,-40.0>
                            right     x*image_width/image_height*2/3
                            look_at   <0.0 , 2.0 , 0.0>}
#declare Camera_1 = camera {/*ultra_wide_angle*/ angle 20   // diagonal view
                            location  <20.0 , 20.0 ,-20.0>
                            right     2*x*image_width/image_height
                            look_at   <1.0 , 2.0 , 0.0>}
#declare Camera_2 = camera {  /*ultra_wide_angle*/ angle 10  //right side view
                            location  <40.0 , 2.0 , 0.0>
                            right     x*image_width/image_height*2/3
                            look_at   <0.0 , 2.0 , 0.0>}
#declare Camera_3 = camera {  /*ultra_wide_angle*/ angle 10        // top view
                            location  <0.0 , 40.0 ,0.0>
                            sky +z
                            direction -y
                            up +z
                            right     x*image_width/image_height*2/3
                            look_at   <0.0 , 1.0 , 0.0>}
#declare GridT = camera { grid 1 Camera_1 }
#declare GridB = camera { grid <3,1> Camera_2 Camera_3 Camera_0 }
camera{ grid <1,2> GridT GridB }

Post a reply to this message

Attachments:
Download 'grid.png' (172 KB)

Preview of image 'grid.png'

On 07.07.2016 11:19, Stephen wrote:

> IIRC It was using megapov and quite a while ago.
> I cannot find a link.

MegaPOV actually had a camera_view pigment.

So you could use one rendered view and use it to texture e.g.
a picture frame. Or of course apply it to 2 x 2 boxes for a grid.

http://megapov.inetart.net/features.html

Post a reply to this message