def test_color_new(): assert Color(0, 0, 0) == (0.0, 0.0, 0.0) assert Color(1, 1, 1) == (1.0, 1.0, 1.0) assert Color(255, 255, 255) == (1.0, 1.0, 1.0) with pytest.raises(ValueError): Color()
def captureOption(): #Clear Terminal ClearTerminal() #Capture Option typew( "\nOptions: \t\tValue\n1)Add text\t\t{}\n2)Brightness\t\t{}\n3)Contrast\t\t{}\n4)Text size\t\t{}\n5)Text Color\n6)Text Background Color\n7)Image Effect\t\t{}\n8)Exposure Mode\t\t{}\n9)Reset\n10)Back\n\nSelect: " .format(camera.annotate_text, camera.brightness, camera.contrast, camera.annotate_text_size, camera.image_effect, camera.exposure_mode)) choose = input() #Text if choose == "1": typew("Text: ") text = input() camera.annotate_text = text captureOption() #Brightness elif choose == "2": typew("\nBrightness({}): ".format(camera.brightness)) brightness = int(input()) if brightness >= 0 and brightness <= 100: camera.brightness = brightness else: typew("\nPlease input within 0-100\n") captureOption() #Contrast elif choose == "3": typew("\nContrast({}): ".format(camera.contrast)) contrast = int(input()) if contrast >= 0 and contrast <= 100: camera.contrast = contrast else: typew("\nPlease input within 0-100\n") captureOption() #Text size elif choose == "4": typew("\nText size({}): ".format(camera.annotate_text_size)) size = int(input()) if size >= 6 and size <= 160: camera.annotate_text_size = size else: typew("\nPlease input within 6-160\n") captureOption() #Text color elif choose == "5": typew("\nText color: ") colortype = input() colorselection = [ "red", "green", "blue", "black", "white", "yellow", "purple", "pink", "orange", "brown", "magenta", "cyan", "grey" ] if colortype.lower() in colorselection: camera.annotate_foreground = Color(colortype.lower()) else: typew("\nPlease type a valid color.\n") captureOption() #Text background color elif choose == "6": typew("\nText background color: ") colortype = input() colorselection = [ "red", "green", "blue", "black", "white", "yellow", "purple", "pink", "orange", "brown", "magenta", "cyan", "grey" ] if colortype.lower() in colorselection: camera.annotate_background = Color(colortype.lower()) else: typew("\nPlease type a valid color.\n") captureOption() #Image Effect elif choose == "7": typew( "\nEffect: none, negative, solarize, sketch, denoise, emboss, oilpaint, hatch, gpen, pastel, watercolor, film, blur, saturation, colorswap, washedout, posterise, colorpoint, colorbalance, cartoon, deinterlace1, and deinterlace2\n" ) typew("\nImage Effect({}): ".format(camera.image_effect)) effect = input() EffectType = [ "none", "negative", "solarize", "sketch", "denoise", "emboss", "oilpaint", "hatch", "gpen", "pastel", "watercolor", "film", "blur", "saturation", "colorswap", "washedout", "posterise", "colorpoint", "colorbalance", "cartoon", "deinterlace1", "deinterlace2" ] if effect.lower() in EffectType: camera.image_effect = effect.lower() else: typew("\nPlease type a valid effect.\n") captureOption() #Exposure Mode elif choose == "8": typew( "\nExposure Type: off, auto, night, nightpreview, backlight, spotlight, sports, snow, beach, verylong, fixedfps, antishake, and fireworks\n" ) typew("Exposure Mode({}): ".format(camera.exposure_mode)) mode = input() modeType = [ "off", "auto", "night", "nightpreview", "backlight", "spotlight", "sports", "snow", "beach", "verylong", "fixedfps", "antishake", "fireworks" ] if mode.lower() in modeType: camera.exposure_mode = mode.lower() else: typew("\nPlease type a valid exposure mode.\n") captureOption() #Reset elif choose == "9": camera.annotate_text = "" camera.contrast = 0 camera.brightness = 50 camera.annotate_text_size = 32 camera.annotate_foreground = Color("white") camera.annotate_background = None camera.image_effect = "none" camera.exposure_mode = "auto" typew("Done reset!!") captureOption() #Back elif choose == "10": Start() #Invalid option else: typew("Please type a valid selection") captureOption()
#pi_cam from picamera import PiCamera, Color from time import sleep camera = PiCamera() #settings camera.rotation = 180 camera.annotate_text = "Wanted for flying under the influence" camera.annotate_text_size = 150 camera.annotate_background = Color('white') camera.annotate_background = Color('red') camera.image_effect = 'posterise' camera.start_preview(alpha=200) sleep(5) camera.capture('/home/pi/Desktop/test1.jpg') camera.stop_preview()
from picamera import PiCamera, Color #get these obects in here from time import sleep #and this one camera = PiCamera() #make a camera object called 'camera' num = 0 #this is a counter num2 = 0 #this too effectsList = ['sketch', 'posterise', 'gpen', 'cartoon', 'negative', 'solarize', 'pastel', 'none', 'denoise', 'emboss', 'oilpaint', 'hatch', 'watercolor', 'film', 'blur', 'saturation', 'colorswap', 'washedout', 'colorpoint', 'colorbalance', 'deinterlace1', 'deinterlace2'] #this long boi contains all the effects we're gonna rotate through while(num < 22): #do this 22 times (we used a while loop because for loops are really gross in Python) camera.start_preview() #open the camera window camera.image_effect = effectsList[num] #set the effect to element 'num' of the effects list (first time is 'sketch', then 'posterise', etc.) camera.annotate_text_size = 55 #set text size camera.annotate_background = Color('Blue') #set background color camera.annotate_text = "This is effect " + effectsList[num] #write some text that says what affect we're using sleep(5) #pause for 5 seconds if(num2 < 5): #for the first 5 iterations, camera.capture('/home/pi/Desktop/' + effectsList[num] + '.jpg') #take a photo at this location with filename of effect type num2 = num2 + 1 #increment this counter num = num + 1 #increment this counter camera.stop_preview() #close the camera window
from picamera import PiCamera, Color from time import sleep camera = PiCamera() #Image can be rotated by 90, 180, 270 degrees, or 0 to reset camera.rotation = 180 #Preview only works if Pi is connected to a monitor #An alpha level can be passed to start_preview to alter the transparency of the preview (0-255) #camera.start_preview(alpha = 200) camera.start_preview() """ The annotation text's background and foreground color can be altered using the Color library from picamera """ camera.annotate_background = Color("blue") camera.annotate_foreground = Color("yellow") #Text can be added to an image using annotate_text camera.annotate_text = "Hello world!" #Sleep for at least 2 seconds to allow the sensor to set its light levels sleep(5) #The path passed to capture is where the picture is saved camera.capture("/home/pi/Desktop/text.jpg") camera.stop_preview()
from picamera import PiCamera, Color from time import sleep demoCamera = PiCamera() demoCamera.start_preview() #打开摄像头预览 demoCamera.annotate_background = Color('white') demoCamera.annotate_foreground = Color('red') demoCamera.resolution = (480, 320) #设置摄像头的分辨率 demoCamera.framate = 60 #设定摄像头的帧率 demoCamera.annotate_text = " SWS3009B - 2018" #在图像上方显示一段文字 sleep(5) #休息5秒 demoCamera.capture('/home/pi/Desktop/classPhoto.jpg') #拍下一张照片 demoCamera.stop_preview() #关闭摄像头预览
# min (64, 64), max (2592, 1944) # camera.resolution = (2592, 1944) # max 15 # camera.framerate = 15 # min 0, max 100 camera.brightness = 70 # min 0, max 100 camera.contrast = 50 # min 6, max 160 camera.annotate_text_size = 32 camera.annotate_background = Color('black') camera.annotate_foreground = Color('white') while True: curtime = datetime.now() outstring = curtime.strftime('%Y/%m/%d %H:%M:%S') filename = "/home/adrian/go/src/adrian/upstairs-" + curtime.strftime( '%Y%m%d-%H:%M:%S') + ".jpg" camera.annotate_text = outstring # camera.start_preview() # sleep(1) camera.capture(filename) # camera.stop_preview() sleep(120)
from picamera import PiCamera, Color from time import sleep import datetime as dt import numpy as np import os from flask import request from flask import Flask, url_for camera = PiCamera() camera.rotation = 180 camera.annotate_text_size = 92 camera.annotate_foreground = Color(r=255, g=255, b=255) camera.annotate_background = Color(r=0, g=0, b=0) def take_picture(name='image.jpg'): #path='/home/pi/Desktop/' unique_id = ''.join([str(np.random.randint(10)) for i in range(20)]) path = "static/" + unique_id camera.annotate_text = "Facebook Hackathon " + dt.datetime.now().strftime( '%Y-%m-%d %H:%M:%S') camera.start_preview() sleep(1) camera.capture(path + name) camera.stop_preview() return path + name
from picamera import PiCamera, Color from time import sleep import time import datetime camera = PiCamera() # camera.resolution = (2592, 1944) # camera.framerate = 15 # camera.rotation = 180 camera.annotate_text_size = 30 camera.annotate_foreground = Color('white') camera.start_preview() for i in range(2): sleep(2) camera.annotate_text = (time.strftime('%H:%M:%S', time.localtime()) + " (" + datetime.date.today().isoformat() + ")") camera.capture('/home/pi/Desktop/image%s.jpg' % i) camera.stop_preview()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', help='File path of .tflite file.', required=True) parser.add_argument('--labels', help='File path of labels file.', required=True) args = parser.parse_args() labels = load_labels(args.labels) interpreter = Interpreter(args.model) interpreter.allocate_tensors() _, height, width, _ = interpreter.get_input_details()[0]['shape'] cameraW = 640 cameraH = 480 frameTime = time.time() * 1000 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: sock.connect((targetHost, targetPort)) with picamera.PiCamera(resolution=(cameraW, cameraH), framerate=30) as camera: camera.start_preview(alpha=255) camera.annotate_foreground = Color('black') camera.annotate_background = Color('white') try: stream = io.BytesIO() for _ in camera.capture_continuous(stream, format='jpeg', use_video_port=True): stream.seek(0) image = Image.open(stream).convert('RGB').resize( (width, height), Image.ANTIALIAS) start_time = time.time() results = classify_image(interpreter, image) elapsed_ms = (time.time() - start_time) * 1000 stream.seek(0) stream.truncate() msg = "" for i in range(10): label = labels[results[1][i] + 1] prob = clamp(0, results[2][i], 1) top = clamp(0, results[0][i][0], 1) left = clamp(0, results[0][i][1], 1) bottom = clamp(0, results[0][i][2], 1) right = clamp(0, results[0][i][3], 1) msg += ( "{0:20} {1:3.1f}% {2:3.3f} {3:3.3f} {4:3.3f} {5:3.3f} {6: 5.1f}ms\n" .format(label, prob * 100, top, left, bottom, right, elapsed_ms)) msg += ( "--------------------------------------------------\n") sock.sendall(bytes(msg + "\n", "utf-8")) #pdb.set_trace() bestIdx = np.argmax(results[2]) label = labels[results[1][bestIdx] + 1] prob = clamp(0, results[2][bestIdx], 1) top = clamp(0, results[0][bestIdx][0], 1) left = clamp(0, results[0][bestIdx][1], 1) bottom = clamp(0, results[0][bestIdx][2], 1) right = clamp(0, results[0][bestIdx][3], 1) camera.annotate_text = '%s (%.1f%%)\n%.1fms' % ( label, prob * 100, elapsed_ms) finally: camera.stop_preview()
def main(): ################################################## # Initialise LCD ## LCD = LCD_1in8.LCD() LCD = ST7735() ## Lcd_ScanDir = LCD_1in8.SCAN_DIR_DFT ## LCD.LCD_Init(Lcd_ScanDir) LCD.begin() ## screenbuf = Image.new("RGB", (LCD.LCD_Dis_Column, LCD.LCD_Dis_Page), "WHITE") screenbuf = Image.new("RGB", (DISPLAY_WIDTH, DISPLAY_HEIGHT), "WHITE") draw = ImageDraw.Draw(screenbuf) draw.text((33, 22), 'Initialising...', fill="BLUE", font=FONT_LARGE) ## LCD.LCD_PageImage(screenbuf) LCD.display(screenbuf) ################################################## parser = argparse.ArgumentParser() parser.add_argument('--model', help='File path of .tflite file.', required=True) parser.add_argument('--labels', help='File path of labels file.', required=True) args = parser.parse_args() labels = load_labels(args.labels) interpreter = Interpreter(args.model) interpreter.allocate_tensors() _, height, width, _ = interpreter.get_input_details()[0]['shape'] cameraW = 640 cameraH = 480 frameTime = time.time() * 1000 with picamera.PiCamera(resolution=(cameraW, cameraH), framerate=30) as camera: camera.start_preview(alpha=255) camera.annotate_foreground = Color('black') camera.annotate_background = Color('white') try: stream = io.BytesIO() for _ in camera.capture_continuous(stream, format='jpeg', use_video_port=True): stream.seek(0) image = Image.open(stream).convert('RGB').resize( (width, height), Image.ANTIALIAS) start_time = time.process_time() results = classify_image(interpreter, image) elapsed_ms = (time.process_time() - start_time) * 1000 stream.seek(0) stream.truncate() # paste camera captured image into screen buffer screenbuf.paste(image.resize((DISPLAY_WIDTH, DISPLAY_HEIGHT))) availColours = [ 'salmon', 'olive', 'orange', 'purple', 'aqua', 'darkgray', 'yellow', 'sienna', 'red', 'blue', 'green' ] usedColours = {} msg = "" for i in range(10): label = labels[results[1][i] + 1] prob = clamp(0, results[2][i], 1) if prob >= 0.5: if label in usedColours: colour = usedColours[label] elif availColours == []: colour = 'salmon' else: colour = availColours.pop() usedColours[label] = colour top = clamp(0, results[0][i][0], 1) left = clamp(0, results[0][i][1], 1) bottom = clamp(0, results[0][i][2], 1) right = clamp(0, results[0][i][3], 1) # draw bounding box draw.rectangle( [(left * DISPLAY_WIDTH, top * DISPLAY_HEIGHT), (right * DISPLAY_WIDTH, bottom * DISPLAY_HEIGHT)], outline=colour) desc = ("{0} {1:3.1f}%".format(label, prob * 100)) txtw, txth = FONT_SMALL.getsize(desc) # draw label rectangle draw.rectangle( [(left * DISPLAY_WIDTH, top * DISPLAY_HEIGHT), (left * DISPLAY_WIDTH + txtw, top * DISPLAY_HEIGHT + txth)], fill=colour) # draw label draw.text((left * DISPLAY_WIDTH, top * DISPLAY_HEIGHT), desc, fill="WHITE", font=FONT_SMALL) # record info for log msg += ( "{0:20} {1:3.1f}% {2:3.3f} {3:3.3f} {4:3.3f} {5:3.3f} {6: 5.1f}ms\n" .format(label, prob * 100, top, left, bottom, right, elapsed_ms)) elapsed_txt = "{0: 5.1f}ms".format(elapsed_ms) txtw, txth = FONT_SMALL.getsize(elapsed_txt) draw.text((DISPLAY_WIDTH - txtw, 0), elapsed_txt, fill="WHITE", font=FONT_SMALL) LCD.display(screenbuf) msg += ("--------------------------------------------------\n") print(msg) #pdb.set_trace() bestIdx = np.argmax(results[2]) label = labels[results[1][bestIdx] + 1] prob = clamp(0, results[2][bestIdx], 1) top = clamp(0, results[0][bestIdx][0], 1) left = clamp(0, results[0][bestIdx][1], 1) bottom = clamp(0, results[0][bestIdx][2], 1) right = clamp(0, results[0][bestIdx][3], 1) # camera.annotate_text = '%s (%.1f%%)\n%.1fms' % (label, prob*100, elapsed_ms) finally: camera.stop_preview() LCD.LCD_Clear()
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')
from picamera import PiCamera, Color from datetime import datetime camera = PiCamera() # take a series of shots without delay #for i in range(3): filename = datetime.today() #filename2="{0:%Y}-{0:%m}-{0:%d}".format(now) #camera.capture( '/root/Pictures/Example1/{0:%Y}-{0:%m}-{0:%d}'.format(now).jpg) print(filename) camera.annotate_background = Color("teal") camera.annotate_foreground = Color("lightpink") camera.annotate_text = datetime.now().strftime('%Y-%m-%d %H:%M:%S') camera.annotate_text_size = 55 camera.capture('/root/Pictures/Example1/PhotoWithDataToday.jpg')
def test_color_new_rgb(): assert Color(r=1, g=0, b=0) == (1.0, 0.0, 0.0) assert Color(r=255, g=255, b=255) == (1.0, 1.0, 1.0) assert Color(red=1, green=0, blue=0.0) == (1.0, 0.0, 0.0) assert Color(red=255, green=255, blue=255) == (1.0, 1.0, 1.0)
sleep(0.1) camera.stop_preview() camera.start_preview() for i in range(100): camera.annotate_text = "Contrast: %s" % i camera.contrast = i sleep(0.1) camera.stop_preview() camera.annotate_text_size = 86 from picamera import PiCamera, Color camera.start_preview() camera.annotate_background = Color('red') camera.annotate_foreground = Color('green') camera.annotate_text = "Dis Guy.... playing Fortnite" sleep(5) camera.stop_preview() camera.start_preview() camera.image_effect = 'colorswap' sleep(5) camera.capture('/home/pi/Desktop/colorswap.jpg') camera.stop_preview() camera.start_preview() for effect in camera.IMAGE_EFFECTS: camera.image_effect = effect camera.annotate_text = "Effect: %s" % effect
from picamera import PiCamera, Color from time import sleep camera = PiCamera() camera.resolution = ( 2592, 1944 ) # Resolucion maxima de las fotografias 2592 x 1944, la resolucion minima que se permite es 64 x 64. camera.framerate = 15 # Para lograr la resolucion maxima se debe configurar los cuadros por segundo en "15". camera.rotation = 0 # Rotar la imagen en 0, 90, 180 o 270 grados camera.start_preview( ) # Dentro del parentesis se puede escribir (alpha=200) lo que permite generar transparencia en la preview. Pero no en el video. camera.exposure_mode = 'auto' # Exposicion de la fotografia. Por defecto es "auto". Opciones (off, auto, night, nightpreview, backlight, spotlight, sports, snow, beach, verylong, fixedfps, antishake, fireworks) camera.awb_mode = 'auto' # Balance de blacos. Por defecto es "auto". Opciones (off, auto, sunlight, cloudy, shade, tungsten, fluorescent, incandescent, flash, horizon) camera.image_effect = 'none' # Opciones de efectos en la fotografia. Por defecto es "none". (none, negative, solarize, sketch, denoise, emboss, oilpaint, hatch, gpen, pastel, watercolor, film, blur, saturation, colorswap, washedout, posterise, colorpoint, colorbalance, cartoon, deinterlace1, deinterlace2) camera.annotate_background = Color('white') # Color del background del texto camera.annotate_foreground = Color('black') # Color de las letras del texto camera.annotate_text = "Escuela Las Cruces" # Texto que llevara la fotografia camera.annotate_text_size = 100 # Va de 6 a 160. Por defecto es 32. camera.brightness = 50 # Brillo de la fotografia (Por defecto es 50%). Va de 0 a 100. camera.contrast = 50 # Constraste de la fotografia (Por defecto es 50%). Va de 0 a 100. for i in range( 1 ): # El numero dentro del parentesis indica el numero de fotografias que se quieren tomar al correr el script sleep(5) camera.capture( '/home/pi/Desktop/image%s.jpg' % i ) #Direccion donde se guardaran las fotografias. Se nombraran como "imagen" y el numero que corresponde a el orden de toma. camera.stop_preview() # LOOPS DE AYUDA
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', help='File path of .tflite file.', required=True) parser.add_argument('--labels', help='File path of labels file.', required=True) args = parser.parse_args() labels = load_labels(args.labels) interpreter = Interpreter(args.model) interpreter.allocate_tensors() _, height, width, _ = interpreter.get_input_details()[0]['shape'] cameraW = 640 cameraH = 480 def clampW(x): return clamp(0, x, cameraW - 1) def clampH(x): return clamp(0, x, cameraH - 1) ov = np.zeros((cameraH, cameraW, 3), dtype=np.uint8) ov[:, :, :] = 0 frameTime = time.time() * 1000 overlayInterval = 100 with picamera.PiCamera(resolution=(cameraW, cameraH), framerate=30) as camera: camera.start_preview(alpha=255) camera.annotate_foreground = Color('black') camera.annotate_background = Color('white') overlay = camera.add_overlay(ov.tobytes(), layer=3, alpha=64) try: stream = io.BytesIO() for _ in camera.capture_continuous(stream, format='jpeg', use_video_port=True): stream.seek(0) image = Image.open(stream).convert('RGB').resize( (width, height), Image.ANTIALIAS) start_time = time.time() results = classify_image(interpreter, image) elapsed_ms = (time.time() - start_time) * 1000 stream.seek(0) stream.truncate() bestIdx = np.argmax(results[2]) label = labels[results[1][bestIdx] + 1] prob = results[2][bestIdx] top = int(np.round(results[0][bestIdx][0] * cameraH)) left = int(np.round(results[0][bestIdx][1] * cameraW)) bottom = int(np.round(results[0][bestIdx][2] * cameraH)) right = int(np.round(results[0][bestIdx][3] * cameraW)) ov[:, :, :] = 0 if top >= 0 and top < cameraH: ov[top, clampW(left):clampW(right), :] = 0xff if bottom >= 0 and bottom < cameraH: ov[bottom, clampW(left):clampW(right), :] = 0xff if left >= 0 and left < cameraW: ov[clampH(top):clampH(bottom), left, :] = 0xff if right >= 0 and right < cameraW: ov[clampH(top):clampH(bottom), right, :] = 0xff if time.time() * 1000 - frameTime > overlayInterval: overlay.update(ov.tobytes()) frameTime = time.time() * 1000 #pdb.set_trace() camera.annotate_text = '%s (%.1f%%)\n%.1fms' % ( label, prob * 100, elapsed_ms) finally: camera.remove_overlay(overlay) camera.stop_preview()
def annotate_picture(camera, camera_config): camera.annotate_text_size = 14 camera.annotate_foreground = Color('black') camera.annotate_background = Color('white') camera.annotate_text = json.dumps({k: v for k, v in camera_config.items() if 'preview' not in k}, indent=4)
def main(): logger.info('Pi-Cam daemon starting...') timeout = 1 local_ip = '127.0.0.1' local_port = 1301 buffer_size = 1024 daemon_killer = GracefulKillDaemon() udp_server = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM) udp_server.bind((local_ip, local_port)) udp_server.setblocking(0) logger.info('UDP server up and listening on {}:{}'.format(local_ip, local_port)) supported_commands = ['start_preview\([\s]*\)', \ 'stop_preview\([\s]*\)', \ 'resolution[\s]*=[\s]*\(\d{,4}[\s]*\,[\s]*\d{,4}\)', \ 'annotate_text_size[\s]*=[\s]*\d{,3}', \ 'annotate_text[\s]*=[\s]*\"[\w\s\%\.\-:;!@#$%&*()+=<>/]*\"', \ 'brightness[\s]*=[\s]*\d{,3}', \ 'rotation[\s]*=[\s]*\d{,3}', \ 'framerate[\s]*=[\s]*\d{,3}', \ 'contrast[\s]*=[\s]*\d{,3}', \ 'iso[\s]*=[\s]*\d{,3}', \ 'capture\([\s]*\"[\w\%/\-\.]*\"[\s]*\)', \ 'start_recording\([\s]*\"[\w\%/\-\.]*\"[\s]*\)', \ 'stop_recording\([\s]*\)', \ 'annotate_background[\s]*=[\s]*Color\([\s]*\"[a-z]*\"[\s]*\)', \ 'annotate_background[\s]*=[\s]*None', \ 'annotate_foreground[\s]*=[\s]*Color\([\s]*\"[a-z]*\"[\s]*\)', \ 'image_effect[\s]*=[\s]*\"[\w]*\"[\s]*', \ # image_effect: none, negative, solarize, sketch, denoise, emboss, oilpaint, hatch, gpen, pastel, watercolor, film # blur, saturation, colorswap, washedout, posterise, colorpoint, colorbalance, cartoon, deinterlace1, deinterlace2 'exposure_mode[\s]*=[\s]*\"[a-z]*\"[\s]*', \ # exposure_mode: off, auto, night, nightpreview, backlight, spotlight, sports, snow, beach, verylong, fixedfps, antishake, fireworks 'awb_mode[\s]*=[\s]*\"[a-z]*\"[\s]*', \ # awb_mode: off, auto, sunlight, cloudy, shade, tungsten, fluorescent, incandescent, flash, horizon ] #text_to_annotate = ' %H:%M:%S on %Y %B %d ' text_to_annotate = '' recording = False with PiCamera() as camera: camera.rotation = 180 camera.framerate = 20 camera.resolution = (2592, 1440) camera.start_preview() camera.annotate_text_size = 40 camera.annotate_background = Color('black') camera.annotate_foreground = Color('white') while not(daemon_killer.kill_now): camera.annotate_text = datetime.datetime.now().strftime(text_to_annotate) ready = select.select([udp_server], [], [], timeout) if ready[0]: server_response = 'OK' received = udp_server.recvfrom(buffer_size) message = received[0].decode().strip() address = received[1] logger.info('Message from Client {}: "{}"'.format(address, message)) match = False for expression in supported_commands: if re.match(expression, message): match = True if (message.startswith('annotate_text ')) or (message.startswith('annotate_text=')): message = message[message.find('=') + 1:].strip() text_to_annotate = message.replace('"', '') break if message.startswith('stop_recording'): if not(recording): server_response = 'There is no recording in progress' break elif message.startswith('capture'): message = message[message.find('(') + 1:].strip() message = message.strip(')').strip() message = ''.join(['capture(datetime.datetime.now().strftime(', message, '))']) elif message.startswith('start_recording'): message = message[message.find("(") + 1:].strip() message = message.strip(')').strip() message = message.strip('"').strip() if (message.find('.h264') != (len(message) - 5)) and (message.find('.mjpeg') != (len(message) - 6)): message = ''.join([message, '.h264']) message = ''.join(['start_recording(datetime.datetime.now().strftime("', message, '"))']) try: exec(''.join(['camera.', message])) except (ValueError, TypeError) as e: server_response = '{}'.format(e) logger.warning(server_response) else: if message.startswith('start_recording'): recording = True break if not(match): server_response = 'Unsupported command' bytes_to_send = str.encode(server_response) udp_server.sendto(bytes_to_send, address) camera.stop_preview() logger.info('Bye!')
def main(): ################################################## # Initialise LCD ## LCD = LCD_1in8.LCD() LCD = ST7735() ## Lcd_ScanDir = LCD_1in8.SCAN_DIR_DFT ## LCD.LCD_Init(Lcd_ScanDir) LCD.begin() ## screenbuf = Image.new("RGB", (LCD.LCD_Dis_Column, LCD.LCD_Dis_Page), "WHITE") screenbuf = Image.new("RGB", (DISPLAY_WIDTH, DISPLAY_HEIGHT), "WHITE") draw = ImageDraw.Draw(screenbuf) draw.text((33, 22), 'LCD Demo', fill="BLUE", font=FONT_SMALL) ## LCD.LCD_PageImage(screenbuf) LCD.display(screenbuf) ################################################## parser = argparse.ArgumentParser() parser.add_argument('--model', help='File path of .tflite file.', required=True) parser.add_argument('--labels', help='File path of labels file.', required=True) args = parser.parse_args() labels = load_labels(args.labels) interpreter = Interpreter(args.model) interpreter.allocate_tensors() _, height, width, _ = interpreter.get_input_details()[0]['shape'] cameraW = 640 cameraH = 480 frameTime = time.time() * 1000 with picamera.PiCamera(resolution=(cameraW, cameraH), framerate=30) as camera: camera.start_preview(alpha=255) camera.annotate_foreground = Color('black') camera.annotate_background = Color('white') try: stream = io.BytesIO() for _ in camera.capture_continuous(stream, format='jpeg', use_video_port=True): stream.seek(0) image = Image.open(stream).convert('RGB').resize( (width, height), Image.ANTIALIAS) start_time = time.time() results = classify_image(interpreter, image) elapsed_ms = (time.time() - start_time) * 1000 stream.seek(0) stream.truncate() msg = "" for i in range(10): label = labels[results[1][i] + 1] prob = clamp(0, results[2][i], 1) top = clamp(0, results[0][i][0], 1) left = clamp(0, results[0][i][1], 1) bottom = clamp(0, results[0][i][2], 1) right = clamp(0, results[0][i][3], 1) msg += ( "{0:20} {1:3.1f}% {2:3.3f} {3:3.3f} {4:3.3f} {5:3.3f} {6: 5.1f}ms\n" .format(label, prob * 100, top, left, bottom, right, elapsed_ms)) draw.rectangle([(0, 0), (160, 128)], fill="WHITE") ## LCD.LCD_PageImage(screenbuf) screenbuf.paste(image.resize((DISPLAY_WIDTH, DISPLAY_HEIGHT))) # draw.rectangle([(0,0),(160,128)], outline = "RED") draw.text((0, 0), msg, fill="BLUE", font=FONT_SMALL) LCD.display(screenbuf) msg += ("--------------------------------------------------\n") print(msg) #pdb.set_trace() bestIdx = np.argmax(results[2]) label = labels[results[1][bestIdx] + 1] prob = clamp(0, results[2][bestIdx], 1) top = clamp(0, results[0][bestIdx][0], 1) left = clamp(0, results[0][bestIdx][1], 1) bottom = clamp(0, results[0][bestIdx][2], 1) right = clamp(0, results[0][bestIdx][3], 1) camera.annotate_text = '%s (%.1f%%)\n%.1fms' % ( label, prob * 100, elapsed_ms) finally: camera.stop_preview() LCD.LCD_Clear()
from picamera import PiCamera, Color from time import sleep # Modified from ch5listing5.py of Page 33 of TheMagPi 'Official Camera Guide' PDF # NOTE: To make picamera preview show when viewing over VNC... # Go to the VNC icon on the taskbar, click the Menu, Options > Troubleshooting # and tick 'Enable Direct Capture Mode', and apply the changes camera = PiCamera() sleep(2) # allow the camera to start up fully camera.start_preview(fullscreen=False, window=(50, 150, 1024, 576)) for effect in camera.IMAGE_EFFECTS: for awbmode in camera.AWB_MODES: camera.awb_mode = awbmode camera.image_effect = effect camera.annotate_background = Color('black') camera.annotate_text = "Effect: {0}, AWB Mode: {1}".format( effect, awbmode) camera.capture('/home/pi/Camera/img_effect_{0}_awbmode_{1}.jpg'.format( effect, awbmode)) sleep(2) camera.stop_preview() camera.close( ) # to turn off the camera (and its status LED) when the script has completed
def encoder1(): return 8 * GPIO.input(26) + 4 * GPIO.input(19) + 2 * GPIO.input( 13) + GPIO.input(6) # create a instance of Picamera camera = PiCamera() # rotate camera 180 degree camera.rotation = 180 ##camera.framerate=15 # preview window size camera.resolution = (500, 1100) camera.annotate_text_size = 160 camera.annotate_background = Color('green') camera.annotate_foreground = Color('yellow') camera.start_preview(alpha=255, fullscreen=False, window=(0, 0, 500, 1100)) sleep(3) # different for loops are using different filters or change different settings for i in range(5): # from selfie0 to selfie4 sleep(3) camera.capture('/home/pi/pro/selfie%s.jpg' % i) #1600x1200 1.2MB # take a video camera.start_recording('/home/pi/pro/firstvideo.h264') # video sleep(5) camera.stop_recording() ##for i in range (100): %change brightness and annotate
def main(): parser = argparse.ArgumentParser() parser.add_argument( '--model_path', required=True, help='Path to converted model file that can run on VisionKit.') parser.add_argument( '--label_path', required=True, help='Path to label file that corresponds to the model.') parser.add_argument('--input_height', type=int, required=True, help='Input height.') parser.add_argument('--input_width', type=int, required=True, help='Input width.') parser.add_argument('--input_layer', required=True, help='Name of input layer.') parser.add_argument('--output_layer', required=True, help='Name of output layer.') parser.add_argument( '--num_frames', type=int, default=None, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--input_mean', type=float, default=128.0, help='Input mean.') parser.add_argument('--input_std', type=float, default=128.0, help='Input std.') parser.add_argument('--input_depth', type=int, default=3, help='Input depth.') parser.add_argument( '--threshold', type=float, default=0.1, help='Threshold for classification score (from output tensor).') parser.add_argument('--top_k', type=int, default=3, help='Keep at most top_k labels.') parser.add_argument( '--preview', action='store_true', default=False, help= 'Enables camera preview in addition to printing result to terminal.') parser.add_argument('--show_fps', action='store_true', default=False, help='Shows end to end FPS.') args = parser.parse_args() model = inference.ModelDescriptor( name='mobilenet_based_classifier', input_shape=(1, args.input_height, args.input_width, args.input_depth), input_normalizer=(args.input_mean, args.input_std), compute_graph=utils.load_compute_graph(args.model_path)) labels = read_labels(args.label_path) with PiCamera(sensor_mode=4, resolution=(1640, 1232), framerate=30) as camera: if args.preview: camera.start_preview() with inference.CameraInference(model) as camera_inference: for result in camera_inference.run(args.num_frames): processed_result = process(result, labels, args.output_layer, args.threshold, args.top_k) send_signal_to_servos(processed_result[0]) message = get_message(processed_result, args.threshold, args.top_k) if args.show_fps: message += '\nWith %.1f FPS.' % camera_inference.rate print(message) if args.preview: camera.annotate_foreground = Color('black') camera.annotate_background = Color('white') # PiCamera text annotation only supports ascii. camera.annotate_text = '\n %s' % message.encode( 'ascii', 'backslashreplace').decode('ascii') if args.preview: camera.stop_preview()
def addTextNight(texto): global camera # camera.annotate_background = Color('white') camera.annotate_foreground = Color('white') camera.annotate_text_size = 50 camera.annotate_text = texto
from picamera import PiCamera, Color from time import sleep with PiCamera() as camera: camera.start_preview() camera.annotate_text_size = 50 camera.annotate_background = Color('green') camera.annotate_foreground = Color('white') camera.annotate_text = " Hello World " sleep(5) camera.capture("picamera_02.jpg") camera.stop_preview()
from picamera import Color led = RGBLED(12, 20, 16) # or whatever pins you’re using led.color = Color('#ffffff') # supports HTML color specs led.color = Color('violet') # or CSS color names led.color = Color(255, 127, 0) # or 0-255 bytes led.color = Color(0.0, 0.5, 0.0) # or 0-1 floats led.color = Color(hue=0, saturation=0.5, lightness=0.5)
def set_annotations(self): self.camera.annotate_background = Color('blue') self.camera.annotate_foreground = Color('yellow') self.camera.annotate_text = "Bongji Cam" self.camera.annotate_text_size = 50
# Quay servo de bao san sang Servos.rotate(0) # Phat am thanh de bao san sang soundfile = sounds_dirr + 'ready.mp3' playSound(soundfile) print("Press Button!!") while True: # Neu button dang nhan if Button.isPressed(): print("Button is pressed") rawCapture = PiRGBArray(camera, size=(720, 480)) camera.start_preview() camera.annotate_background = Color("blue") camera.start_recording(video_output_file) i = 0 for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True): print(i) # 15 frame lay 1 frame xu ly if (i % 10 == 0): test_image = rawCapture.array # Xu ly anh start_time1 = time.time() test_image2 = test_image test_image = cv2.cvtColor(test_image, cv2.COLOR_BGR2GRAY) test_image = cv2.resize(test_image, (128, 128))
from picamera import PiCamera, Color from time import sleep camera = PiCamera() camera.start_preview() camera.annotate_text_size = 50 camera.annotate_background = Color('blue') camera.annotate_foreground = Color('yellow') camera.annotate_text = " Hello world " sleep(5) camera.capture('/home/pi/Desktop/text.jpg') camera.stop_preview()
def register(): folder_dir = "/home/pi/Face_Recognition_Door_Lock/dataset/Known/" # 해당하는 폴더가 없을 경우 생성해줌 if os.path.isdir(folder_dir) == False: os.mkdir(folder_dir) people_name = input("유저 이름: ") if people_name.find('Unknown') > -1 or people_name.find('unknown') > -1: print("[Info]: Can not using name 'unknown'") print("[Info] return the menu") pass elif people_name == "" or people_name.find(' ') > -1: print("[Info]: The name can't contain 'blank'") print("[Info]: return the menu") pass else: save_path = folder_dir + people_name + "/" print("저장할 폴더의 경로는 " + save_path + " 입니다.") # 해당하는 폴더가 없을 경우 생성해줌 if os.path.isdir(save_path) == False: os.mkdir(save_path) with PiCamera() as camera: camera.rotation = 90 camera.annotate_text_size = 100 camera.annotate_background = Color('red') camera.annotate_foreground = Color('yellow') camera.start_preview() camera.brightness = 50 camera.exposure_mode = 'auto' for i in range(5, 0, -1): camera.annotate_text = str(i) time.sleep(1) camera.annotate_text = "" for i in range(10): time.sleep(0.5) camera.capture(save_path + people_name + '%s.jpg' % i) camera.annotate_text = "Finish!" time.sleep(2) camera.stop_preview() encodings_path = "/home/pi/Face_Recognition_Door_Lock/encoding/" if os.path.isdir(encodings_path) == False: os.mkdir(encodings_path) #datasets에 들어있는 이미지 list imagePaths = list(paths.list_images(save_path)) #얼굴 embedding vector 데이터를 저장할 knownEncodings 리스트와, 학습한 얼굴 이름을 저장할 knownNames 리스트 knownEncodings = [] knownNames = [] # dataset의 경로 상에 있는 이미지를 모두 가져옴 for (i, imagePath) in enumerate(imagePaths): print("[INFO] processing image {}/{}".format( i + 1, len(imagePaths))) name = imagePath.split(os.path.sep)[-2] image = cv2.imread(imagePath) rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # 얼굴의 박스 영역을 찾아줌 boxes = face_recognition.face_locations(rgb, model="hog") if not boxes: print("[ERROR] Face does not detected") pass # 박스 영역의 얼굴 임베딩 데이터를 추출 encodings = face_recognition.face_encodings(rgb, boxes) # loop over the encodings for encoding in encodings: knownEncodings.append(encoding) knownNames.append(name) if not knownEncodings: print("[Error] Can't detect faces in all images") else: # 얼굴 임베딩 데이터와 이름을 pickle 파일로 저장 print("[INFO] serializing encodings...") data = {"encodings": knownEncodings, "names": knownNames} with open(encodings_path + people_name + ".pkl", "wb") as f: f.write(pickle.dumps(data)) f.close() print("[Info] Delete images used for encoding") rmtree(save_path)