Photography « A Little Off

1Oct/090

When it’s worth it to destroy something

Look no further than this photo.

Tagged as: camera, destroy, launch, Photography, rocket No Comments

16Jun/090

Infrared Photos

I'd have to say that my favorite style of photography is good black and white infrared photography, occasionally false-color infrared photography is good but black and white is by far my favorite.

I finally got a chance this summer to take some decent IR photos on my parent's ranch in Wyoming. I did all of the photos with my Nikon E-Series 28mm f/2.8, which on my Nikon D50 is a bit closer to a 42.7mm lens than a 28mm lens. How did I figure that you ask?

Given that I can find the angle of view of the camera using the equation^[1]:

$\displaystyle \alpha = 2 \cdot arctan\left (\frac{d}{2f}\right)$

Where alpha is the angle of view, f is the focal length of the lens and d is the diagonal length of the sensor of the camera in question. Given that my camera's sensor is 24.7mm x 15.5mm^[2], we can substitute this in for d as well as the focal length of my lens, 28mm and solve for alpha:

$\displaystyle 53.65^{\circ} = 2 \cdot arctan\left (\frac{\sqrt{(24.7)^2 + (15.5)^2}}{2\cdot 28}\right)$

Now that we've found the angle of view that my camera sees through the 28mm lens we can solve for the focal length f in lets say Nikon's D3X which happens to have a full-frame sensor. The Nikon D3X's sensor is 35.9mm x 24mm^[3].

$\displaystyle f = \frac{d}{2 \cdot tan(\tfrac{\alpha}{2})}$

Substituting in the diagonal length of the D3X's sensor and the angle of view my D50 has we can find what focal length of lens the D3X would need to have to have the same angle of view as my D50.

$\displaystyle 42.7mm = \frac{\sqrt{(35.9)^2 + (24)^2}}{2 \cdot tan(\tfrac{53.65^{\circ}}{2})}$

And now we can figure out how much cropping (magnification if you will) my camera's sensor causes when using a lens meant for a 35mm//full-frame camera.

$\displaystyle \frac{42.7mm}{28mm} = 1.525$

This happens to be pretty close to the ratio that most people give for calculating the focal length of a lens meant for a 35mm//full-frame camera on Nikon DX format cameras. The general rule given is that you should just multiply the focal length by 1.5 which... as you can see is ever-so-slightly off. I'm just a little OCD about that sort of thing and it seemed too simple to be completely correct so I figured I'd just calculate it myself.

Anyway I suppose I should have warned you at the beginning of the post that this would have more to do with photography math than infrared photos but it probably didn't hurt you to learn something new.

Also I almost forgot to mention what filter I used. I used a Hoya R72 Infrared bandpass filter. This particular filter passes light wavelengths 720nm and greater. Since my camera was designed with visible light photography in mind it has a low pass filter installed over the sensor that blocks out a good deal of infrared and ultraviolet light so even in broad daylight I still have to do long exposures to get infrared photos exposed properly.

The photos in that album were all done at f/16 since I found that using extremely long exposures at smaller f-numbers just blows out the photo and I'm not sure why just yet. However it helps to use a smaller aperture anyway since infrared light also focus' at a different point than visible light does, my 28mm lens has an infrared focusing mark on it for correcting but, it's not perfect and I can't compose or focus the shots while the filter is on the camera since being human my eyes are only sensitive to light of wavelengths between about 380nm and 750nm^[4]. As well as making the photos not-blown-out with the aperture so small it also aids in any focusing deficiency since the depth of field is much deeper. Most of the photos were between 2 and 5 second exposures depending on the cloud-cover. You can see detailed shooting info by looking at the EXIF data Picasa shows in the More Info section of each photo, the aperture is erroneous there so ignore it, my Nikon E-Series 28mm is a non-cpu lens so it can't tell the camera what it's current aperture is.

Tagged as: Angle of View, DX Format, Hoya R72, Infrared, Nikon, Photography No Comments

20Feb/099

High(ish)-speed Photography (followup)

So this Tuesday I got my Arduino in the mail. I really mean just in the mail... it was in an anti-static bag in a bubble-wrap envelope! Anyway I managed to waste about 6 hours screwing around with it the first night I got it. Since then after a lot of researching, googling, swearing and scratching my head I've successfully setup the first major part for the camera trigger project.

I discovered that the delay functions built into the Arduino C library are mostly useless. The microsecond delay function is most useless of all because it will only produce accurate delays between 4 microseconds and 16383 microseconds. So I gave up on that and just wrote a custom delay function. But before I wrote the custom delay function I looked at creating my own timer using Timer2 and giving up digital pins 11 and 3 for accurate times. Eventually I ditched this method because I never got any of the sample code to work at all.

Eventually I arrived at this at least reliable if not accurate delay function:

1
2
3
4

void customDelay(unsigned long time) {
unsigned long end_time = micros() + time;
while(micros() < end_time);
}

The advantage to this over the delayMicroseconds() function is that this will at least pay attention to how long it's actually been since it started where the delayMicroseconds() function just blindly sleeps for an arbitrary amount of time and wakes up when it sees fit. The function for oscillating the IR led at the frequency I needed for triggering the camera is of the same form just with a bit of code for switching the LED on and off twice every clock cycle in the while loop. It also turns out that changing the state of a digital pin isn't near instantaneous either, which is to be expected. I've compensated for this using a constant defined for the number of microseconds it takes for it to turn a digital pin on or off.

Once I solved the timing issues it was essentially about cleaning up the code from that point on. I ended up storing the sequence of oscillation and pausing that Nikon SLR's use in two arrays, one for oscillation and one for the matching pause between each oscillation period. Which makes for a clean section for firing the led and pausing all inside a for loop that iterates over each item in the two arrays.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

/*
Author: BeMasher
Description: Code sample in C for firing the IR sequence that mimics the
ML-L1 or ML-L3 IR remote control for most Nikon SLR's.

Based off of: http://make.refractal.org/?p=3
http://www.cibomahto.com/2008/10/october-thing-a-day-day-7-nikon-camera-intervalometer-part-1/
http://ilpleut.be/doku.php/code:nikonremote:start
http://www.bigmike.it/ircontrol/

Notes: This differs slightly from the other 3 versions I found in that this doesn't use the built in
delay functions that the Arduino comes with. I discovered that they weren't accurate enough for
the values I was trying to give them. The delayMicrosecond() function is only accurate between about
4uS and 16383uS which isn't a very workable range for the values we need to delay in for this project.
The ASM code that Matt wrote works well but is limited to only pin 12 and I haven't got a good enough
grasp of the architecture to modify the code to work on any pin. So this is what I've come up with to
produce the same result.
*/

#define IR_LED 13 //Pin the IR LED is on
#define DELAY 13 //Half of the clock cycle of a 38.4Khz signal
#define DELAY_OFFSET 4 //The amount of time the micros() function takes to return a value
#define SEQ_LEN 4 //The number of long's in the sequence

unsigned long seq_on[] = {2000, 390, 410, 400}; //Period in uS the LED should oscillate
unsigned long seq_off[] = {27830, 1580, 3580, 0}; //Period in uS that should be delayed between pulses

void setup() {
Serial.begin(19200); //Initialize Serial at 19200 baud
pinMode(IR_LED, OUTPUT); //Set the IR_LED pin to output
}

void customDelay(unsigned long time) {
unsigned long end_time = micros() + time; //Calculate when the function should return to it's caller
while(micros() < end_time); //Do nothing 'till we get to the end time
}

void oscillationWrite(int pin, int time) {
unsigned long end_time = micros() + time; //Calculate when function should return to it's caller
while(micros() < end_time) { //Until we get to the end time oscillate the LED at 38.4Khz
digitalWrite(pin, HIGH);
customDelay(DELAY);
digitalWrite(pin, LOW);
customDelay(DELAY - DELAY_OFFSET); //Assume micros() takes about 4uS to return a value
}
}

void triggerCamera() {
for(int i = 0; i < SEQ_LEN; i++) { //For each long in the sequence
oscillationWrite(IR_LED, seq_on[i]); //Oscillate for the current long's value in uS
customDelay(seq_off[i]); //Delay for the current long's value in uS
}
customDelay(63200); //Wait about 63mS before repeating the sequence
for(int i = 0; i < SEQ_LEN; i++) {
oscillationWrite(IR_LED, seq_on[i]);
customDelay(seq_off[i]);
}
}

void loop() {
if(Serial.available()) { //Wait 'till something is connected
if(Serial.read() != 0) { //If anything but 0 is sent take a photo
triggerCamera(); //Take a photo
}
delay(100); //Delay an arbitrary amount of time, serial isn't instantaneous
}
}

Tagged as: Arduino, ATmega168, DSLR, IR, Nikon, Remote 9 Comments

16Feb/090

High(ish)-speed Photography

This semester I've started a class with the electrical and computer engineering college called Microprocessor Organization. The purpose of this class is to familiarize the students with you guessed it microprocessors. So far it's basically a glorified lab they wanted to turn into a lecture. The lab portion of the course is heavily oriented around assembling your own prototype board and programming said board. In the class we're using a PIC18F4550 microcontroller, which is fascinating and a bit more complex than I wanted to play with at home.

I started looking around for a microcontroller that was simpler and easier to play around with. Eventually I found the arduino which fit my needs perfectly, it's powered through USB, is cheap, has a built in programmer and enough processing power for most of the simple projects I've been thinking about doing at home for fun. As soon as I picked a decent online store I bought an Arduino Duemillanove and a lithium ion battery pack (rechargable through mini-usb).

I should have both in the next few days and the very first thing I decided on trying was a high-speed camera trigger. I've already done some high-speed flash photography and it was amusing but it was too much of a hassle. Focusing in the dark isn't the easiest thing to do and setting up analog circuits to do this sort of thing aren't the simplest in the world and without custom PCB (breadboards instead) they fall apart as you go. I immediately got started coding a sound-sensitive trigger for firing the IR sequence for shutter release on my Nikon D50. Turns out I'm in luck since I was able to find the sequence and it works for almost all Nikon DSLR's of which my friends have a few. My friend pete wrote about this briefly on his blog and a reader offered to bring his camera out for the expirement to the shooting range (which I haven't mentioned yet... patience).

Now that I've gotten the code written out and a small microphone for sensing sound, an IR LED and at least 3 Nikon DSLR's, all that's left is going out to the shooting range. My main goal for this is to get photographs (in sequence or parallel for stereoscopic photos) of different guns ejecting shells and cycling bolts. Since we're not using the same camera's for each shot they've all got different shutter lag times. My D50 is about 130-140ms when pre-focused. The D40 is 95-105ms when pre-focused. Last but not least the D80 is about 75-85ms. This will turn out well because they're all close enough in time that I won't even need to trigger each camera individually for quick sequences of photos. However this makes doing stereoscopic photos a bit more difficult since I'll have to synchronise two of the camera's to the slower shutter lag of the two. Doing that requires that I have at least two IR LED's, and in the case that I want the cameras to fire in much faster sequence I'll need at least 3 IR LED's (and hope that I can trigger them as quick as I need with the Arduino).

The actual photographic part of this experiment is relatively simple, all I'll need is a similar focal length on each of the cameras which isn't difficult since they all use DX format sensors and it's safe to assume that we all have a lense which can match the same focal length on each camera. And suppose we're shooting at the equivelant sensitivity of iso 400 on each camera (since I doubt we all have prime 35mm lenses that are as fast as the one I've been using) with the same aperture, shutter speed (~1/500-640th) and white-balance we can achieve near identical exposures between the different cameras.

Tagged as: Arduino, ATmega168, DSLR, High-speed Photography, IR, Nikon, Remote No Comments

A Little Off Code, Computers, Photography and Guns

When it’s worth it to destroy something

Infrared Photos

High(ish)-speed Photography (followup)

High(ish)-speed Photography

QR Code

Blogroll

Comics

Info

Archives

Recommended Reading