The RTIViewer program shows the close-up of an ammonite fossil. The different colors represent the direction a particular point of the surface is pointing.

In this article I will describe how to construct a simple reflectance transformation imaging (RTI) setup using an Arduino microprocessor and a 3D printer.

Read articles from the magazine right here on Make:. Don't have a subscription yet? Get one today.
Read articles from the magazine right here on Make:. Don’t have a subscription yet? Get one today.

It can sometimes be difficult for a single photograph to adequately record and represent all of an object’s important detail. By using RTI photographic techniques, researchers are better able to enhance an object’s individual topography, texture, and color. Unlike one single photograph, an RTI photographic system may utilize numerous lighting angles to produce sequential images of the same object or artifact that may reveal obscured or hidden detail.

The RTI technique provides a valuable tool for scientists and conservators for the research and preservation of important historical fine art collections. RTI systems are also used in the area of forensic science to photographically record and analyze bullet or projectile striations. Additionally, RTI may be an extremely useful tool for imaging and analyzing pottery fragments, small archaeological tools, and stone artifacts. RTI applications are limitless, and they may provide key visual information for researchers in many investigative areas.

Botanical and zoological fossils also represent ideal subjects for RTI imaging as many of these ancient fossils have intricate shapes, repeating patterns, and interesting surface textures. Ammonite fossils in particular have ribbed, spiral-form shells. Ammonites were free-swimming mollusks found in our oceans, living about the same time as the dinosaurs.

Project Steps


RTI is a computational photographic method that collects between 40 and 100 images with light sources at different fixed locations. Once the software is able to deduce the location of the light sources, the resulting images can be used to create a mathematical 3D map of the surface.

Software can calculate surface normal vectors from the images. Subsequently, surface features can then be exaggerated to show the exquisite detail. The RTI technique is dependent on taking a number of images with light sources at fixed locations.

The process described in this article outlines a simple device that automatically collects reference images. The software has been developed by a number of researchers and is hosted by Cultural Heritage Imaging. Photographers, researches, and other interested parties are encouraged to read up on the technique. The construction and viewing of the RTI images is done with the RTI builder software maintained by the Cultural Heritage Institute and the resulting RTI file is viewed with their RTI viewer software.

Inside of the large sphere showing the 50 LED lights. Each light is a 10 mm supper bright LED and can be independently controlled by the Adruino Uno microprocessor.

The requirement of the light sources for the RTI image set is that they be about 50 in number and placed evenly on a half sphere.

One readily available dome was a simple lighting dome. In order to remove unwanted room light, I spray painted the inside black and then drilled 4 rows of holes evenly spaced from the horizontal. Each row holds 12 individual lights, which brings the total lights to 50 in number. Each hole was numbered to make the wiring easier. The large circular hole at the top of the dome is for the camera and was cut with a Dremel Drill. This technique easily removes the unwanted plastic and makes a smooth cut.

The lights are large 10mm white LEDs, which draw 80mA. These can easily be powered by the 5V DC supplied from the microprocessor. To control each LED, I used an LED light array manufactured by Adafruit Industries, which has the advantage of limiting the number of control wires needed to drive the 50 individual LEDs.

The placement of the camera on the first prototype Reflectance Transformation Imaging (RTI) sphere. The Adruino Uno microprocessor drives an array of LEDs. Each LED is independently controlled to take a set of 50 images that are in turn combined to an RTI file.

The wiring schematic is simple, but the execution is quite time consuming. It took about 12 hours to cut and solder all the contacts — this was slower than usual due to the Teflon coated wire, which was difficult to strip. Future systems will be assembled with a wire wrap tool, which is preferred for prototyping circuits.


The idea for the program is relatively simple too. Initially, an individual light is turned on, the camera shutter is triggered, and then the light turns off. The program sequentially repeats the cycle for all the remaining lights. The duration of the LED light is adjusted in the software. The prototype is designed for a 105mm macro lens and a Canon 5D Mark III DSLR camera body. In order to image at a low ISO and an adequate depth of field, the lights are programed to stay on for 5 seconds. This allows the full set of images to be collected in about 4 minutes.

The exposure can be optimized for the subject and increased if desired. If a large number of RTI image sets are being collected, the LED on time should be reduced to just slightly longer than the exposure time. To ensure repeatability and exposure efficiency, it is important that the LED illumination continues for the complete duration of the shutter exposure.


Because the Arduino microprocessor does not have 50 outputs to control the lights, the circuit has to use an LED lighting array. To control the array, the microprocessor talks to an LED array driver (board), which in this case is the Adafruit 16×8 LED Matrix Driver Backpack (HT16K33 Breakout). This board is currently available from Adafruit for about $8.00 USD. The communication protocol for this board is I2C that uses only 2 pins. So you may have up to 8 selectable I2C addresses for a total of 8 matrices, each one controlling 16×8 LEDs for 1024 total LEDs. This matrix driver and the microprocessor are both available at Adafruit Industries.


This board is designed to work specifically with the Arduino Uno microprocessor and an array of LED lights. After stringing long lines from each LED back to the array control, I soon discovered there is a shorter technique in which the LEDS in each row can be connected together on their ground side before returning to the array driver. This simplifies the wiring, but complicates how to visualize the circuit. This wiring set up can be seen as the blue wires on the prototype dome.

The camera is triggered by controlling pin 12 on the microprocessor. When this pin goes to 5 Vdc, the reed switch will trip the camera. The reed switch is used to isolate the camera trigger from any voltages generated by the microprocessor. This is a safety measure to ensure the camera is not exposed to dangerous voltages. The reed switch is also easy to wire and is very inexpensive. I have not included a schematic of a trigger system of the camera, since most are different.


The resulting image set is converted to JPG image format and run through the RTI builder software. The software is free to the public and easy-to-follow directions are available in PDF format on the Cultural Heritage Imaging web site. To view the resulting file, the RTI viewer program is used. This program is also available free of charge on the Cultural Heritage Imaging web site.

The RTIViewer program shows the close-up of an ammonite fossil. The specular highlights can be adjusted. The lighting angle is controlled by the position of the pointer in the green circle. Desired images can be exported in full resolution.


The creation of the dome presented a number of problems. To simplify the process and make the design available to researchers, I designed a 3D dome that can be printed in a tabletop 3D printer. The bed size of most 3D printers is limited, so this dome is designed for macro work. The holes are sized to be about the size of a 5mm LED. The holes will change diameter as the RTI dome is scaled for a particular printer. The holes can be considered as pilot holes and can be easily drilled to the desired diameter. This dome also includes an excess of holes, so that future systems can use sets of LEDs, each operating at a different wavelength.



// long lead on LED goes in A0-A15 holes.
#include “Adafruit_LEDBackpack.h”
#include “Adafruit_GFX.h”
Adafruit_8x16matrix matrix = Adafruit_8x16matrix();
#define BUSY_LED 13 // Board IO pin of Arduino ORANGE LED
#define CAMERA_CTL 12 // Board pin controlling the Camera Trigger
// active low.
#define LED_COUNT 50 // number of LEDs to sequence through
void setup() {
Serial.println(“RTI multi-spectral camera”);
matrix.begin(0x70); // pass in the I2C address
matrix.clear(); // clear all lights
// set the digital pin as output:
digitalWrite(CAMERA_CTL, HIGH); // active low
// set up Arduino LED as output
digitalWrite(CAMERA_CTL, HIGH); // active low
/* array indexes – insert LED with long lead on A line.
15 A15 * * * * * * * *
14 A14 * * * * * * * *
. * * * * * * * *
. * * * * * * * *
. * * * * * * * *
1 A1 * * * * * * * *
0 A0 * * * * * * * *
Y= C7 C6 C5 C4 C3 C2 C1 C0
X= 0 1 2 3 4 5 6 7
void loop() {
int x,y,count=0;
for(x=0;x<8;x++) // x’s are the C lines
for(y=0;y<11;y++) // y’s are the A lines { // toggle BUSY LED digitalWrite(BUSY_LED, HIGH); // ON // turn on one LED matrix.drawPixel(x, y, LED_ON); matrix.writeDisplay(); // write the changes we just made to the display delay(6000); // this delay determines the length the led is on // trigger the camera digitalWrite(CAMERA_CTL, LOW); // active low delay(50); digitalWrite(CAMERA_CTL, HIGH); // active low delay(50); // turn off the only LED on matrix.drawPixel(x, y, LED_OFF); matrix.writeDisplay(); // write the changes we just made to the display // delay while image stored on camera? delay(1000); // toggle BUSY LED digitalWrite(BUSY_LED, LOW); // OFF delay(100); // so we can see the OFF state // test for end of light count count++; if( count >= LED_COUNT) goto DONE;
Serial.println(“Camera sequence complete”);
while(1); // infinite loop- stop here


I hope that you find this RTI system an easy and elegant technique for collecting images for the RTI process. I would like to thank Andy Kinsman for his help with the design of the 3D dome file.

Download the 3D Dome

Download the Arduino uno code