def newplay(self): ''' get replay ''' # put image play_b in btn_toogle_pause self.btn_toogle_pause['image'] = self.photos._play # load video stream self.vid = VideoStream(self.video_source) # set delay using self.delay = self.vid.f_rate # set scale value. self.var_t.set(0.1) # get and set duration video stream self.duracion = self.vid.duration # print time duration print('>> newplay: self.duracion ->', self.duracion) # set value maximun scale to self.scale.configure(to=self.duracion) # print configure values scale # print('>> self.scale.configure ->', self.scale) # ajuste valores de sonido al nivel seleccionado. self.vid.player.set_volume(float(self.soundvar.get())) # dimension vertical ventana. h = self.conten_controls.winfo_height() h_f = self.vid.h + h + 2 w_f = self.vid.w + 2 cad = f'{w_f}x{h_f}' self._width = w_f self._height = h_f self.master.geometry(cad) self.canvas.config(width=self.vid.w, height=self.vid.h)
def main_debug(displaying): video_file = os.path.join(os.path.dirname(__file__), "video/staircase.mp4") vid_stream = VideoStream(video_file, interval=0.03) vid_stream.start() if debug: import ptvsd ptvsd.enable_attach(('0.0.0.0', 56781)) ptvsd.wait_for_attach() ptvsd.break_into_debugger() while True: _, frame = vid_stream.get_frame_with_id() detections = detector.detect(frame) #logging.info(detections) if not displaying: logging.info(detections) continue frame = display(frame, detections) # # check to see if the output frame should be displayed to our # # screen cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF if key == ord('q') or key == 27: break cv2.destroyAllWindows()
def __init__(self, usePiCamera=True): # initialize the camera and grab a reference to the raw camera capture self.vs = VideoStream(usePiCamera=usePiCamera, src=0, resolution=(self.FRAME_WIDTH, self.FRAME_HEIGHT), framerate=12) self.kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) self.fgbg = cv2.createBackgroundSubtractorMOG2(history=self.INIT_TIME, varThreshold=12, detectShadows=False) self.face_cascade = cv2.CascadeClassifier( 'models/haarcascade_frontalface_default.xml') self.background1 = cv2.imread('backgrounds/background1.jpeg') self.background1 = cv2.resize(self.background1, (self.FRAME_WIDTH, self.FRAME_HEIGHT)) self.hats = [ cv2.imread('./hats/' + file, cv2.IMREAD_UNCHANGED) for file in os.listdir('./hats') ] self.stopped = False self.frame = None self.state = 0 self.time = 0 self.lastReady = 0 self.lastCapture = 0 self.history = np.zeros(self.HISTORY)
def initVideo(self): try: self.video = VideoStream(src=0) except: print("video stream not found") if(self.video is None): print("video stream was not initialized") return try: self.video.start() except: print("video failed to start") # construct the face detector and allow the camera to warm up try: face = "cascades/haarcascade_frontalface_default.xml" self.faceDetector = FaceDetector(face) sleep(0.1) except: print("face detector init failed") # choose xvid codec try: self.fourcc = cv2.VideoWriter_fourcc(*'XVID') except: print("video writer not found") sleep(0.1)
def main(): default_model_dir = '../all_models' default_model = 'mobilenet_ssd_v2_coco_quant_postprocess_edgetpu.tflite' default_labels = 'coco_labels.txt' parser = argparse.ArgumentParser() parser.add_argument('--model', help='.tflite model path', default=os.path.join(default_model_dir, default_model)) parser.add_argument('--labels', help='label file path', default=os.path.join(default_model_dir, default_labels)) parser.add_argument( '--top_k', type=int, default=3, help='number of categories with highest score to display') parser.add_argument('--camera_idx', type=int, help='Index of which video source to use. ', default=0) parser.add_argument('--threshold', type=float, default=0.1, help='classifier score threshold') args = parser.parse_args() print('Loading {} with {} labels.'.format(args.model, args.labels)) interpreter = common.make_interpreter(args.model) interpreter.allocate_tensors() labels = load_labels(args.labels) videostream = VideoStream().start() while True: frame = videostream.read() #if not ret: # break cv2_im = frame cv2_im_rgb = cv2.cvtColor(cv2_im, cv2.COLOR_BGR2RGB) pil_im = Image.fromarray(cv2_im_rgb) common.set_input(interpreter, pil_im) interpreter.invoke() objs = get_output(interpreter, score_threshold=args.threshold, top_k=args.top_k) cv2_im = append_objs_to_img(cv2_im, objs, labels) cv2.imshow('frame', cv2_im) if cv2.waitKey(1) & 0xFF == ord('q'): break #cap.release() videostream.stop() cv2.destroyAllWindows()
def __init__(self, usePiCamera, width, height, camPort): self.ct = CentroidTracker() self.targetID = -1000000 self.targetCentroid = [] self.radius = 20 self.cap = VideoStream(usePiCamera, width, height, camPort).start() self.haar_cascade = cv2.CascadeClassifier("data/HS.xml") self.frameCount = 0 self.frameCaptureNumber = 7 self.thresholdX = int(width / 2) self.thresholdY = (int)(height / 2) self.width = width self.height = height
def describe(self, request): self.print_log('Process method DESCRIBE') header = { 'CSeq': request.seqnum, 'Session': self.sessionid } try: self.videostream = VideoStream(request.filename) header['Frame-Rate'] = self.videostream.fps header['Frame-Count'] = self.videostream.frm_cnt print(self.videostream.fps) return Response(200, header) except FileNotFoundError: return Response(404)
def __init__(self, **kwargs): super(Main, self).__init__(**kwargs) parser = argparse.ArgumentParser() parser.add_argument('left', metavar='LEFT', help='left stream e.g. rtsp://192.168.0.16:8086') parser.add_argument('right', metavar='RIGHT', help='right stream e.g. rtsp://192.168.0.23:8086') args = parser.parse_args() self.streams = [ VideoStream(args.left, 640, 480), VideoStream(args.right, 640, 480) ] self.separation = 0.125 self.vert_offset = 0
async def stream(request: Request, url: str = Form(...), action: str = Form(...)): if action == 'yolov4': track = False elif action == 'yolov4 + deepsort': track = True return StreamingResponse(VideoStream(url).process_stream(track=track), media_type="multipart/x-mixed-replace; boundary=frame")
ap.add_argument("-r", "--resolution", type=str, default='640x480', help='resolution of cameras (\'max\' for max resolution)') ap.add_argument("-s", "--source", type=str, default='-1', help='indicies of cameras to use') # parse arguments args = vars(ap.parse_args()) # create a list of video streams to reference in generate() vslist = [] # find up to 10 attached cameras and try and start streams on them if args['source'] == '-1': print('shotgun approach') for i in range(0, 9): vs = VideoStream(i, 'vs{}'.format(i+1), args['resolution']) if vs.stream.isOpened() is False: vs.release() else: if maxframesize is None: maxframesize = vs.width vslist.append(vs) # open cameras based on arguments passed else: sources = parseindicies(args['source']) print('opening ' + args['source']) for i in sources: vs = VideoStream(i, 'vs{}'.format(i+1), args['resolution']) if vs.stream.isOpened() is False: vs.release() else:
ALARM_MODE = False ALARM_MODE_MOUTH = False print("Facial Landmark Prediction System Loading...") detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(args["shape_predictor"]) FACIAL_LANDMARKS=FL() # retrieve the indexes of the facial landmarks for the left and right eye (lStart, lEnd) = FACIAL_LANDMARKS["left_eye"] (rStart, rEnd) = FACIAL_LANDMARKS["right_eye"] (mStart,mEnd) = FACIAL_LANDMARKS["mouth"] print("Video Stream Loading...") vs = VideoStream(src=args["webcam"]).start() time.sleep(1.0) # loop over frames from the video stream while True: frame = vs.read() (h, w) = frame.shape[:2] frame = cv2.resize(frame, (w,h), interpolation=cv2.INTER_AREA) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) rects = detector(gray, 0) # loop over the face detections for rect in rects:
import sys import cv2 import zbar from videostream import VideoStream from PIL import Image # Initialise OpenCV window print "OpenCV version: %s" % (cv2.__version__) print "Press q to exit ..." if int(sys.argv[1]) == 1: isPiCamera = True else: isPiCamera = False vs = VideoStream(isPiCamera=isPiCamera, resolution=(640, 480)).start() time.sleep(2.0) scanner = zbar.ImageScanner() scanner.parse_config('enable') # Capture frames from the camera while (True): ticks = time.time() frame = vs.read() # raw detection code gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY, dstCn=0) pil = Image.fromarray(gray) width, height = pil.size
class PersonDetector(): def __init__(self, usePiCamera, width, height, camPort): self.ct = CentroidTracker() self.targetID = -1000000 self.targetCentroid = [] self.radius = 20 self.cap = VideoStream(usePiCamera, width, height, camPort).start() self.haar_cascade = cv2.CascadeClassifier("data/HS.xml") self.frameCount = 0 self.frameCaptureNumber = 7 self.thresholdX = int(width / 2) self.thresholdY = (int)(height / 2) self.width = width self.height = height def frameAdd(self): self.frameCount += 1 def checkFrameCount(self): if self.frameCount % self.frameCaptureNumber == 0: return True return False def robotMoveDirection(self, centroid, center): print(centroid, " ", center) cX = center[0] cY = center[1] targetX = centroid[0] targetY = centroid[1] diffX = cX - targetX diffY = cY - targetY hors = "Move: " verts = " and " if targetX < cX - self.radius: hors += "Left " + str(np.abs(diffX)) + " pixels" elif targetX > cX + self.radius: hors += "Right " + str(np.abs(diffX)) + " pixels" else: hors = "" verts = "Move: " if targetY < cY - self.radius: verts += "Up " + str(np.abs(diffY)) + " pixels" elif targetY > cY + self.radius: verts += "Down " + str(np.abs(diffY)) + " pixels" else: verts = "" return hors + verts def updateObjectIDs(self, upper_body): return self.ct.update(upper_body) def detectPerson(self): capturedframe = self.cap.getFrame() frame = capturedframe[0:self.height, 0:int(self.width / 2)] centerX = -10000 centerY = -100000 cColor = (0, 0, 255) if self.checkFrameCount(): try: # using a greyscale picture, also for faster detection gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY) upper_body = self.haar_cascade.detectMultiScale( gray, scaleFactor=1.1, minNeighbors=12, # Min size for valid detection, changes according to video size or body size in the video. minSize=(50, 100), flags=cv2.CASCADE_SCALE_IMAGE) if len(upper_body) > 0: (x, y, w, h) = upper_body[0] # creates green color rectangle with a thickness size of 1 centerX = (int)(x + w / 2) centerY = (int)(y + h / 2) cv2.rectangle(capturedframe, (x, y), (x + w, y + h), (0, 255, 0), 1) cv2.line(capturedframe, (centerX, y), (centerX, y + h), (255, 0, 0), 1) cv2.line(capturedframe, (x, centerY), (x + w, centerY), (255, 0, 0), 1) cv2.circle(capturedframe, (centerX, centerY), 1, (0, 0, 255), 1) # creates green color text with text size of 0.5 & thickness size of 2 cv2.putText(capturedframe, "Head and Shoulders Detected", (x + 5, y + 15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) if np.abs(centerX - self.thresholdX) <= 20 and np.abs( centerY - self.thresholdY) <= 20: cColor = (0, 255, 0) else: cColor = (0, 0, 255) objects = self.updateObjectIDs(upper_body) # checking if the id is the same as the one detected if len(list(objects.items())) > 0: targetID = list(objects.items())[0][0] targetCentroid = list(objects.items())[0][1] if targetCentroid[0] == centerX and targetCentroid[ 1] == centerY: cv2.putText(capturedframe, str(targetID), (targetCentroid[0], targetCentroid[1]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) cv2.circle(capturedframe, (targetCentroid[0], targetCentroid[1]), 4, (0, 255, 0), -1) else: targetID = -100000 targetCentroid = [] print( self.robotMoveDirection(targetCentroid, (self.width / 2, self.height / 2))) except Exception as e: print(str(e)) return capturedframe #threshold center lines cv2.circle(capturedframe, (self.thresholdX, self.thresholdY), self.radius, cColor, 3) return capturedframe def release(self): self.cap.release()
class VideoCamera(object): INIT_TIME = 100 FRAME_WIDTH = 640 FRAME_HEIGHT = 480 HISTORY = 25 THRESHOLD = 18 def __init__(self, usePiCamera=True): # initialize the camera and grab a reference to the raw camera capture self.vs = VideoStream(usePiCamera=usePiCamera, src=0, resolution=(self.FRAME_WIDTH, self.FRAME_HEIGHT), framerate=12) self.kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) self.fgbg = cv2.createBackgroundSubtractorMOG2(history=self.INIT_TIME, varThreshold=12, detectShadows=False) self.face_cascade = cv2.CascadeClassifier( 'models/haarcascade_frontalface_default.xml') self.background1 = cv2.imread('backgrounds/background1.jpeg') self.background1 = cv2.resize(self.background1, (self.FRAME_WIDTH, self.FRAME_HEIGHT)) self.hats = [ cv2.imread('./hats/' + file, cv2.IMREAD_UNCHANGED) for file in os.listdir('./hats') ] self.stopped = False self.frame = None self.state = 0 self.time = 0 self.lastReady = 0 self.lastCapture = 0 self.history = np.zeros(self.HISTORY) def start(self): self.vs.start() # start the thread to process frames from the video stream t = Thread(target=self.update, args=()) t.daemon = True t.start() return self def stop(self): self.vs.stop() # indicate that the thread should be stopped self.stopped = True def update(self): # Keep looping infinitely until the thread is stopped while True: # If the thread indicator variable is set, stop the thread if self.stopped: return # Grab an image from the video stream frame = self.vs.read() # Wait until frames start to be available if frame is None: time.sleep(1) continue # Resize frame to fit working dimensions frame = cv2.resize(frame, (self.FRAME_WIDTH, self.FRAME_HEIGHT), 0, 0, cv2.INTER_CUBIC) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) gray = cv2.equalizeHist(gray) fgmask = self.fgbg.apply(frame, learningRate=0 if self.state > 0 else -1) fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_OPEN, self.kernel) bgmask = 255 - fgmask # State machine # S0: Training if self.state == 0: cv2.putText(img=fgmask, text='Training Segmentation Algorithm (' + str(int(100.0 * self.time / self.INIT_TIME)) + ' %)', org=(0, self.FRAME_HEIGHT - 5), fontFace=cv2.FONT_HERSHEY_DUPLEX, fontScale=.7, color=(255, 255, 255), thickness=1) # Transition to S1 if self.time >= self.INIT_TIME: self.state = 1 # Show mask when training. self.frame = fgmask # S1: Ready to capture elif self.state == 1: # Detect and draw faces faces = self.face_cascade.detectMultiScale(gray, 1.3, 5) for (x, y, w, h) in faces: cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2) # Update history self.history[self.time % self.HISTORY] = min(len(faces), 1) self.frame = frame #self.frame = cv2.bitwise_and(self.background1, self.background1, mask=bgmask) + cv2.bitwise_and(frame, frame, mask=fgmask) cv2.putText(self.frame, text='Frame ' + str(self.time), org=(0, self.FRAME_HEIGHT - 5), fontFace=cv2.FONT_HERSHEY_DUPLEX, fontScale=.7, color=(255, 255, 255), thickness=1) # Transition to S2 if faces present. if np.sum( self.history ) >= self.THRESHOLD and self.time > self.lastCapture + self.HISTORY: self.lastReady = self.time self.state = 2 # Transition to S0 if no faces and time has gone, reset all elif np.sum( self.history ) < self.THRESHOLD and self.time > 4 * self.INIT_TIME: self.time = 0 self.lastReady = 0 self.lastCapture = 0 self.state = 0 # S2: Cont down elif self.state == 2: self.frame = frame cv2.putText(self.frame, text=str(3 - int((self.time - self.lastReady) / 10)), org=(int(self.FRAME_WIDTH / 2), int(self.FRAME_HEIGHT / 2)), fontFace=cv2.FONT_HERSHEY_DUPLEX, fontScale=3, color=(255, 255, 255), thickness=2) if self.time - self.lastReady >= 29: self.state = 3 # S3: Capture elif self.state == 3: #frame = cv2.bitwise_and(self.background1, self.background1, mask=bgmask) + cv2.bitwise_and(frame, frame, mask=fgmask) faces = self.face_cascade.detectMultiScale(gray, 1.3, 5) for (x, y, w, h) in faces: # Select a hat at fit it to face hat = random.choice(self.hats) x_factor = 1.45 y_offset = 0.15 hat = cv2.resize( hat, (int(w * x_factor), int(w * x_factor / hat.shape[1] * hat.shape[0])), 0, 0, cv2.INTER_CUBIC) # Get fitted hat width/hight, and crop to bounding box. h_h, h_w = hat.shape[:2] h_x1 = max(int(x - (h_w - w) / 2), 0) h_x2 = min(int(x + w + (h_w - w) / 2), self.FRAME_WIDTH) h_y1 = max(int(y + h * y_offset - h_h), 0) h_y2 = min(int(y + h * y_offset), self.FRAME_HEIGHT) # Recalulate hat width/hight if cropped by bounding box. h_w = h_x2 - h_x1 h_h = h_y2 - h_y1 # Blend hat to frame with alpha-channel. for c in range(0, 3): alpha = hat[-h_h:, :h_w, 3] / 255.0 color = hat[-h_h:, :h_w, c] * alpha beta = frame[h_y1:h_y2, h_x1:h_x2, c] * (1.0 - alpha) frame[h_y1:h_y2, h_x1:h_x2, c] = color + beta # Save the image to disk. filename = 'images/' + datetime.datetime.now().strftime( "%Y%m%d-%H%M%S") + '.png' print('Saving image: ', filename) cv2.imwrite(filename, frame) self.frame = frame time.sleep(10) # Transition to S1 self.lastCapture = self.time self.state = 1 self.time = self.time + 1 time.sleep(1 / 16) def get_frame(self): # Wait until frames start to be available while self.frame is None: time.sleep(0) # We are using Motion JPEG, but OpenCV defaults to capture raw images, # so we must encode it into JPEG in order to correctly display the # video stream. ret, jpeg = cv2.imencode('.jpg', self.frame) return jpeg.tobytes()
frame_rate_calc = 1 freq = cv2.getTickFrequency() dnum=0 time_appear_drone = 0 boxthickness = 3 linethickness = 2 # Initialize video stream #videostream = VideoStream(resolution=(800,600),framerate=30).start() Auto_flag = True rectangule_color = (10, 255, 0) sender = imagezmq.ImageSender(connect_to="tcp://{}:5555".format(args.server)) rpi_name = socket.gethostname() # send RPi hostname with each image picam = VideoStream(resolution=(imW,imH),framerate=30).start() print(picam.read().shape) time.sleep(1.0) # allow camera sensor to warm up frame1 = picam.read() rows, cols, _ = frame1.shape x_medium = int(cols / 2) x_center = int(cols / 2) y_medium = int(rows / 2) y_center = int(rows / 2) while True: # send images as stream until Ctrl-C # Start timer (for calculating frame rate) t1 = cv2.getTickCount() frame1 = picam.read() # Acquire frame and resize to expected shape [1xHxWx3] frame = frame1.copy()
cv2.rectangle(self.frame_resized, (x, y), (x + w - 1, y + h - 1), (0, 0, 255), 1) cv2.circle(self.frame_resized, centroid, 2, (0, 255, 0), -1) #cv2.imshow('boxes', self.frame_resized) if __name__ == '__main__': from videostream import VideoStream from videostream import FPS fuente = ['../installationFiles/mySquare.mp4', 0] # Create BG object and get source input bg = CreateBGCNT() vs = VideoStream(src=fuente[0], resolution=(640, 480)).start() # 0.5 pmx fps = FPS().start() while True: frame, frame_resized = vs.read() # Feed frames bg.alimentar(frame_resized) # You want the matches? #print(bg.matches) # Want to see?, put the next two lines bg.draw() cv2.imshow('frame', frame_resized)
dnum = 0 time_appear_drone = 0 boxthickness = 3 linethickness = 2 # Initialize video stream #videostream = VideoStream(resolution=(800,600),framerate=30).start() rectangule_color = (10, 255, 0) sender = imagezmq.ImageSender(connect_to='tcp://192.168.0.44:5555') print("send") rpi_name = socket.gethostname() # send RPi hostname with each image print("name") #picam = VideoStream(usePiCamera=False).start() picam = VideoStream(resolution=(800, 600), framerate=30).start() print(picam.read().shape) print("picam") time.sleep(2.0) # allow camera sensor to warm up print("sleep") while True: # send images as stream until Ctrl-C # Start timer (for calculating frame rate) t1 = cv2.getTickCount() frame1 = picam.read() # Acquire frame and resize to expected shape [1xHxWx3] frame = frame1.copy() frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame_resized = cv2.resize(frame_rgb, (width, height)) input_data = np.expand_dims(frame_resized, axis=0)
def video_feed(): return Response(gen(VideoStream()), mimetype='multipart/x-mixed-replace; boundary=frame')
if int(sys.argv[1]) == 1: isPiCamera = True cam_type = "picamera" else: isPiCamera = False cam_type = "usbcamera" if int(sys.argv[2]) == 640: resolution = (640, 480) elif int(sys.argv[2]) == 320: resolution = (320, 240) else: print "Not valid resolution" quit() vs = VideoStream(isPiCamera=isPiCamera, resolution=resolution).start() numb_of_pics = 0 while (1): img = vs.read() cv2.imshow("Press Space to Save Frame", img) keypress = cv2.waitKey(1) & 0xFF if keypress == 32: numb_of_pics += 1 file_name = cam_type + str(resolution[0]) + '_' + str(numb_of_pics) cv2.imwrite('./calib_pics/' + file_name + '.jpg', img) if keypress == ord('q'): print str(numb_of_pics) + ' pictures saved'
import imagezmq import argparse import socket import time # construct the argument parser and parse the arguments ap = argparse.ArgumentParser() ap.add_argument( "-s", "--server-ip", required=True, help="ip address of the server to which the client will connect") args = vars(ap.parse_args()) # initialize the ImageSender object with the socket address of the # server sender = imagezmq.ImageSender( connect_to="tcp://{}:5555".format(args["server_ip"])) # get the host name, initialize the video stream, and allow the # camera sensor to warmup rpiName = socket.gethostname() vs = VideoStream().start() #vs = VideoStream(src=0).start() time.sleep(2.0) while True: # read the frame from the camera and send it to the server frame = vs.read() sender.send_image(rpiName, frame)
class ScreenPlayer(tk.Frame): def __init__(self, master=None, title=None, video=None): ''' Initialice window app ''' super().__init__(master) self.master = master # self.master.geometry('422x624+629+231') -> desarrollo ahead. self.pack(fill=tk.BOTH, expand=1) self.master.title(title) self.master['bg'] = 'Black' self.master.protocol('WM_DELETE_WINDOW', self.confirmExit) self.master.protocol('WM_TAKE_FOCUS', self.confirmOpen) self.master.protocol('WM_SAVE_YOURSELF', self.confirmSave) self.init = True self.setingfile = 'flash_seting.ini' # self.window.resizable(width=False, height=False) self.n_size = None self.photo = None self.photos = Photos() # self.master.call('wm', 'iconphoto', self.master, self.photos._apply) self.soundvar = tk.DoubleVar(value=0.9) self.master.wm_iconphoto(True, self.photos._apply) self.dirImages = None self.dirpathmovies = tk.StringVar() # directorio path video self.video_source = video w = 350; h = 230; self.duracion = 100.0 self.active_scale = False self.vid = None self.val = 'paused' if self.video_source is not None: # open video source (by default this will try to open the computer webcam) try: self.dirpathmovies.set(os.path.dirname(self.video_source)) self.vid = VideoStream(self.video_source) # w_f, h_f = self.vid.w, self.vid.h self.duracion = self.vid.duration self.soundvar.set(self.vid.player.get_volume()) frame = None while frame is None: self.val, self.pts, frame = self.vid.get_frame() size = frame.get_size() arr = frame.to_memoryview()[0] # array image self.imagen = Image.frombytes("RGB", size, arr.memview) w_f, h_f = self.imagen.size self.delay = self.vid.f_rate self.vid.toggle_pause() self._wxh = (w_f, (h_f + 40)) self._twh = (300, 300) except Exception as e: print(e) self.video_source = None else: self.imagen = self.photos._logo w_f, h_f = self.imagen.size self.delay = 16 self._wxh = (422, 624) self._twh = (629, 231) pass # ajuste ventana. str_window = str(self._wxh[0])+ 'x'+str(self._wxh[1])+ '+' + str(self._twh[0])+ '+' + str(self._twh[1]) self.master.geometry(str_window) print('str ventana de inicio:', str_window) # event changed de volume self.soundvar.trace('w', self.soundvar_adjust) # Create a canvas that can fit the above video source size self.canvas = tk.Canvas(self, bg='red') # contenedor de controles self.conten_controls = tk.LabelFrame(self, height=4) # Button that lets the user take a snapshot self.btn_snapshot=tk.Button(self.conten_controls, text="Snapshot", command=self.snapshot) self.btn_snapshot['image'] = self.photos._snapshot self.btn_snapshot.pack(side='left') # Button open self.btn_open = tk.Button(self.conten_controls, text='...', command=self.open_file) self.btn_open['image'] = self.photos._open self.btn_open.pack(side='right') # button volum self.btn_volume = tk.Button(self.conten_controls, text='volume', command=self.open_adjust_volumen) self.btn_volume['image'] = self.photos._volume self.btn_volume.pack(side='right') # Button replay self.btn_replay = tk.Button(self.conten_controls, text=">>", command=self.replay) self.btn_replay['image'] = self.photos._repeat self.btn_replay.pack(side='right') # Button play-pausa self.btn_toogle_pause = tk.Button(self.conten_controls, text="[]", command=self.toogle_pause) self.btn_toogle_pause['image'] = self.photos._play self.btn_toogle_pause.pack(side='right') # Slade self.var_t = tk.DoubleVar() self.scale = tk.Scale(self.conten_controls, from_=0.0, to= self.duracion, showvalue=0, orient='horizontal', variable=self.var_t, resolution=0.3, sliderrelief='flat', command=self.onScale ) self.scale.pack(side='left', fill='x', expand=1) self.scale.bind('<ButtonPress-1>', self.scale_button_press) self.scale.bind('<ButtonRelease-1>', self.scale_button_release) self.master.bind('<Configure>', self.master_on_resize) # self.master.bind_all('<ButtonPress-1>', self.master_button_press) # self.master.bind('<ButtonRelease-1>', self.master_button_release) # self.master.wm_withdraw() self.canvas.pack(side =tk.TOP, fill=tk.BOTH, expand=1) self.conten_controls.pack(side='bottom', fill='x') if self.video_source is not None: self.scale.configure(to=self.duracion) self.btn_toogle_pause['image'] = self.photos._pause self.vid.player.set_volume(float(self.soundvar.get())) self.canvas_tags = None self.photo = ImageTk.PhotoImage(self.imagen) self.canvas.configure(width = w_f, height=h_f) self.canvas.create_image(w_f/2, h_f/2, image = self.photo, anchor='center', tags='img') self.val = None self.pts = None # if self.video_source is None: self.get_init_status() self.update() self.master.mainloop() def get_init_status(self): ''' extract init status of app Return: ''' if not os.path.exists(self.setingfile): return config = configparser.RawConfigParser() config.read(self.setingfile) dirpathmovies = config.get('Setings', 'path_movies') if os.path.exists(dirpathmovies): self.dirpathmovies.set(dirpathmovies) # inicializa la lista con directorio duardao dirpathimages =config.get('Setings', 'path_images') if os.path.exists(dirpathimages): self.dirImages = dirpathimages # inicializa la lista con directorio duardao def set_init_status(self): ''' write init status of app Return: ''' config = configparser.RawConfigParser() config.add_section('Setings') config.set('Setings', 'path_movies', self.dirpathmovies.get()) config.set('Setings', 'path_images', self.dirImages) with open(self.setingfile, 'w') as configfile: config.write(configfile) print('Write config file') def confirmExit(self): if messagebox.askokcancel('Quit', 'Are you sure you want to exit?'): self.master.quit() self.set_init_status() print('end process') def confirmOpen(self): '''here play the video if exist and window activate at init of app''' print(f">> Confirm Open -- init:{self.init}") if self.init: if self.vid is not None: self.vid.toggle_pause() self.btn_toogle_pause['image'] = self.photos._play self.init=False def confirmSave(self): print('>> push confirm Save.') pass def master_button_press(self, event): print('>> master_button_press') def master_button_release(self, event): print('>> master_button_release') def master_on_resize(self, event): _ventana = event.widget print(_ventana) widget_size =(_ventana.winfo_width(), _ventana.winfo_height() ) if str(_ventana) == '.!screenplayer.!canvas': print('>> canvas:') m_wxh = (event.x, event.y) print('>> rezise:', m_wxh, self._wxh, 'widget_size:', widget_size) if self._wxh != m_wxh and str(_ventana) == '.!screenplayer.!canvas' and m_wxh == (0, 0): print('>> on_resize_master ') self._wxh = widget_size # self.master.configure(width=m_wxh[0], height=m_wxh[1]) h_c = self.conten_controls.winfo_height() w = m_wxh[0] -2 h = m_wxh[1] - h_c -2 self.canvas.configure(width=w, height=h) # si es nulo self.vid or self.imagen is not None or self.vid.player.get_pause() # print('wm_withdraw: ', self.master.wm_withdraw()) if self.vid is None or self.val =='paused': w = self.canvas.winfo_width() h = self.canvas.winfo_height() if w <= 0 or h <= 0: return self.canvas.delete(tk.ALL) # borra todos los objetos con ese tags.... # w_i, h_i = self.imagen.size marco = w, h # marco de ventana self.imagen_copy = self.imagen.copy() self.imagen_copy = image_adjustment(self.imagen_copy, marco) self.photo = ImageTk.PhotoImage(self.imagen_copy) self.canvas.create_image(w/2, h/2, anchor='center', image = self.photo, tags='img') def scale_button_press(self, event): print('>> scale_button_press') self.active_scale = True def scale_button_release(self, event): print('>> scale_button_release') self.active_scale = False def open_adjust_volumen(self): from overpanel import Over param = {'textvariable': self.soundvar} dialog = Over(master=self.master, cnf=param) dialog.mainloop() def soundvar_adjust(self, *args): print('sound adjust ->', self.soundvar.get()) if self.vid: print('if self.vid: soundvar_adjust') self.vid.player.set_volume(self.soundvar.get()) def isurl(self, tip=None): ''' Return bolean true si existe and it's ends with ('.mp4', '.MP4', '.flv', '.FLV', '.mpg', '.avi') ''' if not tip: return False exten = ('.mp4', '.MP4', '.flv', '.FLV', '.mpg', '.avi') if os.path.exists(tip): if tip.endswith(exten): return True return False def open_file(self): ''' Open file with menu ... ''' if self.dirpathmovies.get()=='': dirpath='.' else: dirpath = self.dirpathmovies.get() file = filedialog.askopenfile(initialdir=dirpath, title='select file', filetypes={('flv','*.flv'), ('mp4','*.mp4'), ('avi','*.avi'), ('mpg','*.mpg')}, defaultextension='*.mp4') print(file) if not file == None: if os.path.exists(file.name): self.video_source = file.name self.dirpathmovies.set(os.path.dirname(self.video_source)) self.newplay() def toogle_pause(self): ''' toogle pause ''' if not self.vid: return if self.val =='paused': self.btn_toogle_pause['image'] = self.photos._play self.vid.toggle_pause() else: self.btn_toogle_pause['image'] = self.photos._pause self.vid.toggle_pause() def onScale(self, val): # print('>> scale onScale type val ->', type(val), val) if not self.vid: return try: # self.active_scale = True self.vid.seek(pts=float(val)) # self.active_scale = False except Exception as e: print(e) # self.active_scale = False # self.var_t.set(v) def replay(self): if not self.vid: return if self.val == 'paused': self.vid.seek(pts=0.01) self.vid.toggle_pause() else: self.vid.seek(pts=0.01) pass def newplay(self): ''' get replay ''' # put image play_b in btn_toogle_pause self.btn_toogle_pause['image'] = self.photos._play # load video stream self.vid = VideoStream(self.video_source) # set delay using self.delay = self.vid.f_rate # set scale value. self.var_t.set(0.1) # get and set duration video stream self.duracion = self.vid.duration # print time duration print('>> newplay: self.duracion ->', self.duracion) # set value maximun scale to self.scale.configure(to=self.duracion) # print configure values scale # print('>> self.scale.configure ->', self.scale) # ajuste valores de sonido al nivel seleccionado. self.vid.player.set_volume(float(self.soundvar.get())) # dimension vertical ventana. h = self.conten_controls.winfo_height() h_f = self.vid.h + h + 2 w_f = self.vid.w + 2 cad = f'{w_f}x{h_f}' self._width = w_f self._height = h_f self.master.geometry(cad) self.canvas.config(width=self.vid.w, height=self.vid.h) def snapshot(self): ''' Get a frame from the video source ''' # Get a frame from the video source #frame = self.vid.get_frame()[2] if not self.vid: return frame = self.imagen.copy() if frame is None: print('the video stream is closed') return # define options for opening time_str = time.strftime("%d-%m-%Y-%H-%M-%S") filename = f"frame-{time_str}.jpg" title='Save file as' filetypes={('png','*.png'), ('jpg','*.jpg')} fileExt = '*.jpg' options = {} options['defaultextension'] = fileExt options['filetypes'] = filetypes options['initialfile'] = filename options['title'] = title if self.dirImages is not None: options['initialdir'] = self.dirImages else: options['initialdir'] = os.getenv('HOME') filesave = filedialog.asksaveasfilename(**options) if filesave !='': frame.save(filesave) # actualiza directorio si este ha cambiado self.dirImages = os.path.dirname(filesave) #self.vid.snapshot() print(filesave) pass def update(self): # Get a frame from the video source if not self.vid: pass else: self.val, self.pts, frame = self.vid.get_frame() if frame is not None and not self.active_scale: size = frame.get_size() arr = frame.to_memoryview()[0] # array image self.imagen = Image.frombytes("RGB", size, arr.memview) self.canvas.delete(tk.ALL) # borra todos los objetos con ese tags.... self.imagen_copy = self.imagen.copy() w = self.canvas.winfo_width() h = self.canvas.winfo_height() marco = w, h # marco de ventana self.imagen_copy = self.imagen.copy() self.imagen_copy = image_adjustment(self.imagen_copy, marco) self.photo = ImageTk.PhotoImage(self.imagen_copy) self.canvas.create_image(w/2, h/2, anchor='center', image = self.photo, tags='img') # print('>>> self.active_scale:', self.active_scale) # if not self.active_scale: self.var_t.set(self.pts) self.master.after(self.delay, self.update)
from __future__ import print_function from videostream import VideoStream import RPi.GPIO as GPIO import numpy as np import warnings import ultrasonic import imutils import time import cv2 import csv GPIO.setwarnings(False) # initialise the video stream and allow the camera sensor to warmup print("[INFO] warming up camera...") vs = VideoStream(usePiCamera=False, resolution=(1024,576), framerate=20).start() TRIG,ECHO = ultrasonic.ultrasonic_setup() p = 0 dv,t,ts = [],[],[] # initialise the FourCC, video writer, dimensions of the frame, and zeros array fourcc = cv2.VideoWriter_fourcc(*'MJPG') writer = None (h, w) = (None, None) cv2.namedWindow("Window") print("[INFO] video recoding...") # loop over frames from the video stream while True:
class Handler: """ Request handler """ BUF_SIZE = 2048 # transmission state INIT = 0 READY = 1 PLAYING = 2 def __init__(self, addr): self.addr = addr self.state = self.INIT self.sessionid = self.random_session_id() self.rtpport = 0 self.rtpsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.teardown = False self.videostream = None self.signal = threading.Event() self.call = { 'PLAY': self.play, 'PAUSE': self.pause, 'SETUP': self.setup, 'DESCRIBE': self.describe, 'TEARDOWN': self.teardown } def random_session_id(self): return random.randint(100000, 999999) def print_log(self, msg): curTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) print('\033[31m{} \033[0m: \033[32m{}\033[0m'.format(curTime, msg)) def process(self, request): req_type = request.reqtype try: return self.call[req_type](request) except KeyError: # unknown method print(req_type) return self.unknown(request) def play(self, request): self.print_log('Process method PLAY') if self.state != self.INIT: header = { 'CSeq': request.seqnum, 'Session': self.sessionid } self.signal.set() time.sleep(1) npt = int(request.header['NPT']) if npt: self.videostream.vidcap.set(cv2.CAP_PROP_POS_MSEC, npt) self.state = self.PLAYING self.signal.clear() threading.Thread(target=self.send_rtp_pkt).start() return Response(200, header) else: return Response(455) def pause(self, request): self.print_log('Process method PAUSE') if self.state == self.PLAYING: header = { 'CSeq': request.seqnum, 'Session': self.sessionid } self.state = self.READY self.signal.set() return Response(200, header) else: return Response(455) def setup(self, request): self.print_log('Process method SETUP') if self.state == self.INIT: header = { 'CSeq': request.seqnum, 'Session': self.sessionid } quality = int(request.header['Quality']) self.videostream.quality = quality self.state = self.READY self.rtpport = int(request.lines[2].split()[3]) return Response(200, header) else: return Response(455) def describe(self, request): self.print_log('Process method DESCRIBE') header = { 'CSeq': request.seqnum, 'Session': self.sessionid } try: self.videostream = VideoStream(request.filename) header['Frame-Rate'] = self.videostream.fps header['Frame-Count'] = self.videostream.frm_cnt print(self.videostream.fps) return Response(200, header) except FileNotFoundError: return Response(404) def teardown(self, request): header = { 'CSeq': request.seqnum, 'Session': self.sessionid } self.print_log('Process method TEARDOWN') self.signal.set() self.rtpsock.close() self.teardown = True return Response(200, header) def unknown(self, request): self.print_log(str(request)) self.print_log('Receive unknown method: {}'.format(request.reqtype)) return Response(501) # Send RTP packets(picture) to client def send_rtp_pkt(self): while not self.signal.is_set(): data = self.videostream.next_pkt() # transmission completed if not data: return seqnum = self.videostream.get_pktnum() rtppkt = self.pack_rtp_pkt(data, seqnum) self.rtpsock.sendto(rtppkt, (self.addr[0], self.rtpport)) def pack_rtp_pkt(self, data, seqnum): """Packetize picture data into RTP packet""" rtppkt = RtpPacket() rtppkt.encode(2, 0, 0, 0, seqnum, 0, 26, 0, data) return rtppkt.getPacket()
class PeekabooController(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.running = False self.soundCtrlr = SoundController() self.initVideo() self.whereIsEveryoneFlag = False self.iSeeSomeoneFlag = False self.failure = False self.record = False def initVideo(self): try: self.video = VideoStream(src=0) except: print("video stream not found") if(self.video is None): print("video stream was not initialized") return try: self.video.start() except: print("video failed to start") # construct the face detector and allow the camera to warm up try: face = "cascades/haarcascade_frontalface_default.xml" self.faceDetector = FaceDetector(face) sleep(0.1) except: print("face detector init failed") # choose xvid codec try: self.fourcc = cv2.VideoWriter_fourcc(*'XVID') except: print("video writer not found") sleep(0.1) #called by the thread def run(self): self._start() def toggleRecord(self): if(self.record == True): self.record = False print("video recording stopped") else: self.record = True print("video recording started") # start looking def _start(self): self.running = True zeros = None previousX = 0 direction = "NONE" self.writer = None (h, w) = (None, None) # run until the controller is stopped while (True): # capture frames from the camera if(self.running == True): frame = self.video.read() if(frame is None): print("ERROR: cannot read frame from video, stopping Peekaboo. If you want Peekaboo to work, connect camera and restart R2.py") self.failure = True self.stop() break # resize the frame and convert it to grayscale frame = self.resizeImage(frame, width=500) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # detect faces in the image and then clone the frame # so that we can draw on it faceRects = self.faceDetector.detect(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)) frameClone = frame.copy() # where is everyone? if len(faceRects) <= 0: cv2.putText(frameClone, "WHERE IS EVERYONE?", (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (0, 255, 0), 2) self.whereIsEveryone() else: # peekaboo! # R2 is happy to see someone self.iSeeSomeone() # loop over the face bounding boxes and draw them for (fX, fY, fW, fH) in faceRects: cv2.rectangle(frameClone, (fX, fY), (fX + fW, fY + fH), (255, 0, 0), 2) # only turn head if face gets far out of center if ((previousX - 10) < fX < (previousX + 10)): direction = "NONE" elif fX < (previousX + 10): direction = "LEFT" elif fX > (previousX - 10): direction = "RIGHT" # turn R2's head to keep face centered # if direction == "LEFT": # self.mainCtrlr.rightThumbX(self.mainCntlr, self.mainCtrlr.xValueRight - 10) # elif direction == "RIGHT": # self.mainCtrlr.rightThumbX(self.mainCntlr, self.mainCtrlr.xValueRight + 10) cv2.putText(frameClone, "PEEKABOO!".format(direction), (fX, fY - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (0, 255, 0), 2) if direction != "NONE": cv2.putText(frameClone, "<Turn {}>".format(direction), (fX, fY - 0), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (0, 255, 0), 2) previousX = fX # show our detected faces, then clear the frame in preparation for the next frame # NOTE: comment this out if you don't want the video stream window to show in terminal cv2.imshow("Face", frameClone) # write video to file if self.record == True: if self.writer is None: # store the image dimensions, initialize the video writer, # and construct the zeros array (h, w) = frameClone.shape[:2] self.writer = cv2.VideoWriter("r2_recording.avi", self.fourcc, 4, (w, h), True) output = np.zeros((h, w, 3), dtype="uint8") output[0:h, 0:w] = frameClone self.writer.write(output) # NOTE: comment this out if you don't want the video stream window to show in terminal # if the 'q' key is pressed, stop the loop if cv2.waitKey(1) & 0xFF == ord("q"): print("keypress 'q', stopping Peekaboo") self.stop() break def resume(self): print("starting PeekabooController") if(self.failure == True): print("ERROR: the video had failed to load. If you want Peekaboo to work, you will need to connect the camera and restart R2.py") return self.running = True def stop(self): print("stopping PeekabooController") self.running = False if self.writer is not None: self.writer.release() def stopVideo(self): if(self.video is not None): self.video.stop() try: cv2.destroyAllWindows() except: print("") def whereIsEveryone(self): if(self.whereIsEveryoneFlag == False): SoundController.worried(self.soundCtrlr) self.whereIsEveryoneFlag = True self.iSeeSomeoneFlag = False def iSeeSomeone(self): if(self.iSeeSomeoneFlag == False): SoundController.whistle(self.soundCtrlr) self.whereIsEveryoneFlag = False self.iSeeSomeoneFlag = True def resizeImage(self, image, width=None, height=None, inter=cv2.INTER_AREA): # initialize the dimensions of the image to be resized and # grab the image size dim = None (h, w) = image.shape[:2] # if both the width and height are None, then return the # original image if width is None and height is None: return image # check to see if the width is None if width is None: # calculate the ratio of the height and construct the # dimensions r = height / float(h) dim = (int(w * r), height) # otherwise, the height is None else: # calculate the ratio of the width and construct the # dimensions r = width / float(w) dim = (width, int(h * r)) # resize the image resized = cv2.resize(image, dim, interpolation=inter) # return the resized image return resized
def __init__(self, master=None, title=None, video=None): ''' Initialice window app ''' super().__init__(master) self.master = master # self.master.geometry('422x624+629+231') -> desarrollo ahead. self.pack(fill=tk.BOTH, expand=1) self.master.title(title) self.master['bg'] = 'Black' self.master.protocol('WM_DELETE_WINDOW', self.confirmExit) self.master.protocol('WM_TAKE_FOCUS', self.confirmOpen) self.master.protocol('WM_SAVE_YOURSELF', self.confirmSave) self.init = True self.setingfile = 'flash_seting.ini' # self.window.resizable(width=False, height=False) self.n_size = None self.photo = None self.photos = Photos() # self.master.call('wm', 'iconphoto', self.master, self.photos._apply) self.soundvar = tk.DoubleVar(value=0.9) self.master.wm_iconphoto(True, self.photos._apply) self.dirImages = None self.dirpathmovies = tk.StringVar() # directorio path video self.video_source = video w = 350; h = 230; self.duracion = 100.0 self.active_scale = False self.vid = None self.val = 'paused' if self.video_source is not None: # open video source (by default this will try to open the computer webcam) try: self.dirpathmovies.set(os.path.dirname(self.video_source)) self.vid = VideoStream(self.video_source) # w_f, h_f = self.vid.w, self.vid.h self.duracion = self.vid.duration self.soundvar.set(self.vid.player.get_volume()) frame = None while frame is None: self.val, self.pts, frame = self.vid.get_frame() size = frame.get_size() arr = frame.to_memoryview()[0] # array image self.imagen = Image.frombytes("RGB", size, arr.memview) w_f, h_f = self.imagen.size self.delay = self.vid.f_rate self.vid.toggle_pause() self._wxh = (w_f, (h_f + 40)) self._twh = (300, 300) except Exception as e: print(e) self.video_source = None else: self.imagen = self.photos._logo w_f, h_f = self.imagen.size self.delay = 16 self._wxh = (422, 624) self._twh = (629, 231) pass # ajuste ventana. str_window = str(self._wxh[0])+ 'x'+str(self._wxh[1])+ '+' + str(self._twh[0])+ '+' + str(self._twh[1]) self.master.geometry(str_window) print('str ventana de inicio:', str_window) # event changed de volume self.soundvar.trace('w', self.soundvar_adjust) # Create a canvas that can fit the above video source size self.canvas = tk.Canvas(self, bg='red') # contenedor de controles self.conten_controls = tk.LabelFrame(self, height=4) # Button that lets the user take a snapshot self.btn_snapshot=tk.Button(self.conten_controls, text="Snapshot", command=self.snapshot) self.btn_snapshot['image'] = self.photos._snapshot self.btn_snapshot.pack(side='left') # Button open self.btn_open = tk.Button(self.conten_controls, text='...', command=self.open_file) self.btn_open['image'] = self.photos._open self.btn_open.pack(side='right') # button volum self.btn_volume = tk.Button(self.conten_controls, text='volume', command=self.open_adjust_volumen) self.btn_volume['image'] = self.photos._volume self.btn_volume.pack(side='right') # Button replay self.btn_replay = tk.Button(self.conten_controls, text=">>", command=self.replay) self.btn_replay['image'] = self.photos._repeat self.btn_replay.pack(side='right') # Button play-pausa self.btn_toogle_pause = tk.Button(self.conten_controls, text="[]", command=self.toogle_pause) self.btn_toogle_pause['image'] = self.photos._play self.btn_toogle_pause.pack(side='right') # Slade self.var_t = tk.DoubleVar() self.scale = tk.Scale(self.conten_controls, from_=0.0, to= self.duracion, showvalue=0, orient='horizontal', variable=self.var_t, resolution=0.3, sliderrelief='flat', command=self.onScale ) self.scale.pack(side='left', fill='x', expand=1) self.scale.bind('<ButtonPress-1>', self.scale_button_press) self.scale.bind('<ButtonRelease-1>', self.scale_button_release) self.master.bind('<Configure>', self.master_on_resize) # self.master.bind_all('<ButtonPress-1>', self.master_button_press) # self.master.bind('<ButtonRelease-1>', self.master_button_release) # self.master.wm_withdraw() self.canvas.pack(side =tk.TOP, fill=tk.BOTH, expand=1) self.conten_controls.pack(side='bottom', fill='x') if self.video_source is not None: self.scale.configure(to=self.duracion) self.btn_toogle_pause['image'] = self.photos._pause self.vid.player.set_volume(float(self.soundvar.get())) self.canvas_tags = None self.photo = ImageTk.PhotoImage(self.imagen) self.canvas.configure(width = w_f, height=h_f) self.canvas.create_image(w_f/2, h_f/2, image = self.photo, anchor='center', tags='img') self.val = None self.pts = None # if self.video_source is None: self.get_init_status() self.update() self.master.mainloop()
# import the necessary packages from videostream import VideoStream import imutils import numpy as np import cv2 import time import math def nothing(x): pass cap = VideoStream(usePiCamera=False, resolution=(960, 540)).start() # allow the camera to warmup time.sleep(0.1) pi = math.pi cos = math.cos sin = math.sin pt1x = 860 pt1y = 30 cv2.namedWindow("River Angle") cv2.createTrackbar("Degrees", "River Angle", 90, 180, nothing) while True: image = cap.read()
import imagezmq import argparse import socket import time # construct the argument parser and parse the arguments ap = argparse.ArgumentParser() ap.add_argument( "-s", "--server-ip", required=True, help="ip address of the server to which the client will connect") args = vars(ap.parse_args()) # initialize the ImageSender object with the socket address of the # server sender = imagezmq.ImageSender( connect_to="tcp://{}:5555".format(args["server_ip"])) # get the host name, initialize the video stream, and allow the # camera sensor to warmup rpiName = socket.gethostname() vs = VideoStream(usePiCamera=True).start() #vs = VideoStream(usePiCamera=True, resolution=(320, 240)).start() #vs = VideoStream(src=0).start() # Used for a usb camera time.sleep(2.0) while True: # read the frame from the camera and send it to the server frame = vs.read() #frame = imutils.resize(frame, width=320) between Lines 28 and 29 to resize # Used for resizing frames. sender.send_image(rpiName, frame)
gallery = None kairos = Kairos(gallery) source = 0 # camera #Load a cascade file for detecting faces #xmlfile = '../XML/haarcascades/haarcascade_frontalface_alt.xml' xmlfile = "C:\\Prasad-IoT\\Code\\Python\\CV1-master\\XML\\haarcascades\\haarcascade_frontalface_alt.xml" if not os.path.isfile(xmlfile): print "Could not find cascade training set" raise SystemExit(1) face_cascade = cv2.CascadeClassifier(xmlfile) fileName = "detected_face.jpg" stream = VideoStream(src=source) stream.start() time.sleep(2.0) frame = stream.read() if frame is None: print "No camera !" raise SystemExit(1) print "press any key to save file; ESC to quit.." while (True): frame = stream.read() frame = my_imutils.resize(frame, 640) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.1, 5) if (len(faces) == 0): cv2.imshow("Face", frame)
angle = objectAngle(cx) if self.debug: self.drawStats(cx, cy, box, "wall", "black", None, dist, angle) return [dist, angle] return [None, None] return [None, None] return [None, None] if __name__ == '__main__': from videostream import VideoStream vision = VideoProcess(debug=True, goal='yellow', ball=True, obstacles=True) stream = VideoStream().start() time.sleep(2) try: while True: frame = stream.read() if frame is None: break # (obs1, obs2, obs3), goal, ball (obs), (ball), (goal), (wall) = vision.update(frame) cv2.imshow("scene", vision.get()) key = cv2.waitKey(1) & 0xFF
# -*- coding: utf-8 -*- ''' ### Example.1: 打开USB摄像头 ''' import cv2 from videostream import VideoStream from imutils.video import FPS camera_id = 0 vs = VideoStream(camera_id) vs.start() fps = FPS().start() while True: res, frame = vs.read() fps.update() if not(res): print("Camera Read Failed") break cv2.imshow("test", frame) waikey = cv2.waitKey(1) & 0xFF if waikey == ord('q'): break fps.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))