camera_pi.py

import time
import io
import threading
import picamera
import config as cfg

def init_camera():
    try:
        camera = picamera.PiCamera()
        # camera setup
        camera.resolution = (cfg.width, cfg.height)
        camera.hflip = cfg.pi_hflip
        camera.vflip = cfg.pi_vflip

        # let camera warm up
        camera.start_preview()
        time.sleep(2)
        return True, camera
    except:
        return False, False

def single_frame():
    stream = io.BytesIO()
    cfg.camera.capture(stream, 'jpeg', use_video_port=True)
    stream.seek(0)
    frame = stream.read()
    return frame

class Camera(object):
    thread = None  # background thread that reads frames from camera
    frame = None  # current frame is stored here by background thread
    last_access = 0  # time of last client access to the camera

    def initialize(self):
        if Camera.thread is None:
            # start background frame thread
            Camera.thread = threading.Thread(target=self._thread)
            Camera.thread.start()

            # wait until frames start to be available
            while self.frame is None:
                time.sleep(0)

    def get_frame(self):
        Camera.last_access = time.time()
        self.initialize()
        return self.frame



    @classmethod
    def _thread(cls):
        stream = io.BytesIO()
        for foo in cfg.camera.capture_continuous(stream, 'jpeg',
                                             use_video_port=True):
            # store frame
            stream.seek(0)
            cls.frame = stream.read()

            # reset stream for next frame
            stream.seek(0)
            stream.truncate()

            # if there hasn't been any clients asking for frames in
            # the last 10 seconds or a manual app shutdown was requested then stop the thread.
            if time.time() - cls.last_access > 10 or cfg.camera_active is False:
                break
        cls.thread = None