Astronomical

As we have done in past years, a small group of those interested came to Wooster Hall to observe the skylight lights cross over the staircase at Solar Noon (at 12:58:16 EDT). This year the actual Solstice (at 11:54 EDT) was very close to the same time, which is not always the case. Raj Pandya, director of the John R. Kirk Planetarium, lead everyone there through the simple calculation of the highest angle of the sun that day.
I set up my network camera to make the following time-lapse video:

The reason we are all supposedly there is to watch the bars of light crossing the upper staircase, but it looks to me like people were more interested in everyone else. Which may be as it should be.

A few weeks ago I visited Wooster Hall with a time-lapse camera to try to see what happens to the light from the skylight over the main staircase at solar noon on the Winter Solstice.  I was a few days early, but even so, I think I uncovered the basic idea, which you can review in a previous blog post.

The result is that the four columns of light that appear at the bottom of the staircase on the equinoxes now appear on the slanted ceiling near the skylight, and don’t extend down any further.   Here’s a picture (click on it for a bigger view):

But as you will notice, there appears to be something in the way, preventing the columns of light from extending all the way downward, especially on the left.    What could that be?  In the original post of the video I mused that perhaps there is something on the roof which is casting a shadow.   Looking at the roof from a nearby building I could see that there are vents on the roof that are near that skylight.   And after that post I heard from the building architect that those vents are necessary to remove smoke in the event of a fire. It’s doubtful they could be moved.  But from that viewpoint I wasn’t sure that these were actually in line with the skylight, and I’m still doubtful that they are the culprit.

Someone else suggested that I could see what is on the roof using Google Maps.  That turned out to be very helpful.  Here’s the view from directly above, with some added markings (click on the image for a bigger view):

The skylight is circled in red, and the green line shows my line of sight from the Chemistry building to the Wooster roof.  As indicated by the compass needle at the right edge, vertical on this photo is North, and as you might expect the four openings in the skylight line up with North, rather than with the building.   You can also see the vents near the skylight, the sort-of round things that are to the right and below the skylight.   But note that they are NOT directly below (i.e. South of) the skylight.  This means that they cannot be blocking the light in the way seen in the videos!   Which is what I suspected when viewing them from the Chemistry building.

So what is blocking the light?   I’m going to guess that it’s the roof itself — actually a wall which is a part of the roof.  As you can see from the photo, the roof has several levels (it’s easier to see this from the side view from the other building).   The part of the roof where the skylight is located is higher than the roof farther to the south, and there is a wall dividing the two levels.    You can see this a little better if we zoom in (again, click on the picture to make it (somewhat) larger):

The orange line shows the position of the wall, which I suspect is just high enough to block the lower part of the skylight when the sun is at its lowest in the sky, on the Winter Solstice.   If you go back to the picture of the skylight from the inside, it looks like whatever is casting the shadow is larger on the left and sloping down to the right.   But keep in mind that the building is turned away from North, and the skylight image is cast on a slanted ceiling/wall  (which might even be curved).  My guess is that the shadow is actually a horizontal line, caused by the wall on the roof.

And, by the way, if you don’t see that the orange line marks the position of a wall, then go to Google Maps yourself and find this building and select the “satellite” view.   The way Google presents the images they actually change your view slightly as you drag the map, giving a sense of 3D which shows more clearly that the roof has multiple levels.  It’s pretty cool that they can do this without your having to wear 3D glasses.

Is there anything we can do to unblock the sun?   Well, at least it’s not a vent that’s  required for fire safety, but the wall is probably necessary too.   Maybe a section of the wall could be replaced with an open railing  or chain-link fence which would still provide safety to whoever is working up there, but would let the light through to the entire skylight at the Winter Solstice. Or maybe not.

I still want to get up on the roof to try to confirm this conjecture.  By measuring the distance of the bottom of the skylight to the base of the wall, along with the height of the wall, I could determine the position of the shadow of the wall for a given elevation of the sun, and verify that the shadow would reach the skylight. And maybe figure out how much the wall would have to be lowered  (instead of completely removed).   This isn’t over yet,  so stay tuned…

Wooster Hall at SUNY New Paltz has a neat feature:  the main staircase is aligned directly North/South, and skylights are positioned above it so that at solar noon on the equinoxes the bottom of the staircase is illuminated by four columns of light which crawl slowly across the floor.   It’s an exciting event on campus, for some reason.   This past spring I made a crude time-lapse video of this.   Also, on the summer solstice, and again at solar noon, the upper part of the staircase is illuminated.   I made a much better time-lapse video this time, which includes a demonstration of the reason for the change in the sun’s elevation, where I’m assisted by my 9-year old daughter, Amanda.

But what about the Winter Solstice?   There are no markings on the staircase or nearby, and in any case the sun is so low in the sky in winter that it’s not clear that there would be anything to see.   But since I’m always curious about such things, I decided I had to find out.

The weather for December 21st was expected to be overcast and rainy, so I actually visited Wooster hall earlier in the week, on two different days.  First, on Tuesday, December 18th, I was able to get the general idea of what’s going on:

As you can see, the four columns of light from the skylights move across the wall directly below the skylight,  but they don’t extend further down.

It seemed like I had gotten there a little bit late, so I came back earlier the following day.   This time I think I got the whole thing:

There is a jump at the very beginning of the video, where I repositioned the camera.  Unfortunately, I moved the camera closer to some lights on the wall, and it looks like that changed the contrast of the video and made everything darker.  Even so, you can see the whole event as the sun crosses over.

Both of these time-lapse videos were created using a very nice piece of software called TLDF  (which  stands for “Time-Lapse-De-Flicker).  Actually, I just used the free “lite” version for Mac, called TLDFLITE, and that worked fine for this project.   You can find out more about it at https://timelapsedeflicker.com/

One thing that’s very obvious from both videos is that there are not four full bars of light, the way there are at the summer solstice and the equinoxes.  There is a curved shadow that blocks the light, mainly on the left side, curving down to the right.  It’s probably something on the roof near the skylight, but I don’t quite know what.  I went to the top floor of the nearby Chemistry building to get a view of the roof of Wooster Hall, and I can see that there are ventilation stacks near the skylight which might explain the shadow, but I wasn’t sure either of them lined up quite right.

So now I want to get up on the roof to see what is in the way, and  to see if perhaps it can be moved out of the way.   If I can’t get up on the roof, then perhaps I can find someone with a drone to help inspect that area.  Stay tuned….

Wooster Hall on the SUNY New Paltz campus was completely remodeled recently, and a neat new feature is an alignment of the skylight over the main stairway such that the bottom of the stairs is lit up at exactly solar noon on the Equinox  (both spring and fall).

This spring when I observed this I was inspired, on the fly, to create a time-lapse video of the event, using just my hand-held phone.   You can see the video here.

Making the time-lapse video from the still images was a fun little exercise in Python programming, and the purpose of this post is to show how I did it.   I need to start out by saying that this is all really crude compared to what one can do now with time-lapse photography, but it was what I was able to do with little background or training, so I wanted to at least record what I learned.

One of the challenges to deal with is that the images were not captured at regular intervals, since I was taking them by hand with my phone.   I tried to space them out about every minute, but sometimes it took longer (like when someone was in the way) and sometimes I took them more frequently (as we got closer to solar noon).   Even so, I wanted to make the video flow as smoothly as possible by adjusting the time between frames accordingly.    That lead me to choose to make an animated GIF instead of some other format, because an Animated GIF can have different time delays for different images, whereas most video has a uniform spacing between frames.

My previous experience making an animated GIF was using the command line convert tool from Image Magick, but even that assumes a standard frame rate and does not make it easy to change the delays individually for different frames.   Still, I knew that the time of each image was recorded in the JPG file, so in principle I could use that to adjust the time between frames, if I read that information programatically.   That lead me to choose to write a Python script to do the job.   And then looking at what was available in Python, I chose to use PIL, the Python Image Library.

The way it works, overall, is that you read in all the images into a list, then save the first image as a GIF, and at the same time tell it to append all the other images, with an array of different time durations to show each image.   For animated GIFs the time to show each frame is in hundredths of a second, so I simply scale down the time interval between when the pictures were taken to an appropriate amount in hundredths of a second.

I also needed to do some processing for each image, before it was added to the animation.
Because I held the phone horizontally (landscape) but the JPG files default to “up” being portrait mode, I had to rotate each image by 90 degrees.   I also wanted to scale down the size of the image to make a smaller animated GIF appropriate for a web page, rather than a full sized video.

To get started I imported PIL and set up some empty arrays to hold the images, the durations (time between frames), and the names of the original image files.

from PIL import Image

images = []
durations = []
prev_time = datetime.now()

The current time is saved in prev_time to start the process of computing the time between successive photos. At this point I just needed a value which is both a ‘dateime’ object and somehow signals that it’s not a part of the sequence of times, which this does by being so much later than the first image.

Before reading in images, I needed an ordered list of the file names.  The file names are simply IMG_2921.JPG up to IMG_2821.JPG, in order.   I used the os module and made sure that the list was properly sorted:

import os

# Get a list of .JPG files
filenames = []

for file in os.listdir('.'):
    name, ext = os.path.splitext(file)
    # Only files, only .JPG files
    if os.path.isfile(file) and ext == ".JPG":
        filenames.append(file)
print "Found ", len(N), "image files.  "

filenames.sort()

With this list I was able to use PIL to read in each image file, rotate the image, resize the image, and then save the image in a list:

for file in filenames:
    img =  Image.open(file)
    rotimg = img.rotate(-90,expand=1)
    newsize = ( int(rotimg.size[0]/scale), int(rotimg.size[1]/scale) )
    frame = rotimg.resize(newsize)
    images.append(frame)

I set scale to 5.0 to reduce the size to 1/5 the original.

After saving each frame in the animation, I get the timestamp from the EXIF data in the original image, which just happens to be element 36867 of the EXIF property array. (You can look this up — I certainly had to). From this I computed the time duration for each frame, in hundredths of a second:

    # Duration of frame comes from actual time difference between photos

    exif = img._getexif()         # JPEG photo metadata (EXIF)
    datestamp = exif[36867]       # date/time the photo was taken
    img_time = datetime.strptime(datestamp,"%Y:%m:%d %H:%M:%S") # parse datestamp
    deltat = img_time - prev_time # difference as "timedelta" objects
    dt = deltat.total_seconds()   # difference in seconds (or fraction of)
    if dt < 0:                    # ignore the first one, it's bogus
        durations.append(dt*100.0/speedup) # GIF duration is in 100ths of second
    prev_time = img_time          # Save timestamp for next iteration

In Python, differences between ‘datetime’ objects are ‘timedelta’ objects¹ and then we convert that to a float value in seconds, called dt, and rescale that to hundredths of a second. The scale factor speedup was set to a value of 30.0 to get a reasonable speed for the animation.

Notice that the duration of the frame is not saved for the first frame. That means that for the 99 images in the collection, there are only 98 durations (and of course they are all different). This turns out to be almost what is needed for the next step, putting all the frames together into the animation.

After this loop over all frames, the rotated and scaled images are in the list named images, the duration for each frame is in the list durations, and it’s time to put them all together. The way this is done is to write one frame image, and then tell PIL to append to it the list of the other images, with the list of durations.

print "Writing the movie..."
first = images.pop(0)
durations.append(100)     # pause 1 second at end of loop
print len(images), len(durations)
first.save("WoosterMovie.gif",save_all=True,
                              append_images=images,duration=durations,loop=47)

With 99 images in the list, the first is put into the variable first (and removed from the images list, which now has 98 elements. Meanwhile, I had to add another element to the end of the durations list, so now there are 99 durations. That makes some sense, because there are 99 images overall, but the mis-match between the length of the images list and the durations list was very confusing to me, and is probably the most important reason for writing this posting. Which is why I even printed the lengths to verify them when I finally got it figured out. But as you can see from the comment, it also means I could control the length of the pause at the end of the animation before it repeated. Also as you can see, you “save” the first image, and then pass the other images and durations as parameters, which seemed kinda weird at first, but that’s how the API works, so that’s how you do it. Hopefully this working example is useful to someone else, or at least to me in the future when I forget all this.

References

The newly updated Wooster Hall has a neat feature at the bottom of the staircase between the first and second floors.  Above that stair  there is a large skylight with 4 windows, and at the bottom of the stairs there are markings on the floor that show where the shadows between those windows will be at solar noon on the Vernal Equinox (see the image above).

I was able to observe this phenomenon in some detail on Tuesday, 19 March 2018 (which was actually the day before the equinox, but the weather was expected to be cloudy the next day, and indeed it was). When I arrived I found a nice corner to observe from, and although I had not planned to do so ahead of time, I ended up taking a picture just about every minute (and more frequently right around solar noon) for an hour or so. After a little research I was able to write a Python script to put the images together in the following animated GIF  (keep your eyes on the shafts of sunlight moving across the floor):

The speed  is a little rough — I was aiming for one second of animation for one minute of real time but apparently I still need to make some adjustments, and even then it might depend on which browser you are using.

It was a little tricky to do this right, because I was not able to take the photos at regular intervals, and so the duration of each frame in the animation had to be computed from the time of the photo, which was extracted from the EXIF metadata. In case it is of some interest, the details of how I created this animations are in my next post: “Vernal Equinox in Wooster Hall: Irregular Interval Time-Lapse Animation“