Hi,

I am considering to dig into PovRay, if it can do what I need - so I hope
that someone of you can tell me whether it will:

A light source (the sun) shines on a reflecting surface (say, a
square-shaped mirror that is hanging on a wall). As the sunlight comes from
above and shines onto the mirror, part of the sunlight is reflected
downwards to the floor. Thus, a basically parallelogram-shaped lighter area
should be visible on the floor.

I then would like to determine when (date and time of the day) the reflected
sunlight falls on a certain area of the floor (or objects). It need not be a
realistic rendering - I just want to determine the days in the year when the
reflected sunlight hits an object that sits on the floor.

To my understanding, this should be possible by using photon mapping, and
then trying to make a fast-motion video from it. Is that correct, and is it
feasable for, say, a hobby programmer to do this within two working weeks?

(Is there some module or code-snippet for automatically calculating the
sun's position, given geographical position and date/time?)


Many thanks!
Philipp

Post a reply to this message

Philipp <pov### [at] phipracom> wrote:
> I then would like to determine when (date and time of the day) the reflected
> sunlight falls on a certain area of the floor (or objects). It need not be a
> realistic rendering - I just want to determine the days in the year when the
> reflected sunlight hits an object that sits on the floor.

  Would you be determining this visually (ie. looking at the rendered
images), or would you want an SDL which automatically calculates whether
the light is reflecting on the mirror or not?

  The latter case would be a bit more difficult.

-- 
                                                          - Warp

Post a reply to this message

"Philipp" <pov### [at] phipracom> wrote:
> Hi,
>
> I am considering to dig into PovRay, if it can do what I need - so I hope
> that someone of you can tell me whether it will:
>
> A light source (the sun) shines on a reflecting surface (say, a
> square-shaped mirror that is hanging on a wall). As the sunlight comes from
> above and shines onto the mirror, part of the sunlight is reflected
> downwards to the floor. Thus, a basically parallelogram-shaped lighter area
> should be visible on the floor.
>
> I then would like to determine when (date and time of the day) the reflected
> sunlight falls on a certain area of the floor (or objects). It need not be a
> realistic rendering - I just want to determine the days in the year when the
> reflected sunlight hits an object that sits on the floor.
>
> To my understanding, this should be possible by using photon mapping, and
> then trying to make a fast-motion video from it. Is that correct, and is it
> feasable for, say, a hobby programmer to do this within two working weeks?
>
> (Is there some module or code-snippet for automatically calculating the
> sun's position, given geographical position and date/time?)
>
>
> Many thanks!
> Philipp


Rather than using photon mapping, which can add to render time, if you don't
need to consider any other reflection/refraction other than the mirror
surface, and the mirror surface is flat, it would be far simpler to use
direct lighting.

Assuming you know the position of the sun and the plane of the mirror, you
would just mirror the sun's position relative to the mirror surface,
creating a virtual sun.  Then you can use the projected_through option for
the virtual sun using the mirror surface as the projected_through object.

This may take a little bit more mathematics, but would save considerably on
render time.

-tgq

Post a reply to this message

Trevor G Quayle <Tin### [at] hotmailcom> wrote:
> Rather than using photon mapping, which can add to render time

  In such a simple case as this one photon mapping doesn't add almost
any render time at all. And it's far easier to use than trying some
odd kludge to try to save some 0.1 seconds from the render time.

-- 
                                                          - Warp

Post a reply to this message

"Philipp" <pov### [at] phipracom> wrote:
....
> I then would like to determine when (date and time of the day) the reflected
> sunlight falls on a certain area of the floor (or objects). It need not be a
> realistic rendering - I just want to determine the days in the year when the
> reflected sunlight hits an object that sits on the floor.
>
> To my understanding, this should be possible by using photon mapping, and
> then trying to make a fast-motion video from it. Is that correct, and is it
> feasable for, say, a hobby programmer to do this within two working weeks?
>
> (Is there some module or code-snippet for automatically calculating the
> sun's position, given geographical position and date/time?)
>
To answer your questions: yes, yes, and yes.  POV-Ray comes with sunpos.inc,
a macro to do just what you would like (2.7.20.6 sunpos.inc).   Two weeks
should be sufficient.  Pay particular attention to coordinate handedness.
You'll need a separate piece of software to make the animation.  Here's a
link to the sunpos.inc doc page:

http://www.povray.org/documentation/view/3.6.1/498/

I like to use SunPos() to show the seasonal solar exposure and penetration
of structures so as to minimize heat gain in the summer and maximize it in
the winter.  I throw a bunch of intensity- and color-coded 'suns' in the
sky (red for summer 'cooling days', and blue for winter 'heating days').
The resulting red-magenta-blue hues illuminating the surfaces of the
structure indicate where wanted and unwanted solar radiation is
intercepted.  Passive solar performance should be good when exterior
surfaces appear red (and are well-insulated there) and the surfaces of
internal thermal masses are blue.

Hope this helps.

-David

Post a reply to this message

in news:web.45a82fb9aa573b97442464bf0@news.povray.org waggy wrote:

> I like to use SunPos() to show the seasonal solar exposure and
> penetration of structures so as to minimize heat gain in the summer
> and maximize it in the winter.

That is exactly what I wrote it for :)

>  I throw a bunch of intensity- and
> color-coded 'suns' in the sky (red for summer 'cooling days', and
> blue for winter 'heating days'). The resulting red-magenta-blue hues
> illuminating the surfaces of the structure indicate where wanted and
> unwanted solar radiation is intercepted.

Ah, great trick, never thought of it.

Thanks,

Ingo

Post a reply to this message

"Philipp" <pov### [at] phipracom> wrote:
> Hi,
>
> I am considering to dig into PovRay, if it can do what I need - so I hope
> that someone of you can tell me whether it will:
>
> A light source (the sun) shines on a reflecting surface (say, a
> square-shaped mirror that is hanging on a wall). As the sunlight comes from
> above and shines onto the mirror, part of the sunlight is reflected
> downwards to the floor. Thus, a basically parallelogram-shaped lighter area
> should be visible on the floor.
>
> I then would like to determine when (date and time of the day) the reflected
> sunlight falls on a certain area of the floor (or objects). It need not be a
> realistic rendering - I just want to determine the days in the year when the
> reflected sunlight hits an object that sits on the floor.
>
> To my understanding, this should be possible by using photon mapping, and
> then trying to make a fast-motion video from it. Is that correct, and is it
> feasable for, say, a hobby programmer to do this within two working weeks?
>
> (Is there some module or code-snippet for automatically calculating the
> sun's position, given geographical position and date/time?)
>
>
> Many thanks!
> Philipp

I hate to say so, since one more Povver is obviously good in the greater
scheme of things, ;-) but you don't need to use POV at all to do that.
Simply calculate the angle from the object to the mirror, then determine
where the sun should be in the sky. You may want to convert that to Right
Ascension and Declension (or whatever they're called in English), just
google it. Then look up ephemerides (for example
http://cfa-www.harvard.edu/iau/MPEph/MPEph.html)

Post a reply to this message

"Trevor G Quayle" <Tin### [at] hotmailcom> wrote:
> "Philipp" <pov### [at] phipracom> wrote:
[...]
> Assuming you know the position of the sun and the plane of the mirror, you
> would just mirror the sun's position relative to the mirror surface,
> creating a virtual sun.  Then you can use the projected_through option for
> the virtual sun using the mirror surface as the projected_through object.
>
> This may take a little bit more mathematics, but would save considerably on
> render time.
>

Hi, thanks Warp and Trevor for your responses;

Well, I had simplified the problem a bit.
Actually there are some other objects in the scene, which will be partly
between the sun and the mirror, and also between the mirror and the
"detector object" (I call it like that for now, it is the object that sits
on the floor, waiting to to get hit by reflected sunlight). So this makes
Trevor's "virtual sun" approach more complicated, though this would be a
good idea. The other objects in the scene are quite simple (flat surfaces,
no transparencies).

In fact, I would rather prefer simple programming over little rendering
time, because I have little experience with povray, this is probably a
one-time job, and I want to reduce the risk of program bugs. (So no matter
if rendering takes 3 days in total. :-)

Basically, I want a means to determine when the "detector object" is hit by
the sunlight. I thought about only calculating / drawing it in CAD, but
obviously it is nice to have some visual plausibility check, and a few good
pictures to show.
So I thought I could make a video of one (half?) simulated year, say, at one
frame per hour, and then watch the video (say, 3 secondes per frame) to see
what happens; ...and to find the date/time of critical situations (assuming
a visible date-timeline in the video, hmmmm...).

Regards,
Philipp

Post a reply to this message

ingo <ing### [at] tagpovrayorg> wrote:
> in news:web.45a82fb9aa573b97442464bf0@news.povray.org waggy wrote:
>
> > I like to use SunPos() to show the seasonal solar exposure and
> > penetration of structures so as to minimize heat gain in the summer
> > and maximize it in the winter.
>
> That is exactly what I wrote it for :)

David,

great, I will look into it - many thanks for pointing me there!
(You multi-sun method also looks quite clever...)

And of course, big thanks to ingo for writing SunPos() :-)

Regards,
Philipp

Post a reply to this message

"Grassblade" <nomail@nomail> wrote:
> "Philipp" <pov### [at] phipracom> wrote:
> > Hi,

[...]

> I hate to say so, since one more Povver is obviously good in the greater
> scheme of things, ;-) but you don't need to use POV at all to do that.
> Simply calculate the angle from the object to the mirror, then determine
> where the sun should be in the sky. You may want to convert that to Right
> Ascension and Declension (or whatever they're called in English), just
> google it. Then look up ephemerides (for example
> http://cfa-www.harvard.edu/iau/MPEph/MPEph.html)

Thanks Grassblade, true, yes its basically a geometric problem.

But, the mirror has some dimensions, and also the "detector object" (the one
that waits for catching reflected sunlight) is not a point, but a larger
volume. All the objects are quite close to each other.
So, I thought, I would have to do a separate calculation at least for each
of the four extreme corner points of the mirror, each of these calculations
variated by a range of points within the detector object. (Or, think
thoroughly about which ones to leave away...)
All of that for all different sun positions.

So, I thought, I let POV do all these variations for me.

Does this make sence that way?

Regards,
Philipp

Post a reply to this message