from picamera.array import PiRGBArray

from picamera import PiCamera

#from common import draw_mask

from time import time, sleep

import common

import cv2

import numpy as np

import imutils

import argparse

import sys

import logging

import sched

from datetime import datetime

from setproctitle import setproctitle

LIVE_CAMERA_STEP = 10

FULL_PICTURE_STEP = 10

previewResolution = (640, 480)

#FULL_RES = (3280, 2464)

FULL_RES = (4056, 3040)

mask = (0.5, 0.5)

windowName = 'birbcam'

debugMode = False

noCaptureMode = False

average = None

scheduler = sched.scheduler(time, sleep)

takeFullPicture = False

takeLivePicture = False

nextLivePictureTime = 0

nextFullPictureTime = 0

setproctitle("birbcam -- birbloop2")

def setup_logging():

logging.info("Using Debug Mode")

def process_image(image):

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

gray = cv2.GaussianBlur(gray, (21, 21), 0)

return gray

def current_filestamp():

date = datetime.now()

return date.strftime("%Y-%m-%d-%H:%M:%S")

def save_location():

return "/home/pi/Public/birbs/"

def toggle_full_picture(sc):

fullPictureScheduler = sc

def schedule_full_picture():

global nextFullPictureTime

nextFullPictureTime = time() + FULL_PICTURE_STEP

def is_full_picture_time():

global nextFullPictureTime

return time() >= nextFullPictureTime

def take_full_picture(camera):

return True

def schedule_live_picture():

global nextLivePictureTime

nextLivePictureTime = time() + LIVE_CAMERA_STEP

def is_live_picture_time():

global nextLivePictureTime

return time() >= nextLivePictureTime

def take_live_picture(camera):

schedule_live_picture()

def draw_histogram(key, now, resolution):

return blank

def debug_frame(frame, key):

logging.info("Histogram comparison: %d" % compare)

setup_logging()

camera = PiCamera()

camera.resolution = previewResolution

camera.framerate = 30;

camera.iso = 200

rawCapture = PiRGBArray(camera, size=previewResolution)

camera.exposure_mode = 'auto'

camera.awb_mode = 'auto'

camera.meter_mode = 'spot'

sleep(2)

camera.shutter_speed = camera.exposure_speed

#camera.exposure_mode = 'off'

#g = camera.awb_gains

#camera.awb_mode = 'auto'

#camera.awb_gains = g

if debugMode:

logging.info("Using camera settings...")

logging.info(" ISO: %d", camera.iso)

logging.info(" Metering: " + camera.meter_mode)

logging.info(" Exposure Mode: " + camera.exposure_mode)

logging.info(" White Balance: " + camera.awb_mode)

logging.info(" Shutter: %d", camera.shutter_speed)

# **************************************

# Focus assist

# **************************************

focusWindowName = "Focus Assist"

focusWindowResolution = (800, 600)

focusStart = (0, 0)

focusEnd = focusWindowResolution

isDragging = False

def focus_click_event(event, x, y, camera, resolution):

return

def set_zoom_rect(camera, tl, br, resolution):

camera.zoom = (x, y, w, h)

cv2.namedWindow(focusWindowName)

cv2.setMouseCallback(focusWindowName, lambda event, x, y, flags, param: focus_click_event(event, x, y, camera, focusWindowResolution))

camera.resolution = focusWindowResolution

rawCapture = PiRGBArray(camera, size=focusWindowResolution)

for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):

image = frame.array

rawCapture.truncate(0)

laplacian_var = cv2.Laplacian(image, cv2.CV_64F).var()

# drag rect

if isDragging:

cv2.rectangle(image, focusStart, focusEnd, (255, 0, 255), 2)

# focus amount

cv2.rectangle(image, (0,0), (120, 40), (255, 0, 255), -1)

cv2.putText(image, str(int(laplacian_var)), (5,30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)

# crosshair

common.draw_aim_grid(image, focusWindowResolution)

cv2.imshow(focusWindowName, image)

key = cv2.waitKey(1) & 0xFF

if key == ord("r"):

set_zoom_rect(camera, (0,0), focusWindowResolution, focusWindowResolution)

if key == ord("q"):

break

if key == ord("x"):

sys.exit()

cv2.destroyAllWindows()

# **************************************

# Set mask

# **************************************

maskWindowName = "Set Detection Mask"

maskWindowResolution = (800, 600)

mask = (0.5, 0.5)

pauseRecording = False

camera.zoom = (0, 0, 1, 1)

def mask_click_event(event, x, y, flags, param):

mask = common.change_mask_size(x, y, maskWindowResolution)

cv2.namedWindow(maskWindowName)

cv2.setMouseCallback(maskWindowName, mask_click_event)

camera.resolution = maskWindowResolution

rawCapture = PiRGBArray(camera, size=maskWindowResolution)

for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):

image = frame.array

common.draw_mask(image, mask, maskWindowResolution)

common.draw_aim_grid(image, maskWindowResolution)

rawCapture.truncate(0)

cv2.imshow(maskWindowName, image)

key = cv2.waitKey(1) & 0xFF

if key == ord("q"):

break

if key == ord("x"):

sys.exit()

cv2.destroyAllWindows()

# **************************************

# Capture loop

# **************************************

shutterSpeeds = [333333, 16666, 11111, 8333, 5555, 4166, 3076, 2000, 1333, 1000]

shutterSpeedNames = ["30", "60", "90", "120", "180", "240", "325", "500", "750", "1000"]

isoSpeeds = [100, 200, 400, 600, 800]

exposureComps = [-12, -6, 0, 6, 12]

whiteBalanceModes = ["auto", "sunlight", "cloudy", "shade"]

currentShutterSpeed = 2

camera.shutter_speed = shutterSpeeds[currentShutterSpeed]

camera.iso = isoSpeeds[1]

camera.awb_mode = whiteBalanceModes[0]

def flip_through_array(values, current, delta):

return values[i]

def next_shutter_speed(camera, delta):

currentShutterSpeed = shutterSpeeds.index(shutter)

def next_iso(camera, delta):

global isoSpeeds

camera.iso = flip_through_array(isoSpeeds, camera.iso, delta)

def next_exposure_comp(camera, delta):

global exposureComps

camera.exposure_compensation = flip_through_array(exposureComps, camera.exposure_compensation, delta)

def next_white_balance(camera, delta):

global whiteBalanceModes

camera.awb_mode = flip_through_array(whiteBalanceModes, camera.awb_mode, delta)

camera.resolution = previewResolution

rawCapture = PiRGBArray(camera, size=previewResolution)

mask_resolution = common.get_mask_real_size(mask, previewResolution)

mask_bounds = common.get_mask_coords(mask, previewResolution)

for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):

now = rawCapture.array

gray = process_image(now)

now = imutils.resize(now, 640, 480)

rawCapture.truncate(0)

now = common.extract_image_region(now, mask_bounds)

gray = common.extract_image_region(gray, mask_bounds)

# initialize average

if (average is None):

average = gray.copy().astype('float')

continue

# calculate delta

cv2.accumulateWeighted(gray, average, 0.05)

convertAvg = cv2.convertScaleAbs(average)

frameDelta = cv2.absdiff(gray, convertAvg)

thresh = cv2.threshold(frameDelta, 90, 255, cv2.THRESH_BINARY)[1]

thresh = cv2.dilate(thresh, None, iterations=2)

# detect

cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,

cv2.CHAIN_APPROX_SIMPLE)

cnts = imutils.grab_contours(cnts)

shouldTrigger = False

for c in cnts:

if cv2.contourArea(c) < 600:

continue

(x, y, w, h) = cv2.boundingRect(c)

cv2.rectangle(now, (x, y), (x + w, y + h), (0, 255, 0), 2)

shouldTrigger = True

# capture full

didTakeFullPicture = False

if shouldTrigger and is_full_picture_time() and not pauseRecording:

didTakeFullPicture = take_full_picture(camera)

if didTakeFullPicture and debugMode:

debug_frame(gray, convertAvg)

if is_live_picture_time():

take_live_picture(camera)

# visualize

if debugMode:

convertAvg = cv2.cvtColor(convertAvg, cv2.COLOR_GRAY2BGR)

frameDelta = cv2.cvtColor(frameDelta, cv2.COLOR_GRAY2BGR)

thresh = cv2.cvtColor(thresh, cv2.COLOR_GRAY2BGR)

histogram = draw_histogram(gray, convertAvg, mask_resolution)

cv2.putText(histogram, "(S)hutter (A): " + str(shutterSpeedNames[currentShutterSpeed]), (10, 120), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1)

cv2.putText(histogram, "(E)xposure (W): " + str(camera.exposure_compensation), (10, 150), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1)

cv2.putText(histogram, "(I)SO (U): " + str(camera.iso), (10, 180), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1)

cv2.putText(histogram, "W(B) (V): " + str(camera.awb_mode), (10, 210), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1)

if pauseRecording:

cv2.putText(histogram, "PAUSED", (90, 80), cv2.FONT_HERSHEY_PLAIN, 2, (0, 0, 255), 2)

rtop = cv2.hconcat([now, histogram])

rbottom = cv2.hconcat([frameDelta, thresh])

quad = cv2.vconcat([rtop, rbottom])

#quad = cv2.resize(quad, (800, 600))

cv2.imshow('processors', quad)

if didTakeFullPicture:

stamp = current_filestamp()

cv2.imwrite(save_location() + "/debug/" + stamp + ".jpg", quad)

key = cv2.waitKey(1) & 0xFF

if key == ord("s"):

next_shutter_speed(camera, 1)

if key == ord("a"):

next_shutter_speed(camera, -1)

if key == ord("i"):

next_iso(camera, 1)

if key == ord("u"):

next_iso(camera, -1)

if key == ord("e"):

next_exposure_comp(camera, 1)

if key == ord("w"):

next_exposure_comp(camera, -1)

if key == ord("b"):

next_white_balance(camera, 1)

if key == ord("v"):

next_white_balance(camera, -1)

if key == ord("p"):

pauseRecording = not pauseRecording

if key == ord("q"):

break