JackBarker.com.au

Converting a spreadsheet into an interactive tree diagram

Sun, 09 Nov 2025 00:00:00 +0000

Background

A little while ago, I worked on a project that would let me create a tree diagram, based on the contents of an Excel file.

I wanted to build the diagram using an Excel file that I already had.

The Excel file looked like this:

Parent node	Child node
	Customer
Customer	Customer ID
Customer	Given name
Customer	Surname
Customer	Address
Address	Street Number
Address	Street Name
Address	State
Address	Suburb
Customer	Account
Account	Account ID
Account	Account Type

Here is my resultant D3.js Tree Diagram:

(Click on the “Address” node, and watch the diagram collapse)

I wanted to use Excel because this made for easy collaboration with other users (technical and non-technical).

Once all the data had been entered into Excel, anybody on the team could run the script, and produce the resultant diagram.

Solution

After a bunch of Googling (and visits to Stack Overflow), I finally cobbled together a quick VB script (inspired by Mike Bostok) that would accept my file and then output the necessary html and javascript.

Feel free to try it out yourself:

Complete workflow: CSV data → Cross-platform processing → Interactive tree visualizations

Photo Booth (Part 8): Post production

Wed, 18 Apr 2018 00:00:00 +0000

Post-production Overview

Before I get into the detail I’d just like to say a quick thank you to everyone who’s followed along with all the steps thus far. Also a thanks to those who waited so patiently for this post to come out.

It’s been a journey to get this working just right (so I hope you like it!).

Introducing: The “Photo Processing” application

In parts 1 through 7, we built a photo booth that is able to save photos and store them on the Raspberry Pi’s SD card.

In this, part 8, we’ll be looking to achieve the following:

Write a new “photo processing” application, that we can run alongside our “photo booth” application.
Our photo processing application will be configured to:
- improve image brightness,
- apply some image compression,
- create animated gifs,
- create a “photo strip” layout,
- (and if you’re keen to do some further coding, you can add even more functionality if you like) :wink:.
Upload our images to Dropbox.

Why a separate application?

I wanted a photo uploading solution that gives people the flexibility to choose how their photos get processed, published, shared;

Not everyone will want to publish their photo booth online.
Not everyone will want to publish their photos in the same way.

For this reason, my “photo publishing” is going to be a separate application which sits adjacent to the photo booth application.

The applications can either be run simultaneously (Photos will be captured, and uploaded, during the photo booth event), or at different times (i.e. “Photo booth” application can be run during a daytime event and the “Photo processing” application can be run afterwards). The latter option might be more suitable if you don’t have internet access available.

When the photo publishing application is running, it will routinely check our photo directory to determine if any new photos have been saved, and will then execute the applicable logic.

Installing and running the app

Step 1 : Install Pre-requisisites

Let’s install some additional apps onto our Raspberry Pi to help us with the tasks I’ve listed above.

1.1 : Installing ImageMagick

Imagemagick will help us fine tune our images (compression; brightness; layouts …etc.).

We install ImageMagick from our Rasberry Pi’s terminal with the following commands:

    sudo apt-get update
    sudo apt-get install imagemagick libmagickcore-dev libmagickwand-dev libmagic-dev build-essential -y
    cd
    wget https://www.imagemagick.org/download/ImageMagick.tar.gz
    tar xvzf ImageMagick.tar.gz
    cd ImageMagick-*
    ./configure
    make clean
    make
    sudo make install
    sudo ldconfig /usr/local/lib

We can confirm that the application installed correctly, by entering magick -version:

1.2 : Installing the Dropbox Python SDK

We’re also going to start interacting with Dropbox from within our Python application.

In order to do that we need to install the Dropbox Python SDK, also from the terminal:

    # This python library will help us upload our images to Dropbox:
    pip install dropbox

    # Or, if using Python 3 instead:
    python3 -m pip install dropbox

1.3 : Installing YAML parser

The configuration file for our application is written using the YAML language.

To assist Python in being able to interpret this file, we are also going to ensure that the our YAML-parsing library is installed:

    # This python library will help us read our config file (written in YAML)
    pip install ruamel.yaml

    # Or, if using Python 3 instead:
    python3 -m pip install ruamel.yaml

Step 2 : Installing the “Photo processing” application

As of version 3.0 of the Photo Booth (May 2018), the two applications (i.e. the ‘Photo Booth’ and the ‘Photo Processor’) are packaged together in the one download.

Step 3 : Run the application

    cd ~/photo-booth 
    python photo-processor.py

Notice that our application now appears to be watching for files:

Also notice that we now have a set of additional folders created in our project directory:

Step 4 : Testing the application

Now, as an experiment we can drop a set of 4 photos into /photos-IN:

Our application will start spitting out information to us:

Finally, if we check our /photos-DONE folder, we can see a number of things have happened to our photos:

Each of our 4 images has been reduced in file size. The files are now 1/4 their previous size, without a noticable drop in quality.
The 4 images have also each been “auto-levelled” to help optimise their brightness / contrast (Note: this may only be noticable in poor lighting conditions).
We now have an animated “thumbnail” image, which can great for posting on the web.
We have a couple of “photo strip” layouts (1x4) and (2x2); which may be useful if we want to print our images.

Nice one!

Step 5 : Configuring our application

A configuration file gets created the 1st time the application is run.

If we close our ‘photo processing’ application (via Ctrl + \) then we can have a look at the configuration file photo-processor-config.yaml.

All of the images that are output by the application can be enabled/disabled/customised, within this file:

    #photo-processor-config.yaml
    #---------------------------

    # Photo Processor Config:

    # Images to Output
    "OUTPUT_OPTIMISED_STILLS"    : True
    "OUTPUT_ANIMATED_THUMBNAILS" : True
    "OUTPUT_LAYOUTS"             : True

    # Directories
    "INPUT_DIRECTORY"      : "photos-IN"          # Files will be taken from here.
    "PROCESSING_DIRECTORY" : "photos-PROCESSING"  # Files will temporarily occupy this folder, whilst being processed.
    "OUTPUT_DIRECTORY"     : "photos-DONE"        # Files will be placed in this folder, once all processing is complete.

    # Image compression
    "IMAGE_QUALITY" : 90

    #Thumbnails config
    "THUMBNAILS_IMAGE_QUALITY" : 50
    "THUMBNAILS_SIZE"          : 50

    # List of print layouts to produce (1 column, 2 column)
    "LAYOUTS" :
    1:
        "TILE" : "1x"
        "SIZE" : "1920x1152"
        "MARGIN" : "20"
    2:
        "TILE" : "2x"
        "SIZE" : "1920x1152"
        "MARGIN" : "20"

    # Dropbox
    "DROPBOX_ENABLED" : False
    "DROPBOX_TOKEN"   : ""

Step 6 : Dropbox Integration

By default ‘Dropbox Upload’ is disabled.

In order to enable Dropbox uploads we need to do some additional setup which I’ve described below.

6.1 : Get a Dropbox Account

Dropbox is an online service which helps you to “store, share, and securely access files”.

If you don’t have a Dropbox Account, you can signup for a free account here (using this link will give you an extra 500Mb of storage space).

6.2 : Create a Dropbox App within the Developer page

After signing into your account, you need to navigate to the Developer section of the Dropbox website, and create an ‘Dropbox app’.

To do this:

Go to the Dropbox App Console page.

Click the “Create app” button:

Specify:

‘Dropbox API’
‘App folder’
A name for your app (pi-photo-booth or whatever else you would like to use :smile:)

Click “Create app”.

6.3 : Generate a API token

After recording the details of our “app” with Dropbox, we also need to create a “token”.

The token is similar to a password. It allows our Raspberry Pi’s Photo booth app to talk to the “app” we created within Dropbox.

To generate a token, we need to click the “Generate” button, per the illustration below:

Once the token is generated, you need to copy it…

An example. Not my real Dropbox token.

… and paste the token into our configuration file (photo-processor-config.yaml):

   
    # Dropbox
    "DROPBOX_ENABLED" : True
    "DROPBOX_TOKEN"   : "qwertyuiopAAA_This_Is_Not_My_Real_Token_But_You_Get_The_Idea_AAAplkdfnvlskdmf"

Save and close the configuration file.

6.4 : Test our changes

Start up the Photo Processor app again.

Copy a set of photos from the photos directory into the photos-IN directory.

Now watch as the photos also get uploaded to Dropbox.

Step 7 : Completing the file pipeline

By default:

Our photo booth application (camera.py) saves all the photos it captures into a folder called photos.
Our Photo Processor application (photo-processor.py) watches the folder called photos-IN.
We need to manually copy our photos from the photos into the photos-IN folder.

If we want this manual step to be performed automatically, then we will make one more change to our photo-booth configuration file (camera-config.yaml):

    # Additional location(s) where images will be saved to (optional):
    "COPY_IMAGES_TO" : ["photos-IN"]

Notice that the ‘#’ character has been removed, which preceeded “COPY_IMAGES_TO”.

This will cause our images to be copied into the photos-IN directory (in addition to saving the raw images into our photos directory).

Step 8 : Updating our “Auto-start” script to also include the Photo Processor application.

We can update our autostart script, as follows.

This will ensure that both applications start automatically when we booth the Pi.

(This is, of course, optional).

Update our a new text file;

sudo nano /etc/xdg/autostart/autostart_photo_processor.desktop

Populate the file with the following content:

[Desktop Entry]
Type=Application
Name=photo-processor.py
Comment=Raspberry Pi Photo Processor 
NoDisplay=true
Exec=sudo python /home/pi/photo-booth/photo-processor.py
NotShowIn=GNOME;KDE;XFCE;
Name[en_US]=photo-processor.py

Save and exit the file (Ctrl + X).

For more detail about autostart scripts, refer to the earlier discussion within part 6.

One of the great benefts of choosing Dropbox, is that is can be used in conjunction with ITTT. ITTT is a website that can be used to automate actions between different online platforms.

When a photo gets uploaded to Dropbox, when can use ITTT to trigger additional events such as:

We send a tweet on Twitter
We publish the photo on Tumbler
We share the photo on Facebook

ITTT is super easy to use and you don’t need to write any code. Instead, ITTT provides a set of simple screens that are built around the phrase “If this then that”.

As an example, lets get our photo booth to start integrating with Twitter:

Go to ITTT.com, and Login / Register for an account.
Start a New applet
Click on “If this”, to specify the condition under which our action will be triggered:

If 'this'...

Locate Dropbox:

Complete the steps of connecting your Dropbox account with ITTT:

Choose the trigger “New photo in your folder”

Note: There is a limitation here. ITTT will post a maximum of 15 images per polling period (~per hour).

Specify the Dropbox subfolder that ITTT will check for new images. This will be Apps\ + the name of your Dropbox app + \thumbnails:

Click on “Then that”, to specify the action to be performed:

Locate Twitter (or another service of your choosing), and complete the remaining details:

Photo Booth (Part 7): Photo Day!

Sat, 14 Oct 2017 00:00:00 +0000

My “Top 10 Tips” for ensuring your Photo Booth’s debut is stress-free

If you’ve done all your preparation correctly then hopefully you won’t need a too many tips for the day itself.

In any case, I’ve try to keep this post relatively light (partly because I really want to start writing “Part 8: Post-production”).

Anyhow - here goes:

1. Get heaps of light

As I’ve mentioned earlier, the LEDs on my photo booth did produce some light, but not enough for low light conditions. If you are taking photos in the evening or indoors then try and get every bit of lighting you can muster.

Some other things to consider;

If the venue has areas that are more well lit - then try and set up the booth in those areas.
Consider bringing along (or hiring) additional stage lighting if you think it may be necessary.

2. Backdrop

A backdrop can be as simple as a white tablecloth or curtain. This will really improve the quality of your photos.

Our venue was kind enough to help out with this, but your mileage may vary.

The next time I use my photo booth, I hope to definitely be more prepared in this area. Besides… after going to all the effort of building a photo booth from scratch, constructing a backdrop should be only a minor challenge… right? :smile:

3. Setting the Booth’s height

If your photo booth’s dimensions are similiar to that of mine you will need elevate it somehow.

You’ll need a bar stool, pedestal, or small table.

Do some investigation ahead of time to determine whether your venue can help out in this regard (or alternatively bring something with you).

4. Costumes and props

Costumes and props are what photo booths are all about!

Get some crazy wigs, glasses, hats. Pinterest can be great for providing inspiration!

5. Write a Check-list

If you’ve been reading along up to here, then you might have realised just how many things will need to be brought to the venue, and then set up on the day.

Additionally - if your situation is like mine - you may also have a number of other obligations on the day (i.e. getting married? :smile:).

In short: Write a check list. Don’t forget stuff!

6. Communicate your requirements with the venue

Our venues were all super helpful, but we needed to engage with them to make sure that they were “on board” with the plan.

Things to discuss with the venue:

When + what things be delivered to the venue?
What needs to be set up (also: at what time? by whom)?
What space will you be occupying?
Do you need access to power?
Where will the power leads run? Do they need to be taped down to ensure people can’t trip over them?
Who will be responsible for removing the photo booth after the event, and when?

7. Recruit some help

Recruiting someone to help with all of the above activities will be a huge help.

Make sure that they know the basics of how the booth works, and all the arrangements that have been made with the venue.

8. Plan and Rehearse

The last thing that you want to be dealing with at your photo booth’s debut are software and hardware bugs. Do a thorough round of testing, and then ask some other people to have a test run also. It’s always good to get some early feedback too.

You also want to be sure that everybody is aware of their responsibilities and any questions are resolved. If you have an opportunity to rehearse the setup - then go for it.

9. Deliver a sales pitch

If you’ve reached this point (built an amazingly awesome photo booth, kitted it out with props + backdrop, and recruited an army of helpers), then it would be a real shame if your guests forget to make use of it!

If your event has any speeches, or an event host, see if they can be persuaded to include a small “advertisement” for the photo booth.

You can also designate some official “wranglers” to encourage people to join in.

But honestly, the guests at my event seemed to need very little encouragement, because using the photo booth was a lot of fun.

10. Exit strategy

Finally!

The event is finished. All that is left is to clean up and make sure your photo booth gets home safely.

This step isn’t particularly difficult, but again, if you are relying on others to do this for you just make sure that they know what to do.

And another thing: Have fun!

Chances are that even with an airtight check-list, a rehearsed set of recruits, and a winning sales pitch… there will still be small things that can go wrong.

Here are just a few of the hiccups we faced on the day;

In transporting the photo booth to the venue, we forgot a number of props! Luckily this was solved with some quick phone calls to friends who were able to find some replacements at the last minute.
During our wedding we had a (very brief) power outage. Not only did we lose the photo booth; but our band’s music went silent and we were left only with candle-light! Luckily, a few moments later the power kicked back in and all was back to normal.

Even with these hiccups we had a fantastic fun-filled day (it was my wedding after all)!

I wish you guys all the best for your events.

If anyone else has any tips, feel free to share them below :smile:.

For the last article in this series, I’ll be talking about post-production tweaks you can make to your images, and how to convert your photos into a website.

Photo Booth (Part 6): Fine-tuning

Mon, 28 Aug 2017 00:00:00 +0000

Overview of Part 6

In part 6 of this series we’ll look at some additional improvements we can make for the photo booth.

Personalised images

The assets directory contains a number of images.

Directory contents: /photo-booth/assets

These images are used as the different “screens” within the photo booth application.

You can enhance the photo booth experience for your guests by personalising these images;

Automatically launching the Photo Booth app when the Pi starts

At the moment we need to start the Photo Booth script manually after powering on the Raspberry Pi. Ideally, however, the script should be run automatically as soon as the Pi starts up.

To fix this:

Create a new text file;

sudo nano /etc/xdg/autostart/autostart_photobooth.desktop

Populate the file with the following content:

[Desktop Entry]
Type=Application
Name=camera.py
Comment=Raspberry Pi Photo Booth 
NoDisplay=false
Exec=sudo python /home/pi/photo-booth/camera.py
NotShowIn=GNOME;KDE;XFCE;
Name[en_US]= camera.py

Save and exit the file (Ctrl + X).

Note: To later disable/re-enable this behaviour, you can simply move the file to a different location:

# Disable autostart, by moving the file into home directory instead
sudo mv /etc/xdg/autostart/autostart_photobooth.desktop ~/autostart_photobooth.desktop

# Re-enable autostart, by moving file back into autostart directory
sudo mv ~/autostart_photobooth.desktop /etc/xdg/autostart/autostart_photobooth.desktop

Optional Extras

Finally, here are some other ideas that you can add to your own photo booth.

(If you do implement any of these, be sure to let me know via the comments :smile: )

Real Time Clock (RTC) module

If your Pi photo booth has internet access, then the Pi’s clock will automatically be updated to the correct time upon connecting.

If you are planning to operate the photo booth without internet access, you should note that the clock of the Pi will be incorrect. The impact of this, is that the filenames given to your photos (which include a timestamp as part of the filename) will not be perfectly reliable.

You can choose to rectify this by installing a “Real-time clock” (RTC) module onto your Raspberry Pi. Typically, an RTC works by attaching a small battery to the Pi, which ensures that the clock remains powered after shut down.

You can pick-up this piece of hardware from a local electronic store, or online from your favourite electronics supplier.

Shutdown button

Turning off the Pi by simply cutting the power can have side effects, specifically: data loss. This is similar to removing a USB stick from your computer without using the “safely eject” menu.

If you find that any of your photos get “corrupted” (usually the last one the was saved), then installing a shutdown button is one method to correct this.

There are plenty of tutorials for doing this online and is a great feature to include.

My code actually includes an “Exit app” feature if you attach a button across GPIO pin 13 and ground (which can also be used to avoid corrupting images).

Saving photos to the cloud

Another method to prevent data loss is to backup your photos to the cloud.

Dropbox is a great (free) solution to this problem, and can be installed on a Raspberry Pi - albeit with some challenge.

We’ll be looking at this further in part 8, but there are some other ways to do this described here.

For the next article in this series, I’ll be talking about some tips for your photo booth’s debut, and ideally how to keep your big day “stress free”.

Subscribe to my blog to stay informed of my progress.

Photo Booth (Part 5): Writing the app

Wed, 12 Jul 2017 00:00:00 +0000

Overview of Part 5

Part 5 of this series is all about the code, and optimising the performance of our Pi.

Previous steps

If you’ve followed all the previous parts of this series, then so far, you’ll have:

A Raspberry Pi, running Raspian (or an OS of your choice, as described within Part 2)
The Pi will also be connected to following components;
- An arcade button, connected across GPIO21 and Ground.
- A camera module (i.e. PiCamera)
- An LED screen
(Presumably, all of these components will now all be housed in a photo booth enclosure also)

For the remaining steps we can either;

Connect a mouse and keyboard to the Pi, or
We can remotely connect to the Raspberry Pi (via the steps described in Part 2).

Connecting to the Pi remotely has the advantage of giving you a larger screen, and is the approach I would recommend.

Downloading the code

As we did in Part 2, open your terminal application on the Pi, and enter the following commands:

mkdir ~/photo-booth
git clone https://github.com/jibbius/raspberry_pi_photo_booth.git ~/photo-booth

The above will create a new directory (/home/pi/photo-booth/), and then download the Raspberry Pi Photo Booth code, for you to use.

Downloading the code with 'git clone'

Installing prerequisite packages

The code relies upon some additional Python libraries being downloaded also. We can download these from the terminal:

cd ~/photo-booth
python3 -m pip install -r requirements.txt

Getting the code to run

Now that the code has downloaded, we can open up Python and run the Photo Booth code.

One method of doing this, is opening the Applications menu, and selecting Programming then Python 3 (IDLE).

Note:

My code is also compatible with Python 2, but Python 3 is currently recommended.

Locating the Python 3 GUI in Raspian

Within the Python GUI, you can then the code we downloaded via File>Open.

Within /home/pi/photo-booth, locate and open camera.py:

We can then run the code via File>Run Module:

Examining the code

Looking under the hood

In case you are curious, why not have a look at the code within the python file camera.py? I’ll try to explain the various parts as they appear in the file.

We start off with the file header, which tells us that this is an app written in the Python programming language:

#!/bin/python

Then we have our import statements. These statements used to include some specific Python libraries into our app:

#Imports
import datetime
import os
from time import sleep
from PIL import Image
import picamera
import RPi.GPIO as GPIO

These libraries provide simple mechanisms for dealing with images, timestamps, the Pi’s GPIO pins, and other complex features. This means our code doesn’t need to consider all of the intricacies that are associated with such things, and that saves us a bunch of time.

Configurable options

Further down the file, are a set of variables that will be used by our code:

########################
### Variables Config ###
########################
pin_camera_btn = 21 # pin that the button is attached to
total_pics = 4      # number of pics to be taken
prep_delay = 4      # number of seconds as users prepare to have photo taken
photo_w = 1920      # take photos at this resolution
photo_h = 1152
screen_w = 800      # resolution of the photo booth display
screen_h = 480

Update (April 2018):

The photo booth is now version 2.
The Configurable options are now defined within config.yaml instead (otherwise, the behaviour is the same).

You can modify any of the values above to adjust the behaviour of the photo booth.

Additional configuration applies when initialising the camera:

#Setup Camera
camera = picamera.PiCamera()
camera.rotation = 270

Per the above, my camera is mounted with a rotation of 270°, but if your camera is mounted at a different angle then you will need to adjust this value.

The main loop

After defining our configuration options, there is a number of “helper functions” defined. It’s not super important to understand how these work.

Finally, the file defines the main function, which is effectively the “start” of the program.

The first bit loads up some “intro” images, which we alternate between whilst waiting for a user to push the button:

def main():
    """
    Main program loop
    """

    #Start Program
    print("Welcome to the photo booth!")
    print("Press the button to take a photo")

    #Start camera preview
    camera.start_preview(resolution=(screen_w, screen_h))

    #Display intro screen
    intro_image_1 = REAL_PATH + "/assets/intro_1.png"
    intro_image_2 = REAL_PATH + "/assets/intro_2.png"
    overlay_1 = overlay_image(intro_image_1, 0, 3)
    overlay_2 = overlay_image(intro_image_2, 0, 4)

    #Wait for someone to push the button

The logic for alternating between the images looks like this:

    #Amount of cycles to wait, when alternating between each frame
    blink_speed = 5

    #Use falling edge detection to see if button is pushed
    is_pressed = GPIO.wait_for_edge(pin_camera_btn, GPIO.FALLING, timeout=100)

    #Stay inside loop, until button is pressed
    if is_pressed is None:
        
        i = i+1

        #After every 5 cycles, alternate the overlay
        if i==blink_speed:
            overlay_2.alpha = 255 #make the top image fully visible
        elif i==(2*blink_speed):
            overlay_2.alpha = 0 #make the top image fully transparent
            i=0
        
        #Regardless of what happens above...
        #...restart the loop, and wait for the button to be pressed;
        continue

Once the button is pressed, we:

Generate a filename for our images (which is based on the current date + time).
We are going to take 4 photos, and for each photo there is a “prep for photo” screen.
Taking all four photos, we display a “playback” animation, of each photo.
After the playback animation, the app restarts at the beginning (waiting for the button to be pressed again)

    #Button has been pressed!
    filename_prefix = get_base_filename_for_images()

    for photo_number in range(1, total_pics + 1):
        prep_for_photo_screen(photo_number)
        taking_photo(photo_number, filename_prefix)

    #thanks for playing
    playback_screen(filename_prefix)

Further analysis

The photo booth app has more lines of code than makes sense to explore within this blog post. However, if you’ve followed along this far, feel free to explore these functions further.

(And if you’re feeling super excited, perhaps you might even want to code up some additional features of your own?).

For the next article in this series, I’ll be talking about further optimisations to our Photo Booth’s software, namely:

Replacing the app’s stock images with your own custom ones,
Running the photo booth code as soon as the Pi starts up.

Subscribe to my blog to stay informed of my progress.

Photo Booth (Part 4): Wiring up the Circuit

Thu, 22 Jun 2017 00:00:00 +0000

Overview of Part 4

Part 4 describes:

The steps I took in attaching a 12v LED strip to my photo booth.
How to wire the photo booth

Tools and Materials

We will need the following parts and tools (in addition to the photo booth cabinet that we built earlier):

Required Parts

LED strip lights
- I am using (warm) white colour LEDS.
- If you are using RGB LEDs (i.e. capable of multiple colours) this will require more complex installation
Power supply for the strip lights
(needs to to supply 12 volt and support up to 2 amps)
Hookup wire
Heat shrink tubing

Required Tools

Drill
Soldering iron (and Solder)
Side cutters or Scissors
Wire strippers

Optional Parts/Tools

Multimeter
Alligator clips / wires
Pair of barrel connectors (these came with my lights, but are optional.
Helping hands
Wood clamps
Wood glue

Parts and Tools for this step

The Lights

Intro to LED strips

If you have never worked with LED strip lights before, they are really quite an interesting component. The LED strips come in various flavours (RGB or White; Waterproof or Otherwise; …etc.), densities, levels of brightness, and levels of quality.

Common to all LED strips are dotted line markings which will occur at various intervals, indicating where you are able to cut the strip. You must only cut the strip along the dotted lines.

Measure the width of the photo booth, and cut the strip at the appropriate length.

The dotted lines indicate where you can cut the strip into smaller segments.

Checking the electrical resistance of the LED strip

LEDs have a very low resistance - and as a rule, you should never connect an LED directly to a power supply without the inclusion of a resistor within the circuit.

However - most LED strips will already include the necessary resistors as part of the strip, which means you don’t have to worry.

We can check for the presence of such resistors by attaching the LEDs to a multimeter in resistance mode (Ω).

A quick LED test

You should always get in the habit of testing your circuits early.

In this case, we should test that our LED strip lights up when connected to power. This will also allow you to determine the lights’ brightness, which may influence your design.

If your lights don’t illuminate, check that you have the +ve and -ve connected to the correct terminals.

Preparing the mounting position for the lights

Based on the brightness of my lights, I was keen to ensure that the LED Lights would deflect off my wooden “flash diffuser” rather than being pointed directly at the user of the photo booth.

Regardless of your decision in this regard, you will need to drill a hole that will allow your hookup wires to connect up with the rest of the circuit.

The mounting position for the lights.

Attaching some hookup wires

Attach some hookup wires to your LED strip. For obvious reasons, you want to attach these hookup wires before the LEDs are mounted on the booth.

I’ve used a barrel connector, as this means I can easily detach and re-attach the lights from the rest of the circuit. We don’t want to solder directly to the power supply yet, as this will make it hard to

When soldering:

Give your iron a few minutes to heat up to temperature.
A “helping hands” tool might make it easier to keep your components under control.
Using different colour wires will make it easier to remember which terminal is positive, and which is negative.

Mounting the LEDs to the booth

This step should be relatively simple.

Decide upon the exact position for the lights
Ensure that the hookup wires are able to pass through the hole that we drilled earlier.
Remove the sticky adhesive from the back of the light strip, and attach to the booth.

Close up of the mounted lights (and flash diffuser).

My light strip refused to stay flat against the booth, particularly where the hookup wires were attached. I fixed this with some wood glue, and clamping the stubborn section until the glue dried.

Wiring the Booth

Version 1: The “Power Board Method”

For the first version, I relied on multiple power adapters to provide each of the different voltages required by the circuit.

Note that (in my photo booth) the LEDs in both the arcade button & and LED strip include resistors which allow them to safely operate at 12v (your parts may vary).

Photo booth: Wiring diagram.

Rigged up in the wooden cabinet, the circuit looks like this:

Finished product

Version 2: A Single Power Source

The circuit design can be improved so as to include only one power source.

In a future post I intend to document this further.

For the next article in this series, I’ll be talking about writing the code that will run on our photo booth.

Subscribe to my blog to stay informed of my progress.

Photo Booth (Part 3): Building the Booth

Tue, 16 May 2017 00:00:00 +0000

Overview of Part 3

Part 3 describes the steps I took in making the wooden cabinet for my Photo Booth.

If you already have a cabinet for you photo booth (perhaps a converted wooden winebox?), then feel free to skip ahead to the next post. Otherwise, read on.

I should probably also caveat this post with the fact that I am not a master carpenter. That said, it’s a skill I am presently looking to develop. I may have more updates to this post in future.

I should also note that the cabinet I made was quite large (far larger than is necessitated by the electronic components). I chose to build the photo booth at this size, because I wanted people to see it and interact with it.

Tools and Materials

Required Materials

We need all of the following parts (discussed previously) on hand, because we’ll have to cut holes in the cabinet for each:
- LED screen,
- Arcade button,
- The PiCamera.
Wood;
more specifically, I used:
- A hard plywood for the base
- Some additional plywood for support struts
- A thin plywood laminate for the sides
- Note that My photo booth doesn’t have a lid or back.
  This is something that you may wish to include, however.
Wood screws,
Double-sided tape.

Required Tools

The required tools are pretty basic:

Power drill, with:
- Some standard drill bits of various sizes (for pre-drilling for your screws, starting your interior cuts)
- A “spade” drill bit (cutting the hole for the Arcade button)
A screwdriver,
A hand saw (or power tool equivalent),
A saw for making interior cuts
i.e.
- A jigsaw, or
- A fretsaw, or
- A (possibly) coping saw (provided you have enough clearance between the frame and blade)
A wood file(s),
A pencil,
A tape measure,
A framing square.

I picked up all of the above from the local hardware store.

Optional Parts/Tools

Metal brackets (I used these in my build, but are optional),
Wood glue
A vice (to help with sawing / glueing),
Clamps (to help with glueing).
Sandpaper and paint might also go a long way in finishing your booth.

Parts and Tools for this step

Wood

Hand saw

LED screen

Arcade button

PiCamera v2

Wood Glue

Double-sided tape

Power drill

Drill bits

Spade bit

Jig saw

Wood file

Screwdriver

Build Steps

The Base

I cut the base into shape, and added support struts on either side.

Note:

A third support strut will be required for the top of the photo booth, and
A fourth (all the same size) will be used to form the flash diffuser.

(It may be worthwhile to cut all these pieces at the same time).

Measure Once

If you look closely you can see the pencil lines that I have ruled to help determine where to place the screws. You should also pre-drill your holes to prevent the wood from splitting. Plywood is generally pretty good in this regard (i.e. better than MDF), but better to be safe than sorry.

The base section of the photo booth.

The base of the photo booth is pretty sturdy and heavy (in comparison to the sides). This definitely worked in my favour, as it kept the centre of gravity low. When we later add the screen and button to the front of the booth, we won’t be so worried about it being tipped over.

The above could be improved by countersinking the screws, but I’ll leave that decision up to you.

The Left and Right Side Walls

The side walls are cut, drilled, and attached to the base. Note that when pre-drilling your holes, you will want to leave plenty of space to attach your brackets (i.e. if you are following my exact design).

The metal brackets are, of course, optional.

The photo booth side walls.

The Brass Backets

If you follow the screenshots below, closely, you’ll note that I’ve been attaching some brass brackets to the build.

This improved the look and stability substantially.

There are six in total:

Two at the base,
Two at the top,
Two to attach the flash diffuser.

The Front Panel

Ugh.

This was, without a doubt, the most painful part of the cabinet.

The cut-out for the screen

My suggestions are as follows;

Trace the outline of the LED screen onto a piece of paper.
Cut out the shape which you drew onto the paper, and position it onto the piece of wood that shall be the front of the photo booth.
Try and center the piece of paper, exactly where the screen will be set

Ensure to keep;

Sufficient room above the screen to mount the camera, and
Sufficient room below to place the arcade button.

Once you have determined the correct position for the screen with the paper guide, trace the shape onto the wood to be cut out.

Cutting the hole for the LED screen.

In the above screenshot I have already attached the front panel, but I would strongly recommend keeping the front panel detached, while drilling and cutting the required holes.

Once the shape has been sketched onto the panel, drill some holes to help you insert your saw of choice (i.e. a jigsaw), and complete the cut.

Check to see if the screen fits, by holding it up against the hole.

In my case, the hole was slightly too small.

I spent the next hour with a wood file, gradually increasing the size of the hole, until it fit exactly. The process was time consuming, however the end result was a perfect fit.

LED screen. Fits like a glove.

Drilling the Holes for the Button and Camera

I don’t have detailed instructions for this part, but essentially you just need to drill the holes for each component.

The button includes a threaded shaft, and plastic nut. It affixes to the front panel pretty easily.

Finished front panel. Getting ready to attach the LED lights
(the lights will get discussed in a future post).

The camera needs to be attached to the back of the panel, to line up with the hole you have drilled.

I managed to 3D print a small part that helped with this. This isn’t entirely necessary however, as I am sure you can come up with other methods for attaching this.

I’ve also attached my Raspberry Pi (inside it’s case) to the back of this panel, using double-sided tape.

Back of the cabinet
(I'll explain the lights and wiring shortly).

The Flash Diffuser

The final piece of wood that I cut was a “flash diffuser” (I will be discussing the LEDs in detail later).

However, when I was installing the lights, I found that “direct light” off of the LEDs felt a bit unpleasant.

By “hacking” a grooved angle into an additional piece of wood (off which the light would then bounce), the comfort was improved substantially.

Close up of the flash diffuser.

This completes the woodwork section of the build.

For the next article in this series, I’ll be talking about mounting the LED lights and connecting up the circuits.

Photo Booth (Part 2): Getting started with Pi and PiCamera

Mon, 08 May 2017 00:00:00 +0000

Overview of Part 2

Before providing a full set of components and plans for the Photo Booth, I’d recommend breadboarding out a simple version to get you started.

If you want to skip that step, then feel free to jump ahead.

Getting Started with Pi and PiCamera

To start breadboarding out the photo booth, you will need:

A Raspberry Pi
- I am using version 3 of the Raspberry Pi
- I have also tested my code against;
  - Pi version 4 (works fine)
  - Pi version 2B (works fine)
  - Pi zero (works fine)
An SD card
- I am using a 16Gb card, smaller cards will also work.
A Pi Camera
- I am using PiCamera version 2
- The earlier version of the camera will also be fine (although fewer megapixels)
- The Pi “High Quality” camera will also work.
  - For a photo booth using the HQ camera, you should use the 6mm (wide angle) lens.
  - It might be tempting to use the 16mm (Telephoto) lens, but your photos will be “too zoomed in” to photograph a group of people.
An LCD screen, such as: the XPT2046
To power the screen, you will also need:
- a spare USB phone charger, and
- a spare micro USB cable
Jumper wires
- Get a mix of M-M, M-F, and F-F
A momentary push button
- Later on in the project, we will use a large arcade button w/ LED
- If you don’t have this right now, then you can proceed with a simple momentary switch button, or by just connecting and disconnecting a wire within the circuit
A breadboard
A keyboard you can borrow, and connect up to the Pi.
Optional materials:
- A raspberry Pi breakout breadboard
  (you will see that I was using this in a couple of the images below; but, for this project it’s overkill and really not required)

Preparing your Pi

Installing the Operating System

For prototyping, I am running:

Raspberry Pi OS Legacy (Buster)

Currently, we cannot use the latest version of Pi OS. This is because a number of changes were made to the handling of cameras in the latest version of Pi OS (Bullseye). In future, I will update my code to work with the latest Pi OS, once the relevant Python code libraries (i.e. PiCamera2) are available.**

To install the Pi OS onto an SD card, you will need to download the Raspberry Pi Imager

For additional support in flashing Pi OS to an SD card, refer: Pi Software Guide that will help you in completing this step.

Installing Raspberry Pi OS Legacy (Buster)

Alternatives

Using Raspian, the boot time for the Photo Booth is roughly 40 seconds, and (for me) I was content enough with this duration that I haven’t looked too far into alternatives at this stage.

If you want the booth to boot faster, then you may want to look at running a more light-weight OS. This is not a topic that I intend to cover right now, but I may cover this later after testing a few different options out.

Raspberry Pi Configuration

If you haven’t already done so, make sure you’ve got a keyboard and mouse plugged in to your Pi, and that the Pi is hooked up to a screen (which can even be the photo booth’s LCD screen if you like).

We are going need to change a number of configuration options, in order to get the most out of out Pi.

You can do this via the Raspbian application menu, selecting: Preferences > Raspberry Pi Configuration.

Alternatively, you can access a similar set of options via the command line (using sudo raspi-config).

Within System;
- Make sure you click Change password
  (Even though “it’s only a Pi”, it’s never a good idea to keep using the default password raspberry).

Within Interfaces;
- You must enable ‘Camera’.
- Other useful options to enable here are:
  - ‘VNC’, which lets you remotely connect to the Pi from another computer (after downloading the RealVNC Viewer client application, onto another computer).
  - ‘SSH’, which allows you to connect remotely to the pi via an SSH terminal. This is an option for advanced users, and not required for this tutorial.

Within Localisation;
- By default, your Pi is probably configured to use a UK Keyboard.
- If your keyboard doesn’t have a pound key (£) on it, then you probably need to switch to a US keyboard (or whichever keyboard is appropriate to you).
- It’s also worth changing your Locale, Timezone, and WiFi country while here.

Click OK, to save.

After saving all of these options, you should restart the Pi to ensure that the changes take effect.

Connecting to WiFi

If you haven’t already done so, you’ll now want to connect your Pi to WiFi.

If you are using Raspbian this is relatively straightforward (just click the wireless networking logo in the top right of the screen, and setup the network).

Once you’ve connected up to WiFi, it is also possible to connect to the Pi from another computer via VNC or SSH. We’ll get to this step later on.

Connecting the LCD Screen

If you haven’t already done so, connect the Pi to the LCD screen that we will be using as the screen for the Photo Booth.

My screen connected to the Pi via an HDMI cable.

The screen also requires a separate power source (until I get around to tidying that up). The easiest way to do this is a via a spare USB phone charger and micro-USB cable.

When I first connected the screen, the display settings weren’t 100% correct, but we can fix that now.

Open up the Terminal, we are going to enter the following command:

sudo nano /boot/config.txt
#Note: You will be prompted to enter your password

We can then edit the config file, and we’ll need to add the following lines of code to the end of the file;

hdmi_force_hotplug=1
start_x=1
disable_camera_led=1
gpu_mem=128
hdmi_group=2
hdmi_mode=87
hdmi_cvt=800 480 60 6 0 0 0

The impact of these changes is as follows;

hdmi_force_hotplug=1
- This forces the Pi to use HDMI mode, even if an HDMI cable is not detected.
start_x=1
- This enables the camera module.
disable_camera_led=1
- This disables the camera LED, which usually comes on when the camera is in use.
gpu_mem=128
- This allocates us some memory to use the camera.
hdmi_group=2
- This allows us to use DMT display formats.
hdmi_mode=87
- This allows us to specify custom display settings.
hdmi_cvt=800 480 60 6 0 0 0
- These are the display settings for our screen: (i.e. 800x480 pixels, 60Hz, 15:9 ratio, no margins, progressive interlace, normal)

To exit the file press CTRL + X; and then specifying Y to save changes.

After making these changes, you should reboot the Pi.

If you’ve made a mistake whilst changing any of these settings, you can boot the Pi in recovery mode (hold the right SHIFT key), and then edit the config file (e).

Connecting the Camera

If you’ve gone with a PiCamera per my recommendation then installation is straight-forward (although perhaps a bit fiddly). The camera will connect to your Pi via a Ribbon Connector.

I’d recommend looking up a YouTube video for how to connect your Pi to the camera. It is different for each version of the Pi, and the latch mechanisms can be a bit fragile if forced in the wrong manner.

A Test Run of the Camera

Connecting to the Pi from another computer

Because we will be using the LCD screen to display the camera’s output, and we still want to be able to enter commands at the same time, it is best to connect to the Pi from another computer (using VNC Viewer or SSH).

The easier option for beginners is using the VNC Viewer. There are instructions to help you do this, here.

Once we are connected to the Pi remotely, we can familiarise ourselves with the PyCamera library.

Begin by opening Terminal or UXTerm on the Pi. You will be greeted with a command prompt.

From here, we can access the python interpreter by typing python.

Camera test via Python interpreter

Within the interpreter, enter the following commands:

import picamera
camera = picamera.PiCamera()
camera.start_preview()

The camera will now be displaying your picture on the screen that is connected to the Pi.

(Note, if you ignored my suggestion to connect to the Pi from another computer, you can close the app by typing ctrl + \).

Flip and Rotate the camera

You may need to flip and/or rotate the picture, such that it suits the angle your camera has been mounted at.

camera.hflip = True
camera.rotation = 90

Save a photo

Enter a couple more commands into the terminal, to save a photo:

filename = '~\my_test_photo.jpg'
camera.capture(filename)

Exit the python interpreter:

exit()

You can now see that the photo has been saved to the Pi.

ls ~

Connecting up the button

Now that we have a basic understanding of how our PiCamera will work, it is time to connect our button.

Shutdown the Pi:

sudo shutdown now

Disconnect the power supply.

The button needs to connect to GPIO21 and Ground.

Once the button is attached we can safely boot up the Pi again.

Connect your button to the Pi, as follows:

Photo booth: Wiring diagram.

Running a “Test app”

Once the button is connected we can run a simplified version of our photo booth code.

This piece of code doesn’t have the full functionality of my finished photo booth, but it contains “just enough” to test out the functionality that we care about and get an idea of how the finished code might look.

The code we are going to run is shown here:

Boot up your Raspberry Pi again.

You can then either;

Copy the code into a text file (simple-photo-booth.py) manually, or
Enter the following at the command line on the Pi to download it:

mkdir ~/simple-photo-booth
git clone https://gist.github.com/8105081adfc0d6dd7da77cd813c69593.git ~/simple-photo-booth

Run the code via:

cd ~/simple-photo-booth
python simple-photo-booth.py

Press the button to test the code.

Testing the photo booth components

To exit the simple photo booth app, press ctrl + c.

For the next article in this series, I’ll be talking about building the wood cabinet that houses the photo booth.

If you’d prefer to skip that step, you can jump ahead to Part 5, where we extend our “simple photo booth” code into a Fully-featured Photo Booth app.

Photo Booth (Part 1): Requirements

Mon, 01 May 2017 00:00:00 +0000

Step 1 : Listing out the requirements

Before we go into the specifics of how I built my Photo Booth, you should begin to think about the features and constraints affecting your (potential) photo booth.

“Requirements?!
…typical bleeping Business Analyst!”

Make sure you are clear of your photo booth's requirements, before delving too far into the design.

How will the booth be powered?

For the photo booth I built, I needed the following;

a 5 volt power supply (for the Pi), and
a USB phone charger (also delivering 5 volt) for the screen, and
a 12 volt power supply (for the LED lights)

To achieve this, I:

included a small power board inside the photo booth cabinet, and ran an extension lead to the nearest power point.
attached each of the required power supplies to the power board.

An assumption that I was making, was that the booth would be powered from a power point. If you don’t want your booth to depend on power point access, then you will need a different solution.

In a future build, I will look to tidy up the power supplies, and the possibility of running off a battery.

How much light will you need?

My wedding tested both of these scenarios:

Outdoors, on a relatively sunny day. (Photos came out great!)
Indoors, function venue, at night. (Camera struggled)

Here are some things to consider:

I had added some 12v Ultra-Bright LEDs, and a custom “flash diffuser” to my photo booth.
This really didn’t produce enough light (more on that later).
I was able to remedy the situation by “touching up” the photos later (adjusting the brightness + contrast levels…etc).
If I had my time again, I would rig up some free-standing external lights. I expect this would have made a substantial improvement to the night-time photos.
It is also possible to adjust the “exposure settings” within the PiCamera code library, which might also help.

Internet access?

Internet access will help you for two reasons:

It will allow you to share (and backup) your photos - immediately
It will provide access to a real time clock

Options available to you might differ based on which version of the Pi you are using:

The Raspberry Pi 2 will allow you to connect a wireless internet dongle (or via an Ethernet cable).
The Raspberry Pi 3 comes with wireless internet out of the box (no adapter required).

If you choose to go without internet connectivity, then I highly recommend getting a RTC (Real Time Clock) module. This means that you will be able to record the date + time that each photo was taken. If the Photo Booth needs to be restarted for any reason, then this will be especially useful.

By default, photos will get written to your SD card, and you can distribute them after the event.

Some other options to consider;

Upload to Dropbox (internet access required)
Upload to Website (GitHub Pages)
- (This is how I distributed my photos).
Upload to Tumbler / Google Photos / Similar service
Printer
Email

What will the booth be made out of?

I made my photo booth out of wood from the local hardware store. That said, you might have a wooden box or crate that could easily be converted into a photo booth.

For the next article in this series, I’ll be talking about Getting started with the Raspberry Pi, and the other components that will form the photo booth.

Subscribe to my blog to stay informed of my progress.

How to build a Photo Booth

Mon, 01 May 2017 00:00:00 +0000

My DIY Photo Booth

The Finished Product

Weddings, Parties, Anything: My kickass photo booth!

Back story

Last weekend, I had an absolute blast at my wedding.

So too, apparently, did my guests - who absolutely loved taking shots with the photo booth!

Photo credit: Jonathan Lang Photography.

Where can I see the code?

The code for my photo booth is available here:

https://github.com/jibbius/raspberry_pi_photo_booth

What makes this DIY photo booth special?

My photo booth is unique for the following reasons;

It was the 1st project I ever built with a Raspberry Pi, and it’s a great starting point for beginners.
It takes a “less is more” approach;
- I opted to exclude features that weren’t essential.
- The code runs on both Python 2.7 and Python 3.
- The code introduces very few libraries/dependencies, in the hopes of delivering a solution that “just works”.

Publicity

Since writing about my photo booth, it’s been featured in the following publications:

DIYODE, #1

The MagPi, #60

Thanks to all the above for their support.

Acknowledgements

I’d also like to thank the following;

The Ballarat Hackerspace (an awesome community) for their ideas and assistance.
DrumminHands’ Photo Booth which provided inspiration for parts of this build.

Remixes

I love hearing from people that have built their own “photo booth” versions;

Eric built this brilliant photo booth. His version includes an impressive-looking marquee, a video light, and it writes the photos to a USB stick (if connected).

Have you built a photo booth too?

If so, I’d love to hear from you!

My email address is in the footer.

For the next article in this series, I’ll be talking about the requirements process that I went through when planning my photo booth.

Subscribe to my blog to stay informed of my progress.

JackBarker.com.au

Converting a spreadsheet into an interactive tree diagram

Background

Solution

Photo Booth (Part 8): Post production

Post-production Overview

Introducing: The “Photo Processing” application

Why a separate application?

Installing and running the app

Step 1 : Install Pre-requisisites

1.1 : Installing ImageMagick

1.2 : Installing the Dropbox Python SDK

1.3 : Installing YAML parser

Step 2 : Installing the “Photo processing” application

Step 3 : Run the application

Step 4 : Testing the application

Step 5 : Configuring our application

Step 6 : Dropbox Integration

6.1 : Get a Dropbox Account

6.2 : Create a Dropbox App within the Developer page

6.3 : Generate a API token

6.4 : Test our changes

Step 7 : Completing the file pipeline

Step 8 : Updating our “Auto-start” script to also include the Photo Processor application.

Step 9 (BONUS): Automatically posting images to social media and other sites

Photo Booth (Part 7): Photo Day!

My “Top 10 Tips” for ensuring your Photo Booth’s debut is stress-free

1. Get heaps of light

2. Backdrop

3. Setting the Booth’s height

4. Costumes and props

5. Write a Check-list

6. Communicate your requirements with the venue

7. Recruit some help

8. Plan and Rehearse

9. Deliver a sales pitch

10. Exit strategy

And another thing: Have fun!

Next article

Photo Booth (Part 6): Fine-tuning

Overview of Part 6

Personalised images

Automatically launching the Photo Booth app when the Pi starts

Optional Extras

Real Time Clock (RTC) module

Shutdown button

Saving photos to the cloud

Next article

Photo Booth (Part 5): Writing the app

Overview of Part 5

Previous steps

Downloading the code

Installing prerequisite packages

Getting the code to run

Examining the code

Looking under the hood

Configurable options

The main loop

Further analysis

Next article

Photo Booth (Part 4): Wiring up the Circuit

Overview of Part 4

Tools and Materials

Required Parts

Required Tools

Optional Parts/Tools

The Lights

Intro to LED strips

Checking the electrical resistance of the LED strip

A quick LED test

Preparing the mounting position for the lights

Attaching some hookup wires

Mounting the LEDs to the booth

Wiring the Booth

Version 1: The “Power Board Method”

Version 2: A Single Power Source

Next article

Photo Booth (Part 3): Building the Booth

Overview of Part 3

Tools and Materials