The Pi Camera and Python

Almost all the code and ideas that follow are from:

https://picamera.readthedocs.io/en/release-1.13/index.html

• The Pi camera has a rolling shutter  https://en.wikipedia.org/wiki/Rolling_shutter
  

  
  

• How to Get a Camera   https://www.amazon.ca/s/ref=nb_sb_noss_2?url=search-alias%3Daps&field-keywords=pi+camera

  
  

• Set up camera

• attach

  
  

• configure the camera on

• sudo raspi-config

• 
  
  
  

• Documentation

• From Python:
  
$ python3
Python 3.5.3 (default, Sep 27 2018, 17:25:39)
[GCC 6.3.0 20170516] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import picamera
>>> help (picamera.camera)
...
 
|  capture(self, output, format=None, use_video_port=False, resize=None, splitter_port=0, bayer=False, **options)
     |      Capture an image from the camera, storing it in *output*.
     |     
     |      If *output* is a string, it will be treated as a filename for a new
     |      file which the image will be written to. If *output* is not a string,
     |      but is an object with a ``write`` method, it is assumed to be a
     |      file-like object and the image data is appended to it (the
     |      implementation only assumes the object has a ``write`` method - no
     |      other methods are required but ``flush`` will be called at the end of
     |      capture if it is present). If *output* is not a string, and has no
     |      ``write`` method it is assumed to be a writeable object implementing
     |      the buffer protocol. In this case, the image data will be written
     |      directly to the underlying buffer (which must be large enough to accept
     |      the image data).
     |     
     |      If *format* is ``None`` (the default), the method will attempt to guess
     |      the required image format from the extension of *output* (if it's a
     |      string), or from the *name* attribute of *output* (if it has one). In
     |      the case that the format cannot be determined, a
     |      :exc:`PiCameraValueError` will be raised.
     |     
     |      If *format* is not ``None``, it must be a string specifying the format
     |      that you want the image output in. The format can be a MIME-type or
     |      one of the following strings:
     |     
     |      * ``'jpeg'`` - Write a JPEG file
     |      * ``'png'`` - Write a PNG file
     |      * ``'gif'`` - Write a GIF file
     |      * ``'bmp'`` - Write a Windows bitmap file
     |      * ``'yuv'`` - Write the raw image data to a file in YUV420 format
     |      * ``'rgb'`` - Write the raw image data to a file in 24-bit RGB format
     |      * ``'rgba'`` - Write the raw image data to a file in 32-bit RGBA format
     |      * ``'bgr'`` - Write the raw image data to a file in 24-bit BGR format
     |      * ``'bgra'`` - Write the raw image data to a file in 32-bit BGRA format
     |      * ``'raw'`` - Deprecated option for raw captures; the format is taken
     |        from the deprecated :attr:`raw_format` attribute
     |     
     |      The *use_video_port* parameter controls whether the camera's image or
     |      video port is used to capture images. It defaults to ``False`` which
...


• Python still

• Auto 2s - the camera takes about a bit to stabilize after it is turned on.
  
  
  # Take a picture (camera.py)
  
  from picamera import PiCamera
  from time import sleep
  
  # instantiate a camera object
  camera = PiCamera()
  # turn the image  over
  camera.rotation = 180
  
  # start the camera and wait a bit
  camera.start_preview()
  sleep(1)
  
  camera.capture('image.jpg')
  camera.stop_preview()
  

• Find preset exposure

  # Show exposure numbers  (camera1.py)
  
  from picamera import PiCamera
  from time import sleep
  
  camera = PiCamera()
  camera.start_preview()
  for i in range(100):
      camera.annotate_text = "Brightness: %s" % i
      camera.brightness = i
      sleep(0.5)
  camera.stop_preview()

• Set a preset exposure

  # Set a preset exposure (camera3.py)
  
  from picamera import PiCamera
  camera = PiCamera()
  
  camera.iso = 1600
  camera.brightness = 50
  camera.resolution = (800, 600)
  camera.shutter_speed = 33000
  camera.rotation = 180
  
  camera.capture("aPicture.jpg") 
  

• Save a Stream

• Capture to an in memory stream then write to a file.  This allows analysis (etc.)  of the memory image before writing to disk.
  
  # create a stream and save it (image in memory)  (writeStream.py)
  from io import BytesIO
  from time import sleep
  from picamera import PiCamera
  
  # Create an in-memory stream
  my_stream = BytesIO()
  camera = PiCamera()
  camera.rotation = 180
  camera.start_preview()
  
  # Delay for camera warm-up
  sleep(2)
  
  # Capture to memory and rewind.
  camera.capture(my_stream, 'jpeg')
  my_stream.seek(0)
  
  # Put the picture object into imagedata
  imagedata = my_stream.getvalue()
  
  # Open a file and write the image.
  f = open('imgfile.jpg', 'w+b')
  f.write(imagedata)
  
  
  
  
  

• Video

• Capture video
  
  # Capture a video clip (captureVideo.py)
  from picamera import PiCamera
  from time import sleep
  
  camera = PiCamera()
  camera.rotation = 180
  
  camera.start_preview()
  camera.start_recording('video.h264')
  sleep(10)
  camera.stop_recording()
  camera.stop_preview()

• ffmpeg -framerate 24 -i input.264 -c copy output.mp4  

  
  <

• Motion Detection

• Detect and Capture

  #  (mymotion.py3)
  
  #!/usr/bin/python
  
  # Modified from:  (https://gist.github.com/FutureSharks/ab4c22b719cdd894e3b7ffe1f5b8fd91)
  
  import picamera
  import picamera.array
  import time
  import subprocess
  import datetime as dt
  
  threshold = 10    # How Much pixel changes
  sensitivity = 100 # How many pixels change
  
  # Capture an image in raw rgb format and return an array of the picture
  def takeMotionImage(width, height):
      with picamera.PiCamera() as camera:
          time.sleep(1)
          camera.resolution = (width, height)
          with picamera.array.PiRGBArray(camera) as stream:
              camera.exposure_mode = 'auto'
              camera.awb_mode = 'auto'
              camera.capture(stream, format='rgb')
              return stream.array
  
  # Call takeMotionImage to get a picture, then another and compare the arrays.
  # If the difference in a pixel is > threshold and there are more than sensitivity differences then
  # there is motion.
  def scanMotion(width, height):
      motionFound = False
      data1 = takeMotionImage(width, height)
      while not motionFound:
          data2 = takeMotionImage(width, height)
          diffCount = 0
          for w in range(0, width):
              for h in range(0, height):
                  # get the diff of the pixel. Conversion to int
                  # is required to avoid unsigned short overflow.
                  diff = abs(int(data1[h][w][1]) - int(data2[h][w][1]))
                  if  diff > threshold:
                      diffCount += 1
              if diffCount > sensitivity:
                  break;
          if diffCount > sensitivity:
              motionFound = True
          # No motion this time.  Swap the array.
          else:
              data1 = data2
      return motionFound
  
  # Loop forever looking for motion and capturing and uploading an image if there is motion
  def motionDetection():
      print ("Scanning for Motion threshold=%i sensitivity=%i..."  % (threshold, sensitivity))
      count = 0
      while True:
          if scanMotion(224, 160):
              print ("Motion detected")
  
              # Capture a picture and annotate it with the current time
              pic = picamera.PiCamera()
              pic.rotation = 180
              pic.annotate_text = dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
              pic.resolution= (800,600)
   
              pic.start_preview()
              time.sleep(.25)
              name = 'imagefoo' + str(count) + '.jpg'
              pic.capture(name)
              pic.close()
  
  #  Request a shell program to Upload the image to my web server and count it
              p = subprocess.Popen(['/home/pi/picamera/docs/sendPics.sh', str(count)])
              count = count + 1
  
  # Start the whole thing running or punt error?
  if __name__ == '__main__':
      try:
          motionDetection()
      finally:
          print ("Exiting Program")
  

• Capture Picture when motion detected.
  

# Capture a picture.
pic = picamera.PiCamera()
pic.rotation = 180
pic.resolution= (800,600)

pic.start_preview()
time.sleep(1)
name = 'imagefoo' + str(count) + '.jpg'
pic.capture(name)
pic.close()


• Upload

• Python Code added to upload
  

#  Request a shell program to Upload the image to my web server and count it
# (mymotion2.py)
       p = subprocess.Popen(['/home/pi/picamera/docs/sendPics.sh', str(count)])
       count = count + 1


•  Shell script to do the upload

#! /bin/bash

scp -i forpics imagefoo$1.jpg deid@fibble.ca:public_html/motionCapturePictures/
rm imagefoo$1.jpg


• Tag with text
  

  # (mymotion3.py)
  import datetime as dt
  
  pic.annotate_text = dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
• http://drsol.com/~deid/motionCapturePictures/
  

• Streaming
  

  (https://randomnerdtutorials.com/video-streaming-with-raspberry-pi-camera/)

• Stream via python's web server.

• http://rasport4:8000  (Or IP)?
  

  # Stream a live video (stream.py)
  
  import io
  import picamera
  import logging
  import socketserver
  from threading import Condition
  from http import server
  
  #  Web page served on :8000
  PAGE="""\
  <html>
  <head>
  <title>picamera MJPEG streaming demo</title>
  </head>
  <body>
  <h1>PiCamera MJPEG Streaming Demo</h1>
  <img src="stream.mjpg" width="1024" height="768" />
  </body>
  </html>
  """
  
  # Write the output
  class StreamingOutput(object):
      def __init__(self):
          self.frame = None
          self.buffer = io.BytesIO()
          self.condition = Condition()
  
      def write(self, buf):
          if buf.startswith(b'\xff\xd8'):
              # New frame, copy the existing buffer's content and notify all
              # clients it's available
              self.buffer.truncate()
              with self.condition:
                  self.frame = self.buffer.getvalue()
                  self.condition.notify_all()
              self.buffer.seek(0)
          return self.buffer.write(buf)
  
  # Handle header info
  class StreamingHandler(server.BaseHTTPRequestHandler):
      def do_GET(self):
          if self.path == '/':
              self.send_response(301)
              self.send_header('Location', '/index.html')
              self.end_headers()
          elif self.path == '/index.html':
              content = PAGE.encode('utf-8')
              self.send_response(200)
              self.send_header('Content-Type', 'text/html')
              self.send_header('Content-Length', len(content))
              self.end_headers()
              self.wfile.write(content)
          elif self.path == '/stream.mjpg':
              self.send_response(200)
              self.send_header('Age', 0)
              self.send_header('Cache-Control', 'no-cache, private')
              self.send_header('Pragma', 'no-cache')
              self.send_header('Content-Type', 'multipart/x-mixed-replace; boundary=FRAME')
              self.end_headers()
              try:
                  while True:
                      with output.condition:
                          output.condition.wait()
                          frame = output.frame
                      self.wfile.write(b'--FRAME\r\n')
                      self.send_header('Content-Type', 'image/jpeg')
                      self.send_header('Content-Length', len(frame))
                      self.end_headers()
                      self.wfile.write(frame)
                      self.wfile.write(b'\r\n')
              except Exception as e:
                  logging.warning(
                      'Removed streaming client %s: %s',
                      self.client_address, str(e))
          else:
              self.send_error(404)
              self.end_headers()
  
  # Create the web server
  class StreamingServer(socketserver.ThreadingMixIn, server.HTTPServer):
      allow_reuse_address = True
      daemon_threads = True
  
  #  Main - make everything so.
  with picamera.PiCamera(resolution='1024x768', framerate=24) as camera:
      output = StreamingOutput()
      camera.start_recording(output, format='mjpeg')
      try:
          address = ('', 8000)
          camera.rotation = 180
          server = StreamingServer(address, StreamingHandler)
          server.serve_forever()
      finally:
          camera.stop_recording()
  

References

• http://www.raspberry-pi-geek.com/Archive/2013/02/Working-with-the-Raspberry-Pi-camera-module

• https://www.raspberrypi.org/documentation/hardware/camera/

• https://en.m.wikipedia.org/wiki/Rolling_shutter

• https://picamera.readthedocs.io/en/release-1.13/fov.html

• https://en.m.wikipedia.org/wiki/Motion_JPEG

• https://xkcd.com/676/?sa=X&ved=2ahUKEwixgIP4mdneAhUJHjQIHdtoDJIQ9QEwBHoECAEQAw
  

• https://projects.raspberrypi.org/en/projects/getting-started-with-picamera

• https://github.com/waveform80/picamera/issues/434

• https://www.instructables.com/id/Raspberry-Pi-Motion-Detection-Security-Camera/