def Phase_2_QR_Match(): print("PHASE 2: QR MATCH") vs = PiVideoStream().start() time.sleep(2.0) while True: global MATCH_QR_CODE GPIO.output(4, True) frame = vs.read() qr_display(frame, decode(frame, qr_data_match_len)[0]) if len(qr_data_match_len) > 0: qr_data_match = str(qr_data_match_len[len(qr_data_match_len) - 1]) qr_data_match_split = qr_data_match.replace("'", '').replace('b', "").split(",") qr_data_replace = str(qr_data).replace("'", '').replace('b', "") for i in range(len(qr_data_match_split)): if qr_data_replace in qr_data_match_split[i]: print("{0} is in {1}".format(qr_data_match_split[i], qr_data_replace)) # prints data match MATCH_QR_CODE =True break else: print("{0} no match to {1} line follower".format(qr_data_match_split[i],qr_data_replace)) # prints data match print("forward") if MATCH_QR_CODE == True: break cv2.imshow('frame', frame) cv2.waitKey(10) vs.stop() GPIO.output(4, False)
class QRDetector(object): def __init__(self, flip=False): self.vs = PiVideoStream(resolution=(400, 304), framerate=3).start() self.flip = flip time.sleep(2.0) def __del__(self): self.vs.stop() def flip_if_needed(self, frame): if self.flip: return np.flip(frame, 0) return frame def get_frame(self): frame = self.flip_if_needed(self.vs.read()) frame = self.process_image(frame) ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def process_image(self, frame): decoded_objs = self.decode(frame) # 認識したQRコードの位置を描画する frame = self.draw_positions(frame, decoded_objs) num = 0 if len(decoded_objs) > 0: num = decoded_objs cv2.putText(frame, 'Num: {}'.format(num), (15, 30), cv2.FONT_HERSHEY_DUPLEX, 0.8, (0, 255, 255), 1) return frame detected = False if len(decoded_objs) > 0: detected = True cv2.putText(frame, 'Detected: {}'.format(detected), (15, 30), cv2.FONT_HERSHEY_DUPLEX, 0.8, (0, 255, 255), 1) return frame def decode(self, frame): decoded_objs = pyzbar.decode(frame, scan_locations=True) for obj in decoded_objs: print(datetime.now().strftime('%H:%M:%S.%f')) print('Type: ', obj.type) print('Data: ', obj.data) return decoded_objs def draw_positions(self, frame, decoded_objs): for obj in decoded_objs: left, top, width, height = obj.rect frame = cv2.rectangle(frame, (left, top), (left + width, height + top), (0, 255, 0), 2) data = obj.data.decode('utf-8') return frame
def videoStream(): ##PiVideoStream starts camera capture continous in a seperate thread #Keeping call to I/O in seperate thread keeps our main loop uniterupted and acheives higher FPS encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90] vs = PiVideoStream().start() time.sleep(1.0) print("Capturing video...") #keep reading frames try: while True: frame = vs.read() #compress image - allows for faster live stream ret, frame = cv2.imencode('.jpg',frame, encode_param) #View stream on RPI HDMI #cv2.imshow("frame", frame) #cv2.waitKey(1) & 0xFF #Now serialize the data with pickle data = pickle.dumps(frame) #add msgLength to a struct- send message length first, then data message_size = struct.pack("L", len(data)) #SEND msg length + DATA videoSocket.sendall(message_size + data) except: vs.stop() videoSocket.close() commSocket.close() exit()
def __init__(self, flip=True): self.vs = PiVideoStream(resolution=(800, 608)).start() self.flip = flip time.sleep(2.0) self.hog = cv2.HOGDescriptor() self.hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
class VideoCamera(object): def __init__(self): self.vs = PiVideoStream().start() time.sleep(2.0) def __del__(self): self.vs.stop() def get_frame(self): frame = self.vs.read() ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def get_object(self, classifier): found_objects = False frame = self.vs.read().copy() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) objects = classifier.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE) if len(objects) > 0: found_objects = True for (x, y, w, h) in objects: cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) ret, jpeg = cv2.imencode('.jpg', frame) return (jpeg.tobytes(), found_objects)
def __init__(self, config={}): self.config = config self.flip = self.config['flip_cam'] self.frame_width = self.config['res_x'] self.frame_height = self.config['res_y'] if not isLoadPiCam: self.cap = cv2.VideoCapture(0) # getting width and height from the capture device self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.frame_width) self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.frame_height) else: self.cap = PiVideoStream(resolution=( self.frame_width, self.frame_height)).start() self.canRecord = True self.timeWithoutBody = 0 self.startRecordingTime = 0 self.pauseRecording = 0 # self.fourcc = 0x00000021 self.fourcc = cv2.VideoWriter_fourcc(*'avc1') self.out = cv2.VideoWriter() self.maxRecordingTime = self.config['max_record_time'] self.classifier = cv2.CascadeClassifier(self.config['classifier']) self.isRecording = False self.currentFrame = None
class Camera(object): def __init__(self, calib_img, resolution, framerate): self.stream = PiVideoStream(resolution=resolution, framerate=framerate) calib = undistort(cv2.imread(calib_img)) self.transform = birdseye_transform(calib) def start(self): self.stream.start() def stop(self): self.stream.stop() def get_line(self): frame = self.stream.read() test = undistort(frame) bird = birdseye(test, transform=self.transform) u = u_channel(bird) filtered = sobel(u) thresh = threshold(filtered) lines, line_coeff = detect_lines(thresh) # print("line:", p) # print("curvature: {}, slope: {}, offset: {}".format(*line_coeff)) return line_coeff
def __init__(self, flip=False): self.vs = PiVideoStream().start() self.vs.camera.rotation = 270 self.flip = flip self.conf = json.load(open("conf.json")) self.client = boto3.resource('s3') time.sleep(2.0)
class QRDetector(object): def __init__(self, flip=False): self.vs = PiVideoStream(resolution=(800, 608)).start() self.flip = flip time.sleep(2.0) def __del__(self): self.vs.stop() def flip_if_needed(self, frame): if self.flip: return np.flip(frame, 0) return frame def get_frame(self): frame = self.flip_if_needed(self.vs.read()) frame = self.process_image(frame) ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def process_image(self, frame): pass def decode(self, frame): pass def draw(self, frame, decoded_objs): pass
def detect_face(): face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') #cap = cv2.VideoCapture(0) cap = PiVideoStream().start() time.sleep(2.0) face_detected = False while (True): # Read the frame #_, img = cap.read() frame = cap.read() # Convert to grayscale gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # Detect the faces faces = face_cascade.detectMultiScale(gray, 1.1, 4) # Draw the rectangle around each face for (x, y, w, h) in faces: cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 0), 2) # print("face detected") face_detected = True # When everything done, release the capture cap.release() cv2.destroyAllWindows() if face_detected == True: return True return False
def run(self): HOST = '' PORT = 7878 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((HOST, PORT)) sock.listen(1) vs = PiVideoStream().start() #time.sleep(2.0) while True: print('WAIT FOR PORT 7878') conn, addr = sock.accept() while True: try: frame = vs.read() ret, buff = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 100]) data = np.array(buff) stringData = data.tostring() b = binascii.hexlify(stringData) conn.send(b) conn.send(b'\n') except socket.error as msg: break
def __init__(self, flip = True): self.vs = PiVideoStream(resolution=(800, 608)).start() self.flip = flip time.sleep(2.0) # opencvの顔分類器(CascadeClassifier)をインスタンス化する self.face_cascade = cv2.CascadeClassifier('camera/processor/model/haarcascades/haarcascade_frontalface_default.xml')
def createVideoStream(system, source, fps, resx, resy, begin): try: # Camera as source source = int(source) if system == "Windows": vs = cv2.VideoCapture(source) vs.set(3, resx) # Set resolution x (3 = CV_CAP_PROP_FRAME_WIDTH) vs.set(4, resy) # Set resolution y (4 = CV_CAP_PROP_FRAME_HEIGHT) vs.set(5, fps) # Set frame rate (5 = CV_CAP_PROP_FPS ) cv2.ocl.setUseOpenCL( False) # Necessary to avoid background subtraction errors elif system == "Raspi": vs = PiVideoStream((resx, resy), fps).start() except ValueError: # Video as source vs = cv2.VideoCapture(source) vs.set( 0, begin) # Set start of video in ms (0 = CV_CAP_PROP_POS_MSEC) if system == "Windows": cv2.ocl.setUseOpenCL( False) # Necessary to avoid background subtraction errors return vs
class Camera(object): def __init__(self): if cv2.__version__.startswith('2'): PROP_FRAME_WIDTH = cv2.cv.CV_CAP_PROP_FRAME_WIDTH PROP_FRAME_HEIGHT = cv2.cv.CV_CAP_PROP_FRAME_HEIGHT elif cv2.__version__.startswith('3'): PROP_FRAME_WIDTH = cv2.CAP_PROP_FRAME_WIDTH PROP_FRAME_HEIGHT = cv2.CAP_PROP_FRAME_HEIGHT # self.video = cv2.VideoCapture(0) self.video = PiVideoStream().start() #self.video = cv2.VideoCapture(1) #self.video.set(PROP_FRAME_WIDTH, 640) #self.video.set(PROP_FRAME_HEIGHT, 480) # self.video.set(PROP_FRAME_WIDTH, 320) # self.video.set(PROP_FRAME_HEIGHT, 240) def __del__(self): self.video.stop() def get_frame(self): while True: try: image = self.video.read() ret, jpeg = cv2.imencode('.jpg', image) return jpeg.tostring() except: continue
class PersonDetector(object): def __init__(self, flip=True): self.vs = PiVideoStream(resolution=(640, 480)).start() self.flip = flip self.last_uploaded = datetime.now() time.sleep(2.0) def __del__(self): self.vs.stop() def flip_if_needed(self, frame): # PersonDetectorはFlipしない return frame def get_frame(self): frame = self.flip_if_needed(self.vs.read()) frame = self.process_image(frame) ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def process_image(self, frame): persons = 0 frame = imutils.resize(frame, width=300) (h, w) = frame.shape[:2] blob = cv2.dnn.blobFromImage(frame, 0.007843, (300, 300), 127.5) net.setInput(blob) detections = net.forward() for i in np.arange(0, detections.shape[2]): confidence = detections[0, 0, i, 2] # 認識した物体の確からしさ if confidence < 0.5: continue idx = int(detections[0, 0, i, 1]) # 15は人 if idx != 15: continue box = detections[0, 0, i, 3:7] * np.array([w, h, w, h]) (startX, startY, endX, endY) = box.astype('int') label = '{}: {:.2f}%'.format('Person', confidence * 100) cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 255, 0), 2) y = startY - 15 if startY - 15 > 15 else startY + 15 cv2.putText(frame, label, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1) persons += 1 if persons > 0: timestamp = datetime.now() if (timestamp - self.last_uploaded).seconds >= 30: cv2.imwrite("image.jpg", frame) print('Uploading...') upload(persons) self.last_uploaded = timestamp print('Finished.') return frame
def __init__(self, flip=False): try: self.vs = PiVideoStream(resolution=(640, 480)).start() except: print(slf.vs) self.flip = flip time.sleep(2.0)
def __init__(self, model_path, threshold=0.8, resolution=(512, 352), framerate=5, head_line=80): """初期化処理""" # True: 立っている状態, False: かがんでいる状態 self.is_standing = True # is_standing の判定に使うしきい値 self.head_line = head_line # カメラへの接続 self.camera = PiVideoStream(resolution=resolution, framerate=framerate) # どのくらいの尤度で人として検知するか self.threshold = threshold # TFLiteモデルの読み込み self.detector = tf.lite.Interpreter(model_path=model_path) # TFLiteの初期化 self.detector.allocate_tensors() self.detector.set_num_threads(4) # モデルの入出力情報の取得 self.input_details = self.detector.get_input_details() self.output_details = self.detector.get_output_details() self.input_height = self.input_details[0]['shape'][1] self.input_width = self.input_details[0]['shape'][2]
class VideoCamera(object): def __init__(self, flip=False): self.mydb = mysql.connector.connect(host="#################", user="******", passwd="#################", database="################") self.carsarray = [] self.vs = PiVideoStream().start() self.flip = flip time.sleep(2.0) def __del__(self): self.vs.stop() def flip_if_needed(self, frame): if self.flip: return np.flip(frame, 0) return frame def get_frame(self): frame = self.flip_if_needed(self.vs.read()) ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def get_object(self, classifier): found_objects = False frame = self.flip_if_needed(self.vs.read()).copy() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) objects = classifier.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(15, 15), flags=cv2.CASCADE_SCALE_IMAGE) if len(objects) > 0: found_objects = True # Draw a rectangle around the objects numofcars = 0 for (x, y, w, h) in objects: numofcars = numofcars + 1 cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) #print (numofcars) print("Analyzing...") self.carsarray.append(numofcars) cv2.imshow('video', frame) cv2.waitKey(50) if len(self.carsarray) > 9: avginimage = math.ceil(sum(self.carsarray) / 10) print(avginimage) mycursor = self.mydb.cursor() #sql = "UPDATE cars SET Cars =%s%s" #val = (" ", avginimage) mycursor.execute("UPDATE cars SET Cars = %s" % (avginimage)) self.mydb.commit() self.carsarray = [] ret, jpeg = cv2.imencode('.jpg', frame) return (jpeg.tobytes(), found_objects)
class VideoCamera(object): def __init__(self, flip=False): self.vs = PiVideoStream().start() self.flip = fliptime.sleep(2.0) def __del__(self): self.vs.stop() def flip_if_needed(self, frame): if self.flip: return np.flip(frame, 0) return frame
class PersonDetector(object): def __init__(self, flip=True): self.last_upload = time.time() self.vs = PiVideoStream(resolution=(800, 608)).start() self.flip = flip time.sleep(2.0) def __del__(self): self.vs.stop() def flip_if_needed(self, frame): if self.flip: return np.flip(frame, 0) return frame def get_frame(self): frame = self.flip_if_needed(self.vs.read()) frame = self.process_image(frame) ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def process_image(self, frame): frame = imutils.resize(frame, width=300) (h, w) = frame.shape[:2] blob = cv2.dnn.blobFromImage(frame, 0.007843, (300, 300), 0) net.setInput(blob) detections = net.forward() count = 0 for i in np.arange(0, detections.shape[2]): confidence = detections[0, 0, i, 2] if confidence < 0.2: continue idx = int(detections[0, 0, i, 1]) if idx != 15: continue box = detections[0, 0, i, 3:7] * np.array([w, h, w, h]) (startX, startY, endX, endY) = box.astype('int') label = '{}: {:.2f}%'.format('Person', confidence * 100) cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 255, 0), 2) y = startY - 15 if startY - 15 > 15 else startY + 15 cv2.putText(frame, label, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1) count += 1 if count > 0: print('Count: {}'.format(count)) elapsed = time.time() - self.last_upload if elapsed > 60: cv2.imwrite('hello.jpg', frame) upload() self.last_upload = time.time() return frame
class FaceDetector(object): def __init__(self, flip=True): self.vs = PiVideoStream(resolution=(800, 608)).start() self.flip = flip time.sleep(2.0) # opencvの顔分類器(CascadeClassifier)をインスタンス化する self.face_cascade = cv2.CascadeClassifier( 'camera/processor/model/haarcascades/haarcascade_frontalface_default.xml' ) self.eye_cascade = cv2.CascadeClassifier( 'camera/processor/model/haarcascades/haarcascade_eye.xml') def __del__(self): self.vs.stop() def flip_if_needed(self, frame): if self.flip: return np.flip(frame, 0) return frame def get_frame(self): frame = self.flip_if_needed(self.vs.read()) frame = self.process_image(frame) ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def process_image(self, frame): # opencvでframe(カラー画像)をグレースケールに変換 gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # 上記でグレースケールに変換したものをインスタンス化した顔分類器の # detectMultiScaleメソッドで処理し、認識した顔の座標情報を取得する faces = self.face_cascade.detectMultiScale(gray, 1.3, 3) # 文字列を作成する iSize = len(faces) # iRow = frame.shape[0] # iCol = frame.shape[1] font = cv2.FONT_HERSHEY_SIMPLEX # 取得した座標情報を元に、cv2.rectangleを使ってframe上に # 顔の位置を描画する for (x, y, w, h) in faces: cv2.rectangle(frame, (x, y), (x + w, y + h), (128, 128, 0), 2) face = frame[y:y + h, x:x + w] face_gray = gray[y:y + h, x:x + w] eyes = self.eye_cascade.detectMultiScale(face_gray) for (ex, ey, ew, eh) in eyes: cv2.rectangle(face, (ex, ey), (ex + ew, ey + eh), (0, 255, 0), 2) # 文字列を書く cv2.putText(frame, str(iSize), (10, 100), font, 4, (128, 0, 255), 3, cv2.LINE_AA) # frameを戻り値として返す return frame
def __init__(self, flip = True): self.vs = PiVideoStream(resolution=(800, 608)).start() self.flip = flip time.sleep(2.0) self.argvs = sys.argv self.face_cascade = cv2.CascadeClassifier('camera/processor/model/haarcascades/haarcascade_frontalface_default.xml') if len(self.argvs) >= 2 and "eyes" in self.argvs: self.eye_cascade = cv2.CascadeClassifier('camera/processor/model/haarcascades/haarcascade_eye.xml')
def __init__(self, flip=True): self.vs = PiVideoStream(resolution=(800, 608)).start() self.flip = flip time.sleep(2.0) self.firstFrame = None self.move_time = time.time() self.movelist = [] self.enter = 0 self.leave = 0
def __init__(self, flip=False): self.mydb = mysql.connector.connect(host="#################", user="******", passwd="#################", database="################") self.carsarray = [] self.vs = PiVideoStream().start() self.flip = flip time.sleep(2.0)
def __init__(self): if cv2.__version__.startswith('2'): PROP_FRAME_WIDTH = cv2.cv.CV_CAP_PROP_FRAME_WIDTH PROP_FRAME_HEIGHT = cv2.cv.CV_CAP_PROP_FRAME_HEIGHT elif cv2.__version__.startswith('3'): PROP_FRAME_WIDTH = cv2.CAP_PROP_FRAME_WIDTH PROP_FRAME_HEIGHT = cv2.CAP_PROP_FRAME_HEIGHT self.video = PiVideoStream().start()
def __init__(self, flip=False): #self.camera = PiCamera() #self.camera.resolution = (640, 480) #self.camera.framerate = 32 #self.rawCapture = PiRGBArray(self.camera, size=(640, 480)) self.vs = PiVideoStream(resolution=(800, 608)).start() self.flip = flip time.sleep(2.0)
def __init__(self): PiVideoStream.__init__(self, (640, 480)) # camera.vflip = True camera.hflip = True camera.awb_mode = 'off' # camera.image_effect = 'solarize' # camera.image_effect_params = 0 camera.brightness = 75 camera.awb_gains = (1.45, 1.45) camera.exposure_mode = 'off'
def __init__(self, flip=True): self.vs = PiVideoStream((640, 480)).start() self.vs.camera.vflip = True # self.vs.camera.framerate = 30 #self.vs.camera.exposure_mode = 'night' #self.vs.camera.vflip = True self.flip = flip self.vs.camera.start_preview() time.sleep(2.0)
class VideoCamera(object): def __init__(self, flip=False): self.vs = PiVideoStream().start() self.vs.camera.rotation = 270 self.flip = flip self.conf = json.load(open("conf.json")) self.vs.framerate = self.conf["fps"] self.vs.resolution = self.conf["resolution"] self.client = boto3.resource('s3') time.sleep(2.0) def __del__(self): self.vs.stop() def flip_if_needed(self, frame): if self.flip: return np.flip(frame, 0) return frame def get_frame(self): frame = self.flip_if_needed(self.vs.read()) ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def get_object(self, classifier): timestamp = datetime.datetime.now() ts = timestamp.strftime("%A %d %B %Y %I:%M:%S.%f%p") found_objects = False frame = self.flip_if_needed(self.vs.read()).copy() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) objects = classifier.detectMultiScale(gray, scaleFactor=1.05, minNeighbors=5, minSize=(60, 60), flags=cv2.CASCADE_SCALE_IMAGE) if len(objects) > 0: found_objects = True # Draw a rectangle around the objects for (x, y, w, h) in objects: cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) #t = TempImage() #cv2.imwrite(t.path, frame[y:y+h,x:x+w]) #self.client.meta.client.upload_file(t.path, self.conf["s3bucket_faces"], t.key ) #t.cleanup() cv2.putText(frame, ts, (10, frame.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.35, (0, 255, 0), 1) #cv2.imshow("feed",frame) #cv2.waitKey(1000) ret, jpeg = cv2.imencode('.jpg', frame) return (jpeg.tobytes(), found_objects, frame)
class VideoCamera(object): def __init__(self, flip = False): self.vs = PiVideoStream(resolution=(480 , 320),framerate=32).start() #resolution and framerate self.flip = flip time.sleep(0.1) def __del__(self): self.vs.stop() def flip_if_needed(self, frame): if self.flip: return np.flip(frame, 0) return frame def get_frame(self, classifier): frame = self.flip_if_needed(self.vs.read()).copy() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) objects = classifier.detectMultiScale( gray, scaleFactor=1.5, minNeighbors=4, minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE ) for (x, y, w, h) in objects: cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) ret, jpeg = cv2.imencode('.jpg', frame) return jpeg.tobytes() def get_object(self, classifier): found_objects = False frame = self.flip_if_needed(self.vs.read()).copy() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) objects = classifier.detectMultiScale( gray, scaleFactor=1.5, minNeighbors=4, minSize=(30, 30), flags=cv2.CASCADE_SCALE_IMAGE ) if len(objects) > 0: found_objects = True # Draw a rectangle around the objects for (x, y, w, h) in objects: cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) ret, jpeg = cv2.imencode('.jpg', frame) #print('called = ', found_objects ) return (jpeg.tobytes(), found_objects,frame)
def run_main(): # created a "threaded" video stream, allow the camera sensor to warmup vs = PiVideoStream((640,480)).start() time.sleep(2.0) # read the first frame of the video frame = vs.read() # Set the ROI c, r, w, h=200, 100, 70, 70 track_window=(c, r, w, h) # Create mask and nomralized histogram roi = frame[r:r+h, c:c+w] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_roi, np.array((0., 30., 32.)), np.array((180.,255.,255.))) roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180]) cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) # Setup the termination criteria, either 80 iteration or move by atleast 1pt term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 80, 1) while True: frame = vs.read() hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0,180], 1) # apply meanshift to get the new location ret, track_window = cv2.meanShift(dst, track_window, term_crit) # apply camshift to get the new location #ret, track_window = cv2.CamShift(dst, track_window, term_crit) # draw it on image x, y, w, h = track_window cv2.rectangle(frame, (x, y), (x+w, y+h), 255, 2) cv2.putText(frame, 'Tracked M', (x-25, y-10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2, cv2.LINE_AA) cv2.imshow('Tracking', frame) # if the 'q' key is pressed, break from the loop key = cv2.waitKey(1) & 0xFF if key == ord("q"): break vs.stop() cv2.destroyAllWindows()
def __init__(self): threading.Thread.__init__(self) self.running = True self.fps_counter = FPS().start() self.camera = PiVideoStream(resolution=(config.RAW_FRAME_WIDTH, config.RAW_FRAME_HEIGHT)) self.camera.start() time.sleep(config.CAMERA_WARMUP_TIME) # wait for camera to initialise self.frame = None self.frame_chroma = None self.centre = config.CENTRE self.can_see_lines = False self.last_yellow_mean = config.WIDTH * 0.8 self.last_blue_mean = config.WIDTH * 0.2 self.desired_steering = config.NEUTRAL_STEERING # 0 = left, 0.5 = center, 1 = right self.desired_throttle = config.NEUTRAL_THROTTLE # 0 = stop, 0.5 = medium speed, 1 = fastest
return self.data if __name__ == '__main__': import sys print(__doc__) try: fn = sys.argv[1] except: fn = 0 '''camera = PiCamera() camera.resolution = (640, 480) camera.framerate = 32 rawCap= PiRGBArray(camera, size = (640, 480))''' cap = PiVideoStream().start() def process_frame(frame, t0): # some intensive computation... frame = cv2.medianBlur(frame, 19) # frame = cv2.medianBlur(frame, 19) return frame, t0 threadn = cv2.getNumberOfCPUs() pool = ThreadPool(processes = threadn) pending = deque() threaded_mode = True latency = StatValue()
# 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 cv2.destroyAllWindows() stream.close() rawCapture.close() camera.close() # created a *threaded *video stream, allow the camera sensor to warmup, # and start the FPS counter print("[INFO] sampling THREADED frames from `picamera` module...") vs = PiVideoStream().start() time.sleep(2.0) 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
from imutils.video.pivideostream import PiVideoStream from imutils.video import FPS # Pour mesurer les FPS import cv2 # Librairie OpenCV import time # Fonctions temporelles # Definition des seuils HSV pour le vert greenLower = (85, 126, 60) greenUpper = (95, 255, 255) # Creation de la fenetre d'affichage cv2.namedWindow('Tracking', cv2.WINDOW_NORMAL) # Demarage du flux video sur un thread different vs = PiVideoStream() vs.camera.video_stabilization = True vs.start() # Laisse le temps de chauffer a la camera time.sleep(1.0) # Demarre le compteur de FPS fps = FPS().start() # Boucle principale while True : frame = vs.read() #frame = imutils.resize(frame, width = 400) # Convertis la frame en HSV hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # Construis un masque pour la couleur définie mask = cv2.inRange(hsv, greenLower, greenUpper) # Effectue 2 passages d'erosion pour retirer les petits éléments mask = cv2.erode(mask, None, iterations = 2) # Effectue 2 passages de dilatation pour conserver la taille mask = cv2.dilate(mask, None, iterations = 2) # Detecte les contours dans le masque
class DroidVisionThread(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.running = True self.fps_counter = FPS().start() self.camera = PiVideoStream(resolution=(config.RAW_FRAME_WIDTH, config.RAW_FRAME_HEIGHT)) self.camera.start() time.sleep(config.CAMERA_WARMUP_TIME) # wait for camera to initialise self.frame = None self.frame_chroma = None self.centre = config.CENTRE self.can_see_lines = False self.last_yellow_mean = config.WIDTH * 0.8 self.last_blue_mean = config.WIDTH * 0.2 self.desired_steering = config.NEUTRAL_STEERING # 0 = left, 0.5 = center, 1 = right self.desired_throttle = config.NEUTRAL_THROTTLE # 0 = stop, 0.5 = medium speed, 1 = fastest def run(self): debug("DroidVisionThread: Thread started") self.vision_processing() self.camera.stop() cv2.destroyAllWindows() debug("DroidVisionThread: Thread stopped") def stop(self): self.running = False debug("DroidVisionThread: Stopping thread") def vision_processing(self): while self.running: self.grab_frame() # colour mask blue_mask = cv2.inRange(self.frame_chroma, config.BLUE_CHROMA_LOW, config.BLUE_CHROMA_HIGH) yellow_mask = cv2.inRange(self.frame_chroma, config.YELLOW_CHROMA_LOW, config.YELLOW_CHROMA_HIGH) colour_mask = cv2.bitwise_or(blue_mask, yellow_mask) colour_mask = cv2.erode(colour_mask, config.ERODE_KERNEL) colour_mask = cv2.dilate(colour_mask, config.DILATE_KERNEL) # lines lines = cv2.HoughLinesP(colour_mask, config.HOUGH_LIN_RES, config.HOUGH_ROT_RES, config.HOUGH_VOTES, config.HOUGH_MIN_LEN, config.HOUGH_MAX_GAP) blue_lines = np.array([]) yellow_lines = np.array([]) if lines != None: for line in lines: x1,y1,x2,y2 = line[0] angle = np.rad2deg(np.arctan2(y2-y1, x2-x1)) if config.MIN_LINE_ANGLE < abs(angle) < config.MAX_LINE_ANGLE: if config.IMSHOW: cv2.line(self.frame, (x1,y1), (x2,y2), (0,0,255), 1) if angle > 0: yellow_lines = np.append(yellow_lines, [x1, x2]) elif angle < 0: blue_lines = np.append(blue_lines, [x1, x2]) # find centre blue_mean = self.last_blue_mean yellow_mean = self.last_yellow_mean if len(blue_lines): blue_mean = int(np.mean(blue_lines)) if len(yellow_lines): yellow_mean = int(np.mean(yellow_lines)) self.centre = (blue_mean + yellow_mean) / 2.0 self.last_blue_mean = blue_mean self.last_yellow_mean = yellow_mean self.can_see_lines = (len(blue_lines) or len(yellow_lines)) # set steering and throttle self.desired_steering = (1.0 - (self.centre / config.WIDTH)) if len(blue_lines) or len(yellow_lines): self.desired_throttle = 0.22 else: self.desired_throttle = 0 if config.IMSHOW: cv2.circle(self.frame, (int(self.centre), config.HEIGHT - 20), 10, (0,0,255), -1) cv2.imshow("colour_mask without noise", colour_mask) cv2.imshow("raw frame", self.frame) cv2.waitKey(1) def grab_frame(self): self.fps_counter.update() # grab latest frame and index the ROI self.frame = self.camera.read() self.frame = self.frame[config.ROI_YMIN:config.ROI_YMAX, config.ROI_XMIN:config.ROI_XMAX] # convert to chromaticity colourspace B = self.frame[:, :, 0].astype(np.uint16) G = self.frame[:, :, 1].astype(np.uint16) R = self.frame[:, :, 2].astype(np.uint16) Y = 255.0 / (B + G + R) b = (B * Y).astype(np.uint8) g = (G * Y).astype(np.uint8) r = (R * Y).astype(np.uint8) self.frame_chroma = cv2.merge((b,g,r)) def get_fps(self): self.fps_counter.stop() return self.fps_counter.fps() def get_error(self): return (config.CENTRE - self.centre) def get_steering_throttle(self): return self.desired_steering, self.desired_throttle
flow = DropboxOAuth2FlowNoRedirect(conf["dropbox_key"], conf["dropbox_secret"]) print( "[INFO] Authorize this application: {}".format(flow.start())) authCode = input("Enter auth code here: ").strip() # finish the authorization and grab the Dropbox client (accessToken, userID) = flow.finish(authCode) client = DropboxClient(accessToken) print( "[SUCCESS] dropbox account linked") # initialize the camera and grab a reference to the raw camera capture #camera = PiCamera() #camera.rotation = conf["rotation"] #camera.resolution = tuple(conf["resolution"]) #camera.framerate = conf["fps"] #rawCapture = PiRGBArray(camera, size=tuple(conf["resolution"])) vs = PiVideoStream((320, 240), 30, conf["rotation"]).start() # allow the camera to warmup, then initialize the average frame, last # uploaded timestamp, and frame motion counter print( "[INFO] warming up...") time.sleep(conf["camera_warmup_time"]) avg = None lastUploaded = datetime.datetime.now() motionCounter = 0 cv2.namedWindow("Security Feed") cv2.namedWindow("ctrl", cv2.WINDOW_NORMAL) cv2.setMouseCallback("Security Feed",moveMask) cv2.createTrackbar('1:Exit app',"ctrl",0,1,quit) cv2.createTrackbar('Mask size',"ctrl",maskw,255,setMaskSize) cv2.createTrackbar('0:Off\n1:On',"ctrl",0,1,startDetect)