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