KeyboardInterrupt Handling with picamera

Question

So I have a python program in which I'm using the picamera library to shoot pictures and record video. I'm using my program for scientific purposes and my goal is keep each picture as close to the previous picture as possible, both visually and in file size (post & pre-processing). I'm aware that I most likely should be creating YUV images or getting the Bayer data, but JPEGs allow me to visually inspect the images easily and I want to see if they will be good enough.

So what I am doing is similar to both this recipe and this question. In that I'm trying to keep all picamera parameters held constant: resolution, no denoise, LED off, shutter speed, iso and AWB. The issue is that I create a new PiCamera() instance everytime I call my take_picture() function. So what I believe it happening is in the time from when I create the camera instance to when I turn off exposure_mode the digital_gain and analog_gain could settle on different values based on light conditions. This could skew the results of my tests.

So what I believe I'll do is make my camera module a class and create the PiCamera() instance in init so that it is persistent through program scope and all parameters are held constant. The question I have is that I usually exit my program by pressing CTRL+C, A.K.A. raising a KeyboardInterrupt. If I do this will the camera instance never call close() and be left in a weird state?

Answer 1

If you're trying to shoot absolutely consistent pictures the one thing you can't do is re-initialize the camera between each shot. The reason is that the camera firmware provides no means of setting the camera's gains; all it provides is the ability to fix them at their current values (or let them float according to the results of the AGC process).

So, I'd recommend doing as the recipe suggests and set up the camera, then capture several images without re-initializing it. The recipe demonstrates one method of doing that with the capture_sequence method, but you could simply use capture instead, and even do that within your take_picture function. For example:

import time
import picamera

def take_picture(cam, filename):
    cam.capture(filename)

with picamera.PiCamera() as camera:
    camera.resolution = (1280, 720)
    camera.framerate = 30
    # Wait for analog gain to settle on a higher value than 1
    while camera.analog_gain <= 1:
        time.sleep(0.1)
    # Now fix the values
    camera.shutter_speed = camera.exposure_speed
    camera.exposure_mode = 'off'
    g = camera.awb_gains
    camera.awb_mode = 'off'
    camera.awb_gains = g
    # Finally, take several photos with the fixed settings
    take_picture(camera, '1.jpg')
    take_picture(camera, '2.jpg')
    take_picture(camera, '3.jpg')
    take_picture(camera, '4.jpg')

No need to be messing around with signal handlers here! In the code above there's no need to explicitly call close on the camera as it'll be called implicitly when the with block exits (even in response to KeyboardInterrupt). Generally speaking, there's very rarely a need to call close. It's mentioned in the docs because I wasn't sure whether it was required or not, so I figured I should err on the side of caution, but subsequent practice has shown the firmware is generally very good at cleaning up on shutdown. There are some exceptions to this (usually involving complex situations with multiple recordings) so I won't be removing the recommendation from the docs, but don't worry too much!