Homemade Panoramic Head for Gigapixel Resolution Landscape Imaging

Gigapixel Panoramas

Gigapixel  images consist of  at least 1 billion pixels. That's  a huge number, and quite a bit more than the number of pixels on the sensor of your digital camera.

Making such images requires specialized hardware and an elaborate workflow. On this site I describe in detail  the hardware and the workflow.

The above view of the  Lake Starnberg area is only a small  section  of a Gigapixel panorama which can be viewed in detail here.

Most amazing about gigapixel panoramas is the fact that you can zoom in to a very high level of detail.

Below: different zoom levels showing  the city of Munich from the Herzogstand mountain (which is located at the northern edge of the bavarian alps).

See the zoomable Gigapixel panoramas  in my Gigapixel Gallery here and there.

DIY Panorama-Hardware  for Gigapixel Imaging

I started panorama photography with my first digital camera in 2003 . Soon I realized the limitations of hand-shot panoramas: Not only is it very tedious,  with longer focal lengths you can easily miss parts of the image, ending up with gaps in the panorama .  The way to go is a panoramic tripod head. Mostly those are manually operated, which is fine  for panoramas comprising up to 100 single shots.   If you want to shoot multi-row  gigapixel  panoramas (possibly comprising 1000s of single shots) you should seriously consider using an automated panoramic head. 

I built my first  simple RC-Servo-based platform  in 2008.  This panorama rig was controlled by  a Conrad C-Control board  and was pretty fast (about 4 seconds/image). However, it was mechanically not very robust. I had to account for this with very large  overlaps,  and  still sometimes mechanical problems resulted in missing columns in the panorama.

Looking for a more robust approach I bought an Orion/Merlin  tracking-mount, which quite a few  people also use for panorama imaging. This mount is rock-steady and can be remotely operated either from a mobile phone or from a netbook (bluetooth interface required). However, I soon realized that it has it's drawbacks:  hiking in the mountains I realized its heavy weight. And, since it was originally made for star tracking, its focus is on precision and not on speed. The best image acquisition  rate I could achieve was about 7 seconds/image.  The slow axis speed and acceleration do not seem to be an intrinsic necessity  though. Therefore  I tried to improve the speed by writing a custom control software. I gave up on this approach when I realized that the speed limitations are too deep within  the controller firmware.

So I started my next DIY project based on a stepper motor direct drive for the pan  axis. This design was basically working, however the stepper draws a lot of current,  and it cannot be turned off without losing position. Without microstepping position control was rather coarse.  The heavy weight stepper and the requirement for large battery packs made me rethink the concept once more.

This is why I returned to using RC-servos. They are simple to use,  consume  little power (=> very long battery life),   they are light-weight,  they  are self-locking (to some degree), and they move  fast.  At the same time I was playing with Arduino boards and I discovered Phil Warners Panoduino - an automated panoramic head based on an Arduino controller. Phil's design is based on servo gearboxes from ServoCity which provide the platform a high degree  of stability.  I adopted Phil's design in my setup, and was very happy with the servo driven pan-tilt platform. 

In my efforts to improve the workflow I  added high resolution (absolute) position encoders to the pan and tilt axis. When the shutter is released, the precise position (yaw and pitch angle) is registered and saved in a papywizard file.  Later on the PTGui stitching software can use this  information to  place the images at the correct 'initial position', providing a good base for stitching.

The 14-bit position information  from the rotary encoders can also be used for closed loop control of the RC-Servos. This  helps to improve the precision of the shoot positions. I detached the servo motors from their built-in controllers and attached them to an H-Bridge motor driver.  A PID-controller loop was added to the arduino code,  allowing for precise closed loop position control.

Recently I integrated all the electronics on a small custom-made PCB, comprising the arduino controller, the H-Bridge motor driver and the bluetooth communication.

On  this page you will find:

• Design files and software for building a professional  automated pan-tilt platform  that can be used for heavy gear (currently a Sony A7 R2, with a 400mm telephoto  lens)

• a comprehensive description of  my elaborate gigapixel acquisition and stitching workflow  (optimized for  landscape photography)

Panoduino Version #1 (based on an Arduino mega and a pololu maestro servo controller)

Inspired by Phil's Panoduino concept and by the  possibilities offered by my (then) new Thing-o-Matic 3D printer, I started the construction of my  own  Panoduino platform.

An  Arduino Mega 2560  is mainly used as a communications relay. It connects the bluetooth-to-serial module with the Pololu micro serial servo controller and it provides the remote shutter signal for operating my Canon Power Shot G9 (via USB - CHDK remote shutter). Actually, using the Mega2560 is overkill (a small Arduino Nano is powerful enough), but its comfortable as it fits the standard arduino shields. The system can easily be extended  - e.g.  with a motor controller, blue tooth,  encoders, camera  remote triggers.

My  panorama acquisition software PanoramaControl is written in C#. It features the selection of camera parameters (focal length etc.), number of rows/columns, navigation via mouse click, setting of start and end point. It sends commands (e.g. the raw commands for the pololu servo controller , or  command for the remote shutter) the arduino controller.  Communication between the netbook and the arduino is achieved via bluetooth - which is basically handled as a normal COM-Port.

With Panoduino #1 I use a Canon Powershot G9  with a 2x teleconverter. The remote shutter is operated via the cameras USB port. For this purpose the camera has to be run with CHDK (the Canon Hack Development Kit).

For panorama acquisition I use the Manual Mode of the camera. The focus is normally  adjusted manually to infinity (in this case I use only one trigger pulse  with a length of about 40 ms).

Another option is to use the manual mode and the with the safety focus enabled (in the cameras main menu). In this case the camera can adjust the focus within a small range around the manual setting. This requires two pulses - one for focusing and one for triggering the shutter.

• A minigorilla mobile power supply is light, has a high battery capacity of 9000 mAh, provides large enough currents 3A max. and displays the battery status.

• A UBEC (Battery Elimination Circuit) provides enough power (at 5V) for the servos (thus preventing jitter at large loads), and prevents unnecessary power consumption.

• The pololu micro maestro servo controller provides smooth (accelerated) servo motion, serial communication via one of the Arduino Megas UARTs.

• An accelerometer (LSM303) continuously measures the motion state of the platform. It is directly mounted on the camera support, thus sensing any motion, vibration etc. The sensor tells when the camera has completely finished the motion - only then the shutter is released. This is faster than fixed settling times.  So far I have achieved to  take about 40 to 45  images per minute, higher rates might well be feasible. Communication is via I2C.

• Bluetooth module: I use an extented range bluetooth module F2M03GXA (which I previously used on my quadcopter for telemetry purposes).  However, a standard  Arduino bluetooth shield should do equally well. Using the interface is simple: On the Arduinos side it is connected to a serial ports and the Netbook also sees  a serial port (which can easily be accessed from .NET programs).

• New camera: The Lumix FZ200 superzoom camera provides a (35 mm equiv. ) focal length of 600 mm (at f/2.8), and has 12fps (continuous shooting).

• Remote shutter control circuit:

  • For the Lumix FZ200 (and some other Lumixes) this works well:

  • http://www.robotroom.com/Macro-Photography-2.html

  • Instead of mechanical switches I use optocouplers as described here: http://authenticinvention.com/authentic/?p=69

  • If you want to use a Canon Powershot you can install the CHDK firmware (it is installed on  the SD-Card and thus considered to be reversible) and use the cameras USB-Port for triggering the shutter:

  • http://chdk.wikia.com/wiki/USB_Remote

• Control-Software  - new features: "Pause" - if somebody is walking by right in front of the camera, "one column back" to repeat the previous column.

The following photos  show the  outdated setup with the Canon Powershot G9, and a heavy NiMH battery pack.

The black plastic parts (right angle, end pieces, electronic box and the tripod adaptor) were printed with my Makerbot Thing-O-Matic 3D printer. Pretty robust ABS-Parts. An advantage of this design: after disassembling  the two legs of the angled platform the setup will fit into a small rucksack.

Panoduino Version #2  - with position encoders and  closed loop servo control (on the Arduino)

This new version of the hardware contains a lot of improvements:

• Closed Loop Servo position control using 14-bit rotary encoders

• Output of positional data (papywizard format) for use in PTGUI or Autopano Giga

• Added support for the Sony A7R II  full-frame mirrorless camera

• Camera mounted on an adjustable Macro Focusing Rail

• Open-source software for gigapixel panorama acquisition  -  PanoramaControl  https://github.com/TomNaiser/PanoramaControl/

• Arduino code driving the panorama hardware   -  PanoduinoControl  https://github.com/TomNaiser/PanoDuinoControl

• Electronics  cleanup  - everything is now  mounted on an integrated PCB  - github.com/TomNaiser/PanoBoard

Motorized Panorama head (Panoduino Version #2) in action

Parts List

• Angle Piece (3D printed)

• Terminal Block (2x) (3D printed)

• Aluminum Tube 12mmx225 mm (2x) - horizontal beams

• Aluminum Tube 12mmx198 mm (2x) - vertical beams

• ServoCity Top-Mount Servo Gearbox (5:1) (2x)

• RC-Servo HiTec HS-785HB (2x) - Hacked: control via external H-Bridge & PID position control  on Arduino

• Rotary Encoder AMS5048B (14 bit) on TSSOP-14 Board (2x) + adapter-boards for I2C cable connection

• Bubble Level

• Camera Mounting Plate

• Macro Focusing Rail (for adjustment of camera position)

• Tripod Adapter (3D printed)

• Controller Box (3D printed)

• Arduino Mega 2560 + Velleman Shield KA03 (Motor and Power)

• Various 3D printed parts for camera alignment,  vibration damping etc.

Alternative Approach for Building a Pan-/Tilt-Head

If you don't want to build the mechanics you possibly can use a commercial approach:

ServoCity is offering ready-made Pan&Tilt Kits. I have neither seen nor tested such a setup,  but I guess they should work fine.

You can add your own servo-controller and write a more  or less advanced software for panorama acquisition, or you can do that based on my controller hardware and software.   Of course you would have to do a few adaptions (e.g. disable the servos internal position control) to get the system running fine.

Depending on how precise the mechanics is, you possibly don't have to implement   an encoder-based  PID control. This will make things a lot easier.

Integrated PanoBoard Electronics

I must admit, the previous electronics was a mess. An Arduino Mega board with a Motor Shield on top,  voltage converters  boards, a long range bluetooth module, several small boards  (for remote shutter control) and a lot of wires. Everything in a box that was much larger than necessary.

Recently  I learned that AISLER  makes very affordable custom circuit boards for hobbyists, and so I created the PanoBoard, which integrates most of the above components on one board.

Features of the PanoBoard:

• Arduino Nano

• SparkFun BlueSMiRF Gold modem for wireless  communication with notebook

• Integrated H-Bridge motor driver

• Remote shutter for Sony A7r II  and Panasonic FZ200  (with some basics electronics knowledge you should be able to  extend this to other remote shutter capable cameras)

Eagle PCB Design Files

Design files (in Eagle format) can be downloaded from my PanoBoard Github repository: github.com/TomNaiser/PanoBoard

Soon to come: The latest version of the PanoBoard got more compact.

PanoramaControl - an Open-Source Software for Automated Acquisition of Gigapixel Panoramas

Above I have given a description of my motorized panorama head.  Just as important is the software!

Over the last ten years I have developed hardware and software in parallel. When I go to the mountains  for panorama photography,  I often return with new ideas to improve panorama acquisition and processing.

The source code of PanoramaControl can be downloaded from Github:  https://github.com/TomNaiser/PanoramaControl

Features

• PanoramaControl is tailored for ease of use, with a focus on the acquisition of gigapixel panoramas comprising thousands of single shots

• configuration of stitching parameters for various cameras and camera/lens-combinations (e.g. Sony A7 with various lenses, Lumix FZ200, Lumix FZ28)

• adjustable timing,  overlap parameters

• configuration (new cameras etc.) can be set in PanoControlConfig.xml

• enter start- and end-positions for panorama acquisition

• start/stop/pause acquisition

• timelapse mode

• recording of exact shoot positions (based on position encoder readings) for import to professional stitching software

• wireless communication with microcontroller-based panorama head

• can be extended to various acquisition modes (default: flat panorama for large gigapixel panoramas) . I didn't care much about spherical panoramas (not very well implemented yet), but a proper implementation shouldn't be too difficult.