def start(self):
helper = Helper()
if settings.myList["env"] == "raspberrypi":
cam = PiCamera()
cam.flash_mode = self.flashmode
cam.vflip = self.upsidedown
cam.hflip = self.mirrorview
cam.resolution = (3280, 2464)
#cam.resolution = (2000, 2000)
#cam.framerate = 15
cam.start_preview(resolution=(1640, 1232),
fullscreen=False,
window=(0, 0, 800, 480))
#sleep(5)
# Add Overlay Countdown For-Schleife
sleep(1)
for i in self.images:
o = cam.add_overlay(i.tobytes(), size=i.size, layer=3)
sleep(1)
cam.remove_overlay(o)
#Flash White
o = cam.add_overlay(self.imgwhite.tobytes(),
size=self.imgwhite.size,
layer=3)
o.alpha = 128
sleep(0.2)
#cam.remove_overlay(o)
cam.annotate_text_size = self.textsize
cam.annotate_text = self.textlong
self.imgname = helper.getImagename(self.textshort)
#print(self.imgname)
if self.mirror:
cam.hflip = not cam.hflip
cam.capture(self.imgname)
if self.mirror:
cam.hflip = not cam.hflip
cam.stop_preview()
cam.close()
else:
self.imgname = helper.getImagename('random')
randomimage = self.getRandomImage()
copyfile(randomimage, self.imgname)
print(self.imgname)
def camThread(q):
logging.debug('Starting')
# initialise
# start preview
global overlay
global image
camera = PiCamera()
camera.resolution = (camWidth, camHeight)
camera.framerate = 49
camera.rotation = 180
camera.start_preview(anamorphic=True)
# camera.start_preview(resolution=(720,576))
text = time.strftime('%H:%M:%S', time.gmtime())
image = Image.new("RGBA", (camWidth, camHeight))
overlay = camera.add_overlay(image.tobytes(),
layer=3,
format='rgba',
size=(camWidth, camHeight),
anamorphic=True)
draw = ImageDraw.Draw(image)
draw.font = ImageFont.truetype(
"/usr/share/fonts/truetype/roboto/Roboto-Regular.ttf", 50)
# draw.text((10, 10), text, (255, 255, 255))
# draw.text((45,10), "123456789", (255, 255, 255))
# overlay.update(image.tobytes())
# process q messages
while True:
i = q.get()
q.task_done()
draw.rectangle([0, 0, 300, 100], fill=(255, 255, 255, 0))
# draw.text((45,10), text, fill=(255, 255, 255, 0))
text = time.strftime('%H:%M:%S', time.gmtime())
draw.text((45, 10), text, fill=(255, 255, 255, 128))
overlay.update(image.tobytes())
# camera.preview.rotation = camera.preview.rotation + 180
# global camHeight
# camHeight = camHeight +16
# camera.resolution = (camWidth, camHeight)
logging.debug('width height %d:%d', camWidth, camHeight)
# logging.debug('anamorphic %d ', camera.preview.anamorphic)
if i == 'start':
camStartRecording(camera)
elif i == 'stop':
camStopRecording(camera)
elif i == 'exit':
# continue
break
else:
logging.debug('get %d' % i)
logging.debug('Exiting')
return
def start(self):
print("Picamera Function")
if host == "raspberrypi":
cam = PiCamera()
cam.vflip = True
cam.resolution = (3280, 2464)
#cam.resolution = (2000, 2000)
#cam.framerate = 15
cam.start_preview(resolution=(1640, 1232),
fullscreen=False,
window=(0, 0, 800, 480))
#sleep(5)
# Add Overlay Countdown For-Schleife
sleep(1)
for i in self.images:
o = cam.add_overlay(i.tobytes(), size=i.size, layer=3)
sleep(1)
cam.remove_overlay(o)
#Flash White
sleep(120)
o = cam.add_overlay(self.imgwhite.tobytes(),
size=self.imgwhite.size,
layer=3)
o.alpha = 128
sleep(0.2)
#cam.remove_overlay(o)
cam.annotate_text_size = self.textsize
cam.annotate_text = self.textlong
self.imgname = imagename(self.textshort)
#print(self.imgname)
if self.mirror:
cam.hflip = True
cam.capture(self.imgname)
if self.mirror:
cam.hflip = False
cam.stop_preview()
cam.close()
def run(self):
# Write captures to memory
stream = BytesIO()
# Init camera
camera = PiCamera()
camera.sensor_mode = 2
camera.resolution = (2592, 1944)
camera.framerate = 12
camera.hflip = True
camera.annotate_text_size = 100
# Add overlay
o = camera.add_overlay(self.overlay.padded.tobytes(),
layer=3,
alpha=255,
size=self.overlay.image.size)
RED = Color('#ff0000')
GREEN = Color('#00ff00')
BLUE = Color('#0000ff')
camera.annotate_text = 'SCANNING'
camera.annotate_background = BLUE
camera.start_preview()
try:
while True:
camera.annotate_text = 'SCANNING'
camera.annotate_background = BLUE
sleep(3)
stream.seek(0)
camera.capture(stream,
format='jpeg',
resize=(self.overlay.image.size[0],
self.overlay.image.size[1]))
stream.seek(0)
image = Image.open(stream)
image = image.crop(self.overlay.roi_a + self.overlay.roi_b)
image = image.transpose(Image.FLIP_LEFT_RIGHT)
qr = qrdecode(image)
print(qr)
if len(qr) != 0:
if self.qr_validator(qr[0][0].decode()):
camera.annotate_text = 'AUTHORIZED'
camera.annotate_background = GREEN
else:
camera.annotate_text = 'NOT AUTHORIZED'
camera.annotate_background = RED
sleep(3)
finally:
camera.remove_overlay(o)
camera.close()
class KingOfTheHill:
def __init__(self, input_pin):
self.input_pin = input_pin
# set up cammera
self.camera = PiCamera()
self.camera.start_preview()
# set up button
GPIO.setmode(GPIO.BOARD) # Use physical pin numbering
GPIO.setup(input_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
#GPIO.add_event_detect(input_pin, GPIO.RISING, callback=self.button_callback)
self.last_layer = None
def picture(self):
pic_file = PIC_DIR + "probably_someone_getting_hurt_{}.png".format(
datetime.datetime.now())
if not os.path.exists(PIC_DIR):
os.mkdir(PIC_DIR)
self.camera.capture(pic_file)
self.display_image(pic_file)
def display_image(self, file):
img = Image.open(file)
pad = Image.new('RGB', ( \
((img.size[0] + 31) // 32) * 32, \
((img.size[1] + 15) // 16) * 16, \
))
# Paste the original image into the padded one
pad.paste(img, (0, 0))
o = self.camera.add_overlay(pad.tobytes(), size=img.size)
if self.last_layer:
self.last_layer.layer = 2
o.alpha = 255
o.layer = 3
if self.last_layer:
self.camera.remove_overlay(self.last_layer)
self.last_layer = o
time.sleep(1)
def button_pressed(self):
return GPIO.input(self.input_pin) == GPIO.HIGH
class VideoRecorder:
def __init__(self, preview=True):
self.lock = threading.Lock()
self.camera = PiCamera()
self.camera.resolution = (1920, 1080) # (640, 480)
self.camera.framerate = 25
self.camera.rotation = 180
#self.camera.annotate_background = Color('red')
#self.camera.annotate_foreground = Color('white')
#self.camera.annotate_text_size = 70
#self.camera.annotate_text = ANNOTATION_TEXT
self.overlay_img = Image.open('overlay.png')
if preview:
self.camera.start_preview()
self.add_overlay()
def add_overlay(self):
self.overlay = self.camera.add_overlay(self.overlay_img.tobytes(),
size=self.overlay_img.size,
alpha=0,
layer=3)
def remove_overlay(self):
self.camera.remove_overlay(self.overlay)
def start(self, file_name, file_dir):
self.lock.acquire()
file_name = f"{file_dir}/{file_name}.h264"
# self.camera.annotate_text = ""
self.remove_overlay()
log.info('starting video recording: %s', file_name)
video_thread = threading.Thread(target=self.camera.start_recording,
args=(file_name, ))
video_thread.start()
def stop(self):
if self.lock.locked():
self.lock.release()
self.camera.stop_recording()
self.add_overlay()
# self.camera.annotate_text = ANNOTATION_TEXT
return True
else:
return False
# Create window to be able capture key press events
cv2.namedWindow("Image")
# Initialize the camera and start preview
camera = PiCamera()
camera.resolution=(photo_width, photo_height)
camera.hflip = True
camera.start_preview()
camera.preview.fullscreen = True
# Adding ovrlay with center line for camera adjust
o = camera.add_overlay(np.getbuffer(a), layer=3, alpha=64)
cv2.waitKey(0)
# Key pressed - remove overlay, stop preview
camera.remove_overlay(o)
camera.stop_preview()
# Grab an image from the camera
rawCapture = PiRGBArray(camera)
camera.capture(rawCapture, format="bgr", use_video_port=True)
image = rawCapture.array
# Display image and wait for a keypress
class PhotoBooth:
def __init__(self,id_in="VOID"):
self.camera = PiCamera()
#self.camera.resolution = (1024, 768)
self.camera.resolution = (1640, 1232)
self.fid=id_in
self.camera.rotation = 270
image1 = Image.open("overlay.png")
print "Creating Overlay"
pad1 = Image.new("RGB", (
((self.camera.resolution[0]+31)//32)*32,
((self.camera.resolution[1]+15)//16)*16,
))
print "Pasting Image"
pad1.paste(image1,(0,0))
print "Adding Overlay"
self.camera.add_overlay(pad1.tobytes(),alpha=64,layer=3)
print "Starting Preview"
self.camera.annotate_text="Text 'Snap' to <Phone Number> to start countdown!"
self.gauth = GoogleAuth()
self.gauth.LocalWebserverAuth()
self.drive = GoogleDrive(self.gauth)
print "Ready"
self.camera.start_preview()
def takePicture(self):
#self.camera.start_preview()
self.camera.annotate_text="5"
sleep(1)
self.camera.annotate_text="4"
sleep(1)
self.camera.annotate_text="3"
sleep(1)
self.camera.annotate_text="2"
sleep(1)
self.camera.annotate_text="1"
sleep(1)
self.camera.annotate_text=""
outfilename = "SpecialName_img_"+strftime("%m%d%Y_%I%M%S")+".jpg"
self.camera.capture(outfilename)
self.camera.annotate_text="Uploading.....Please wait"
if "VOID" in self.fid:
file1 = self.drive.CreateFile()
else:
file1 = self.drive.CreateFile({"parents":[{"kind": "drive#fileLink","id":self.fid}]})
file1.SetContentFile(outfilename)
file1.Upload()
permission = file1.InsertPermission({
'type': 'anyone',
'value': 'anyone',
'role': 'reader'})
print 'Image uploaded: '+file1['alternateLink']
#self.camera.stop_preview()
self.camera.annotate_text="Text 'Snap' to <Phone Number> to start countdown!"
return file1['alternateLink']
def closePhotobooth(self):
self.camera.close()
class BoothCamera(object):
CAMERA = 'device-camera-icon.png'
yes = "Save.png"
no = "Retry.png"
countdown = ['Five.png', 'Four.png', 'Three.png', 'Two.png', 'One.png']
def __init__(self, window):
self.window = window
self.camera = PiCamera()
self.previewing = False
self.prompting = False
self.confirming = False
self.promptOverlay = None
self.confirmOverlay = None
self.yesOverlay = None
self.noOverlay = None
def startPreview(self):
log.debug("Starting Preview")
try:
if not Config.testMode():
self.camera.start_preview(fullscreen=True)
except Exception as e:
log.error("Error when starting preview", e)
self.previewing = True
def stopPreview(self):
log.debug("Stopping Preview")
try:
if not Config.testMode():
self.camera.stop_preview()
except Exception as e:
log.error("Error when stopping preview", e)
self.previewing = False
def showPrompt(self, btnBox):
if (self.prompting):
log.warn("Tried to show prompt againt")
return
log.debug("Showing Prompt at {0}".format(btnBox))
self.promptOverlay = self.addOverlay(
btnOverlay(BoothCamera.CAMERA, self.window, btnBox))
self.prompting = True
def hidePrompt(self):
if not self.prompting:
log.warn("Tried to hide prompt again")
return
log.debug("Hiding Prompt")
self.removeOverlay(self.promptOverlay)
self.prompting = False
def showConfirm(self, imagePath, yesBox, noBox):
if self.confirming:
log.warn("Tried to show confirm again")
return
if Config.testMode():
size = vecMult(self.window, 0.3)
else:
size = self.window
log.info(size)
img = Image.open(imagePath).resize(size)
self.confirmOverlay = self.addOverlay(
padImage(img, self.window, (0, 0), (0, 0)))
yesO = btnOverlay(BoothCamera.yes, self.window, yesBox)
noO = btnOverlay(BoothCamera.no, self.window, noBox)
self.yesOverlay = self.addOverlay(yesO)
self.noOverlay = self.addOverlay(noO)
self.confirming = True
def hideConfirm(self):
if not self.confirming:
log.warn("Tried to hide confirm again")
return
self.confirming = False
self.removeOverlay(self.confirmOverlay)
self.removeOverlay(self.yesOverlay)
self.removeOverlay(self.noOverlay)
def takePicture(self, imagePath, numBox):
if not self.previewing:
log.warn("Tried taking a picture without previewing")
return
try:
self.__displayCountdown(numBox)
self.camera.capture(imagePath, use_video_port=True)
except Exception as e:
log.error("Error when taking picture", e)
def __capture(self, imagePath):
self.camera.capture(imagePath, use_video_port=True)
def __displayCountdown(self, numBox):
prevOverlay = None
try:
for filename in BoothCamera.countdown:
#~ img = self.__getCountdownImage(filename)
img = btnOverlay(filename, self.window, numBox)
overlay = self.addOverlay(img)
self.removeOverlay(prevOverlay)
prevOverlay = overlay
sleep(1)
finally:
self.removeOverlay(prevOverlay)
def __getCountdownImage(self, filename, size=(128, 128)):
img = Image.open(filename).resize(size)
log.info('{0} {1}'.format(self.window, findCenter(self.window)))
return padImage(img, self.window, findCenter(self.window))
def addOverlay(self, img):
o = self.camera.add_overlay(img.tobytes(),
size=img.size,
format='rgba')
o.layer = 3
o.alpha = 50
return o
def removeOverlay(self, o):
if o: self.camera.remove_overlay(o)
acc = getImg("Accueil.png")
merci = getImg("Merci.png")
waits = []
for i in range(3):
waits.append(getImg("%d.png" % (i + 1)))
camera.start_preview()
while True:
try:
# Add the overlay with the padded image as the source,
# but the original image's dimensions
# note: we need to hflip the overlay only if vfliped
o = camera.add_overlay(acc.tobytes(),
format='rgba',
vflip=camera.vflip,
hflip=camera.vflip)
# By default, the overlay is in layer 0, beneath the
# preview (which defaults to layer 2). Here we make
# the new overlay semi-transparent, then move it above
# the preview
#o.alpha = 128
o.layer = 3
led.pulse(2, 2)
button.wait_for_press()
camera.remove_overlay(o)
ledStrip.on()
#display_text = ['Pwr: {} W'.format(0),'Cad: {} rpm'.format(0.0), 'Dist: {} km'.format(0.0), 'Heart rate: {} bpm'.format(0)]
display_text = [
'Pwr: {}'.format(0), 'Cad: {}'.format(0.0), 'Dist: {}'.format(0.0),
'H/r: {}'.format(0)
]
text_height = 20
text_font = ImageFont.truetype(
'/usr/share/fonts/truetype/freefont/FreeSans.ttf', text_height)
for i in range(len(display_text)):
draw.text((10, 10 + text_height * i),
display_text[i],
font=text_font,
fill='black')
# Add the image to the preview overlay
overlay = camera.add_overlay(img.tostring(), format='rgba', size=img.size)
overlay.layer = 3
overlay.fullscreen = True
"""
Text display for time. "annotate_text" is used instead of "draw.text" because by default,
(1) the text generated by "annotate_text" is centrally aligned in the middle of the screen,
and (2) the text is saved toghether with the recorded video while "draw.text" will not be saved.
"""
camera.annotate_text = dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
camera.annotate_text_size = 26
camera.annotate_foreground = Color('black')
# Update the time after 1 second
while True:
sleep(1)
camera.annotate_text = dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
class BoothCam:
def __init__(self):
self.camera = PiCamera()
self.camera.resolution = (2592, 1944)
self.camera.framerate = 24
self.previewOn = False
print('setting up mainCanvas')
self.mainCanvas = self.__renderBlock(READY_PATH, (0, 0))
self.mainCanvas.layer = 2
print('setting up countdown')
self.countdownSection = self.__renderBlock('content/countdown/Blank.jpg', (0, 0))
self.countdownSection.layer = 0
print('setting up thumbNail')
self.thumbNailSection = self.__renderBlock('content/thumb/new/thumb_0.jpg', (40, 410))
self.thumbNailSection.layer = 0
def __getPaddedImage(self, imagePath):
img = Image.open(imagePath)
pad = Image.new('RGB', (self.safeResolution(img.size[0], img.size[1])))
pad.paste(img, (0, 0))
return pad
def rendermainCanvas(self, bgType):
targetImage = READY_PATH
if (bgType == "instructions"):
targetImage = INSTRUCTION_PATH
if (bgType == "website"):
targetImage = WEBSITE_PATH
print('setting mainCanvas to ' + targetImage)
self.mainCanvas.update(self.__getPaddedImage(targetImage).tobytes())
print('hide thumbnail layer')
self.thumbNailSection.layer = 0
def __renderBlock(self, target, pos):
img = Image.open(target)
pad = self.__getPaddedImage(target)
o = self.camera.add_overlay(pad.tobytes(),
size=img.size,
fullscreen=0,
window=(pos[0], pos[1], img.size[0], img.size[1]))
o.alpha = 255
return o
def renderCountdown(self, num):
target = 'content/countdown/' + str(num) + '.jpg'
pad = self.__getPaddedImage(target)
self.countdownSection.update(pad.tobytes())
def takePic(self, imgName, picNum):
self.camera.capture(imgName)
#os.system('mpg123 -q /home/pi/Projects/content/Click.mp3')
self.showThumb(imgName, picNum)
def showThumb(self, location, picNum):
size = (self.safeResolution(256, 341))
thumb = Image.open(location)
thumb.thumbnail(size, Image.ANTIALIAS)
self.thumbNailSection.update(thumb.tobytes())
self.thumbNailSection.layer = 3
def hideThumb(self):
self.thumbNailSection.layer = 0
def hidePreview(self):
self.camera.stop_preview()
def showPreview(self):
self.camera.start_preview(fullscreen=False,
window=(405, 218, self.safeResolution(800, 600)))
def shutdown(self):
self.camera.close()
def safeResolution(self, x, y):
# // = Floor division - division that results into whole number
# adjusted to the left in the number line
return ((x + 31) // 32 * 32, (y + 15) // 16 * 16)
def camera(request):
model = Scan.objects.last()
lastScanned = model.id
#initialize the colormap
colormap = mpl.cm.jet
cNorm = mpl.colors.Normalize(vmin=0, vmax=255)
scalarMap = mtpltcm.ScalarMappable(norm=cNorm, cmap=colormap)
srpath= "/home/pi/Desktop/restapi/captureimages"
dstpath="/home/pi/Desktop/restapi/captureimagesth"
camera = PiCamera()
camera.rotation = 180
camera.resolution = (1280, 720)
camera.framerate = 24
camera.start_preview(alpha=200)
img = Image.open('/home/pi/Desktop/restapi/ml/overlay2.png')
pad = Image.new('RGBA', (
((img.size[0] + 31) // 32) * 32,
((img.size[1] + 15) // 16) * 16,
))
pad.paste(img,(0, 0))
o = camera.add_overlay(pad.tobytes(), size=img.size)
o.alpha = 125
o.layer = 3
def crop(image_path, coords, saved_location):
"""
@param image_path: The path to the image to edit
@param coords: A tuple of x/y coordinates (x1, y1, x2, y2)
@param saved_location: Path to save the cropped image
"""
image_obj = Image.open(image_path)
cropped_image = image_obj.crop(coords)
cropped_image.save(saved_location)
cropped_image.show()
arduino=True
nofcapture=2
for i in range(1, nofcapture+1):
## ser.write(str.encode('{}'.format(i)))
sleep(3)
camera.capture(join(srpath,'image%s-%s.jpg' % (lastScanned,i)))
image = join(srpath,'image%s-%s.jpg' % (lastScanned,i))
crop(image,(460, 150, 830, 580),join(srpath,'image%s-%s.jpg' % (lastScanned,i)))
camera.stop_preview()
camera.close()
sleep(3)
## ser.write(str.encode('3'))
print(listdir(srpath))
srpathl=glob.glob("/home/pi/Desktop/restapi/captureimages/image%s-*.jpg"%lastScanned)
print("srpathl")
print(srpathl)
srlist=[]
for i in srpathl:
srlist.append(i[39:])
print(srlist)
files = [f for f in srlist if isfile(join(srpath, f))]
for i in files:
try:
image = cv2.imread(join(srpath, i))
gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
gray = cv2.bitwise_not(gray)
blur = cv2.GaussianBlur(gray, (15, 15), 0)
colors = scalarMap.to_rgba(blur, bytes=True)
dstPath = join(dstpath, i)
cv2.imwrite(dstPath,colors)
except:
print("{} is not converted".format(i))
cv2.destroyAllWindows
## path = glob.glob("/home/pi/Desktop/virtualenvs/PD/restapi/captureimages/*.*")
## a = glob.glob("/home/pi/Desktop/virtualenvs/PD/restapi/images/*.*")
## b="/home/pi/Desktop/virtualenvs/PD/restapi/images/"
## bth="/home/pi/Desktop/virtualenvs/PD/restapi/imagesth/"
## totalimages=len(a)+numberofcapture+1
## totalimagesi = len(a)+1
## print(totalimagesi, totalimages)
## for i ,n in zip(range(1, numberofcapture+1),range(totalimagesi, totalimages)):
## shutil.copy2("/home/pi/Desktop/virtualenvs/PD/restapi/captureimages/image%s-%s.jpg" %(lastScanned,i) ,join(b,"image%s-%s.jpg" %(lastScanned,n)))
## shutil.copy2("/home/pi/Desktop/virtualenvs/PD/restapi/captureimagesth/image%s-%s.jpg" %(lastScanned,i), join(bth, "image%s-%s.jpg" %(lastScanned,n)))
##
url = reverse('start')
return HttpResponseRedirect(url)
preview_window = (0, 0, 640, 480)
camera_resolution = (1296, 972) # "1080p"
camera_framerate = 24
preview = False
recording = False
# create access to camera
camera = PiCamera(resolution=camera_resolution, framerate=camera_framerate)
# create overlays
if use_image_overlay:
img0 = Image.open('recording.png')
pad0 = Image.new('RGB', (((img0.size[0] + 31) // 32) * 32,
((img0.size[1] + 15) // 16) * 16))
pad0.paste(img0, (0, 0), img0)
o0 = camera.add_overlay(pad0.tostring(), size=img0.size)
o0.layer = 3
o0.alpha = 0
img1 = Image.open('not-recording.png')
pad1 = Image.new('RGB', (((img1.size[0] + 31) // 32) * 32,
((img1.size[1] + 15) // 16) * 16))
pad1.paste(img1, (0, 0), img1)
o1 = camera.add_overlay(pad1.tostring(), size=img1.size)
o1.layer = 4
o1.alpha = 0
# create list of properties to display
properties = [
"analog_gain",
"annotate_text",
class Camera:
def __init__(self):
self.cam = PiCamera()
self.cam.resolution = (400, 400)
self.cam.hflip = True
self.cam.led = False
self.img = None
self.mcp3208 = MCP3208()
def is_preview(self):
return self.cam.preview
def set_brightness(self, light):
if light > 300:
self.cam.brightness = 50
self.cam.contrast = 50
else:
self.cam.brightness = 70
self.cam.contrast = 20
def new_picture(self):
self.cam.led = True
self.cam.start_preview()
def take_picture(self):
# Configure directory path and image file name
base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
img_name = Pokinator.generate(generation=2, lowercase=True) + '.png'
img_path = os.path.join(base_dir, 'saved_images', img_name)
# Add overlay (countdown)
img_list = ('./static/overlay_img_3.png', './static/overlay_img_2.png',
'./static/overlay_img_1.png')
overlay_img_list = list()
for img in img_list:
overlay_img_list.append(Image.open(img))
for overlay_img in overlay_img_list:
pad = Image.new('RGBA', (
((overlay_img.size[0] + 31) // 32) * 32,
((overlay_img.size[1] + 15) // 16) * 16,
))
pad.paste(overlay_img, (0, 0))
overlay = self.cam.add_overlay(pad.tobytes(),
size=overlay_img.size,
layer=3,
alpha=100)
sleep(1)
self.cam.remove_overlay(overlay)
# Capture the image
self.cam.capture(img_path)
self.cam.stop_preview()
self.cam.led = False
# Save image file path
self.img = img_path
# Read data from light sensor
light_data = subprocess.check_output('./light/light_sensor.out')
light_data = light_data.decode('utf-8')
light_data = int(light_data)
# Insert icon and datetime
insert_datetime(img_path)
insert_icon(img_path, light_data)
return self.img
def send_email(self, email_addr):
# Send an email or back to main
send_email(self.img, '*****@*****.**', email_addr)
self.img = None
print("Taille image Quatre = (", QuadPhoto_Size_X, ",", QuadPhoto_Size_Y, ")")
print("Position images, 0=(", QuadPhoto_Img0_X, ",", QuadPhoto_Img0_Y,
") 1=(", QuadPhoto_Img1_X, ",", QuadPhoto_Img1_Y, ") 2=(",
QuadPhoto_Img2_X, ",", QuadPhoto_Img2_Y, ")")
QuadImage = Image.new("RGB", (QuadPhoto_Size_X, QuadPhoto_Size_Y),
(255, 255, 255)) #Crée l'image composite (init en blanc)
ImageQuatre = Image.open(ImageFond)
QuadImage.paste(ImageQuatre, (0, 0)) # Copie l'image
# Initialise la partie son, basée sur pygames
pygame.mixer.init()
pygame.mixer.music.set_volume(1.0)
# add an overlay which cut the picture at the right size (camera format is 4/3)
o1 = camera.add_overlay(FondEcran.tobytes(),
size=(Screen_Size_X, Screen_Size_Y),
format='rgba',
layer=1,
vflip=camera.vflip,
hflip=camera.vflip)
camera_preview = camera.start_preview(
resolution=(Screen_Size_Preview_X,
Screen_Size_Preview_Y)) #start preview with format 4/3
camera_preview.fullscreen = True
while True:
try:
buttonKeep.when_pressed = None
buttonThrow.when_pressed = None
# Affiche les instructions (appyer sur gros bouton vert) au dessus de l'image de la camera
# Reduit l'image de la camera au dimensions de l'affichage et non à sa résolution réelle.
# Utilise un overlay 32 bits (RGBA) pour profiter du paramètre transparence des fichiers PNG
# Cela économise beaucoup de calculs sur le raspberry
detector = MTCNN()
camera = PiCamera(framerate=2, resolution=(736, 480))
raw_capture = PiRGBArray(camera, size=camera.resolution)
time.sleep(0.5)
encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90]
win_xstart, win_ystart = 100, 100
win_width, win_height = 736, 480
camera.start_preview(fullscreen=False,
window=(win_xstart, win_ystart, win_width, win_height))
img_empty = Image.new("RGBA", (736, 480))
img = Image.new("RGBA", (736, 480))
o = camera.add_overlay(img.tobytes(), layer=3, size=img.size, alpha=32)
# how to add multi-area text-overlay in picamera preview
#o = rectangle_overlay(o, "test")
for i in range(100):
camera.capture(raw_capture, 'bgr')
start = time.time()
image_frame = raw_capture.array
image_array = np.ascontiguousarray(image_frame[:, :, ::-1], dtype=np.uint8)
image, _ = load_image(detector, image_array, 'unknown')
if image is not None:
embedding = np.array([get_embedding(face_detection_model, image[0])])
# print_time_elapsed(start, "Embedding")
norm_embedding = in_encoder.transform(embedding)
random_face_pixels = image[0]
except FileNotFoundError:
initialize_frame_file()
while True:
try:
if prevframe != frame:
try:
camera.remove_overlay(o)
except Exception:
pass
try:
im = Image.open('/home/pi/Animation/frame/frame%04d.jpg' %
(frame - 1))
o = camera.add_overlay(im.tobytes(),
size=im.size,
format='rgb')
o.alpha = 128
o.layer = 3
except FileNotFoundError:
pass
prevframe = frame
camera.annotate_text = '%04d/9999' % frame
if capture_button.is_pressed:
start_time = time.time()
capture_button.wait_for_release()
button_time = time.time() - start_time
if .1 <= button_time < 5:
camera.annotate_text = ''
camera.capture('/home/pi/Animation/frame/frame%04d.jpg' %
#Program reference start timestamp
start = time.time()
# Raw Output
output = yolo.predict(image)
printTimeStamp(start, "Detection Time")
#Process model output data. annotate image with bounding boxes
#processModelOutput(image_src, output, all_classes)
processModelOutput(pad, output, all_classes)
#Remove previous overlays
for o in camera.overlays:
camera.remove_overlay(o)
o = camera.add_overlay(pad.tobytes(),
alpha=255,
layer=3,
size=image_src.size)
rawCapture.truncate(0)
#break #uncomment to end loop and output image to jpg file
#Combine original image & bounding box annotation overlays image into one image
# & save to jpg file.
output_overlay("out/goproyolo.jpg", image_src, pad)
camera.stop_preview()
camera.close()
SWS=data['SADWindowSize']
PFS=data['preFilterSize']
PFC=data['preFilterCap']
MDS=data['minDisparity']
NOD=data['numberOfDisparities']
TTH=data['textureThreshold']
UR=data['uniquenessRatio']
SR=data['speckleRange']
SPWS=data['speckleWindowSize']
f.close()
print ('Parameters loaded from file '+fName)
load_map_settings ("3dmap_set.txt")
o = camera.add_overlay(np.getbuffer(a), layer=3, alpha = 160)
a[0:photo_Height,imageWidth:photo_Width,:] = 0
counter = 0
while (counter <100):
t1 = datetime.now()
counter+=1
print ('Counter: '+str(counter))
rawCapture.truncate(0)
camera.capture(rawCapture, format="bgr", use_video_port=True)
image = rawCapture.array
pair_img = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY)
imgLeft = pair_img [0:photo_Height,leftIndent:imageWidth] #Y+H and X+W
imgRight = pair_img [0:photo_Height,rightIndent:rightIndent+imageWidth] #Y+H and X+W
rectified_pair = calibration.rectify((imgLeft, imgRight))
disparity = stereo_depth_map(rectified_pair)
disparity = cv2.cvtColor (disparity, cv2.COLOR_BGR2RGB)
font=datafont,
alin="center")
#if DataToDisplay['warning'] == True:
#movingIM.paste(WarningIM,[int(linegap*2),int(screenY-2*linegap)])
if DataToDisplay['battery'] == True:
movingIM.paste(
BatteryIM,
[int(linegap * 4), int(screenY - 2 * linegap)])
#update the overlay with the new image
movingoverlay.update(movingIM.tobytes())
#Start Show
camera.start_preview()
#adding stationary and initial status overlays
stationaryoverlay = camera.add_overlay(pitchYawAxisIM.tobytes(), layer=3)
movingoverlay = camera.add_overlay(movingIM.tobytes(), layer=4)
indicatorsoverlay = camera.add_overlay(indicatorsIM.tobytes(), layer=4)
timeoverlay = camera.add_overlay(timeIM.tobytes(), layer=4)
while True:
#check status on of the button
SwitchStatus(DataToButton)
SerielOverlay()
#sleep(1)
# if DataToButton['status']==motors:
# timetext= camera.timestamp - DataToButton['time']
#
# minutes = timetext /(60*10**6)
# seconds = (timetext % (60*10**6)) /(10**6)
# timestamptext = str(int(minutes)) + ':' + str(int(seconds))
# define default values
camera_recording = 0
loop_recording = 1
camera_preview = 0
camera_rearcam = 0
savingfile = 0
exit = 0
# Add default overlay for rearcam mode
sizeA = (1280, 720)
img = Image.open(imageoverlay)
pad = Image.new("RGB", (((img.size[0] + 31) // 32) * 32,
((img.size[1] + 15) // 16) * 16))
pad.paste(img, (0, 0), img)
overlay = camera.add_overlay(pad.tobytes(), size=sizeA)
overlay.alpha = 0
overlay.layer = 0
def freespace(p):
s = os.statvfs(p)
return round(s.f_bsize * s.f_bavail / 1024 / 1024, 0)
free = freespace(recordpath)
def updateWindow():
global free, camera_recording, savingfile
counter = 0
camera.rotation = 90
camera.annotate_background = Color('black')
camera.resolution = (1640, 1232)
#timing image overlays. This is the 54321 that shows up before a snap
timing = []
for i in range(5):
img = Image.open('images/%d.png' % (i + 1))
pad = Image.new('RGB', (
((img.size[0] + 31) // 32) * 32,
((img.size[1] + 15) // 16) * 16,
))
pad.paste(img, (0, 0))
o = camera.add_overlay(pad.tostring(), size=img.size)
o.alpha = 0
o.layer = 0
timing.insert(0, o)
def hideOverlays():
for j in range(5):
timing[j].layer = 0
timing[j].alpha = 0
def showOverlay(k):
timing[k].layer = 3
timing[k].alpha = 64 #128
hideOverlays()
sleep(.5)
class Camera(object):
_overlay_rederer = None
_screen_w = 0
_screen_h = 0
def __init__(self):
self._camera = PiCamera()
self._camera.framerate = 24
self._camera.sharpness = 0
self._camera.contrast = 0
self._camera.brightness = 50
self._camera.saturation = 0
self._camera.ISO = 0
self._camera.video_stabilization = False
self._camera.exposure_compensation = 0
self._camera.exposure_mode = 'auto'
self._camera.meter_mode = 'matrix'
self._camera.awb_mode = 'auto'
self._camera.image_effect = 'none'
self._camera.image_effect = 'none'
self._camera.rotation = 0
self._camera.hflip = False
self._camera.vflip = False
self._screen_w = self._camera.resolution[0] / 2
self._screen_h = self._camera.resolution[1]
self._camera.resolution = (self._screen_w, self._screen_h)
def annotate_text(self, text):
self._camera.annotate_text = text
def start_preview(self):
w = self._camera.resolution[0]
h = self._camera.resolution[1]
self._camera.start_preview(fullscreen=False, window=(0, 0, w, h))
def stop_preview(self):
self._camera.stop_preview()
@property
def fullscreen(self):
return self._camera.preview.fullscreen
@fullscreen.setter
def fullscreen(self, value):
if value:
self._camera.resolution = (self._screen_w * 2, self._screen_h)
else:
self._camera.resolution = (self._screen_w, self._screen_h)
self._camera.preview.fullscreen = value
def close(self):
self._camera.close()
def capture_to_file(self, file_name):
stream = io.BytesIO()
self._camera.capture(stream, use_video_port=True, format='jpeg')
frame = Image.open(stream)
frame.save(file_name, "JPEG")
def show_frame(self, image_name):
try:
img = Image.open(image_name)
pad = Image.new('RGB', (
(((self._camera.resolution[0] * 2) + 31) // 32) * 32,
((img.size[1] + 15) // 16) * 16,
))
pad.paste(img, (self._camera.resolution[0], 0))
source = pad.tobytes()
if not self._overlay_rederer:
self._overlay_rederer = self._camera.add_overlay(
pad.tobytes(),
size=(self._camera.resolution[0] * 2, img.size[1]))
else:
self._overlay_rederer.update(source)
except:
logging.error(traceback.format_exc())
def zoom_reset(self):
if self._camera.zoom[1] < 1.0 and self._camera.zoom[2] < 1.0:
self._camera.zoom = (0.0, 0.0, 1.0, 1.0)
def zoom_in(self):
self._camera.zoom = (0.0, 0.0, self._camera.zoom[2] - 0.1,
self._camera.zoom[3] - 0.1)
def zoom_out(self):
self._camera.zoom = (0.0, 0.0, self._camera.zoom[2] + 0.1,
self._camera.zoom[3] + 0.1)
class AHF_Camera_PiStream(AHF_Camera):
@staticmethod
def about():
return 'uses picamera.PiCamera to run the standard Raspberry Pi camera, recording by frame'
@staticmethod
def config_user_get(starterDict = {}):
defaultFormat = 'hdf5'
defaultRes =(640,480)
defaultQuality = 20
defaultSensorMode = 4
defaultFrameRate = 30
defaultISO = 200
defaultShutterSpeed = 30000
defaultPath = '/home/Pi/Videos/closed_loop/'
# video path
video_path = starterDict.get('video_path', defaultPath)
tempInput = input('Set Video path for recording movies(currently ' + video_path + ') to :')
if tempInput != '':
video_path = tempInput
starterDict.update({'video_path' : video_path})
# videoFormat
videoFormat = starterDict.get('format', defaultFormat)
tempInput = input('Set Video format for recording movies(currently ' + videoFormat + ') to :')
if tempInput != '':
videoFormat = tempInput
starterDict.update({'format' : videoFormat})
# quality
quality = starterDict.get('quality', defaultQuality)
tempInput = input('Set Video quality for h264 movies, best=1, worst =40,0 for auto(currently ' + str(quality) + ') to :')
if tempInput != '':
quality = int(tempInput)
starterDict.update({'quality' : quality})
# resolution
resolution = starterDict.get('resolution', defaultRes)
tempInput = input('set X,Y resolution(currently {0}): '.format(resolution))
if tempInput != '':
resolution = tuple(int(x) for x in tempInput.split(','))
starterDict.update({'resolution' : resolution})
# framerate
frameRate = starterDict.get('framerate', defaultFrameRate)
tempInput = input('Set Frame rate in Hz of recorded movie(currently {0}): '.format(frameRate))
if tempInput != '':
frameRate = float(tempInput)
starterDict.update({'framerate' : frameRate})
# ISO
iso = starterDict.get('iso', defaultISO)
tempInput = input('Set ISO for video, or 0 to auto set gains(currently ' + str(iso) + ') to :')
if tempInput != '':
iso = int(tempInput)
starterDict.update({'iso' : iso})
# shutter speed
shutter_speed = starterDict.get('shutter_speed', defaultShutterSpeed)
tempInput = input('Set Shutter speed(in microseconds) for recorded video(currently ' + str(shutter_speed) + ') to :')
if tempInput != '':
shutter_speed= int(tempInput)
starterDict.update({'shutter_speed' : shutter_speed})
# Sensor mode
sensor_mode = starterDict.get('sensor_mode', defaultSensorMode)
tempInput = input('Set sensor mode for recording (currently ' + str(sensor_mode) + ') to :')
if tempInput != '':
sensor_mode= int(tempInput)
starterDict.update({'sensor_mode' : sensor_mode})
# preview window
previewWin = starterDict.get('previewWin',(0,0,640,480))
tempInput = input('Set video preview window, left, top, right, bottom,(currently ' + str(previewWin) + ') to :')
if tempInput != '':
previewWin = tuple(int(x) for x in tempInput.split(','))
starterDict.update({'previewWin' : previewWin})
# white balance
whiteBalance = starterDict.get('whiteBalance', False)
tempInput = input('Set white balancing for video, 1 for True, or 0 for False(currently ' + str(whiteBalance) + ') to :')
if tempInput !='':
tempInput = bool(int(tempInput))
starterDict.update({'whiteBalance' : whiteBalance})
# return already modified dictionary, needed when making a new dictionary
return starterDict
def setup(self):
# Set up text file and paths
self.data_path = self.settingsDict.get('data_path', '/home/Pi/Videos/closed_loop/')
# Create pi camera objecy
try:
self.piCam = PiCamera()
except Exception as anError:
print("Error initializing camera.." + str(anError))
raise anError
# set fields in Picamera
self.piCam.resolution = self.settingsDict.get('resolution',(640, 480))
self.piCam.framerate = self.settingsDict.get('framerate', 30)
self.piCam.iso = self.settingsDict.get('iso', 0)
self.piCam.shutter_speed = self.settingsDict.get('shutter_speed', 30000)
self.piCam.sensor_mode = self.settingsDict.get('sensor_mode', 4)
# turn off LED on camera
self.piCam.led = False
# set fields that are in AHF_Camera class
self.AHFvideoFormat = self.settingsDict.get('format', 'hdf5')
self.AHFvideoQuality = self.settingsDict.get('quality', 20)
self.AHFframerate= self.settingsDict.get('framerate', 30)
self.AHFpreview = self.settingsDict.get('previewWin',(0,0,640,480))
whiteBalance = self.settingsDict.get('whiteBalance', False)
self.AHFgainMode =(whiteBalance == True) # set bit 0 of gain for auto white balancing
self.AHFgainMode += 2 *(self.piCam.iso == 0) # set bit 1 for auto gain
# set gain based on 2 sec preview
self.set_gain()
self.rawCapture = PiRGBArray(self.piCam, size=self.resolution())
# Allow the camera to warmup
time.sleep(0.1)
print("done initializing!")
return
def resolution(self):
return self.piCam.resolution
def hardwareTest(self):
"""
Tests functionality, gives user a chance to change settings
"""
print('Now displaying current output')
self.piCam.start_preview(fullscreen = False, window=self.AHFpreview)
result = input('Do you wish to edit Camera settings?')
while result [0].lower() != 'y' and result[0].lower() !='n':
result = input('Do you wish to edit Camera settings?(Y/N)')
if result [0] == 'y' or result [0] == 'Y':
self.setdown()
self.settingsDict = self.config_user_get(self.settingsDict)
self.setup()
self.piCam.stop_preview()
pass
def setdown(self):
"""
Writes session end and closes log file
"""
self.piCam.close()
pass
def set_gain(self):
"""
Sets the gain and white balance of the camera based on a 2 second preview - so set illumination as you like before calling
If ISO for the camera is set to non-zero value, gain is not settable. If pWhiteBalance was set to False, white balancing is not done,
and gains for red and green are set to 1.
:raises PiCameraError: error raised by superclass PiCamera from preview
"""
DescStr = 'Setting Gain for AHF_Camera '
if(self.AHFgainMode & 2):
DescStr += 'from current illumination'
else:
DescStr += "from ISO " + str(self.piCam.iso)
if(self.AHFgainMode & 1):
DescStr += ' with white balancing'
else:
DescStr += " with No white balancing"
print(DescStr)
if(self.AHFgainMode & 1):
self.piCam.awb_mode='auto'
else:
self.piCam.awb_mode='off'
self.piCam.awb_gains =(1,1)
#if(self.AHFgainMode & 2):
self.exposure_mode = 'auto'
#else:
# self.exposure_mode = 'off'
self.piCam.start_preview(fullscreen = False, window=self.AHFpreview)
sleep(2.0) # let gains settle, then fix values
if(self.AHFgainMode & 1):
savedGain = self.piCam.awb_gains
self.piCam.awb_gains = savedGain
self.piCam.awb_mode = "off"
#if(self.AHFgainMode & 2):
self.exposure_mode = 'off'
self.piCam.stop_preview()
print("Red Gain for white balance =" + str(float(self.piCam.awb_gains [0])))
print("Blue Gain for white balance =" + str(float(self.piCam.awb_gains [1])))
print("Analog Gain = " + str(float(self.piCam.analog_gain)))
print("Digital Gain = " + str(float(self.piCam.digital_gain)))
return
def capture(self, path, type, video_port =False):
self.piCam.capture(path, type, use_video_port=video_port)
def start_recording(self, video_name_path):
"""
Starts a video recording using the saved settings for format, quality, gain, etc.
A preview of the recording is always shown
:param video_name_path: a full path to the file where the video will be stored. Always save to a file, not a PIL, for, example
"""
if self.AHFvideoFormat == 'rgb':
self.piCam.start_recording(output=video_name_path, format=self.AHFvideoFormat)
else:
self.piCam.start_recording(video_name_path, format = self.AHFvideoFormat, quality = self.AHFvideoQuality)
self.piCam.start_preview(fullscreen = False, window= self.AHFpreview)
return
def add_overlay(self, bytes, layer, alpha):
return self.piCam.add_overlay(bytes, layer=layer, alpha = alpha, fullscreen=False, window= self.AHFpreview)
def remove_overlay(self, overlay):
self.piCam.remove_overlay(overlay)
def start_preview(self):
self.piCam.start_preview(fullscreen = False, window= self.AHFpreview)
def stop_preview(self):
self.piCam.stop_preview()
def stop_recording(self):
"""
Stops a video recording previously started with start_recording.
"""
if self.piCam.recording:
self.piCam.stop_recording()
self.piCam.stop_preview()
return
def timed_recording(self, video_name_path, recTime):
"""
Does a timed video recording using the PiCamera wait_recording function.
A preview of the recording is always shown
Control does not pass back to the calling function until the recording is finished
:param video_name_path: a full path to the file where the video will be stored.
:param recTime: duration of the recorded video, in seconds
"""
if self.AHFvideoFormat == 'rgb':
self.piCam.start_recording(output=video_name_path, format=self.AHFvideoFormat)
else:
self.piCam.start_recording(output=video_name_path, format=self.AHFvideoFormat)
self.piCam.start_preview(fullscreen = False, window= self.AHFpreview)
self.piCam.wait_recording(timeout=recTime)
self.stop_recording()
return
takePicture()
else:
redPressCount = 0
# key handling
for event in pygame.event.get():
if event.type == pygame.QUIT:
GPIO.output(18, GPIO.LOW)
pygame.quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_h:
if not helpScreen:
o = camera.add_overlay(help.tobytes(),
size=help.size,
layer=3)
helpScreen = True
else:
camera.remove_overlay(o)
helpScreen = False
if event.key == pygame.K_SPACE:
takePicture()
if event.key == pygame.K_v:
takeVideo()
if event.key == pygame.K_t:
takeSequence(timeLapseSeconds)
if event.key == pygame.K_a:
class Photobooth:
def __init__(self):
self.picture_count = 1
self.event_name = "fotokiosk"
self.base_path = "/home/pi/photobooth/" + self.event_name
self.assert_path_exist()
self.width = 1280
self.height = 960
self.flash_overlay = np.zeros((self.width, self.height, 3),
dtype=np.uint8)
self.flash_overlay[:, :, :] = 0xff
self.flash_overlay[:, :, :] = 0xff
self.camera = PiCamera()
# xdpyinfo | grep 'dimensions:'
# https://picamera.readthedocs.io/en/release-1.10/fov.html
self.camera.resolution = (self.width, self.height)
self.camera.framerate = 15
#self.camera.image_effect = 'denoise'
self.camera.awb_mode = "fluorescent"
self.camera.brightness = 55
# TODO: consider using board for wider Pi support
# https://raspberrypi.stackexchange.com/questions/12966/what-is-the-difference-between-board-and-bcm-for-gpio-pin-numbering
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(15, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
def start(self):
preview = self.camera.start_preview()
while True:
self.start_button_listener()
#sleep(10)
for i in range(self.picture_count):
photobooth.start_countdown()
photobooth.capture()
self.stop()
def stop(self):
self.camera.stop_preview()
self.camera.close()
def capture(self):
dt = datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
filename = self.base_path + "/" + self.event_name + "-" + dt + ".jpg"
o = self.camera.add_overlay(np.getbuffer(self.flash_overlay),
layer=3,
alpha=200)
sleep(.1)
self.camera.remove_overlay(o)
self.camera.capture(filename,
format="jpeg",
quality=100,
thumbnail=(60, 45, 35))
img = Image.open(filename)
pad = Image.new('RGB', (
((img.size[0] + 31) // 32) * 32,
((img.size[1] + 15) // 16) * 16,
))
pad.paste(img, (0, 0))
o = self.camera.add_overlay(pad.tobytes(), size=img.size)
o.layer = 3
o.layer = 3
sleep(5)
self.camera.remove_overlay(o)
def start_button_listener(self):
while True:
# wait until button is pressed
if GPIO.input(15) == GPIO.HIGH:
return
def start_countdown(self):
sleep(1)
# red light
GPIO.setup(17, GPIO.OUT)
GPIO.output(17, GPIO.HIGH)
sleep(1)
GPIO.output(17, GPIO.LOW)
# yellow ligth
GPIO.setup(18, GPIO.OUT)
GPIO.output(18, GPIO.HIGH)
sleep(1)
GPIO.output(18, GPIO.LOW)
# green light
GPIO.setup(27, GPIO.OUT)
GPIO.output(27, GPIO.HIGH)
sleep(1)
GPIO.output(27, GPIO.LOW)
def assert_path_exist(self):
assert (os.path.exists(self.base_path) is
True), "path does not exist: " + self.base_path
GPIO.output(in2, GPIO.LOW)
pwm_servo.ChangeDutyCycle(13)
# grab raw NumPy array representing image - 3D array
image = frame.array
#convert image to grayscale
gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Wait and read key input
key = cv2.waitKey(1) & 0xFF
# Find stopsign in image
print("Before stop sign finding")
found_stopsigns = stopsign_cascade.detectMultiScale(gray_img, 1.1, 5)
print("Found " + str(len(found_stopsigns)) + " stop sign(s)")
if len(found_stopsigns) > 0:
for (x, y, w, h) in found_stopsigns:
cv2.rectangle(image, (x, y), (x + w, y + h), (255, 255, 0), 2)
camera.add_overlay(image)
cv2.imwrite("found_stopsign_Jun_25_20.jpg", image)
sign_width = w
sign_height = h
print("width of stop sign:", w, "and height:", h)
if (sign_width > 65 or sign_height > 65):
print("Turn on brake lights")
print("Decrease motor speed")
print("stop car")
GPIO.output(in1, GPIO.LOW)
GPIO.output(in2, GPIO.LOW)
sleep(1)
break
#clear the stream in preparation for the next frame
rawCapture.truncate(0)
# if the 'q' key was pressed or a stop sign was found
class PiCameraStream(object):
"""
Continuously capture video frames, and optionally render with an overlay
Arguments
resolution - tuple (x, y) size
framerate - int
vflip - reflect capture on x-axis
hflip - reflect capture on y-axis
"""
def __init__(self,
resolution=(320, 240),
framerate=24,
vflip=False,
hflip=False,
rotation=0,
max_workers=2):
self.camera = PiCamera()
self.camera.resolution = resolution
self.camera.framerate = framerate
self.camera.vflip = vflip
self.camera.hflip = hflip
self.camera.rotation = rotation
self.overlay = None
self.data_container = PiRGBArray(self.camera, size=resolution)
self.stream = self.camera.capture_continuous(self.data_container,
format="rgb",
use_video_port=True)
self.overlay_buff = None
self.frame = None
self.stopped = False
logging.info('starting camera preview')
self.camera.start_preview()
def render_overlay(self):
while True:
if self.overlay and self.overlay_buff:
self.overlay.update(self.overlay_buff)
elif not self.overlay and self.overlay_buff:
self.overlay = self.camera.add_overlay(
self.overlay_buff, layer=3, size=self.camera.resolution)
_monkey_patch_picamera(self.overlay)
def start_overlay(self):
Thread(target=self.render_overlay, args=()).start()
return self
def start(self):
'''Begin handling frame stream in a separate thread'''
Thread(target=self.flush, args=()).start()
return self
def flush(self):
# looping until self.stopped flag is flipped
# for now, grab the first frame in buffer, then empty buffer
for f in self.stream:
self.frame = f.array
self.data_container.truncate(0)
if self.stopped:
self.stream.close()
self.data_container.close()
self.camera.close()
return
def read(self):
return self.frame
def stop(self):
self.stopped = True
def overlay():
CAMERA = PiCamera()
CAMERA.rotation = 180
CAMERA.start_preview()
sensitivity = -7 #BT edit: was -5
overlay1, overlay2 = None, None
loop = True
startT = time.time()
while loop:
endT = time.time()
if (endT - startT > 3600):
print('restarting overlay...')
logger.info('restarting overlay...')
startT = time.time()
loop = False
pad = Image.new('RGB', (F_WIDTH, F_HEIGHT))
draw = ImageDraw.Draw(pad)
#read the pixels
# pixels_d = sensor.readPixels()
pixels_d = []
for row in sensor.pixels:
pixels_d = pixels_d + row
# Remap pixels
# Remap pixels
pixels = [
map(p, MINTEMP + sensitivity, MAXTEMP + sensitivity, 0,
COLORDEPTH - 1) for p in pixels_d
]
#Perform interpolation
bicubic = griddata(points, pixels, (grid_x, grid_y), method='cubic')
#Draw Overlay
x = 31 * PIXEL_WIDTH
y = -6 * PIXEL_HEIGHT
for ix, row in enumerate(bicubic):
for jx, pixel in enumerate(row):
draw.rectangle((x, y, x + PIXEL_WIDTH, y + PIXEL_HEIGHT),
fill=colors[constrain(int(pixel), 0,
COLORDEPTH - 1)])
y = y + PIXEL_HEIGHT
x = x - PIXEL_WIDTH
y = -6 * PIXEL_HEIGHT
if overlay1 == None:
overlay1 = CAMERA.add_overlay(pad.tobytes(),
size=pad.size,
layer=3,
alpha=OVERLAY_ALPHA)
if not overlay2 == None:
CAMERA.remove_overlay(overlay2)
overlay2 = None
else:
overlay2 = CAMERA.add_overlay(pad.tobytes(),
size=pad.size,
layer=3,
alpha=OVERLAY_ALPHA)
if not overlay1 == None:
CAMERA.remove_overlay(overlay1)
overlay1 = None
if GPIO.input(BTN2) == GPIO.LOW:
sensitivity = sensitivity - 1
time.sleep(0.5)
elif GPIO.input(BTN3) == GPIO.LOW:
sensitivity = sensitivity + 1
time.sleep(0.5)
elif GPIO.input(BTN4) == GPIO.LOW:
loop = False
time.sleep(0.5)
if not overlay1 == None:
CAMERA.remove_overlay(overlay1)
if not overlay2 == None:
CAMERA.remove_overlay(overlay2)
CAMERA.stop_preview()
CAMERA.close()
class CameraGsmToUrl(app.App):
_logger = logging.getLogger('camera_gsm_to_url')
def __init__(self):
app.App.__init__(self,
constants,
spam_loggers=sheets.Sheets.SPAM_LOGGERS +
('PIL.PngImagePlugin', 'urllib3.connectionpool'))
self._modules.extend((sim800, drive, sheets))
# google drive uploader
try:
self.drive = drive.Drive(constants.SERVICE_ACCOUNT_PATH)
except:
self._logger.exception('self.drive')
self.drive = None
# google sheets logger
try:
self.sheets = sheets.Sheets(constants.SERVICE_ACCOUNT_PATH)
except:
self._logger.exception('self.sheet')
self.sheets = None
# url shorter
try:
self.short_url = Shortener(**constants.SHORT_URL_ARGS).short
except:
self._logger.exception('self.short_url')
self.short_url = None
# google sheets name is the hostname
constants.WORKSHEET_SMS_NAME = platform.node()
# last pictures overlays
self.pictures = []
# attach to raspberrypi camera
self.camera = PiCamera()
# configure camera
if hasattr(constants, 'CAMERA_FPS'):
self.camera.framerate = constants.CAMERA_FPS
if hasattr(constants, 'CAMERA_RESOLUTION'):
self.camera.resolution = constants.CAMERA_RESOLUTION
if not hasattr(constants, 'CAMERA_CROP'):
constants.CAMERA_CROP = (0, 0, 0, 0)
if not hasattr(constants, 'SCREEN_RESOLUTION'):
constants.SCREEN_RESOLUTION = tuple(
map(
int,
os.popen(r'tvservice -s | grep -oP "\d\d+x\d\d+"',
'r').read().strip().split('x')))
# calc draw stuff and draw preview
self.calc_and_draw_preview()
# draw pictures overlays
self.draw_pictures()
# log display parameters
self._logger.info(
'\nmain window: %s sep: %s\ncamera resolution: %sx%s @ %s fps',
(self.left, self.top, self.width, self.height), self.sep,
self.camera.resolution.width, self.camera.resolution.height,
self.camera.framerate)
self._logger.debug('\nfirst picture window: %s count: %s',
(self.pictures_l, self.pictures_t, self.pictures_w,
self.pictures_h), self.pictures_c)
# gsm module
try:
self._gsm_uart = serial.serial_for_url(**constants.GSM_UART)
self._gsm_reader = serial.threaded.ReaderThread(
self._gsm_uart, sim800.Sim800)
self._gsm_reader.start()
self.gsm = self._gsm_reader.connect()[1]
except:
self._logger.exception('gsm')
self._logger.error(
'gsm problem: check DC power is stable..\n'
'new modules needs to be configure with:\n'
'ATE0;+CMGF=1;+CNMI=2,2,0,0,0;+CSCS="UCS2";+CSMP=17,167,0,8;+CSAS;+IPR=115200\n'
'AT&W')
self.gsm = None
else:
self.gsm.status_changed = self.gsm_status_changed
self.gsm.sms_recived = self.gsm_sms_recived
def gsm_status_changed(self):
self._logger.info('gsm_status_changed: %s', self.gsm.status)
if self.gsm.status == 'ALIVE':
self._logger.info(constants.GSM_DATA_FORMAT, self.gsm.get_csq(),
self.gsm.get_vbat(), self.gsm.get_temperature())
elif self.gsm.status == 'TIMEOUT':
self._logger.warning('gsm did not respond')
def gsm_sms_recived(self, number, send_time, text):
# normalize sms text, number and send_time
text = text.encode(errors='replace').decode().strip().replace(
'\n', ' ').replace('\t', ' ').replace('\r', '')
normalize_number = self.gsm.normalize_phone_number(number)
send_time = send_time.strftime(constants.DATETIME_FORMAT)
self._logger.info('AT: %s FROM: %s MESSAGES: %s', send_time,
normalize_number, text)
if text == 'REBOOT':
# self._logger.info(constants.REBOOT_FORMAT)
self.send_sms(number, constants.REBOOT_FORMAT, False)
os.system('shutdown -r')
elif text == 'GSM DATA':
try:
t = constants.GSM_DATA_FORMAT % (self.gsm.get_csq(),
self.gsm.get_vbat(),
self.gsm.get_temperature())
except:
self._logger.warning('cant read gsm data')
return
# self._logger.info(t)
self.send_sms(number, t.replace(', ', '\n'), False)
else:
url = self.capture_and_share(number)
# log to worksheet
if self.sheets is not None:
try:
self.sheets.append_worksheet_table(
constants.SHEET_SMS_LOG_NAME,
constants.WORKSHEET_SMS_NAME, send_time,
normalize_number, text, url)
except:
self._logger.error(
'capture_and_share: append_worksheet_table failed')
def capture_and_share(self, number):
try:
path = self.take_picture()
except:
self._logger.error('capture_and_share: take_picture failed')
return ''
try:
url = self.upload_picture(path)
except:
self._logger.exception('capture_and_share: upload_picture failed')
return ''
try:
self.send_sms(number, constants.GSM_SEND_SMS_FORMAT % (url, ))
except:
self._logger.error('capture_and_share: send_sms failed')
return url
def calc_and_draw_preview(self):
self.left, self.top = 0, 0
self.width, self.height = constants.SCREEN_RESOLUTION
crop_l, crop_t, crop_r, crop_b = constants.CAMERA_CROP
camera_w, camera_h = self.camera.resolution.width, self.camera.resolution.height
croped_camera_w, croped_camera_h = camera_w - crop_l - crop_r, camera_h - crop_t - crop_b
view_scale, camera_scale = croped_camera_w / croped_camera_h, camera_w / camera_h
self.sep = int(min(self.width, self.height) * constants.SEP_SCALE)
# calc pictures count, size and positions
self.pictures_h = int(
(self.height - 3 * self.sep) * constants.PICTURES_HEIGHT_SCALE)
self.pictures_w = int(view_scale * self.pictures_h)
self.pictures_c = int(
(self.width - self.sep) / (self.pictures_w + self.sep))
self.pictures_l = int((self.width - self.pictures_c *
(self.pictures_w + self.sep) - self.sep) /
2) + self.sep + self.left
self.pictures_t = self.sep + self.top
# calc final view size and position
view_t = self.sep + self.pictures_h + self.sep
view_h = self.height - view_t - self.sep
view_w = int(view_scale * view_h)
max_view_w = self.width - self.sep * 2
if view_w > max_view_w:
view_w = max_view_w
view_h = int(1 / view_scale * view_w)
view_l = int((self.width - view_w) / 2) + self.left
# calc camera preview size and position
preview_scale = lambda x: int(x * view_w / camera_w)
offset_l = preview_scale(crop_l)
offset_t = preview_scale(crop_t)
offset_r = preview_scale(crop_r)
offset_b = preview_scale(crop_b)
preview_l = view_l - offset_l
preview_t = view_t - offset_t
preview_w = view_w + preview_scale(crop_l + crop_r)
# preview_h = view_h + preview_scale(crop_t + crop_b)
# preview_w = view_w + offset_l + offset_r
# preview_h = view_h + offset_t + offset_b
preview_h = int(1 / camera_scale * preview_w)
# draw camera preview
self.camera.start_preview()
self.camera.preview.fullscreen = False
self.camera.preview.window = [
preview_l, preview_t, preview_w, preview_h
]
# draw preview crop mask (black rectangle with transparent rectangle inside)
img = Image.new('RGBA', (preview_w, preview_h), (0, 0, 0, 255))
draw = ImageDraw.Draw(img)
draw.rectangle(
(offset_l, offset_t, preview_w - offset_r, preview_h - offset_b),
(0, 0, 0, 0))
self.preview_crop = self._image_to_overlay(
img, layer=self.camera.preview.layer + 1)
self.preview_crop.window = self.camera.preview.window
def draw_pictures(self):
# draw pictures overlays
for i, p in enumerate(self.pictures):
p.window = (self.pictures_l + i * (self.pictures_w + self.sep),
self.pictures_t, self.pictures_w, self.pictures_h)
def take_picture(self):
# capture picture and return its path
self.camera.preview.alpha = 100
time.sleep(0.7)
path = constants.PICTURES_PATH % (datetime.datetime.now().strftime(
constants.PICTURES_DATETIME_FORMAT), )
self._logger.info('take_picture: %s', path)
self.camera.capture(path)
self.camera.preview.alpha = 255
# crop sides and re-save image
img = Image.open(path, 'r')
l, t, r, b = 140, 80, 300, 170 # constants.CAMERA_CROP
img = img.crop((l, t, img.width - r, img.height - b))
img.save(path)
self.add_picture(path)
# add frame and re-save image
draw = Image.open(constants.LOGO3_PATH, 'r').convert('RGBA')
img_w, img_h = img.size
draw_w, draw_h = draw.size
img.paste(draw, (int((img_w - draw_w) / 2), img_h - draw_h), draw)
frame = Image.open(constants.FRAME_PATH, 'r').convert('RGBA')
img = img.resize(constants.FRAME_SIZE)
frame.paste(img, constants.FRAME_POS)
img = frame
img = img.convert('RGB')
img.save(path)
return path
def add_picture(self, path):
# add the given picture to pictures list
self.pictures.append(
self._image_path_to_overlay(path,
resize=(self.pictures_w,
self.pictures_h),
transparent=False,
layer=self.preview_crop.layer + 1))
if len(self.pictures) > self.pictures_c:
self.pictures[0].close()
self.pictures.pop(0)
self.draw_pictures()
def set_effect(self, index):
# set camera image effect by its index
self._logger.info('set_effect: %s', index)
self.camera.image_effect = constants.CAMERA_EFFECTS[index % len(
constants.CAMERA_EFFECTS)]
def upload_picture(self, path):
if self.drive is None:
raise IOError('can\t upload: self.drive is None')
self._logger.info('upload_picture: %s', path)
file_id = self.drive.upload_file(
path,
share=True,
delete=True,
parent_directory=constants.DRIVE_SMS_CAMERA_FOLDER,
timeout=constants.DRIVE_UPLOAD_TIMEOUT)
url = self.drive.VIEW_FILE_URL % (file_id, )
if self.short_url is not None:
url = self.short_url(self.drive.VIEW_FILE_URL % (file_id, ))
self._logger.debug('upload_picture url: %s', url)
return url
def _image_path_to_overlay(self, image_path, resize=None, *args, **kwargs):
# open image and resize it if needed
img = Image.open(image_path)
if resize is not None:
img = img.resize(resize)
return self._image_to_overlay(img, *args, **kwargs)
def _image_to_overlay(self,
img,
layer=0,
alpha=255,
fullscreen=False,
transparent=True):
# create required size (32, 16) padding for the image
pad = Image.new('RGBA' if transparent else 'RGB',
[((n + m - 1) // m) * m
for n, m in zip(img.size, (32, 16))])
# paste the original image into the padding
pad.paste(img)
# crearw image overlay, and return it with its size
overlay = self.camera.add_overlay(pad.tobytes(),
img.size,
layer=layer,
alpha=alpha,
fullscreen=fullscreen)
overlay.width, overlay.height = img.size
return overlay
def send_sms(self, number, text, raise_exception=True):
try:
if number.replace('+', '').isdigit():
self.gsm.send_sms(number, text)
except:
if raise_exception:
raise
def smart_reload(self, reason=None):
self.reload()
return
def __exit__(self):
try:
self._gsm_reader.close()
except:
pass
try:
self.camera.close()
except:
pass
app.App.__exit__(self)
from threading import Thread
import cv2
import numpy as np
from picamera.array import PiRGBArray
from picamera import PiCamera
from PIL import Image
import logging
import threading
GPIO.setmode(GPIO.BCM)
#Camera setup for video and overlays
camera = PiCamera()
camera.resolution = (800, 480)
camera.framerate = 32
img = Image.open('bg_overlay480x320.png')
img_overlay=camera.add_overlay(img.tobytes(),size=img.size)
img_overlay.alpha=128
img_overlay.layer=3
rawCapture = PiRGBArray(camera, size=(800, 480))
kernel = np.ones((2,2),np.uint8)
event = threading.Event()
#GPIO Pin Setup for Sensors & Buzzers
TRIG_1 = 17
ECHO_1 = 27
TRIG_2 = 22
ECHO_2 = 10
TRIG_3 = 9
ECHO_3 = 11
Left_buzzer = 20
Right_buzzer = 21
