def new_execute(): global recst global recbtn GPIO.setmode(GPIO.BOARD) GPIO.setup(recbtn, GPIO.IN) GPIO.add_event_detect(recbtn, GPIO.FALLING, callback=btn_th, bouncetime=200) phpath = "./data/rec/" os.makedirs(phpath, exist_ok=True) # Left Camera camera0 = nano.Camera(device_id=0, flip=2, width=224, height=224, fps=60) # Right Camera camera1 = nano.Camera(device_id=1, flip=2, width=224, height=224, fps=60) # wait rec button print("REC wait ...") waitrec() # rec start print("REC START! ...") # recloop_old(camera0, "./data/apex/", 0.1) # recloopDual_old(camera0,camera1, phpathL,phpathR, 0.1) # recloopStereo_old(camera0,camera1, phpathMx, phpathL,phpathR, 0.1) recloopDual(camera0, camera1, phpath, 0.05) # testloop() print("REC END!! ...") camera0.release() camera1.release() # finish del camera0 GPIO.cleanup()
def init_nanocam(imgwd, imghg, fpsc, angle): # Left Camera cameraL = nano.Camera(device_id=0, flip=angle, width=imgwd, height=imghg, fps=fpsc) # Right Camera cameraR = nano.Camera(device_id=1, flip=angle, width=imgwd, height=imghg, fps=fpsc) return cameraL, cameraR
def doexecute(): print("start") CATEGORIES = ['apex'] device = torch.device('cuda') model = torchvision.models.resnet18(pretrained=False) model.fc = torch.nn.Linear(512, 2 * len(CATEGORIES)) model = model.cuda().eval().half() # model.load_state_dict(torch.load('model.pth')) model.load_state_dict(torch.load('data/model.pth')) print("1") data = torch.zeros((1, 3, 224, 224)).cuda().half() model_trt = torch2trt(model, [data], fp16_mode=True) torch.save(model_trt.state_dict(), 'road_following_model_trt.pth') print("2") model_trt = TRTModule() model_trt.load_state_dict(torch.load('road_following_model_trt.pth')) print("model load end") car = NvidiaRacecar() # Left Camera camera0 = nano.Camera(device_id=0, flip=2, width=224, height=224, fps=60) # Right Camera camera1 = nano.Camera(device_id=1, flip=2, width=224, height=224, fps=60) STEERING_GAIN = 0.75 STEERING_BIAS = 0.00 cnt = 0 while True: image = camera0.read() image = preprocess(image).half() output = model_trt(image).detach().cpu().numpy().flatten() x = float(output[0]) car.steering = x * STEERING_GAIN + STEERING_BIAS car.throttle = 0.5 print(str(cnt) + ":" + str(x) + ":") cnt = cnt + 1
def prepare(): # 走行Button GPIO.setmode(GPIO.BOARD) GPIO.setup(recbtn, GPIO.IN) GPIO.add_event_detect(gobtn, GPIO.FALLING, callback=btn_thrd, bouncetime=200) # Left Camera camera0 = nano.Camera(device_id=0, flip=2, width=224, height=224, fps=60) # Right Camera camera1 = nano.Camera(device_id=1, flip=2, width=224, height=224, fps=60) CATEGORIES = ['apex'] device = torch.device('cuda') model = torchvision.models.resnet18(pretrained=False) model.fc = torch.nn.Linear(512, 2 * len(CATEGORIES)) model = model.cuda().eval().half() # model.load_state_dict(torch.load('model.pth')) model.load_state_dict(torch.load('data/model.pth')) data = torch.zeros((1, 3, 224, 224)).cuda().half() model_trt = torch2trt(model, [data], fp16_mode=True) torch.save(model_trt.state_dict(), 'road_following_model_trt.pth') model_trt = TRTModule() model_trt.load_state_dict(torch.load('road_following_model_trt.pth')) car = NvidiaRacecar() STEERING_GAIN = -0.75 STEERING_BIAS = 0.00 car.throttle = 0.25 cnt = 0 while True: image = camera0.read() image = preprocess(image).half() output = model_trt(image).detach().cpu().numpy().flatten() x = float(output[0]) car.steering = x * STEERING_GAIN + STEERING_BIAS print(str(cnt) + ":" + str(x) + ":") cnt = cnt + 1
def __init__(self, settings, camSpecs): # Create the Camera instance self.camera = nano.Camera(flip=2, width=1280, height=720, fps=60) print('CSI Camera ready? - ', self.camera.isReady()) # read the first camera image frame_read = self.camera.read() # Setup the variables we need, hopefully this function stays active self.yolo = YOLO() height, width = frame_read.shape[:2] self.yolo.init(width, height, time.time(), settings, camSpecs)
def __init__(self, settings, camSpecs, unitTest): self.unitTest = unitTest if self.unitTest: self.cap = cv2.VideoCapture(settings.inputFilename) # Local Stored video detection - Set input video ret, frame_read = self.cap.read() # Capture frame and return true if frame present else: # Create the Camera instance self.camera = nano.Camera(flip=2, width=1280, height=720, fps=60) print('CSI Camera ready? - ', self.camera.isReady()) # read the first camera image frame_read = self.camera.read() # Setup the variables we need, hopefully this function stays active self.yolo = YOLO() height, width = frame_read.shape[:2] self.yolo.init(width, height, time.time(), settings, camSpecs)
def main(args=None): rclpy.init(args=args) node = JarvisCameraHandle() cap = nano.Camera(flip=2, width=node.width, height=node.height, fps=25) while rclpy.ok(): try: if cap.isReady(): node.frame = cap.read() node.has_frame = True rclpy.spin_once(node) except KeyboardInterrupt: cap.release() break cap.release() node.destroy_node() rclpy.shutdown()
def cam(): # Create the Camera instance camera = nano.Camera(device_id=0, flip=0, width=640, height=480, fps=30) print('CSI Camera ready? - ', camera.isReady()) while camera.isReady(): try: # read the camera image frame = camera.read() # display the frame cv2.imshow("Video Frame", frame) if cv2.waitKey(25) & 0xFF == ord('q'): break except KeyboardInterrupt: break # close the camera instance camera.release() # remove camera object del camera
def cam(): # Create the Camera instance camera = nano.Camera(device_id=0, flip=0, width=640, height=480, fps=30) print('CSI Camera ready? - ', camera.isReady()) while camera.isReady(): # read the camera image frame = camera.read() canny_image = canny(frame) cropped_image = region_of_interest(canny_image) lines = cv2.HoughLinesP(cropped_image, 2, np.pi/180, 100, np.array([]), minLineLength= 125, maxLineGap=10) line_image = display_lines(frame, lines) combo_image = cv2.addWeighted(frame, 0.8, line_image, 1, 1) cv2.imshow("results", cropped_image) # display the frame if cv2.waitKey(25) & 0xFF == ord('q'): break # close the camera instance camera.release() # remove camera object del camera
def run_camera(): # Create the Camera instance camera = nano.Camera(camera_type=1, device_id=0, width=640, height=480, fps=30) print('USB Camera ready? - ', camera.isReady()) while camera.isReady(): try: # read the camera image frame = camera.read() #detect the person now global isPersonDetected global lpd_deadline global last_detected if (detectPerson(frame)): time_now = time.time() if (time_now - last_detected > lpd_deadline): last_detected = time_now isPersonDetected = True else: isPersonDetected = False # display the frame cv2.imshow("Video Frame", frame) if cv2.waitKey(25) & 0xFF == ord('q'): break # Definetly want to eventually change this after testing # Should be running on its own thread # if isPersonDetected: # break except KeyboardInterrupt: break # close the camera instance camera.release()
def run_camera(): global isPersonDetected global lpd_deadline global last_detected global real_time_detect_person # Create the Camera instance camera = nano.Camera(camera_type=1, device_id=0, width=640, height=480, fps=30) print('USB Camera ready? - ', camera.isReady()) while camera.isReady(): try: # read the camera image frame = camera.read() # detect the person now if (detectPerson(frame)): time_now = time.time() real_time_detect_person = True if (time_now - last_detected > lpd_deadline): last_detected = time_now isPersonDetected = True else: isPersonDetected = False else: real_time_detect_person = False # display the frame cv2.imshow("Video Frame", frame) if cv2.waitKey(25) & 0xFF == ord('q'): break except KeyboardInterrupt: break # close the camera instance camera.release()
def capture_image(): # grab global references to the output frame and lock variables global outputFrame, lock # Create the Camera instance camera = nano.Camera(flip=2, width=1280, height=720, fps=30) print('CSI Camera ready? - ', camera.isReady()) # Now that the init is done, lets get our IP and print to terminal so we know where to connect myip = [ l for l in ([ ip for ip in socket.gethostbyname_ex(socket.gethostname())[2] if not ip.startswith("127.") ][:1], [[(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)] ][0][1]]) if l ][0][0] print("Please connect to http://" + str(myip) + ":5000 to see the video feed.") while camera.isReady(): # read the camera image frame_read = camera.read() # Setup the variables we need, hopefully this function stays active with lock: # get the lock and set the image to the current one outputFrame = frame_read
def processImages(settings, camSpecs): firstIteration = True yolo = None # grab global references to the output frame and lock variables global outputFrame, lock if settings.useCamera: # Create the Camera instance camera = nano.Camera(flip=2, width=1280, height=720, fps=30) print('CSI Camera ready? - ', camera.isReady()) while camera.isReady(): try: # read the camera image frame_read = camera.read() if firstIteration: # Setup the variables we need, hopefully this function stays active yolo = YOLO() height, width = frame_read.shape[:2] yolo.init(width, height, time.time(), settings, camSpecs) firstIteration = False # Now that the init is done, lets get our IP and print to terminal so we know where to connect myip = [ l for l in ([ ip for ip in socket.gethostbyname_ex( socket.gethostname())[2] if not ip.startswith("127.") ][:1], [[(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [ socket.socket(socket.AF_INET, socket.SOCK_DGRAM) ]][0][1]]) if l ][0][0] print("Please connect to http://" + str(myip) + ":5000 to see the video feed.") else: image, timestamp, coordinates = yolo.readFrame( frame_read, time.time()) with lock: if image is not None: outputFrame = image.copy() if coordinates is not None: outputCoordinates = coordinates # Sleep just a bit so control-c works time.sleep(.001) if cv2.waitKey(25) & 0xFF == ord('q'): break except KeyboardInterrupt: break # close the camera instance camera.release() # remove camera object del camera else: #os.chdir("A:\\Users\edwar\Downloads") print("Opening captured video file ", settings.inputFilename) cap = cv2.VideoCapture( settings.inputFilename ) # Local Stored video detection - Set input video currentTime = 0.0 fps = 10.0 while True: # Load the input frame and write output frame. ret, frame_read = cap.read( ) # Capture frame and return true if frame present # For Assertion Failed Error in OpenCV if not ret: # Check if frame present otherwise he break the while loop cap.set(cv2.CAP_PROP_POS_FRAMES, 0) else: height, width, layers = frame_read.shape new_h = int(height) new_w = int(width) frame_read = cv2.resize(frame_read, (new_w, new_h)) # We do some special setup if this is the first frame, otherwise just send the image if firstIteration: # Setup the variables we need, hopefully this function stays active yolo = YOLO() height, width = frame_read.shape[:2] yolo.init(width, height, time.time(), settings, camSpecs) firstIteration = False # Now that the init is done, lets get our IP and print to terminal so we know where to connect myip = [ l for l in ([ ip for ip in socket.gethostbyname_ex( socket.gethostname())[2] if not ip.startswith("127.") ][:1], [[(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in [ socket.socket(socket.AF_INET, socket.SOCK_DGRAM) ]][0][1]]) if l ][0][0] print("Please connect to http://" + str(myip) + ":5000 to see the video feed.") else: image, timestamp, coordinates = yolo.readFrame( frame_read, time.time()) with lock: if image is not None: outputFrame = image.copy() if coordinates is not None: outputCoordinates = coordinates currentTime += 1.0 / fps # Sleep just a bit so control-c works time.sleep(.001) if cv2.waitKey(25) & 0xFF == ord('q'): break
import cv2 # from nanocamera.NanoCam import Camera import nanocamera as nano if __name__ == '__main__': # requires the RTSP location. Something like this: rtsp://localhost:8888/stream # For RTSP camera, the camera_type=2. # This only supports H.264 codec for now # a location for the rtsp stream rtsp_location = "192.168.1.26:8554/stream" # Create the Camera instance camera = nano.Camera(camera_type=2, source=rtsp_location, width=640, height=480, fps=30) print('RTSP Camera is now ready') while True: try: # read the camera image frame = camera.read() # display the frame cv2.imshow("Video Frame", frame) if cv2.waitKey(25) & 0xFF == ord('q'): break except KeyboardInterrupt: break # close the camera instance
cv2.line(line_image, (x1, y1), (x2, y2), (255, 0, 0), 10) return line_image def average_slope_intercept(frame, lines): rail = [] for line in lines: x1, y1, x2, y2 = line.reshape(4) parameters = np.polyfit((x1,x2), (y1, y2), 1) slope = parameters[0] intercept = parameters[1] if slope > 2 rail.append((Slope, intercept)) if __name__ == '__main__': # Create the Camera instance camera = nano.Camera(device_id=0, flip=0, width=640, height=480, fps=30) print('CSI Camera ready? - ', camera.isReady()) while camera.isReady(): # read the camera image frame = camera.read() canny_image = canny(frame) cropped_image = region_of_interest(canny_image) lines = cv2.HoughLinesP(cropped_image, 1, np.pi/180, 50, np.array([]), minLineLength=100, maxLineGap=15) line_image = display_lines(frame, lines) combo_image = cv2.addWeighted(frame, 0.8, line_image, 1, 1) cv2.imshow("results",combo_image) # display the frame if cv2.waitKey(25) & 0xFF == ord('q'): break
# create the shape rect = Rectangle((x1, y1), width, height, fill=False, color='white') # draw the box ax.add_patch(rect) # draw text and score in top left corner label = "%s (%.3f)" % (v_labels[i], v_scores[i]) pyplot.text(x1, y1, label, color='white') # show the plot pyplot.show() # load yolov3 model model = load_model('yolo.h5') # Create the Camera instance camera = nano.Camera(flip=0, width=640, height=480, fps=30) print('CSI Camera is now ready') while True: try: # read the camera image image = camera.read() # scale pixel values to [0, 1] image = image.astype('float32') image /= 255.0 # add a dimension so that we have one sample image = expand_dims(image, 0) input_w, input_h = image.shape[1], image.shape[0] # make prediction yhat = model.predict(image) # summarize the shape of the list of arrays
import nanocamera as nano parser = argparse.ArgumentParser(description="Inference from web-cam") parser.add_argument( "--resolution", type=int, nargs=2, metavar=("width", "height"), default=(1280 // 2, 720 // 2), ) parser.add_argument("--quality", help="jpeg quality", type=int, default=90) args = parser.parse_args() # Accept connections on all tcp addresses, port 5555 sender = imagezmq.ImageSender(connect_to="tcp://*:5555", REQ_REP=False) sender_name = socket.gethostname() # send hostname with each image width, height = args.resolution jpeg_quality = args.quality # 0 to 100, higher is better quality cam = nano.Camera(flip=0, width=width, height=height, fps=30) while True: # send images until Ctrl-C image = cam.read() # sender.send_image(sender_name, image) ret_code, jpg_buffer = cv2.imencode( ".jpg", image, [int(cv2.IMWRITE_JPEG_QUALITY), jpeg_quality]) jpg_buffer = jpg_buffer.tobytes() reply = sender.send_jpg(sender_name, jpg_buffer)
cv.fillPoly(mask, polygon, 255) cropped_edges = cv.bitwise_and(edges, mask) return cropped_edges # define a range of black color in HSV lower_black = np.array([0, 0, 0]) upper_black = np.array([227, 100, 70]) # Rectangular Kernel rectKernel = cv.getStructuringElement(cv.MORPH_RECT, (7, 7)) # Create the Camera instance for 640 by 480 camera = nano.Camera() if __name__ == '__main__': print('Started') print("Beginning Transmitting to channel: Happy_Robots") now = time() # commencing subtraction while True: try: # fetching each frame frame = camera.read() if frame is None: break
def takepicture(filename): if (camera.isReady()): frame = camera.read() cv2.imwrite(filename, frame) def update_class1(): n_class1 = len(os.listdir("./class1")) tmp_c1_name = "./class1/class1_" + str(n_class1) + ".jpg" takepicture(tmp_c1_name) sleep(3.0) def update_class2(): n_class2 = len(os.listdir("./class2")) tmp_c2_name = "./class2/class2_" + str(n_class2) + ".jpg" takepicture(tmp_c2_name) sleep(3.0) camera = nanocamera.Camera(flip=0, width=1280, height=800, fps=30) sleep(2.0) GPIO.setmode(GPIO.BOARD) GPIO.setup(38, GPIO.IN) GPIO.setup(37, GPIO.IN) while (True): if (GPIO.input(38)): update_class1() if (GPIO.input(37)): update_class2()
import cv2 # from nanocamera.NanoCam import Camera import nanocamera as nano if __name__ == '__main__': # requires the Camera streaming url. Something like this: http://localhost:80/stream # For IP/MJPEG camera, the camera_type=3. # This works with only camera steaming MJPEG format and not H.264 codec for now # a location for the camera stream camera_stream = "192.168.1.26:80" # Create the Camera instance camera = nano.Camera(camera_type=3, source=camera_stream, width=640, height=480, fps=30) print('MJPEG/IP Camera is now ready') while True: try: # read the camera image frame = camera.read() # display the frame cv2.imshow("Video Frame", frame) if cv2.waitKey(25) & 0xFF == ord('q'): break except KeyboardInterrupt: break # close the camera instance camera.release()
def threadVid(): # Get access to the webcam. The method is different depending on if this is running on a laptop or a Jetson Nano. #if running_on_jetson_nano(): # #RTSP_ADDR = 'rtsp://*****:*****@192.168.0.100:554/cam/realmonitor?channel=1&subtype=0' # # Accessing the camera with OpenCV on a Jetson Nano requires gstreamer with a custom gstreamer source string # #print(get_jetson_gstreamer_source(RTSP_ADDR)) # #video_capture = cv2.VideoCapture(get_jetson_gstreamer_source(0), cv2.CAP_GSTREAMER) # video_capture = open_cam_usb(1, 320, 240) #else: # # Accessing the camera with OpenCV on a laptop just requires passing in the number of the webcam (usually 0) # # Note: You can pass in a filename instead if you want to process a video file instead of a live camera stream # video_capture = cv2.VideoCapture(0) #video_capture = cv2.VideoCapture(RTSP_ADDR) #video_capture = cv2.VideoCapture(0) #video_capture = cv2.VideoCapture("rtsp://*****:*****@192.168.0.100:554/cam/realmonitor?channel=1&subtype=0") #video_capture_thermal = cv2.VideoCapture("rtsp://*****:*****@192.168.0.100:554/cam/realmonitor?channel=2&subtype=0") video_capture = nano.Camera(camera_type=1, device_id=0, width=640, height=480, fps=30, enforce_fps=True) # Track how long since we last saved a copy of our known faces to disk as a backup. number_of_faces_since_save = 0 while video_capture.isReady(): # Grab a single frame of video frame = video_capture.read() #ret_thermal, frame_thermal = video_capture_thermal.read() #video_capture.grab() #video_capture_thermal.grab() #if ret == 0:# or ret_thermal == 0: # continue #frame = cv2.resize(frame, (640, 480)) #frame_thermal = cv2.resize(frame_thermal, (480, 640)) # Resize frame of video to 1/4 size for faster face recognition processing small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25) # Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses) rgb_small_frame = small_frame[:, :, ::-1] # Find all the face locations and face encodings in the current frame of video face_locations = face_recognition.face_locations(rgb_small_frame, model='cnn') face_encodings = face_recognition.face_encodings( rgb_small_frame, face_locations) # Loop through each detected face and see if it is one we have seen before # If so, we'll give it a label that we'll draw on top of the video. face_labels = [] for face_location, face_encoding in zip(face_locations, face_encodings): # See if this face is in our list of known faces. metadata = lookup_known_face(face_encoding) # If we found the face, label the face with some useful information. if metadata is not None: time_at_door = datetime.now( ) - metadata['first_seen_this_interaction'] face_label = "At door {}s".format( int(time_at_door.total_seconds())) # If this is a brand new face, add it to our list of known faces else: face_label = "New visitor!" # Grab the image of the the face from the current frame of video top, right, bottom, left = face_location face_image = small_frame[top:bottom, left:right] face_image = cv2.resize(face_image, (150, 150)) # Add the new face to our known face data register_new_face(face_encoding, face_image) face_labels.append(face_label) # Draw a box around each face and label each face for (top, right, bottom, left), face_label in zip(face_locations, face_labels): # Scale back up face locations since the frame we detected in was scaled to 1/4 size top *= 4 right *= 4 bottom *= 4 left *= 4 # Draw a box around the face cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2) # Draw a label with a name below the face cv2.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255), cv2.FILLED) cv2.putText(frame, face_label, (left + 6, bottom - 6), cv2.FONT_HERSHEY_DUPLEX, 0.8, (255, 255, 255), 1) # Display recent visitor images number_of_recent_visitors = 0 for metadata in known_face_metadata: # If we have seen this person in the last minute, draw their image if datetime.now() - metadata["last_seen"] < timedelta( seconds=10) and metadata["seen_frames"] > 5: # Draw the known face image x_position = number_of_recent_visitors * 150 frame[30:180, x_position:x_position + 150] = metadata["face_image"] number_of_recent_visitors += 1 # Label the image with how many times they have visited visits = metadata['seen_count'] visit_label = "{} visits".format(visits) if visits == 1: visit_label = "First visit" cv2.putText(frame, visit_label, (x_position + 10, 170), cv2.FONT_HERSHEY_DUPLEX, 0.6, (255, 255, 255), 1) if number_of_recent_visitors > 0: cv2.putText(frame, "Visitors at Door", (5, 18), cv2.FONT_HERSHEY_DUPLEX, 0.8, (255, 255, 255), 1) # Yield video frame to flask #frame_concat = np.concatenate((frame,frame_thermal),axis=1) _, jpeg = cv2.imencode('.jpg', frame) yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + jpeg.tobytes() + b'\r\n\r\n') # Display the final frame of video with boxes drawn around each detected fames ##cv2.imshow('Video', frame) # Hit 'q' on the keyboard to quit! #if cv2.waitKey(1) & 0xFF == ord('q'): # save_known_faces() # break # We need to save our known faces back to disk every so often in case something crashes. if len(face_locations) > 0 and number_of_faces_since_save > 100: save_known_faces() number_of_faces_since_save = 0 else: number_of_faces_since_save += 1 # Release handle to the webcam video_capture.release() cv2.destroyAllWindows()
map_location=device), strict=False) if args.model_type != "trt": model = model.eval().to(device=device, dtype=precision) width, height = args.resolution if nano is None: cam = Camera(width=width, height=height) else: # See https://picamera.readthedocs.io/en/release-1.13/fov.html cam = nano.Camera( flip=0, width=width, height=height, fps=30, capture_width=640, capture_height=480, ) if pyfakewebcam is not None and args.fake_cam: fake_cam = pyfakewebcam.FakeWebcam("/dev/video1", cam.width, cam.height) else: fake_cam = None dsp = Displayer("MattingV2", cam.width, cam.height, show_info=(not args.hide_fps)) dsp.fake_cam = fake_cam
s3.upload_file(local_file, bucket, s3_file) print("Upload Successful") return True except FileNotFoundError: print("The file was not found") return False except NoCredentialsError: print("Credentials not available") return False #this initializes a CSI camera device #camera = nano.Camera(flip=0,width=640,height=480,fps=30) #this initializes a USB camera device camera = nano.Camera(camera_type=1, device_id=1, width=640, height=480, fps=30) myMQTTClient = AWSIoTMQTTClient("JetsonNano") myMQTTClient.configureEndpoint( "a2mzhorq6795m9-ats.iot.us-east-2.amazonaws.com", 8883) myMQTTClient.configureCredentials("AmazonRootCA1.pem", "902d95efbc-private.pem.key", "902d95efbc-certificate.pem.crt") myMQTTClient.configureOfflinePublishQueueing(-1) myMQTTClient.configureDrainingFrequency(2) myMQTTClient.configureConnectDisconnectTimeout(10) myMQTTClient.configureMQTTOperationTimeout(5) allowedConnectingTime = time.time() + 10 if time.time() < allowedConnectingTime:
## for single USB (left and rigth frames are "glued together ) cap = cv2.VideoCapture(int(cam_ids[0])) cap.set(cv2.CAP_PROP_FRAME_WIDTH, width * 2) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, height) else: ### for double USB # cap_left = cv2.VideoCapture(int(cam_ids[0])) # cap_right = cv2.VideoCapture(int(cam_ids[1])) # cap_left.set(cv2.CAP_PROP_FRAME_WIDTH, width) # cap_left.set(cv2.CAP_PROP_FRAME_HEIGHT, height) # cap_right.set(cv2.CAP_PROP_FRAME_WIDTH, width) # cap_right.set(cv2.CAP_PROP_FRAME_HEIGHT, height) # nano.Camera() cap_left = nano.Camera(device_id=0, flip=2, width=800, height=480, fps=30) cap_right = nano.Camera(device_id=1, flip=2, width=800, height=480, fps=30) ######################################################################## ############################################################################# ## GET ALL CAMERA MATRICES AND COEFFICIENTS camera_matrix_left, camera_matrix_right, map_left_x, map_left_y, map_right_x, map_right_y, Q = init_calibration( left_xml, right_xml, image_size, resolution) ################################################################################ ############################################################################## # INITIALIZE IMAGE WINDOWS windowName = "Live Camera Input" cv2.namedWindow(windowName, cv2.WINDOW_NORMAL) cv2.resizeWindow(windowName, width, height)
""" # from nanocamera.NanoCam import Camera import nanocamera as nano if __name__ == '__main__': # you can see connected USB cameras by running : ls /dev/video* on the terminal # for usb camera /dev/video2, the device_id will be 2 # Create the Camera instance try: # Create the Camera instance print("camera stream") camera = nano.Camera(camera_type=1, device_id=0, width=640, height=480, fps=30, debug=True) except Exception as e: print("Exception occurred ------ ") print("Exception Type - ", e) else: print('USB Camera ready? - ', camera.isReady()) while True: try: # read the camera image frame = camera.read() print("do something with frame") # send_to_cloud(frame) # display the frame
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import cv2 import nanocamera as nano import uuid # Left Camera camera0 = nano.Camera(device_id=0, flip=2, width=224, height=224, fps=30) # Right Camera camera1 = nano.Camera(device_id=1, flip=2, width=224, height=224, fps=30) imgL = camera0.read() imgR = camera1.read() s_uuid = str(uuid.uuid1()) print("snap_shot!") filenameL = './nanocam_test/%d_%d_%s_L.jpg' % (0, 0, s_uuid) filenameR = './nanocam_test/%d_%d_%s_R.jpg' % (0, 0, s_uuid) filenameM = './nanocam_test/%d_%d_%s_M.jpg' % (0, 0, s_uuid) imgMx = cv2.addWeighted(src1=imgL, alpha=0.5, src2=imgR, beta=0.5, gamma=0) cv2.imwrite(filenameL, imgL) cv2.imwrite(filenameR, imgR) cv2.imwrite(filenameM, imgMx) camera0.release() camera1.release()