def cv2_demo(net, transform): def predict(frame): height, width = frame.shape[:2] x = torch.from_numpy(transform(frame)[0]).permute(2, 0, 1) x = Variable(x.unsqueeze(0)) y = net(x) # forward pass detections = y.data # scale each detection back up to the image scale = torch.Tensor([width, height, width, height]) for i in range(detections.size(1)): j = 0 while detections[0, i, j, 0] >= 0.6: pt = (detections[0, i, j, 1:] * scale).cpu().numpy() cv2.rectangle(frame, (int(pt[0]), int(pt[1])), (int(pt[2]), int(pt[3])), COLORS[i % 3], 2) cv2.putText(frame, labelmap[i - 1], (int(pt[0]), int(pt[1])), FONT, 2, (255, 255, 255), 2, cv2.LINE_AA) j += 1 return frame # start video stream thread, allow buffer to fill print("[INFO] starting threaded video stream...") stream = WebcamVideoStream(src=0).start() # default camera time.sleep(1.0) # start fps timer # loop over frames from the video file stream while True: # grab next frame frame = stream.read() key = cv2.waitKey(1) & 0xFF # update FPS counter fps.update() frame = predict(frame) # keybindings for display if key == ord('p'): # pause while True: key2 = cv2.waitKey(1) or 0xff cv2.imshow('frame', frame) if key2 == ord('p'): # resume break cv2.imshow('frame', frame) if key == 27: # exit break
def __init__(self, center=int(cvsettings.CAMERA_WIDTH / 2), debug=False, is_usb_webcam=True, period_s=0.025): # Our video stream # If its not a usb webcam then get pi camera if not is_usb_webcam: self.vs = PiVideoStream(resolution=(cvsettings.CAMERA_WIDTH, cvsettings.CAMERA_HEIGHT)) # Camera cvsettings self.vs.camera.shutter_speed = cvsettings.SHUTTER self.vs.camera.exposure_mode = cvsettings.EXPOSURE_MODE self.vs.camera.exposure_compensation = cvsettings.EXPOSURE_COMPENSATION self.vs.camera.awb_gains = cvsettings.AWB_GAINS self.vs.camera.awb_mode = cvsettings.AWB_MODE self.vs.camera.saturation = cvsettings.SATURATION self.vs.camera.rotation = cvsettings.ROTATION self.vs.camera.video_stabilization = cvsettings.VIDEO_STABALIZATION self.vs.camera.iso = cvsettings.ISO self.vs.camera.brightness = cvsettings.BRIGHTNESS self.vs.camera.contrast = cvsettings.CONTRAST # Else get the usb camera else: self.vs = WebcamVideoStream(src=0) self.vs.stream.set(cv2.CAP_PROP_FRAME_WIDTH, cvsettings.CAMERA_WIDTH) self.vs.stream.set(cv2.CAP_PROP_FRAME_HEIGHT, cvsettings.CAMERA_HEIGHT) # Has camera started self.camera_started = False self.start_camera() # Starts our camera # To calculate our error in positioning self.center = center # To determine if we actually detected lane or not self.detected_lane = False # debug mode on? (to display processed images) self.debug = debug # Time interval between in update (in ms) # FPS = 1/period_s self.period_s = period_s # Starting time self.start_time = time.time()
def __init__(self, cam_L_src, cam_R_src, display_frames=True, threshold=110): # initialize camera feed threads self.capL = WebcamVideoStream(src=cam_L_src).start() time.sleep(0.5) self.capR = WebcamVideoStream(src=cam_R_src).start() self.stop = False self.display_frames = display_frames # initialize windows if self.display_frames == True: cv2.namedWindow('Depth Map') cv2.namedWindow('Threshold') cv2.namedWindow('Shapes') # import calibration matrices self.undistMapL = np.load('calibration/undistortion_map_left.npy') self.undistMapR = np.load('calibration/undistortion_map_right.npy') self.rectMapL = np.load('calibration/rectification_map_left.npy') self.rectMapR = np.load('calibration/rectification_map_right.npy') # initialize blank frames self.rectL = np.zeros((640, 480, 3), np.uint8) self.rectR = np.zeros((640, 480, 3), np.uint8) self.quadrant_near_object = np.zeros((3, 3), dtype=bool) self.threshold = threshold self.exec_time_sum = 0 self.frame_counter = 0 self.fps = 0 self.no_object_left_column = False self.no_object_mid_column = False self.no_object_right_column = False self.no_object_bottom_row = False self.no_object_mid_row = False self.no_object_top_row = False
# Ref: http://dlib.net/face_landmark_detection.py.html # Ref: https://ibug.doc.ic.ac.uk/resources/facial-point-annotations/ # loading the DLIB's face detector/predictor dlib_detector = dlib.get_frontal_face_detector() print("Logs: DLIB Face Landmark Predictor has been loaded...") # creating a variable for face landmark prediction, and load the pre-trained model on facial landmarks dlib_predictor = dlib.shape_predictor(shape_predictor_file) #Fetching the landmarks for the eyes and storing the beginning and end of the left and right eyes (left_beg, left_end) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"] (right_beg, right_end) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"] # initializing the camera for live detection cam_stream = WebcamVideoStream(src=0).start() print("Logs: Camera started ~ 📷 ~ ") # Starting while loop for the frames of the camera streams while True: #Read the camera stream frame by frame stream_frame = cam_stream.read() #print("Logs: Reading the stream frame by frame...") #Resizing the frame width to 600 stream_frame = imutils.resize(stream_frame, width=600) # convert the frames into grayscale gray_scale = cv2.cvtColor(stream_frame, cv2.COLOR_BGR2GRAY)
# list of tracked points yellowLower = (5, 25, 130) yellowUpper = (60, 220, 320) highestY = 0 farLeft = 600 farRight = 0 # defines udp server address for jetson HOST = "0.0.0.0" PORT = 5806 sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.bind((HOST, PORT)) camera = WebcamVideoStream(src=0).start() message = None # keep looping while True: try: cycle, rioAddress = sock.recvfrom(65507) except Exception: cycle = None rioAddress = None # grab the current frame (grabbed, frame) = camera.read()
def recvallVideo(size): databytes = b'' while len(databytes) != size: to_read = size - len(databytes) if to_read > (5000 * CHUNK): databytes += serverVideoSocket.recv(5000 * CHUNK) else: databytes += serverVideoSocket.recv(to_read) return databytes serverVideoSocket = socket(family=AF_INET, type=SOCK_STREAM) serverVideoSocket.bind((HOST, PORT_VIDEO)) wvs = WebcamVideoStream(0).start() serverAudioSocket = socket(family=AF_INET, type=SOCK_STREAM) serverAudioSocket.bind((HOST, PORT_AUDIO)) print('Server listening ...') serverVideoSocket.listen(4) serverAudioSocket.listen(4) serverVideoSocket.accept() print('Video connected ...') serverAudioSocket.accept() print('Audio connected ...') audio = pyaudio.PyAudio() stream = audio.open(format=FORMAT, channels=CHANNELS,
# stop the timer and display FPS information fps.stop() print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) # do a bit of cleanup stream.release() cv2.destroyAllWindows() ################################################################################### # created a *threaded* video stream, allow the camera sensor to warmup, # and start the FPS counter print("[INFO] sampling THREADED frames from webcam...") vs = WebcamVideoStream(src=1).start() fps = FPS().start() # loop over some frames...this time using the threaded stream while fps._numFrames < args["num_frames"]: # grab the frame from the threaded video stream and resize it # to have a maximum width of 400 pixels frame = vs.read() frame = imutils.resize(frame, width=400) # check to see if the frame should be displayed to our screen if args["display"] > 0: cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF # update the FPS counter
import cv2 from imutils.video import WebcamVideoStream import imutils vs = WebcamVideoStream(src=0).start() avg = None while True: frame = vs.read() frame = imutils.resize(frame, width=400) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (21, 21), 0) if avg is None: avg = gray.copy().astype("float") continue cv2.accumulateWeighted(gray, avg, 0.1) frameDelta = cv2.absdiff(gray, cv2.convertScaleAbs(avg)) thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1] thresh = cv2.dilate(thresh, None, iterations=2) _, contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) for c in contours: if cv2.contourArea(c) < 4000: print("Tiny") continue (x, y, w, h) = cv2.boundingRect(c) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
def main(): if rsFlag: camera = d435.d435() pipeline, align, clipping_distance, NIR = camera.setup() else: camera = WebcamVideoStream(camera_index).start() # load the COCO class labels our YOLO model was trained on labelsPath = PARAM_PATH + classes[classes_index] LABELS = open(labelsPath).read().strip().split("\n") # initialize a list of colors to represent each possible class label np.random.seed(42) COLORS = np.random.randint(0, 255, size=(len(LABELS), 3), dtype="uint8") # derive the paths to the YOLO weights and model configuration if not os.path.isfile(PARAM_PATH + weights[classes_index]): os.system(PARAM_PATH + "getWeights.sh") weightsPath = PARAM_PATH + weights[classes_index] configPath = PARAM_PATH + config[classes_index] # load our YOLO object detector trained on COCO dataset (80 classes) #print("[INFO] loading YOLO from disk...") net = cv2.dnn.readNetFromDarknet(configPath, weightsPath) print("Classify objects is now running...") try: while True: if rsFlag: # Wait for a coherent pair of frames: depth and color frames = pipeline.wait_for_frames() # Align the depth frame to color frame aligned_frames = align.process(frames) # Get aligned frames aligned_depth_frame = aligned_frames.get_depth_frame( ) # aligned_depth_frame is a 640x480 depth image color_aligned_frame = aligned_frames.get_color_frame() if NIR: nir_lf_frame = frames.get_infrared_frame(1) nir_rg_frame = frames.get_infrared_frame(2) if NIR: if not aligned_depth_frame or not color_aligned_frame or not nir_lf_frame or not nir_rg_frame: continue else: if not aligned_depth_frame or not color_aligned_frame: continue # Convert images to numpy arrays depth_image = np.asanyarray(aligned_depth_frame.get_data()) image = np.asanyarray(color_aligned_frame.get_data()) # Remove background - Set pixels further than clipping_distance to grey grey_color = 153 depth_image_3d = np.dstack( (depth_image, depth_image, depth_image )) # depth image is 1 channel, color is 3 channels bg_removed = np.where((depth_image_3d > clipping_distance) | (depth_image_3d <= 0), grey_color, image) if NIR: nir_lf_image = np.asanyarray(nir_lf_frame.get_data()) nir_rg_image = np.asanyarray(nir_rg_frame.get_data()) # Apply colormap on depth image (image must be converted to 8-bit per pixel first) depth_colormap = cv2.applyColorMap( cv2.convertScaleAbs(depth_image, alpha=0.03), cv2.COLORMAP_JET) else: # Capture frame-by-frame image = camera.read() (H, W) = image.shape[:2] if invColor: image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # determine only the *output* layer names that we need from YOLO ln = net.getLayerNames() ln = [ln[i[0] - 1] for i in net.getUnconnectedOutLayers()] # construct a blob from the input image and then perform a forward # pass of the YOLO object detector, giving us our bounding boxes and # associated probabilities blob = cv2.dnn.blobFromImage(image, 1 / 255.0, (416, 416), swapRB=True, crop=False) net.setInput(blob) start = time.time() layerOutputs = net.forward(ln) end = time.time() # show timing information on YOLO # print("[INFO] YOLO took {:.6f} seconds".format(end - start)) # initialize our lists of detected bounding boxes, confidences, and # class IDs, respectively boxes = [] confidences = [] classIDs = [] # loop over each of the layer outputs for output in layerOutputs: # loop over each of the detections for detection in output: # extract the class ID and confidence (i.e., probability) of # the current object detection scores = detection[5:] classID = np.argmax(scores) confidence = scores[classID] # filter out weak predictions by ensuring the detected # probability is greater than the minimum probability if confidence > conf: # scale the bounding box coordinates back relative to the # size of the image, keeping in mind that YOLO actually # returns the center (x, y)-coordinates of the bounding # box followed by the boxes' width and height box = detection[0:4] * np.array([W, H, W, H]) (centerX, centerY, width, height) = box.astype("int") # use the center (x, y)-coordinates to derive the top and # and left corner of the bounding box x = int(centerX - (width / 2)) y = int(centerY - (height / 2)) # update our list of bounding box coordinates, confidences, # and class IDs boxes.append([x, y, int(width), int(height)]) confidences.append(float(confidence)) classIDs.append(classID) # apply non-maxima suppression to suppress weak, overlapping bounding # boxes idxs = cv2.dnn.NMSBoxes(boxes, confidences, conf, threshold) # ensure at least one detection exists if len(idxs) > 0: # loop over the indexes we are keeping for i in idxs.flatten(): # extract the bounding box coordinates (x, y) = (boxes[i][0], boxes[i][1]) (w, h) = (boxes[i][2], boxes[i][3]) # draw a bounding box rectangle and label on the image color = [int(c) for c in COLORS[classIDs[i]]] cv2.rectangle(image, (x, y), (x + w, y + h), color, 2) text = "{}: {:.4f}".format(LABELS[classIDs[i]], confidences[i]) cv2.putText(image, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2) if rsFlag: cv2.rectangle(depth_colormap, (x, y), (x + w, y + h), color, 2) cv2.putText(depth_colormap, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2) # show the output image if rsFlag and stackFlag: images1 = np.hstack((image, depth_colormap)) cv2.imshow("Intel RealSense D435 RGB and Depth Map ", images1) if NIR: images2 = np.hstack((nir_lf_image, nir_rg_image)) cv2.imshow("Intel RealSense D435 NIRs Left and Right ", images2) elif rsFlag and not stackFlag: cv2.imshow("Intel RealSense D435 RGB ", image) cv2.imshow("Intel RealSense D435 depth map ", depth_colormap) if NIR: cv2.imshow("Intel RealSense D435 NIR Left ", nir_lf_image) cv2.imshow("Intel RealSense D435 NIR Right ", nir_rg_image) else: cv2.imshow("Camera ", image) if cv2.waitKey(1) == 27: break # esc to quit cv2.destroyAllWindows() finally: # Stop streaming print("Closing camera device.") if rsFlag: pipeline.stop() del camera else: camera.stop()
# result = cv.bitwise_and(frame, frame, mask = mask) contours, _ = cv.findContours(mask, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) x = 0 y = 0 radius = 0 if len(contours) > 0: c = max(contours, key=cv.contourArea) ((x, y), radius) = cv.minEnclosingCircle(c) M = cv.moments(c) if int(M["m00"]) > 0: rads = int(rw.read("setting/radius_bola.txt")) if radius > rads: return ((int(x), int(y))) return (framecenter) cap = WebcamVideoStream(0).start() while True: frame = cap.read() obj = ObjCenter() print(obj.update(frame, (0, 0))) print("exiting")
from detect_text import detect_text API_ENDPOINT = "http://159.89.172.250:4000/api/v1/vehicles/" CLASSES = [ "background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor" ] COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3)) net = cv2.dnn.readNetFromCaffe( "models/Car_Detect_Model/MobileNetSSD_deploy.prototxt.txt", "models/Car_Detect_Model/MobileNetSSD_deploy.caffemodel") #Main_Stream: cap1 = WebcamVideoStream( src="rtsp://*****:*****@121.6.207.205:8081/").start() cap2 = WebcamVideoStream( src="rtsp://*****:*****@121.6.207.205:8083/").start() ''' Sub_Stream: cap1=WebcamVideoStream(src="rtsp://*****:*****@121.6.207.205:8081/cam/realmonitor?channel=1&subtype=1").start() cap2=WebcamVideoStream(src="rtsp://*****:*****@121.6.207.205:8083/cam/realmonitor?channel=1&subtype=1").start() ''' lis = list() lis1 = list() lis2 = list() j = 0 while True: image = cap1.read()
face_net.setInput(blob) detections = face_net.forward() for i in range(0, detections.shape[2]): confidence = detections[0, 0, i, 2] if confidence < 0.5: continue box = detections[0, 0, i, 3:7] * np.array([w, h, w, h]) (startX, startY, endX, endY) = box.astype("int32") dlibrect = dlib.rectangle(int(startX), int(startY), int(endX), int(endY)) return dlibrect (lx, ly) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"] (rx, ry) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"] file = WebcamVideoStream(src=0).start() first_frame = file.read() (iheight, iwidth) = first_frame.shape[:2] print(iheight, iwidth) def det_to_bb(det): x = det.left() y = det.top() w = det.right() h = det.bottom() return (x, y, w, h) def video_detector(age_net): counter = 0
def init_streams(): _out_streams = [] _in_stream = WebcamVideoStream(src=config.in_stream).start() for stream in config.out_stream: _out_streams.append(WebcamVideoStream(src=stream).start()) return _in_stream, _out_streams
from time import time, sleep import numpy as np import cv2 import brickpi3 from statistics import median from imutils.video import WebcamVideoStream, FPS BP = brickpi3.BrickPi3() cam = WebcamVideoStream(src=0).start() fps = FPS().start() def drive(left_motor, right_motor, max_speed=100, min_speed=100): #So maybe this wasn't the most "Functional" code. if right_motor < min_speed: right_motor = -min_speed elif left_motor < -min_speed: left_motor = -min_speed if left_motor > max_speed: left_motor = max_speed if right_motor > max_speed: right_motor = max_speed print('C:', -right_motor) print('B:', -left_motor) BP.set_motor_dps(BP.PORT_B, -left_motor) BP.set_motor_dps(BP.PORT_C, -right_motor)
if tracker_type == 'BOOSTING': tracker = cv2.TrackerBoosting_create() if tracker_type == 'MIL': tracker = cv2.TrackerMIL_create() if tracker_type == 'KCF': tracker = cv2.TrackerKCF_create() if tracker_type == 'TLD': tracker = cv2.TrackerTLD_create() if tracker_type == 'MEDIANFLOW': tracker = cv2.TrackerMedianFlow_create() if tracker_type == 'GOTURN': tracker = cv2.TrackerGOTURN_create() # start video stream thread, allow buffer to fill print("[INFO] starting threaded video stream...") stream = WebcamVideoStream(src=0).start() # default camera time.sleep(1.0) # first frame frame = stream.read() # Define an initial bounding box bbox = (287, 23, 86, 320) # Select object to track bbox = cv2.selectROI(frame, False) # Initialize tracker with first frame and bounding box ok = tracker.init(frame, bbox) while True: # grab next frame
# create 2D gaussian kernel def create_gaussian_kernel(kernel_size_X, kernel_size_Y, sigma_X, sigma_Y): gx = cv2.getGaussianKernel(kernel_size_X, sigma_X, cv2.CV_32F) gy = cv2.getGaussianKernel(kernel_size_Y, sigma_Y, cv2.CV_32F) return gx * gy.T # init DoG kernel g1 = create_gaussian_kernel(3, 3, 50, 50) g2 = create_gaussian_kernel(3, 3, 0, 0) DoG_kernel = g1 - g2 print("Camera init -> DONE") cam = WebcamVideoStream(src=0).start() print("Start DoG") while True: # get current sensory state frame = cam.read() # grayscale frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # resize frame = cv2.resize(frame, (65, 65)) # convolve frame = cv2.filter2D(frame, -1, DoG_kernel) # plot plt.imshow(frame) plt.pause(0.0000001) plt.draw()
prototxt_path = os.path.join(path + 'model_data/deploy.prototxt') caffemodel_path = os.path.join(path + 'model_data/weights.caffemodel') net = cv2.dnn.readNetFromCaffe(prototxt_path,caffemodel_path) # Start video print("Use default webcam? \n y/n : ") cam= 0 if(input()=='n'): print("Enter video stream output link: ") cam = input() video = WebcamVideoStream(cam).start() time.sleep(1) while(True): frame = video.read() frame = cv2.flip(frame,flipCode=1) ret=True if ret==True: (h, w) = frame.shape[:2] # Convert image to blob blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300,300)),1.0, (300,300), (104.0,177.0,123.0)) net.setInput(blob)
import sys import time import numpy as np from imutils.video import WebcamVideoStream import imutils #from matplotlib import pyplot as plt def nothing(x): pass # grab camera feeds #capL = cv2.VideoCapture(1) #capR = cv2.VideoCapture(0) capL = WebcamVideoStream(src=1).start() capR = WebcamVideoStream(src=0).start() # initialize windows #WINDOW_L1 = 'undistorted left cam' #WINDOW_R1 = 'undistorted right cam' cv2.namedWindow('Depth Map') #cv2.namedWindow('Threshold') #cv2.namedWindow('Shapes') #cv2.namedWindow('Test') # import calibration matrices undistMapL = np.load('calibration/undistortion_map_left.npy')
#######VARIABLES#################### ##Aruco ids_to_find = [129, 72] marker_sizes = [40, 19] #cm marker_heights = [7, 4] takeoff_height = 10 velocity = .5 aruco_dict = aruco.getPredefinedDictionary(aruco.DICT_ARUCO_ORIGINAL) parameters = aruco.DetectorParameters_create() ## ##Camera horizontal_res = 640 vertical_res = 480 cap = WebcamVideoStream(src=0, width=horizontal_res, height=vertical_res).start() horizontal_fov = 62.2 * (math.pi / 180) ##Pi cam V1: 53.5 V2: 62.2 vertical_fov = 48.8 * (math.pi / 180) ##Pi cam V1: 41.41 V2: 48.8 ##REQUIRED: Calibration files for camera ##Look up https://github.com/dronedojo/video2calibration for info calib_path = "/home/pi/video2calibration/calibrationFiles/" cameraMatrix = np.loadtxt(calib_path + 'cameraMatrix.txt', delimiter=',') cameraDistortion = np.loadtxt(calib_path + 'cameraDistortion.txt', delimiter=',') ######### ##Counters and script triggers found_count = 0
# 800x600 windowed mode #mon = {'top': 100, 'left': 2020, 'width': 1280, 'height': 720} #mon = {'top': 0, 'left': 1920, 'width': 1280, 'height': 720} mon = {'top': 0, 'left': 0, 'width': 1280, 'height': 720} sct = None if "screen" in url: sct = mss.mss() webcam=False #webcam=True cap = None if sct is None: if webcam: #cap = WebcamVideoStream(src=""+str(videoUrl)+"").start() cap = WebcamVideoStream(videoUrl).start() else: cap = cv2.VideoCapture(videoUrl) cap.set(cv2.CAP_PROP_FRAME_WIDTH, procWidth) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, procHeight) #cap = cv2.VideoCapture(videoUrl) count=50 #skip=2000 skip=skipNr SKIP_EVERY=150 #pick a frame every 5 seconds count=1000000 #skip=0 #int(7622-5)
def right_click(x, y): win32api.SetCursorPos((x, y)) win32api.mouse_event(win32con.MOUSEEVENTF_RIGHTDOWN, x, y, 0, 0) win32api.mouse_event(win32con.MOUSEEVENTF_RIGHTUP, x, y, 0, 0) eye_cascade1 = cv2.CascadeClassifier('xml/haarcascade_mcs_eyepair_big.xml') eye_cascade2 = cv2.CascadeClassifier('xml/haarcascade_mcs_eyepair_small.xml') eye_cascade3 = cv2.CascadeClassifier('xml/haarcascade_eye_tree_eyeglasses.xml') eye_cascade4 = cv2.CascadeClassifier('xml/haarcascade_eye.xml') window_size = 5 windowX = [] windowY = [] cap = WebcamVideoStream(src=0).start() mx = 0 my = 0 upper_mx = 0 lower_mx = 0 upper_my = 0 lower_my = 0 start_flag = True while True: img = cap.read() img = cv2.flip(img, 1)
def __init__(self, camera=CAMERA, rotate=ROTATE): cams = [WebcamVideoStream(src=cam).start() for cam in camera] imgs = [] for i, cam in enumerate(cams): # cam.set(cv2.CAP_PROP_BUFFERSIZE, 1) # Internal buffer will now store only x frames img = cam.read() imgs.append(img) image = mainhuman_activity.preprocess(imgs, rotate) # h, w, c = image_raw.shape # h2, w2, c2 = image2_raw.shape # print(h, w, c, h2, w2, c2) print("\n######################## Darknet") dark = dk.darknet_recog() print(dark.performDetect(image)) print("\n######################## Openpose") opose = openpose_human(image) print("\n######################## LSTM") act = activity_human() # print("\n######################## Deepface") # dface = df.face_recog() # print(dface.run(image)) print("\n######################## Facerec") facer = fr.face_recog(face_dir="./facerec/face/") act_labs = [] act_confs = [] # Main loop try: f = open(r'\\.\pipe\testing', 'r+b', 0) d = 0 # mode in communication alarmmode = False # False mode deactive True mode active mode = True # False normal mode True recognition mode security_threshold = 0.5 face_tolerance = 0.6 while True: # imgs = [mainhuman_activity.read2(cam) for cam in cams] n = struct.unpack('I', f.read(4))[0] # Read str length s = f.read(n).decode('ascii') # Read str f.seek(0) print('Accept from C#', s) if (s == 'AlarmDeactive'): d = 7 elif (s == 'AlarmActive'): d = 6 elif (s == 'FaceInput'): d = 5 elif (s == 'Normal'): d = 4 elif (s == 'Recognition'): d = 3 elif (s == 'Start'): d = 2 elif (s == 'Stop'): d = 1 elif (s == 'Received'): d = 0 else: s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) if (d == 7): alarmmode = False # False mode deactive True mode active s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) elif (d == 6): alarmmode = True # False mode deactive True mode active s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) elif (d == 5): s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) n = struct.unpack('I', f.read(4))[0] # Read str length facename = f.read(n).decode('ascii') # Read str f.seek(0) print('Accept from C#', facename) imgs = [] img = cams[0].read() imgs.append(img) # for i, cam in enumerate(cams): # # Decode the captured frames # ret_val, img = cam.retrieve() # imgs.append(img) # Skip frame if there's nothing if (imgs is [None]): continue image = mainhuman_activity.preprocess(imgs, rotate) face_locs, face_names = facer.runinference( image, tolerance=face_tolerance, prescale=0.25, upsample=2) # Facerec display for (top, right, bottom, left), face in zip(face_locs, face_names): print(face) if (face == "Unknown"): bounds = [4 * left, 4 * top, 4 * right, 4 * bottom] image = image[bounds[1]:bounds[3], bounds[0]:bounds[2]] cv2.imwrite('facerec/face/' + facename + '.jpg', image) print("\n######################## Facerec") s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) elif (d == 4): mode = False # False normal mode True recognition mode s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) elif (d == 3): mode = True # False normal mode True recognition mode s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) elif (d == 2): for i, cam in enumerate(cams): # cam.set(cv2.CAP_PROP_BUFFERSIZE, 1) # Internal buffer will now store only x frames cam.stop() camera = [] rotate = [] s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) n = struct.unpack('I', f.read(4))[0] # Read str length camnumber = f.read(n).decode('ascii') # Read str f.seek(0) try: cam_number = int(camnumber) except ValueError: pass print('Accept from C#', camnumber) for x in range(cam_number): s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) n = struct.unpack('I', f.read(4))[0] # Read str length camtemp = f.read(n).decode('ascii') # Read str f.seek(0) try: camera.append(int(camtemp)) rotate.append(180) except ValueError: camera.append(camtemp) rotate.append(180) pass print('Accept from C#', camtemp) s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) n = struct.unpack('I', f.read(4))[0] # Read str length securitythresholdtemp = f.read(n).decode( 'ascii') # Read str f.seek(0) if (securitythresholdtemp != " "): try: security_threshold = float(securitythresholdtemp) except ValueError: pass print('Accept from C#', securitythresholdtemp) s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) n = struct.unpack('I', f.read(4))[0] # Read str length facetolerancetemp = f.read(n).decode('ascii') # Read str f.seek(0) if (facetolerancetemp != " "): try: face_tolerance = float(facetolerancetemp) except ValueError: pass print('Accept from C#', facetolerancetemp) cams = [ WebcamVideoStream(src=cam).start() for cam in camera ] s = 'Go' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) elif (d == 1): s = 'Wait' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) elif (d == 0): imgs = [] for i, cam in enumerate(cams): # Grab the frames AND do the heavy preprocessing for each camera # ret_val, img = cam.read() # For better synchronization on multi-cam setup: # Grab the frames first without doing the heavy stuffs (decode, demosaic, etc) # ret_val = cam.grab() # The FIFO nature of the buffer means we can't get the latest frame # Thus skip the earlier frames. Delay stats: 7s 8fps +artifact >>> 2s 3fps # for i in range(5): # ret_val = cam.grab() # Multi-threading using WebcamVideoStream img = cam.read() imgs.append(img) # for i, cam in enumerate(cams): # # Decode the captured frames # ret_val, img = cam.retrieve() # imgs.append(img) # Skip frame if there's nothing if (imgs is [None]): continue image = mainhuman_activity.preprocess(imgs, rotate) print("\n######################## Openpose") start_act, human_keypoints, humans = opose.runopenpose( image) # print(humans, human_keypoints) print("\n######################## Darknet") dobj = dark.performDetect(image) print(dobj) print("\n######################## Facerec") face_locs, face_names = facer.runinference( image, tolerance=face_tolerance, prescale=0.01, upsample=1) print(face_locs, face_names) print("\n######################## LSTM") print("Frame: %d/%d" % (opose.videostep, n_steps)) if start_act == True: act_labs = [] act_confs = [] for key, human_keypoint in human_keypoints.items(): print(key, human_keypoint) if (len(human_keypoint) == n_steps): act.runinference(human_keypoint) act_labs.append(act.action) act_confs.append(act.conf) print("\n######################## Display") # opose.display_all(image, humans, act.action, act.conf, dobj, face_locs, face_names) opose.display_all(image, humans, act_labs, act_confs, dobj, face_locs, face_names, mode) s = 'Image' f.write(struct.pack('I', len(s)) + s.encode('ascii')) # Write str length and str f.seek(0) print('Sending to C#:', s) if cv2.waitKey(1) == 27: break except FileNotFoundError: raise cv2.destroyAllWindows() # print("FPS: ", opose.hisfps) fh = open("fps.txt", "w") for fps in opose.hisfps: fh.write("%.3f \n" % fps) fh.close()
print("TiltMove called: desired position is beneath lower limit" + '\n') desPosTilt = _TiltServoLL tiltDesPosQ.put(desPosTilt) tiltCurSpeedQ.put(speed) # Send the new speed to the subprocess return #Video Prep camWandH = np.array([320, 240]) #set camera frame height and width here camCenter = [(camWandH[0] / 2), (camWandH[1] / 2)] #Ordered as Pan and Tilt print("Center of screen is " + str(camCenter[0]) + ", " + str(camCenter[1])) frontalface = cv2.CascadeClassifier("haarcascade_frontalface_default.xml") profileface = cv2.CascadeClassifier("haarcascade_profileface.xml") cv2.namedWindow('CreepyEye', cv2.WINDOW_NORMAL) vs = WebcamVideoStream( src=0).start() #If src is changed to a URL it will use that as the camera while True: # Capture frame-by-frame frame = vs.read() # Our operations on the frame come here frame = imutils.resize(frame, width=camWandH[0]) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.flip(gray, 1, gray) # flip the image face = np.array( [0, 0, 0, 0] ) # This will hold the array that OpenCV returns when it finds a face: (makes a rectangle) Cface = np.array( [0, 0]) # Center of the face: a point calculated from the above variable lastface = 0 # int 1-3 used to speed up detection. The script is looking for a right profile face,-
def main(): # ---===--- Get the filename --- # '''filename = sg.popup_get_file('Filename to play') if filename: cap = cv2.VideoCapture(filename) #cap = WebcamVideoStream(src="http://192.168.0.101:8081").start() else: #vs = WebcamVideoStream(src=0).start() cap = cv2.VideoCapture(0)''' # ---===--- get stream --- # # cap = WebcamVideoStream(src=0).start() # cap = cv2.VideoCapture('actions1.mpg') # cap = WebcamVideoStream(src="http://192.168.0.100:8081").start() # ---===--- initialize --- # fps = FPS().start() count = 0 count_th = 20 rec = False sg.theme('Black') useVideo = False isFirst = True now = datetime.now() vodname = now.strftime("%m_%d_%Y,%H-%M-%S") cap = None # ---===--- define the window layout --- # tab1_layout = [ [ sg.T('Battery: '), sg.ProgressBar(1000, orientation='h', size=(10, 10), key='battbar'), sg.Text('Last detected: '), sg.Text(' ', key='-detected-', size=(20, 1)), sg.Button('Capture', key='-STOP-'), sg.Button('EXIT', key='-EXIT-') ], [sg.Image(filename='', key='-image-')], [ sg.Text('Height: ', size=(15, 1)), sg.Text('', size=(10, 1), justification='center', key='_HEIGHT_') ], [ sg.Text('Latitude: ', size=(15, 1)), sg.Text('', size=(10, 1), justification='center', key='_LATI_') ], [ sg.Text('Longitude: ', size=(15, 1)), sg.Text('', size=(10, 1), justification='center', key='_LONGTI_') ], [ sg.Text('FPS: '), sg.Text(size=(15, 1), key='-FPS-'), ], ] column1 = [ [ sg.Text('Detected history', background_color='#333333', justification='center', size=(20, 1)), ], #sg.Output(size=(40, 20))], [sg.Text('Gimbal command: '), sg.Text(size=(15, 1), key='-Gimbal-')] ] tab2_layout = [[sg.T('cropped/masked')], [ sg.Image(filename='', key='-cropped-'), sg.T(' ' * 30), sg.Image(filename='', key='-masked-'), sg.Column(column1, background_color='#333333') ], [ sg.Text('Size of the object: ', size=(15, 1)), sg.Text('', size=(10, 1), justification='center'), sg.Slider(range=(0, 500), default_value=15, size=(50, 10), orientation='h', key='-slider-') ]] tab3_layout = [[sg.Image(filename='', key='-histp-')], [sg.Text(' ', key='-history-', size=(20, 1))], [ sg.Button('Next'), sg.Button('Refresh'), sg.Button('Prev') ]] layout = [ [sg.Text('DemodetectionUI', size=(15, 1), font='Helvetica 20')], [ sg.TabGroup([[ sg.Tab('Cam view', tab1_layout), sg.Tab('Area view', tab2_layout), sg.Tab('Detected view', tab3_layout) ]], ) ], ] layoutWin2 = [ [sg.Text('Tracking and DetectionDemo', key='-STATUS-')], # note must create a layout from scratch every time. No reuse [ sg.Button('Start', key='-START-', disabled=True), sg.Button('Connect'), sg.Button('video'), sg.Checkbox('Record', key='-RECORD-', size=(12, 1), default=False) ], [sg.T(' ' * 12), sg.Button('Exit', )] ] # create the window and show it # main window window = sg.Window('DemoUI', layout, no_titlebar=False) # Open Connect Vods window window2 = sg.Window('DetectedHistory', layoutWin2, no_titlebar=False) # locate the elements we'll be updating. Does the search only 1 time image_elem = window['-image-'] cropped_elem = window['-cropped-'] masked_elem = window['-masked-'] # initializing stuffs mcd = MCDWrapper() # subtractor = cv2.createBackgroundSubtractorMOG2(history = 50,varThreshold=50,detectShadows=True) object_bounding_box = None cropped = None count, fcount, fmeter = 0, 0, 0 netip = '192.168.0.102' port = 25000 out = None s = None win2_active = True showhist = False frame = None event2, values2 = None, None capp = os.listdir("cap") ptr = 1 if capp: histpic = capp[len(capp) - ptr] while True: ev1, vals1 = window2.Read(timeout=100) if ev1 is None or ev1 == '-START-': window2.Close() win2_active = False if window2['-RECORD-'].Get(): fourcc = cv2.VideoWriter_fourcc(*'XVID') out = cv2.VideoWriter('./recording/%s.avi' % (vodname), fourcc, 20.0, (1020, 720)) break if ev1 is None or ev1 == 'Exit': if out: out.release() break if ev1 is ev1 == 'video': filename = sg.popup_get_file('Filename to play') useVideo = True if filename: cap = cv2.VideoCapture(filename) else: cap = cv2.VideoCapture(0) if ev1 is ev1 == 'Connect': try: s = comm(netip, port) s = s.start() #cap = cv2.VideoCapture("http://192.168.0.102:8081") #streamer = ThreadedCamera("http://192.168.0.102:8081") cap = WebcamVideoStream( src="http://192.168.0.102:8081").start() time.sleep(1) except: sg.popup('Error CameraIP not found') if not cap: window2['-START-'].update(disabled=True) else: if useVideo: captype = 'Video' else: captype = 'Aerial camera' window2['-STATUS-'].update(captype) window2['-START-'].update(disabled=False) # ---===--- LOOP through video file by frame --- # while True and win2_active == False: event, values = window.read(timeout=20) if event in ('-EXIT-', None): if s: s.stop() if out: out.release() break if useVideo == True: if frame is not None: lastframe = frame.copy() try: ret, frame = cap.read() except: frame = lastframe else: #frame = streamer.grab_frame() if frame is not None: lastframe = frame.copy() try: frame = cap.read() except: frame = None while i <= 5 or frame: try: cap = WebcamVideoStream( src="http://192.168.0.102:8081").start() time.sleep(1) frame = cap.read() except: continue frame = lastframe i = 0 now = datetime.now() s1 = now.strftime("%m_%d_%Y,%H-%M-%S") objsize = int(values['-slider-']) logging.basicConfig(filename='Detected.log', format='%(asctime)s %(message)s', datefmt='%m_%d_%Y,%H-%M-%S') data = "X0_0_0_0" if s: s.getxyhf() data = s.getxyh() split = data.split('_') if len(split) > 3 and split[0][0] == 'X': window['_LATI_'].update(split[0][1:]) window['_LONGTI_'].update(split[1]) window['_HEIGHT_'].update(split[2]) window['battbar'].update_bar(int(float(split[3][0:2]))) if frame is None: # if out of data stop looping frame = lastframe if out: frameout = cv2.resize(frame, (1020, 720)) out.write(frameout) # resizing the big pic # frame = cv2.resize(frame,(1280,500)) # draw a bb around the obj # --------Event handler---------------- if event == '-STOP-': # stop video stop = window["-STOP-"] if frame.sum() > 0: object_bounding_box = cv2.selectROI("Frame", frame, fromCenter=False, showCrosshair=True) object_tracker = cv2.TrackerMOSSE_create() object_tracker.init(frame, object_bounding_box) cv2.destroyAllWindows() if event == 'Refresh': capp = os.listdir("cap") ptr = 1 if capp: histpic = capp[len(capp) - ptr] histtemp = cv2.imread("./cap/%s" % (histpic)) histbytes = cv2.imencode('.png', histtemp)[1].tobytes() # ditto histpic = histpic.replace('-', ':') window['-histp-'].update(data=histbytes) window['-history-'].update(histpic.replace('.jpg', '')) if event == 'Prev' and capp: if ptr <= len(capp): ptr += 1 histpic = capp[len(capp) - ptr] histtemp = cv2.imread("./cap/%s" % (histpic)) histbytes = cv2.imencode('.png', histtemp)[1].tobytes() # ditto histpic = histpic.replace('-', ':') window['-histp-'].update(data=histbytes) window['-history-'].update(histpic.replace('.jpg', '')) if event == 'Next' and capp: if ptr > 1: ptr -= 1 histpic = capp[len(capp) - ptr] histtemp = cv2.imread("./cap/%s" % (histpic)) histbytes = cv2.imencode('.png', histtemp)[1].tobytes() # ditto histpic = histpic.replace('-', ':') window['-histp-'].update(data=histbytes) window['-history-'].update(histpic.replace('.jpg', '')) '''if event == '-detected-': # stop video capp = os.listdir("cap") tab3_layout = [[sg.T('Captured')], [sg.Listbox(values=capp,size=(20, 12), key='-LIST-')], [sg.Text(' ',key ='-File-'), sg.Button('Select',size=(15, 1))]] winchoose = sg.Window('Detected History', tab3_layout) event2, values2 = winchoose.Read() if event2 is not None and event2 == 'Select': filechoosen = True if values2['-LIST-'] and filechoosen == True: filechoosen = str(values2['-LIST-'][0]) winchoose.close() histtemp = cv2.imread("./cap/%s" % (filechoosen)) histbytes = cv2.imencode('.png', frame)[1].tobytes() # ditto winpic = sg.Window(filechoosen,[[sg.Image(data= histbytes, key='-histp-')],[sg.Button('Exit')]]) eventp, valuesp = winpic.read() winpic['-histp-'].update(data=histbytes) if eventp == 'Exit': filechoosen == False winpic.close()''' # --------bgsubtraction-----------# if object_bounding_box is not None: success, object_bounding_box = object_tracker.update(frame) if success: (x, y, w, h) = [int(v) for v in object_bounding_box] cropped = frame[y:y + h, x:x + w].copy() cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) #detectsize = objsize/2 cv2.rectangle(frame, (x + objsize, y + objsize), (x + w - objsize, y + h - objsize), (0, 0, 255), 2) if (y + (h / 2) - 50) > frame.shape[0] / 2: # order gimbal if count >= count_th: inp = "u" if s: s.setinp(inp) s.sendcommand() window['-Gimbal-'].update(inp) print((y + h) / 2, frame.shape[0]) count = 0 elif (y + (h / 2)) + 50 < frame.shape[0] / 2: if count >= count_th: inp = "d" if s: s.setinp(inp) s.sendcommand() print((y + h) / 2, frame.shape[0]) window['-Gimbal-'].update(inp) count = 0 else: if count >= count_th: inp = "s" if s: s.setinp(inp) s.sendcommand() print((y + h) / 2, frame.shape[0]) window['-Gimbal-'].update(inp) count = 0 count += 1 if cropped is not None and cropped.sum() > 0: # resizing the small pic # cropped = cv2.resize(cropped,(600,400)) # cv2.imwrite("./all/frame%d.jpg" % count, cropped) count += 1 # mask = subtractor.apply(cropped) # for some reason the fast MCD accepts only the %4 size if cropped.shape[0] % 4 != 0 or cropped.shape[1] % 4 != 0: cropped = cv2.resize(cropped, ((cropped.shape[1] // 4) * 4, (cropped.shape[0] // 4) * 4)) gray = cv2.cvtColor(cropped, cv2.COLOR_RGB2GRAY) mask = np.zeros(gray.shape, np.uint8) if (isFirst): mcd.init(gray) isFirst = False else: try: mask = mcd.run(gray) except: mcd.init(gray) # draw contours (cnts, _) = cv2.findContours(mask.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) for contour in cnts: if (cv2.contourArea(contour) > objsize): cv2.drawContours(cropped, contour, -1, (0, 255, 0), 2) (x, y, w, h) = cv2.boundingRect(contour) cv2.rectangle(cropped, (x, y), (x + w, y + h), (0, 255, 0), 3) ##if cv2.contourArea(contour)>50: # print(contour) # cv2.drawContours(cropped,contour,-1,(0,255,0),2) if x <= objsize / 2 or x >= cropped.shape[ 1] - objsize / 2 or x + w <= objsize / 2 or x + w >= cropped.shape[ 1] - objsize / 2: if fmeter >= 3: cv2.imwrite("./capc/%s.jpg" % (s1), cropped) cv2.imwrite("./cap/%s.jpg" % (s1), frame) logging.warning(" ") fcount += 1 window['-detected-'].update(s1) count += 1 fmeter = 0 else: fmeter += 1 elif y <= objsize / 2 or y >= cropped.shape[ 0] - objsize / 2 or y + h <= objsize / 2 or y + h >= cropped.shape[ 0] - objsize / 2: if fmeter >= 3: cv2.imwrite("./capc/%s.jpg" % (s1), cropped) cv2.imwrite("./cap/%s.jpg" % (s1), frame) logging.warning(" ") fcount += 1 window['-detected-'].update(s1) count += 1 fmeter = 0 else: fmeter += 1 # showing imgbytes = cv2.imencode('.png', frame)[1].tobytes() # ditto image_elem.update(data=imgbytes) fps.update() fps.stop() window['-FPS-'].update("{:.2f}".format(fps.fps())) if cropped is not None: try: # print(cropped.shape) imgcropped = cv2.imencode('.png', cropped)[1].tobytes() imgmarked = cv2.imencode('.png', mask)[1].tobytes() cropped_elem.update(data=imgcropped) masked_elem.update(data=imgmarked) except: continue
import argparse import imutils import multiprocessing as mp import cv2 import label_image import os #disable error. Maybe visit later os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #value for resizing image: Adjust and test stuff size = 4 # testing speed stuff cv2.setUseOptimized(False) cv2.useOptimized() # We load the xml file classifier = cv2.CascadeClassifier('haarcascade_frontalface_alt.xml') vs = WebcamVideoStream(src=0).start() #Using default WebCam connected to the PC. #if vs = null then break gently... #pool = mp.Pool(processes=mp.cpu_count()) while True: im = vs.read() # Flip camera im=cv2.flip(im,1,0) # Resize the image to speed up detection mini = cv2.resize(im, (int(im.shape[1]/size), int(im.shape[0]/size))) # detect MultiScale / faces faces = classifier.detectMultiScale(mini) # Draw rectangles around each face for f in faces: (x, y, w, h) = [v * size for v in f] #Scale the shapesize backup cv2.rectangle(im, (x,y), (x+w,y+h), (255,255,255), 3)
class ObjectDetection: def __init__(self, id): # self.cap = cv2.VideoCapture(id) self.cap = WebcamVideoStream(src=id).start() self.cfgfile = "cfg/yolov3.cfg" # self.cfgfile = 'cfg/yolov3-tiny.cfg' self.weightsfile = "yolov3.weights" # self.weightsfile = 'yolov3-tiny.weights' self.confidence = float(0.6) self.nms_thesh = float(0.8) self.num_classes = 1 self.classes = load_classes('data/butt.names') self.colors = pkl.load(open("pallete", "rb")) self.model = Darknet(self.cfgfile) self.CUDA = torch.cuda.is_available() self.model.load_weights(self.weightsfile) self.model.net_info["height"] = 160 self.inp_dim = int(self.model.net_info["height"]) self.width = 1280 #640#1280 self.height = 720 #360#720 print("Loading network.....") if self.CUDA: self.model.cuda() print("Network successfully loaded") assert self.inp_dim % 32 == 0 assert self.inp_dim > 32 self.model.eval() def main(self): q = queue.Queue() while True: def frame_render(queue_from_cam): frame = self.cap.read( ) # If you capture stream using opencv (cv2.VideoCapture()) the use the following line # ret, frame = self.cap.read() frame = cv2.resize(frame, (self.width, self.height)) queue_from_cam.put(frame) cam = threading.Thread(target=frame_render, args=(q, )) cam.start() cam.join() frame = q.get() q.task_done() fps = FPS().start() try: img, orig_im, dim = prep_image(frame, self.inp_dim) im_dim = torch.FloatTensor(dim).repeat(1, 2) if self.CUDA: #### If you have a gpu properly installed then it will run on the gpu im_dim = im_dim.cuda() img = img.cuda() # with torch.no_grad(): #### Set the model in the evaluation mode output = self.model(Variable(img), self.CUDA) output = write_results(output, self.confidence, self.num_classes, nms=True, nms_conf=self.nms_thesh ) #### Localize the objects in a frame output = output.type(torch.half) if list(output.size()) == [1, 86]: print(output.size()) pass else: output[:, 1:5] = torch.clamp(output[:, 1:5], 0.0, float( self.inp_dim)) / self.inp_dim # im_dim = im_dim.repeat(output.size(0), 1) output[:, [1, 3]] *= frame.shape[1] output[:, [2, 4]] *= frame.shape[0] list( map( lambda boxes: write(boxes, frame, self.classes, self.colors), output)) except: pass fps.update() fps.stop() ret, jpeg = cv2.imencode('.jpg', frame) print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.1f}".format(fps.fps())) return jpeg.tostring()
def cv2_demo(net, transform, use_cuda): if use_spatial: tresh = 0.3 # UPDATE (smaller is more restrict) else: tresh = 0.25 detected_objs = {} # store by label name step = 0 def predict(step, frame, detected_objs, obj_tracked): # - Also return the bbox of the tracked obj (2018.07.30) pt_tracked = [0, 0, 0, 0] k_reduce = 0.1 # bbox reduction for matching purpose (detected bbox is large...) pts = [] # Start timer timer = cv2.getTickCount() height, width = frame.shape[:2] x = torch.from_numpy(transform(frame)[0]).permute(2, 0, 1) xx = Variable(x.unsqueeze(0)) if use_cuda: xx = xx.cuda() y = net(xx) else: y = net(xx) # forward pass detections = y.data # Objects detected in the frame # scale each detection back up to the image scale = torch.Tensor([width, height, width, height]) for i in range(detections.size(1)): j = 0 while detections[0, i, j, 0] >= 0.6: pt = (detections[0, i, j, 1:] * scale).cpu().numpy() # Detection box # Store tracked obj bbox if labelmap[i - 1] == obj_tracked: pt_tracked = pt # Check whether object was already detected if labelmap[i - 1] not in detected_objs: # Add vxy = [0, 0] # assume static obj at beginning detected_objs[labelmap[i - 1]] = [ myobj(time.time(), frame, 1, labelmap[i - 1], get_bbox(pt, k_reduce), vxy) ] # Draw box cv2.rectangle( frame, (int(pt[0]), int(pt[1])), # UPPER LEFT (int(pt[2]), int(pt[3])), # LOWER RIGHT COLORS[i % 3], 2) cv2.putText(frame, labelmap[i - 1] + '(1)', (int(pt[0]), int(pt[1])), FONT, 1, (255, 255, 255), 1, cv2.LINE_AA) else: if labelmap[i - 1] == 'person': treshx = 0.5 # Less restrict for people else: treshx = tresh # Reduce bbox for figure matching newobj = myobj(time.time(), frame, 0, labelmap[i - 1], get_bbox(pt, k_reduce), [0, 0]) #showme(newobj.get_img()) # Check it was detected before #print('Comparing images...') num, match_obj, dist = get_matching( newobj, detected_objs[labelmap[i - 1]], treshx) # Return 0 if not in the list if num != 0: # object found --> estimate the spatial evidence if use_spatial: dt = newobj.get_time() - match_obj.get_time( ) # Time diff prior_x, prior_y = predict_pos(match_obj, dt) likelihood_x, likelihood_y = newobj.get_p_xy() x_distrib = update(prior_x, likelihood_x) y_distrib = update(prior_y, likelihood_y) x, y = newobj.get_xy() approx_spatial_diff = abs( x - x_distrib.mean) + abs(y - y_distrib.mean) # Experimental #spatial_evidence = 1 - approx_spatial_diff/300 if ( dist + approx_spatial_diff / 300 ) < treshx: # If spatial difference is small, it will keep # udate velocity for the next iteration vxy = [] vxy.append((newobj.get_xy()[0] - match_obj.get_xy()[0]) / dt) vxy.append((newobj.get_xy()[1] - match_obj.get_xy()[1]) / dt) newobj.set_vxy(vxy) # set velocity detected_objs[labelmap[i - 1]][ match_obj.get_id() - 1] = newobj.set_id( num ) # Update with the matched newer object print('-- dist(spatial):%2.2f(dt=%2.2fs)' % (approx_spatial_diff, dt)) else: print('\n -- Too far!! New object distance:', approx_spatial_diff, ' --') num = len(detected_objs[labelmap[ i - 1]]) + 1 # Add as new image as well detected_objs[labelmap[i - 1]].append( newobj.set_id(num)) else: # Add if the same image was never seem before num = len(detected_objs[labelmap[i - 1]]) + 1 detected_objs[labelmap[i - 1]].append( newobj.set_id(num)) print(' -- New object added: %s...' % (labelmap[i - 1])) cv2.rectangle( frame, (int(pt[0]), int(pt[1])), # UPPER LEFT (int(pt[2]), int(pt[3])), # LOWER RIGHT COLORS[i % 3], 2) # Print info # Calculate Frames per second (FPS) fps_current = cv2.getTickFrequency() / ( cv2.getTickCount() - timer) score = detections[0, i, j, 0] #cv2.putText(frame, labelmap[i - 1]+'('+str(num)+'): score:'+str(int(100* score)) +' (fps:'+ str(int(fps_current)) +')', (int(pt[0]), int(pt[1])), # FONT, 1, (255, 255, 255), 1, cv2.LINE_AA) cv2.putText( frame, labelmap[i - 1] + ': score:' + str(int(100 * score)) + ' (fps:' + str(int(fps_current)) + ')', (int(pt[0]), int(pt[1])), FONT, 1, (255, 255, 255), 1, cv2.LINE_AA) j += 1 pts.append(pt) if not pts: print(' -- No detection (score < 60)...') return frame, pts, detected_objs, pt_tracked def detect_tracked(frame, bbox_tracked): obj_tracked = '' bb = bbox_tracked height, width = frame.shape[:2] x = torch.from_numpy(transform(frame)[0]).permute(2, 0, 1) xx = Variable(x.unsqueeze(0)) if use_cuda: xx = xx.cuda() y = net(xx) else: y = net(xx) # forward pass detections = y.data # Objects detected in the frame # scale each detection back up to the image scale = torch.Tensor([width, height, width, height]) for i in range(detections.size(1)): j = 0 pt = (detections[0, i, j, 1:] * scale).cpu().numpy() # Detection box while detections[0, i, j, 0] >= 0.6: # Check whether bbox_tracked is within the detected obj if bb[0] > pt[0] and bb[1] > pt[1] and ( bb[0] + bb[2]) < pt[2] and (bb[1] + bb[3]) < pt[3]: obj_tracked = labelmap[i - 1] j += 1 if not obj_tracked: print(' -- Tracked object not detected (score < 60)...') obj_tracked = '' return obj_tracked # start video stream thread, allow buffer to fill print("[INFO] starting threaded video stream...") stream = WebcamVideoStream(src=0).start() # default camera time.sleep(1.0) # grab frame for TDL selection frame = stream.read() # Select object to track bbox = cv2.selectROI(frame, False) # Define the tracker tracker = cv2.TrackerTLD_create() # Initialize tracker with first frame and bounding box ok = tracker.init(frame, bbox) # Identify tracked object obj_tracked = detect_tracked(frame, bbox) print('Tracked object:', obj_tracked) # start fps timer # loop over frames from the video file stream while True: step += 1 # grab next frame frame = stream.read() key = cv2.waitKey(1) & 0xFF # update FPS counter fps.update() #frame0 = frame frame, pts, objs, pt_tracked = predict(step, frame, detected_objs, obj_tracked) print('Step:', step, end='') # Update tracker ok, bbox = tracker.update(frame) delta = 10 # delta to amplify bbox of detected obj # Draw bounding box if ok and bbox[0] > pt_tracked[0] - delta and bbox[ 1] > pt_tracked[1] - delta and ( bbox[0] + bbox[2]) < pt_tracked[2] + delta and ( bbox[1] + bbox[3]) < pt_tracked[3] + delta: # Tracking success p1 = (int(bbox[0]), int(bbox[1])) p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3])) cv2.rectangle(frame, p1, p2, (0, 0, 255), 2, 1) else: # Tracking failure cv2.putText(frame, "Tracking failure detected", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2) # keybindings for display if key == ord('p'): # pause while True: key2 = cv2.waitKey(1) or 0xff cv2.imshow('frame', frame) if key2 == ord('p'): # resume break cv2.imshow('frame', frame) if key == 27: # Esc break
class EyeCanSee(object): def __init__(self, center=int(cvsettings.CAMERA_WIDTH / 2), debug=False, is_usb_webcam=True, period_s=0.025): # Our video stream # If its not a usb webcam then get pi camera if not is_usb_webcam: self.vs = PiVideoStream(resolution=(cvsettings.CAMERA_WIDTH, cvsettings.CAMERA_HEIGHT)) # Camera cvsettings self.vs.camera.shutter_speed = cvsettings.SHUTTER self.vs.camera.exposure_mode = cvsettings.EXPOSURE_MODE self.vs.camera.exposure_compensation = cvsettings.EXPOSURE_COMPENSATION self.vs.camera.awb_gains = cvsettings.AWB_GAINS self.vs.camera.awb_mode = cvsettings.AWB_MODE self.vs.camera.saturation = cvsettings.SATURATION self.vs.camera.rotation = cvsettings.ROTATION self.vs.camera.video_stabilization = cvsettings.VIDEO_STABALIZATION self.vs.camera.iso = cvsettings.ISO self.vs.camera.brightness = cvsettings.BRIGHTNESS self.vs.camera.contrast = cvsettings.CONTRAST # Else get the usb camera else: self.vs = WebcamVideoStream(src=0) self.vs.stream.set(cv2.CAP_PROP_FRAME_WIDTH, cvsettings.CAMERA_WIDTH) self.vs.stream.set(cv2.CAP_PROP_FRAME_HEIGHT, cvsettings.CAMERA_HEIGHT) # Has camera started self.camera_started = False self.start_camera() # Starts our camera # To calculate our error in positioning self.center = center # To determine if we actually detected lane or not self.detected_lane = False # debug mode on? (to display processed images) self.debug = debug # Time interval between in update (in ms) # FPS = 1/period_s self.period_s = period_s # Starting time self.start_time = time.time() # Mouse event handler for get_hsv def on_mouse(self, event, x, y, flag, param): if event == cv2.EVENT_LBUTTONDBLCLK: # Circle to indicate hsv location, and update frame cv2.circle(self.img_debug, (x, y), 3, (0, 0, 255)) cv2.imshow('hsv_extractor', self.img_debug) # Print values values = self.hsv_frame[y, x] print('H:', values[0], '\tS:', values[1], '\tV:', values[2]) def get_hsv(self): cv2.namedWindow('hsv_extractor') while True: self.grab_frame() # Bottom ROI cv2.rectangle(self.img_debug, (0, cvsettings.HEIGHT_PADDING_BOTTOM-2), (cvsettings.CAMERA_WIDTH, cvsettings.HEIGHT_PADDING_BOTTOM + cvsettings.IMG_ROI_HEIGHT + 2), (0, 250, 0), 2) # Top ROI cv2.rectangle(self.img_debug, (0, cvsettings.HEIGHT_PADDING_TOP-2), (cvsettings.CAMERA_WIDTH, cvsettings.HEIGHT_PADDING_TOP + cvsettings.IMG_ROI_HEIGHT + 2), (0, 250, 0), 2) # Object cv2.rectangle(self.img_debug, (0, cvsettings.OBJECT_HEIGHT_PADDING), (cvsettings.CAMERA_WIDTH, cvsettings.HEIGHT_PADDING_TOP - cvsettings.OBJECT_HEIGHT_PADDING), (238, 130, 238), 2) self.hsv_frame = cv2.cvtColor(self.img, cv2.COLOR_BGR2HSV) # Mouse handler cv2.setMouseCallback('hsv_extractor', self.on_mouse, 0) cv2.imshow('hsv_extractor', self.img_debug) key = cv2.waitKey(0) & 0xFF if key == ord('q'): break self.stop_camera() cv2.destroyAllWindows() # Starts camera (needs to be called before run) def start_camera(self): self.camera_started = True self.vs.start() time.sleep(2.0) # Wait for camera to cool def stop_camera(self): self.camera_started = False self.vs.stop() # Grabs frame from camera def grab_frame(self): # Starts camera if it hasn't been started if not self.camera_started: self.start_camera() self.img = self.vs.read() self.img_debug = self.img.copy() # Normalizes our image def normalize_img(self): # Crop img and convert to hsv self.img_roi_bottom = np.copy(self.img[cvsettings.HEIGHT_PADDING_BOTTOM:int(cvsettings.HEIGHT_PADDING_BOTTOM + cvsettings.IMG_ROI_HEIGHT), :]) self.img_roi_top = np.copy(self.img[cvsettings.HEIGHT_PADDING_TOP:int(cvsettings.HEIGHT_PADDING_TOP + cvsettings.IMG_ROI_HEIGHT), :]) self.img_roi_bottom_hsv = cv2.cvtColor(self.img_roi_bottom, cv2.COLOR_BGR2HSV).copy() self.img_roi_top_hsv = cv2.cvtColor(self.img_roi_top, cv2.COLOR_BGR2HSV).copy() # Get our ROI's shape # Doesn't matter because both of them are the same shape self.roi_height, self.roi_width, self.roi_channels = self.img_roi_bottom.shape # Smooth image and convert to bianry image (threshold) # Filter out colors that are not within the RANGE value def filter_smooth_thres(self, RANGE, color): for (lower, upper) in RANGE: lower = np.array(lower, dtype='uint8') upper = np.array(upper, dtype='uint8') mask_bottom = cv2.inRange(self.img_roi_bottom_hsv, lower, upper) mask_top = cv2.inRange(self.img_roi_top_hsv, lower, upper) blurred_bottom = cv2.medianBlur(mask_bottom, 5) blurred_top = cv2.medianBlur(mask_top, 5) # Morphological transformation kernel = np.ones((2, 2), np.uint8) smoothen_bottom = blurred_bottom #cv2.morphologyEx(blurred, cv2.MORPH_OPEN, kernel, iterations=5) smoothen_top = blurred_top # cv2.morphologyEx(blurred, cv2.MORPH_OPEN, kernel, iterations=5) """ if self.debug: cv2.imshow('mask bottom ' + color, mask_bottom) cv2.imshow('blurred bottom' + color, blurred_bottom) cv2.imshow('mask top ' + color, mask_top) cv2.imshow('blurred top' + color, blurred_top) """ return smoothen_bottom, smoothen_top # Gets metadata from our contours def get_contour_metadata(self): # Metadata (x,y,w,h)for our ROI contour_metadata = {} for cur_img in [self.thres_yellow_bottom, self.thres_yellow_top, self.thres_blue_bottom, self.thres_blue_top]: key = '' # Blue is left lane, Yellow is right lane if cur_img is self.thres_yellow_bottom: key = 'right_bottom' elif cur_img is self.thres_yellow_top: key = 'right_top' elif cur_img is self.thres_blue_bottom: key = 'left_bottom' elif cur_img is self.thres_blue_top: key = 'left_top' _, contours, hierarchy = cv2.findContours(cur_img.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) cur_height, cur_width = cur_img.shape # Get index of largest contour try: areas = [cv2.contourArea(c) for c in contours] max_index = np.argmax(areas) cnt = contours[max_index] # Metadata of contour x, y, w, h = cv2.boundingRect(cnt) # Normalize it to the original picture x += int(cvsettings.WIDTH_PADDING + w / 2) if 'top' in key: y += int(cvsettings.HEIGHT_PADDING_TOP +h /2) else: y += int(cvsettings.HEIGHT_PADDING_BOTTOM + h / 2) contour_metadata[key] = (x, y) self.detected_lane = True # If it throws an error then it doesn't have a ROI # Means we're too far off to the left or right except: # Blue is left lane, Yellow is right lane x = int(cvsettings.WIDTH_PADDING) - cvsettings.CAMERA_WIDTH if 'bottom' in key: y = int(cur_height / 2) + int(cvsettings.HEIGHT_PADDING_BOTTOM + cur_height / 2) else: y = int(cur_height / 2) + int(cvsettings.HEIGHT_PADDING_TOP + cur_height / 2) if 'right' in key: x = int(cur_width)*2 contour_metadata[key] = (x, y) self.detected_lane = False return contour_metadata # Gets the centered coord of the detected lines def get_centered_coord(self): bottom_centered_coord = None top_centered_coord = None left_xy_bottom = self.contour_metadata['left_bottom'] right_xy_bottom = self.contour_metadata['right_bottom'] left_xy_top = self.contour_metadata['left_top'] right_xy_top = self.contour_metadata['right_top'] bottom_xy = (left_xy_bottom[0] + right_xy_bottom[0], left_xy_bottom[1] + right_xy_bottom[1]) bottom_centered_coord = (int(bottom_xy[0] / 2), int(bottom_xy[1] / 2)) top_xy = (left_xy_top[0] + right_xy_top[0], left_xy_top[1] + right_xy_top[1]) top_centered_coord = (int(top_xy[0] / 2), int(top_xy[1] / 2)) # Left can't be greater than right and vice-versa if left_xy_top > right_xy_top: top_centered_coord = (0, top_centered_coord[1]) elif right_xy_top < left_xy_top: top_centered_corrd = (cvsettings.CAMERA_WIDTH, top_centered_coord[1]) if left_xy_bottom > right_xy_bottom: bottom_centered_coord = (0, bottom_centered_coord[1]) elif right_xy_bottom < left_xy_bottom: bottom_centered_coord = (cvsettings.CAMERA_WIDTH, top_centered_coord[1]) return bottom_centered_coord, top_centered_coord # Gets the error of the centered coordinates (x) # Also normlizes their values def get_errors(self): top_error = (float(self.center_coord_top[0]) - float(self.center))/float(cvsettings.CAMERA_WIDTH + cvsettings.WIDTH_PADDING) bottom_error = (float(self.center_coord_bottom[0]) - float(self.center))/float(cvsettings.CAMERA_WIDTH + cvsettings.WIDTH_PADDING) relative_error = (float(self.center_coord_top[0]) - float(self.center_coord_bottom[0]))/float(cvsettings.CAMERA_WIDTH + cvsettings.WIDTH_PADDING) return (top_error + relative_error + bottom_error)/3.0 # Object avoidance def where_object_be(self): # We only want to detect objects in our path: center of top region and bottom region # So to save processing speed, we'll only threshold from center of top region to center of bottom region left_x = cvsettings.WIDTH_PADDING right_x = cvsettings.CAMERA_WIDTH # Image region with objects img_roi_object = self.img[cvsettings.OBJECT_HEIGHT_PADDING : int(cvsettings.HEIGHT_PADDING_TOP - cvsettings.OBJECT_HEIGHT_PADDING), left_x:right_x] img_roi_object_hsv = cv2.cvtColor(img_roi_object, cv2.COLOR_BGR2HSV).copy() # Filtering color and blurring for (lower, upper) in cvsettings.OBJECT_HSV_RANGE: lower = np.array(lower, dtype='uint8') upper = np.array(upper, dtype='uint8') mask_object = cv2.inRange(img_roi_object_hsv, lower, upper) blurred_object = cv2.medianBlur(mask_object, 25) # Finding position of object (if its there) _, contours, hierarchy = cv2.findContours(blurred_object.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) left_x = self.contour_metadata['left_top'][0] right_x = self.contour_metadata['right_top'][0] for c in contours: areas = cv2.contourArea(c) # Object needs to be larger than a certain area if areas > cvsettings.OBJECT_AREA: x, y, w, h = cv2.boundingRect(c) y += int(cvsettings.OBJECT_HEIGHT_PADDING + h / 2) # Confusing part - this finds the object and makes it think that # it is also a line to avoid bumping into it # It +w and -w to find which line its closest to and then set # the opposite as to be the new left/right lane # e.g. line is closest to left lane (x-w), so left lane new x is # (x+w) distance_to_left = abs(x - left_x) distance_to_right = abs(x+w - right_x) # Make object's left most area the middle of right lane if distance_to_left > distance_to_right: self.contour_metadata['right_top'] = (x, self.contour_metadata['right_top'][1]) # Make object's right most area the middle of left lane elif distance_to_right > distance_to_right: self.contour_metadata['left_top'] = (x+w, self.contour_metadata['left_top'][1]) if self.debug: cv2.circle(self.img_debug, (x+(w/2), y+(h/2)), 5, (240, 32, 160), 2) if self.debug: cv2.imshow('Blurred object', blurred_object) # Where are we relative to our lane def where_lane_be(self): # Running once every period_ms while float(time.time() - self.start_time) < self.period_s: pass # Update time instance self.start_time = time.time() # Camera grab frame and normalize it self.grab_frame() self.normalize_img() # Filter out them colors self.thres_blue_bottom, self.thres_blue_top = self.filter_smooth_thres(cvsettings.BLUE_HSV_RANGE, 'blue') self.thres_yellow_bottom, self.thres_yellow_top = self.filter_smooth_thres(cvsettings.YELLOW_HSV_RANGE, 'yellow') # Get contour meta data self.contour_metadata = self.get_contour_metadata() # Finds objects and (and corrects lane position) # this overwrite contour_metadata #self.where_object_be() # Find the center of the lanes (bottom and top) [we wanna be in between] self.center_coord_bottom, self.center_coord_top = self.get_centered_coord() # Gets relative error between top center and bottom center self.relative_error = self.get_errors() if self.debug: # Drawing locations blue_top_xy = self.contour_metadata['left_top'] blue_bottom_xy = self.contour_metadata['left_bottom'] yellow_top_xy = self.contour_metadata['right_top'] yellow_bottom_xy = self.contour_metadata['right_bottom'] # Circles to indicate lanes cv2.circle(self.img_debug, blue_top_xy, 5, (255, 0, 0), 2) cv2.circle(self.img_debug, blue_bottom_xy, 5, (255, 0, 0), 2) cv2.circle(self.img_debug, yellow_top_xy, 5, (0, 255, 255), 2) cv2.circle(self.img_debug, yellow_bottom_xy, 5, (0, 255, 255), 2) cv2.circle(self.img_debug, self.center_coord_bottom, 5, (0, 255, 0), 3) cv2.circle(self.img_debug, self.center_coord_top, 5, (0, 255, 0), 3) # ROI for object detection cv2.rectangle(self.img_debug, (0, cvsettings.OBJECT_HEIGHT_PADDING), (cvsettings.CAMERA_WIDTH, cvsettings.HEIGHT_PADDING_TOP - cvsettings.OBJECT_HEIGHT_PADDING), (238, 130, 238), 2) # Displaying image cv2.imshow('img', self.img_debug) #cv2.imshow('img_roi top', self.img_roi_top) #cv2.imshow('img_roi bottom', self.img_roi_bottom) #cv2.imshow('img_hsv', self.img_roi_hsv) cv2.imshow('thres_blue_bottom', self.thres_blue_bottom) cv2.imshow('thres_blue_top', self.thres_blue_top) cv2.imshow('thres_yellow_bottom', self.thres_yellow_bottom) cv2.imshow('thres_yellow_top', self.thres_yellow_top) key = cv2.waitKey(0) & 0xFF # Change 1 to 0 to pause between frames # Use this to calculate fps def calculate_fps(self, frames_no=100): fps = FPS().start() # Don't wanna display window if self.debug: self.debug = not self.debug for i in range(0, frames_no): self.where_lane_be() fps.update() fps.stop() # Don't wanna display window if not self.debug: self.debug = not self.debug print('Time taken: {:.2f}'.format(fps.elapsed())) print('~ FPS : {:.2f}'.format(fps.fps())) # Use this to save images to a location def save_images(self, dirname='dump'): import os img_no = 1 # Makes the directory if not os.path.exists('./' + dirname): os.mkdir(dirname) while True: self.grab_frame() if self.debug: cv2.imshow('frame', self.img) k = cv2.waitKey(1) & 0xFF if k == ord('s'): cv2.imwrite(os.path.join(dirname, 'dump_' + str(img_no) + '.jpg'), self.img) img_no += 1 elif k == ord('q'): break cv2.destroyAllWindows() # Destructor def __del__(self): self.vs.stop() cv2.destroyAllWindows()
import threading import cv2 from PIL import Image from werkzeug.utils import secure_filename outputFrame = None lock = threading.Lock() app = Flask(__name__) APP_ROOT = os.path.dirname(os.path.abspath(__file__)) uploads_path = os.path.join(APP_ROOT, 'datasets') allowed_set = set(['png', 'jpg', 'jpeg']) app.secret_key = os.urandom(24) vs = WebcamVideoStream(src=0).start() time.sleep(2.0) faceObj = FaceObject() @app.route('/') def index_page(): return render_template(template_name_or_list='index.html') def detect_face_live(): global outputFrame,vs, lock while True:
from imutils.video import WebcamVideoStream import time def triggered(message): url = 'https://bosch-ville-api.unificationengine.com/v1/message/send' api_token = 'Y2gmZGV2aWNlX3R5cGU9WERJ' headers = {'Content-Type': 'application/json', 'Authorization': api_token} body = {"phone_number": "+6590698810", "message": message} requests.post(url, data=json.dumps(body), headers=headers) #this is the cascade we just made. Call what you want wrist_cascade = cv2.CascadeClassifier('wrist_cascade.xml') vs = WebcamVideoStream(src=0).start() time.sleep(1) fps = FPS().start() while fps._numFrames < 10000: #capture frame-by-frame img = vs.read() gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) wrist = wrist_cascade.detectMultiScale(gray, 50, 50) for (x, y, w, h) in wrist: #place a rectangle around object detected print(wrist) cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2) #font = cv2. FONT_HERSHEY_SIMPLEX
def Camera(source=0): return WebcamVideoStream(source).start()
trackers = [] trackableObjects = {} # Load the model #net = cv2.dnn.readNet('models/mobilenet-ssd/FP16/mobilenet-ssd.xml', 'models/mobilenet-ssd/FP16/mobilenet-ssd.bin') net = cv2.dnn.readNetFromCaffe("models/MobileNetSSD_deploy.prototxt", "models/MobileNetSSD_deploy.caffemodel") # Specify target device #net.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD) # if a video path was not supplied, grab a reference to the webcam if not args.get("input", False): print("[INFO] starting video stream...") #vs = VideoStream(src=0).start() vs = WebcamVideoStream(src=0).start() time.sleep(2.0) # otherwise, grab a reference to the video file else: print("[INFO] opening video file...") vs = cv2.VideoCapture(args["input"]) time.sleep(1) fps = FPS().start() # loop over frames from the video file stream while True: try: # grab the frame from the threaded video stream # make a copy of the frame and resize it for display/video purposes
import numpy as np import argparse import imutils import time import cv2 from utils.fps2 import FPS2 import dlib from trackers.camshifttracker import CAMShiftTracker if __name__ == '__main__': print("[info] starting to read a webcam ...") capWebCam = WebcamVideoStream(0).start() time.sleep(1.0) # initialize dlib face detector frontFaceDetector = dlib.get_frontal_face_detector() # meanShift tracker camShifTracker = None curWindow = None # start the frame per second (FPS) counter #fps = FPS2().start()
from imutils.object_detection import non_max_suppression from imutils.video import WebcamVideoStream import imutils import cv2 import numpy vs = WebcamVideoStream(src=0).start() SIZE_W = 300 while(True): frame = vs.read() cv2.imshow('Video',imutils.resize(frame, width=min(SIZE_W, frame.shape[1]))) if cv2.waitKey(10) & 0xFF == ord('q'): break
class MyPhoto(threading.Thread): def __init__(self, img_root, stream_type, pi_ip_address, listen_port, debug): threading.Thread.__init__(self) print("Initializing MyPhoto class") self.img_root = img_root self.debug = debug self.img_root_date = os.path.join(self.img_root, datetime.now().strftime("%Y-%m-%d")) self.pi_ip_address = pi_ip_address self.listen_port = listen_port #self.bad_img_transfers = 0 self.stream_type = stream_type self.video_status = False self.img_checked = False self.img_seconds = [str(x).zfill(2) for x in range(0, 60)] # self.create_root_img_dir() ## this action is strictly duplicated in MyClient self.connect_to_video() self.start() self.total_missing = 0 self.per_min_missing = [] self.ten_missing = False self.img_checker_thread = threading.Thread(target=self.img_checker, daemon=True) self.img_checker_thread.start() # comment this function out # def create_message(self, to_send): # """ # Configure the message to send to the server. # Elements are separated by a carriage return and newline. # The first line is always the datetime of client request. # param: to_send <class 'list'> # List of elements to send to server. # return: <class 'bytes'> a byte string (b''), ready to # send over a socket connection # """ # dt_str = [datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")] # for item in to_send: # dt_str.append(item) # message = '\r\n'.join(dt_str) # logging.log(25, "Sending Message: \n{}".format(message)) # return message.encode() def my_recv_all(self, s, timeout=2): """ Regardless of message size, ensure that entire message is received from server. Timeout specifies time to wait for additional socket stream. param: s <class 'socket.socket'> A socket connection to server. return: <class 'str'> A string containing all info sent. """ # try: # make socket non blocking s.setblocking(0) # total data partwise in an array total_data = [] data = '' # beginning time begin = time.time() while 1: # if you got some data, then break after timeout if total_data and time.time() - begin > timeout: break # if you got no data at all, wait a little longer, twice the timeout elif time.time() - begin > timeout * 2: break # recv something try: data = s.recv(8192).decode() if data: total_data.append(data) # change the beginning time for measurement begin = time.time() else: # sleep for sometime to indicate a gap time.sleep(0.1) except: pass # join all parts to make final string return ''.join(total_data) def has_correct_files(self): ''' Image Check Files''' logging.info('Running image checker has_correct_files') t = datetime.now() - timedelta(minutes=1) d = t.strftime("%Y-%m-%d") hr = t.strftime("%H%M") self.prev_min_img_dir = os.path.join(self.img_root_date, t.strftime("%H%M")) should_have_files = [ os.path.join(self.prev_min_img_dir, '{} {}{}_photo.png'.format(d, hr, s)) for s in self.img_seconds ] has_files = [ os.path.join(self.prev_min_img_dir, f) for f in os.listdir(self.prev_min_img_dir) if f.endswith('.png') ] missing = list(set(should_have_files) - set(has_files)) num_missing_now = len(missing) if self.debug: logging.info('Number of images missing this minute: {}'.format( num_missing_now)) print('images missing this min: {} files'.format(num_missing_now)) print('images missing these files: {}'.format(missing)) if len(missing) > 0: #self.bad_img_transfers += 1 self.total_missing += num_missing_now logging.warning( 'images missing this min: {} files'.format(num_missing_now)) logging.warning('images missing these files: {}'.format(missing)) if len(missing) > 3: self.per_min_missing.append((hr, num_missing_now)) """ restarts if 3 or more image files are missing for more than 10 minutes in the last 15 minutes""" if self.ten_missing == False: if len(self.per_min_missing) > 10: self.ten_missing = True self.time_missing = datetime.now() self.missing_now = len(self.per_min_missing) logging.critical( 'first check: self.per_min_missing = {} at {}'.format( self.missing_now, self.time_missing.strftime("%H:%M:%S"))) else: if datetime.now() > self.time_missing + timedelta(minutes=5): if len(self.per_min_missing) > int(self.missing_now + 1): logging.critical( 'self.total_image_missing = {}. Next line runs os._exit(1)' .format(self.total_missing)) os._exit(1) else: self.ten_missing = False logging.info( 'Resetting per_min_missing. Time is: {}. Number missing is: {}' .format(datetime.now().strftime('%H:%M:%S'), len(self.per_min_missing))) self.per_min_missing = [] else: logging.critical( 'More than 10 images missing: {} at {}. Total missing minutes = {}' .format(len(missing), hr, len(self.per_min_missing))) # if first_check: # first_check = False time.sleep(30) def create_root_img_dir(self): if not os.path.isdir(self.img_root): os.makedirs(self.img_root) def connect_to_video(self): self.video_status = False # Select the stream type based on that specified in server.conf if self.stream_type == "mjpeg": stream_path = "http://" + self.pi_ip_address + ":8080/stream/video.mjpeg" elif self.stream_type == "h264": stream_path = "http://" + self.pi_ip_address + ":8080/stream/video.h264" elif self.stream_type == "jpeg": stream_path = "http://" + self.pi_ip_address + ":8080/stream/video.jpeg" # Attempt to start the video stream self.cam = WebcamVideoStream(stream_path).start() self.img_restart_attempts = 0 # Keep attempting to open the video stream until it is opened while not self.cam.stream.isOpened(): self.cam = WebcamVideoStream(stream_path).start() self.video_status = False self.img_restart_attempts += 1 logging.warning("Unable to connect to video") if self.debug: print('Unable to connect to video') if self.img_restart_attempts >= 5: # self.restart_dat_img() # subprocess.run("sudo reboot", shell = True) # subprocess.run("sudo service uv4l_raspicam restart", shell = True) # time.sleep(5) self.img_restart_attempts = 0 # subprocess.run("sudo service hpd_mobile restart", shell = True) time.sleep(10) # Set the video status to true self.video_status = True logging.info("Connected to video stream") if self.debug: print('Connected to video stream') def img_dir_update(self): # This function is run in a separate thread to continuously create a new directory for each day, and for each minute. while 1: date_dir = os.path.join(self.img_root, datetime.now().strftime("%Y-%m-%d")) if not os.path.isdir(date_dir): os.makedirs(date_dir) self.img_root_date = date_dir min_dir = os.path.join(self.img_root_date, datetime.now().strftime("%H%M")) if not os.path.isdir(min_dir): os.makedirs(min_dir) self.img_dir = min_dir def img_checker(self): while True: try: if datetime.now().second == 1 and not self.img_checked: if self.debug: logging.info('Checking images captured') # file_checker = threading.Thread(target=self.has_correct_files) # file_checker.start() self.has_correct_files() self.img_checked = True except Exception as e: logging.warning( 'Error with img_checker. Exception: {}'.format(e)) if datetime.now().second != 1: self.img_checked = False def run(self): dir_create = threading.Thread(target=self.img_dir_update) dir_create.start() # Wait for self.img_dir to exist time.sleep(1) while True: # if self.bad_img_transfers >= 5: # try: # self.cam.stop() # except Exception as e: # logging.warning( # 'Unable to close cam. Potentially closed. Exception: {}'.format(e)) # finally: # self.cam.stop() # self.bad_img_transfers = 0 # self.connect_to_video() f_name = datetime.now().strftime("%Y-%m-%d %H%M%S_photo.png") f_path = os.path.join(self.img_dir, f_name) # Only capture a photo if it doesn't already exist if not os.path.isfile(f_path): if not len(os.listdir(self.img_dir)) >= 60: img = False img = self.cam.read() if type(img) is not np.ndarray: logging.warning( 'Camera read did not return image. Attempting to reconnect to video' ) if self.debug: print( 'Camera read did not return image. Attempting to restart video connection' ) try: self.cam.stop() except Exception as e: logging.warning( 'Unable to close cam. Potentially closed. Exception: {}' .format(e)) finally: self.cam.stop() self.connect_to_video() elif type(img) is np.ndarray: try: # Convert image to greyscale img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) # Write to disk # This is closing the image file??? # look into /var/log/messages grep for oom killer cv2.imwrite(f_path, img) if datetime.now().second == 0: logging.info("Created file: {}".format(f_path)) except Exception as e: logging.warning( "Unable to convert to grayscale and write to disk. Error: {}. File: {}\tAttempting to restart video connection" .format(e, f_name)) if self.debug: print( "Unable to convert to grayscale and write to disk. Error: {}. File: {}\tAttempting to restart video connection" .format(e, f_name)) try: self.cam.stop() except Exception as e: logging.warning( 'Unable to close cam. Potentially closed. Exception: {}' .format(e)) self.connect_to_video()
class Stereo_Vision: """Class for obtaining and analyzing depth maps""" def __init__(self, cam_L_src, cam_R_src, display_frames=True, threshold=110): # initialize camera feed threads self.capL = WebcamVideoStream(src=cam_L_src).start() time.sleep(0.5) self.capR = WebcamVideoStream(src=cam_R_src).start() self.stop = False self.display_frames = display_frames # initialize windows if self.display_frames == True: cv2.namedWindow('Depth Map') cv2.namedWindow('Threshold') cv2.namedWindow('Shapes') # import calibration matrices self.undistMapL = np.load('calibration/undistortion_map_left.npy') self.undistMapR = np.load('calibration/undistortion_map_right.npy') self.rectMapL = np.load('calibration/rectification_map_left.npy') self.rectMapR = np.load('calibration/rectification_map_right.npy') # initialize blank frames self.rectL = np.zeros((640, 480, 3), np.uint8) self.rectR = np.zeros((640, 480, 3), np.uint8) self.quadrant_near_object = np.zeros((3, 3), dtype=bool) self.threshold = threshold self.exec_time_sum = 0 self.frame_counter = 0 self.fps = 0 self.no_object_left_column = False self.no_object_mid_column = False self.no_object_right_column = False self.no_object_bottom_row = False self.no_object_mid_row = False self.no_object_top_row = False def start(self): self.vision_thread = Thread(target=self.start_stereo) self.vision_thread.start() def stop_vision(self): self.stop = True def get_quadrants(self): return self.quadrant_near_object def start_stereo(self): while (self.stop != True): self.start_time = time.time() self.frameL = self.capL.read() self.frameR = self.capR.read() # remap cameras to remove distortion self.rectL = cv2.remap(self.frameL, self.undistMapL, self.rectMapL, cv2.INTER_LINEAR) self.rectR = cv2.remap(self.frameR, self.undistMapR, self.rectMapR, cv2.INTER_LINEAR) # convert rectified from RGB to 8 bit grayscale self.grayRectL = cv2.cvtColor(self.rectL, cv2.COLOR_BGR2GRAY) self.grayRectR = cv2.cvtColor(self.rectR, cv2.COLOR_BGR2GRAY) self.grayFrameL = cv2.cvtColor(self.frameL, cv2.COLOR_BGR2GRAY) self.grayFrameR = cv2.cvtColor(self.frameR, cv2.COLOR_BGR2GRAY) # create depth map self.object_left_column = True self.object_mid_column = True self.object_right_column = True self.object_top_row = True self.object_mid_row = True self.object_bottom_row = True self.stereo = cv2.StereoBM_create(numDisparities=0, blockSize=13) self.disparity = self.stereo.compute(self.grayRectL, self.grayRectR).astype(np.float32) self.disparity = cv2.normalize(self.disparity, self.disparity, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8UC1) # blur depth map to filter high frequency noise self.disparity_blur = cv2.medianBlur(self.disparity, 13) #apply 2 pixel border, helps keep contours continuous at extreme edges of image self.disparity_blur = cv2.copyMakeBorder(self.disparity_blur, top=2, bottom=2, right=2, left=2, borderType=cv2.BORDER_CONSTANT, value=0) # threshold depth map self.disparity_thresh_imm = cv2.threshold(self.disparity_blur, self.threshold, 255, cv2.THRESH_BINARY)[1] self.disparity_edge = cv2.Canny(self.disparity_thresh_imm, 100, 200) # contour finding self.contours = cv2.findContours(self.disparity_edge, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[1] self.disparity_contours = np.zeros((480, 640, 3), np.uint8) for self.contour_index in self.contours: #draw bounding rectangle around each contour self.rect = cv2.minAreaRect(self.contour_index) self.box = cv2.boxPoints(self.rect) self.box = np.int0(self.box) #calculate area of each box self.box_area = abs(self.box[2][0] - self.box[0][0]) * abs(self.box[2][1] - self.box[0][1]) self.col = -1 self.row = -1 if self.box_area > 1000: #pixels^2 cv2.drawContours(self.disparity_contours, [self.box], 0, (0, 255, 0), 2) # draw green box # determine which quadrants the rectangle occupies for corner_index in range(0, 3): self.col = self.box[corner_index][0] / 213 # x coordinates self.row = self.box[corner_index][1] / 160 # y coordinates if self.row > 2: self.row = 2 if self.col > 2: self.col = 2 if self.col != -1 and self.row != -1: self.quadrant_near_object[self.row][self.col] = True #Boolean logic to set flags for main program if (self.quadrant_near_object[0][0] == False and self.quadrant_near_object[1][0] == False or self.quadrant_near_object[2][0] == False): self.no_object_left_column = True else: self.no_object_left_column = False if (self.quadrant_near_object[0][1] == False and self.quadrant_near_object[1][1] == False and self.quadrant_near_object[2][1] == False): self.no_object_mid_column = True else: self.no_object_mid_column = False if (self.quadrant_near_object[0][2] == False and self.quadrant_near_object[1][2] == False and self.quadrant_near_object[2][2] == False): self.no_object_right_column = True else: self.no_object_right_column = False if (self.quadrant_near_object[0][0] == False and self.quadrant_near_object[0][1] == False and self.quadrant_near_object[0][2] == False): self.no_object_top_row = True else: self.no_object_top_row = False if (self.quadrant_near_object[1][0] == False and self.quadrant_near_object[1][1] == False and self.quadrant_near_object[1][2] == False): self.no_object_mid_row = True else: self.no_object_mid_row = False if (self.quadrant_near_object[2][0] == False and self.quadrant_near_object[2][1] == False and self.quadrant_near_object[2][2] == False): self.no_object_bottom_row = True else: self.no_object_bottom_row = False #FPS calculations self.end_time = time.time() self.exec_time = self.end_time - self.start_time self.exec_time_sum += self.exec_time self.frame_counter += 1 self.fps = 1.0 / self.exec_time #draw edges in pink cv2.drawContours(self.disparity_contours, self.contours, -1, (180, 105, 255), -1) cv2.line(self.disparity_contours, (0,160), (640,160), (255,0,0)) cv2.line(self.disparity_contours, (0,320), (640,320), (255,0,0)) cv2.line(self.disparity_contours, (213,0), (213,480), (255,0,0)) cv2.line(self.disparity_contours, (426,0), (426,480), (255,0,0)) if self.display_frames == True: cv2.imshow('Threshold', self.disparity_edge) cv2.imshow('Depth Map', self.disparity) cv2.imshow('Shapes', self.disparity_contours) if cv2.waitKey(1) & 0xFF == ord('q'): self.capL.stop() self.capR.stop() break self.capL.stop() self.capR.stop() cv2.destroyAllWindows() def save_frames(self, filename_index): cv2.imwrite("Images/DepthMap" + str(filename_index) + ".jpg", self.disparity) cv2.imwrite("Images/DepthMapBlur" + str(filename_index) + ".jpg", self.disparity_blur) cv2.imwrite("Images/Contours_" + str(filename_index) + ".jpg", self.disparity_contours) cv2.imwrite("Images/LeftCam" + str(filename_index) + ".jpg", self.frameL) cv2.imwrite("Images/RightCam" + str(filename_index) + ".jpg", self.frameR)
def __init__(self, camid,camname,camlocation,cam_type,threadID, name, counter): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.counter = counter # Getting camera details self.camname = camname self.camid = camid self.camlocation = camlocation cam_type = cam_type self.face_cascade = cv2.CascadeClassifier('./models/haarcascades/haarcascade_frontalface_default.xml') self.font= cv2.FONT_HERSHEY_SIMPLEX self.fileDir = os.path.dirname(os.path.realpath(__file__)) self.unknownusers_dir = os.path.join(self.fileDir, "img/unknownusers") self.classifierModel = os.path.join(self.fileDir, 'ginilib/openface/generated-embeddings/classifier.pkl') if os.path.exists(self.classifierModel): with open(self.classifierModel, 'rb') as f: if sys.version_info[0] < 3: (self.le, self.clf) = pickle.load(f) else: (self.le, self.clf) = pickle.load(f, encoding='latin1') dbs=dbops() # create a directory for camera settingdetails = dbs.get_settingsdetails() rootpathprimary = settingdetails[0][2] rootpathsecondary = settingdetails[0][3] rootpathtertiary = settingdetails[0][4] if os.path.exists(rootpathprimary): pvideoroot = rootpathprimary else: self.createdir(rootpathprimary) pvideoroot = rootpathprimary if os.path.exists(rootpathsecondary): svideoroot = rootpathsecondary else: self.createdir(rootpathsecondary) svideoroot = rootpathsecondary if os.path.exists(rootpathtertiary): tvideoroot = rootpathtertiary else: self.createdir(rootpathtertiary) tvideoroot = rootpathtertiary camdir = pvideoroot+"/videos/" + camname self.base = pvideoroot+"/videos/" self.root = self.base + camname + "/live" self.root_hist = self.base + camname + "/hist" self.createdir(camdir) self.createdir(self.base) self.createdir(self.root) self.createdir(self.root_hist) framerate = 18.0 self.fps = FPS().start() self.Camtype=cam_type if self.Camtype=="webcam": try: ur =int(self.camid) self.video = WebcamVideoStream(src=ur).start() except Exception as e: print(e) print("Unable to open",camname) elif self.Camtype == "rtsp": try: ur = self.camid self.video = VideoStream(ur).start() except Exception as e: # print(e) print("Unable to open", camname) elif self.Camtype=="http": try: self.ur = camid self.imgResp = urllib.request(self.ur) # self.imgResp= requests.get(self.ur,stream=True,verify=True) except Exception as e: #print(e) print("Unable to open",camname) elif self.Camtype=="pi": try: # camera = PiCamera() # rawCapture = PiRGBArray(camera) # allow the camera to warmup time.sleep(0.1) except Exception as e: #print(e) print("Unable to open",camname)
def main(): points = [] ticks =str(int(time.time() * 1000)) # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-v", "--video", help="path to the (optional) video file") ap.add_argument("-b", "--buffer", type=int, default=64, help="max buffer size") args = vars(ap.parse_args()) # define the lower and upper boundaries of the "green" # ball in the HSV color space, then initialize the # list of tracked points # BLUE ballLower, ballUpper = getBallColor() pts = deque(maxlen=args["buffer"]) # created a *threaded *video stream, allow the camera senor to warmup, # and start the FPS counter debugPrint("[INFO] sampling THREADED frames from webcam...") vs = WebcamVideoStream(src=1).start() frame = vs.read() if frame is None: debugPrint("Changed to default camera!") # Take the default camera (webcam is not connected) vs = WebcamVideoStream(src=0).start() if __ENABLE_VIDEO_OUT__: outStream = cv2.VideoWriter('Output/output' + ticks +'.avi', -1, 20.0, (1000,705)) eventHook = EventHook() # keep looping while True: # grab the current frame frame = vs.read() if frame is None: continue # resize the frame, blur it, and convert it to the HSV # color space frame = imutils.resize(frame, width=1000) frame = frame[40:745,0:1000] # blurred = cv2.GaussianBlur(frame, (11, 11), 0) hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # construct a mask for the color "green", then perform # a series of dilations and erosions to remove any small # blobs left in the mask mask = cv2.inRange(hsv, ballLower, ballUpper) mask = cv2.erode(mask, None, iterations=2) mask = cv2.dilate(mask, None, iterations=2) # find contours in the mask and initialize the current # (x, y) center of the ball cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2] center = None # only proceed if at least one contour was found if len(cnts) > 0: # find the largest contour in the mask, then use # it to compute the minimum enclosing circle and # centroid c = max(cnts, key=cv2.contourArea) ((x, y), radius) = cv2.minEnclosingCircle(c) M = cv2.moments(c) center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) # only proceed if the radius meets a minimum size if radius > 5: #Changed from 10 # draw the circle and centroid on the frame, # then update the list of tracked points cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2) cv2.circle(frame, center, 5, (0, 0, 255), -1) # update the points queue pts.appendleft(center) debugPrint(center) if center is None: points.append((-1,-1)) else: points.append(center) # loop over the set of tracked points for i in xrange(1, len(pts)): # if either of the tracked points are None, ignore # them if pts[i - 1] is None or pts[i] is None: continue # otherwise, compute the thickness of the line and # draw the connecting lines thickness = int(np.sqrt(args["buffer"] / float(i + 1)) * 2.5) cv2.line(frame, pts[i - 1], pts[i], (0, 0, 255), thickness) # show the frame to our screen cv2.imshow("Frame", frame) if __ENABLE_VIDEO_OUT__: outStream.write(frame) # add replay frame addReplayFrame(frame) key = cv2.waitKey(1) & 0xFF # if the 'q' key is pressed, stop the loop if key == ord("q"): break if center is None: if eventHook.fire([(-1,-1)]): saveGoalVideo() else: normalizePoint = (int(2000*float(center[0]/1000.0)),int(1000*float(center[1]/705.0))) if eventHook.fire([normalizePoint]): saveGoalVideo() debugPrint(normalizePoint) # cleanup the camera and close any open windows cv2.destroyAllWindows() vs.stop() savePtsVector(points,ticks) raise SystemExit if __ENABLE_VIDEO_OUT__: outStream.release()
ap.add_argument("-i", "--input", default=int(0), help="path to input") ap.add_argument("-o", "--output", default=int(0), help="path to output") ap.add_argument("-f", "--file", required=False, default=None, help="path to output file txt") args = vars(ap.parse_args()) # initialize the QRdecoder object qr = QRdecoder() # created a *threaded* video stream, allow the camera sensor to warmup, # and start the FPS counter if args["mode"] == 0: vs = WebcamVideoStream(args["input"]).start() time.sleep(2.0) else: vs = FileVideoStream(args["input"]).start() #fourcc = cv2.VideoWriter_fourcc(*'mp4v') resolution = (640, 480) frame_rate = 20 #rec = cv2.VideoWriter(args["output"], fourcc, frame_rate, resolution) print("[INFO] THREADED frames initialized...") fps = FPS().start() # loop over some frames...this time using the threaded stream while True:
host = args["IPaddress"] port = args["PORT"] s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # s.connect((host, port)) s.bind((host, port)) print ("UDP socket bound to %s" %(port)) #initialize the video stream and allow the camera sensor to warmup print("Warming up camera") if args["setting"]: os.system('qv4l2') vs1 = WebcamVideoStream(src=1).start() vs2 = WebcamVideoStream(src=2).start() time.sleep(2.0) #initialize the FourCC, video writer, dimensions of the frame, and zeros array fps = args["fps"] frame1 = vs1.read() frame1 = imutils.resize(frame1, args["width"]) (h, w) = frame1.shape[:2] print(h, w) numframe = int(fps * args['length'] * 60) print(numframe) ts = None toverflow = 0 record = False
class App: def __init__(self, logger, src, ROOT_DIR): self.vs = WebcamVideoStream(src) self.fps = FPS() self.logger = logger self.ROOT_DIR = ROOT_DIR cv2.namedWindow("Webcam") cv2.namedWindow("roi") cv2.namedWindow("stacked") cv2.createTrackbar('dilate kernel', 'roi', 3, 5, self.none) cv2.createTrackbar('erode kernel', 'roi', 2, 5, self.none) cv2.createTrackbar('blackhat kernel', 'roi', 21, 30, self.none) self.mouse = Mouse(window="Webcam") self.gt = Graphics() # self.hist = Hist() self.msg = "draw a rectangle to continue ..." self.font_20 = ImageFont.truetype(f'{self.ROOT_DIR}/fonts/raleway/Raleway-Light.ttf', 20) self.font_10 = ImageFont.truetype(f'{self.ROOT_DIR}/fonts/raleway/Raleway-Light.ttf', 15) self.font_30 = ImageFont.truetype(f'{self.ROOT_DIR}/fonts/raleway/Raleway-Light.ttf', 30) self.font_40 = ImageFont.truetype(f'{self.ROOT_DIR}/fonts/raleway/Raleway-Medium.ttf', 50) # self.stabilizer = VidStab() self.predictor = parser_v3.Predictor(model_path=f'{self.ROOT_DIR}/models/model_0.1v7.h5', root_dir=self.ROOT_DIR) def run(self): self.vs.start() self.fps.start() self.logger.info("app started ...") frame = self.vs.read() wh, ww, _ = frame.shape cv2.moveWindow("Webcam", 0, 0) cv2.moveWindow("roi", ww, 0) cv2.moveWindow("stacked", 0, wh + 79) self.mouse.rect = ((200, 200), (ww - 200, wh - 200)) while True: frame = self.vs.read() # frame = frame[:, ::-1] # flip orig = frame.copy() # stabilized_frame = self.stabilizer.stabilize_frame( # input_frame=frame, smoothing_window=30, border_size=50) if self.mouse.rect: p1, p2 = self.mouse.rect roi = self.gt.draw_roi(orig, p1, p2) if roi.size != 0: gray_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY) dk = cv2.getTrackbarPos("dilate kernel", "roi") ek = cv2.getTrackbarPos("erode kernel", "roi") bk = cv2.getTrackbarPos("blackhat kernel", "roi") thresh = im.thresify(gray_roi, dk, ek, bk) # print(thresh.shape) # overlap thresh on original image mod_thres = cv2.bitwise_not(thresh) #orig[p1[1]:p2[1], p1[0]:p2[0]] = cv2.merge((mod_thres, mod_thres, mod_thres)) # boxes, digits, cnts = component.get_symbols( # thresh, im=roi, draw_contours=True) digits, boxes = component.connect_cnts2(thresh, roi) stacked_digits, resized_digits = component.stack_digits(digits, im.resize) res, latex_image, labels = self.predictor.parse(resized_digits, boxes) # annotate symbols # for label, (pre_label, x_min, y_min, x_max, y_max) in zip(labels, boxes): # self.gt.write(orig, label, (x_min, y_min), self.font_20) # res = self.predictor.parse(resized_digits, boxes) #print(f"res: {res}") self.gt.write(orig, res, (10, wh - wh / 8), self.font_10) # self.gt.draw_boxes(orig, boxes, p1, p2) # self.hist.draw(gray_roi) cv2.imshow('roi', thresh) cv2.imshow('stacked', stacked_digits) # cv2.imshow('latex_image', latex_image) # self.gt.write(orig, self.msg, (10, 10), self.font_20) else: orig[:, :] = cv2.blur(orig, (100, 100)) windowRect = cv2.getWindowImageRect('Webcam') wx, wy, ww, wh = windowRect self.gt.write(orig, self.msg, (100, wh / 2 - 30), self.font_30) cv2.imshow('Webcam', orig) # cv2.imshow('stab', stabilized_frame) self.fps.update() key = cv2.waitKey(1) if (key & 0xFF == ord('q')) or (key & 0xFF == 27): self.logger.info('exiting ...') break elif key & 0xFF == ord('c'): CAPTURED_DIR = f'{self.ROOT_DIR}/screenshots' imageName = f'{CAPTURED_DIR}/{str(time.strftime("%Y_%m_%d_%H_%M"))}.png' cv2.imwrite(imageName, orig) self.logger.info(f'screenshot saved at {imageName}') self.fps.stop() self.vs.stop() cv2.destroyAllWindows() self.logger.info("elapsed time: {:.2f}".format(self.fps.elapsed())) self.logger.info("approx. FPS: {:.2f}".format(self.fps.fps())) def none(self, x): pass