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()
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 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
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
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 main():
targetFramerate = 20
sleepLength = 1/targetFramerate
vs = PiVideoStream(resolution=(640,480), vflip=True).start()
time.sleep(2.0)
fps = FPS().start()
# loop over some frames...this time using the threaded stream
capture = True
try:
while capture:
frame = vs.read()
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
fps.update()
if key == ord('q'):
capture = False
# time.sleep(sleepLength)
# on break
fps.stop()
print("[INFO] elasped time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
finally:
# do a bit of cleanup
cv2.destroyAllWindows()
vs.stop()
def detect_face():
#camera = PiCamera()
#camera.resolution = (640, 480)
#camera.framerate = 32
#rawCapture = PiRGBArray(camera, size = (640, 480))
#stream = camera.capture_continuous(rawCapture, format="bgr", use_video_port=True)
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
#cap = cv2.VideoCapture(0)
cap = PiVideoStream().start()
time.sleep(2.0)
face_detected = False
while face_detected == False:
# Read the frame
#_, img = cap.read()
# print('looking for faces')
frame = cap.read()
frame = imutils.resize(frame, width=400)
# 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.stop()
cv2.destroyAllWindows()
if face_detected == True:
return True
return False
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
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)
class FaceDetector(object):
def __init__(self, flip=True):
self.vs = PiVideoStream(resolution=(800, 608)).start()
self.flip = flip
time.sleep(2.0)
# opencvの顔分類器(CascadeClassifier)をインスタンス化する
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(カラー画像)をグレースケールに変換
# 上記でグレースケールに変換したものをインスタンス化した顔分類器の
# detectMultiScaleメソッドで処理し、認識した顔の座標情報を取得する
# 取得した座標情報を元に、cv2.rectangleを使ってframe上に
# 顔の位置を描画する
# frameを戻り値として返す
return frame
class VideoCamera(object):
def __init__(self, flip=False):
self.vs = None
self.flip = flip
def __del__(self):
if self.vs is not None:
self.vs.stop()
def start(self, flip=False):
if self.vs is None:
self.vs = PiVideoStream().start()
self.flip = flip
time.sleep(2.0)
def stop(self):
if self.vs is not None:
self.vs.stop()
self.vs = None
def flip_if_needed(self, frame):
if self.flip:
return np.flip(frame, 0)
return frame
def get_frame(self):
if self.vs is None:
return
frame = self.flip_if_needed(self.vs.read())
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
class ThreadVideoStream:
def __init__(self, resolution=(320, 240), framerate=32):
from imutils.video.pivideostream import PiVideoStream
# initialize the picamera stream and allow the camera
# sensor to warmup
self.stream = PiVideoStream(resolution=resolution, framerate=framerate)
def start(self):
# start the threaded video stream
#self.stream.start()
#Thread(target=self.update, args=()).start()
return Thread(target=self.update, args=()).start()
#return self.stream.start()
def update(self):
# grab the next frame from the stream
self.stream.update()
def read(self):
# return the current frame
return self.stream.read()
def stop(self):
# stop the thread and release any resources
self.stream.stop()
class VideoCamera(object):
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)
def __del__(self):
self.vs.stop()
def flip_if_needed(self, frame):
# return frame
if not 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.tostring().tobytes()
def get_object(self, classifiers):
found_objects = False
xLocation = 0
yLocation = 0
frame = self.flip_if_needed(self.vs.read()).copy()
# print(frame[1].size
height, width = frame.shape[:2]
#print width
#print height
# small = cv2.resize(frame, (width/2, height/2), interpolation = cv2.INTER_AREA)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
classifier_used = -1
for i in range(len(classifiers)):
objects = classifiers[i].detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(64, 64),
flags=cv2.CASCADE_SCALE_IMAGE)
if len(objects) > 0:
found_objects = True
print 'found with %s' % i
classifier_used = i
break
# Draw a rectangle around the objects
for (x, y, w, h) in objects:
cv2.circle(frame, (x + w / 2, y + h / 2), 10, (0, 255, 0), 2)
xLocation = x
yLocation = y
ret, jpeg = cv2.imencode('.jpg', frame)
return (jpeg.tobytes(), found_objects, xLocation, yLocation,
classifier_used, width, height)
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 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
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)
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 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'
)
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)
# 取得した座標情報を元に、cv2.rectangleを使ってframe上に
# 顔の位置を描画する
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 255, 0), 2)
cv2.putText(frame,
'Happy!', (x, y),
cv2.FONT_HERSHEY_SIMPLEX,
1.0, (255, 255, 255),
thickness=2)
# cv2.putText(frame, '顔の数:' + str(len(faces)), (100,100), cv2.FONT_HERSHEY_SIMPLEX, 10, (255,255,255),3,cv2.CV_AA )
# cv2.putText(frame, "SAMPLE_TEXT", (x,y), cv2.FONT_HERSHEY_SIMPLEX, 10, 7, (0, 0, 255), 3, cv2.CV_AA)
cv2.putText(frame,
str(len(faces)) + ' Happy people', (20, 40),
cv2.FONT_HERSHEY_SIMPLEX,
1.0, (255, 255, 255),
thickness=2)
# frameを戻り値として返す
return frame
class FaceDetector(object):
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')
# opencvの顔分類器(CascadeClassifier)をインスタンス化する
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):
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = self.face_cascade.detectMultiScale(gray, 1.3, 3)
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
if len(self.argvs) >= 2 and "eyes" in self.argvs:
roi_gray = gray[y:y + h, x:x + w]
roi_color = frame[y:y + h, x:x + w]
eyes = self.eye_cascade.detectMultiScale(roi_gray)
for (ex, ey, ew, eh) in eyes:
cv2.rectangle(roi_color, (ex, ey), (ex + ew, ey + eh),
(0, 255, 0), 2)
# opencvでframe(カラー画像)をグレースケールに変換
return frame
# 上記でグレースケールに変換したものをインスタンス化した顔分類器の
# detectMultiScaleメソッドで処理し、認識した顔の座標情報を取得する
# 取得した座標情報を元に、cv2.rectangleを使ってframe上に
# 顔の位置を描画する
# frameを戻り値として返す
return frame
class VideoStreamer(object):
def __init__(self, flip=False, resolution=(640, 480)):
self.video_stream = PiVideoStream(resolution=resolution,
framerate=8).start()
time.sleep(2.0)
def __del__(self):
self.video_stream.stop()
def get_frame(self):
frame = self.video_stream.read()
#ret, jpg = cv2.imencode('.jpg', frame) # 圧縮
return frame
def mainLoop():
vs = PiVideoStream().start()
time.sleep(2)
baseFrame = None
frameTimer = time.time()
while True:
frame = vs.read()
HSV = cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)
white_mask = cv2.inRange(HSV, np.array([0, 0, 40]), np.array([360, 111, 255]))
whiteSmooth = cv2.GaussianBlur(white_mask, (3, 3), 0)
if baseFrame is None:
baseFrame = whiteSmooth
frameDelta = cv2.absdiff(whiteSmooth, baseFrame)
thresh = cv2.threshold(frameDelta, 150, 255, cv2.THRESH_BINARY)[1]
cv2.imshow('white_mask', whiteSmooth)
cv2.imshow('thresh', thresh)
cv2.imshow('frameDelta',frameDelta)
cv2.imshow('baseFrame', baseFrame)
#cv2.imshow('frame',frame)
_, cnts, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
im = np.copy(frame)
cv2.drawContours(im,cnts, -1, (0,255,0), 1)
key = cv2.waitKey(1) & 0xFF
if (len(cnts) == 0 and time.time()- frameTimer > 3) or time.time() - frameTimer > 8:
baseFrame = whiteSmooth
print("New reference frame")
frameTimer = time.time()
#contours = imutils.grab_contours(cnts)
for c in cnts:
if cv2.contourArea(c) < 50:
continue
print(cv2.contourArea(c))
M = cv2.moments(c)
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
cv2.circle(im, (cX, cY), 7, (255, 255, 255), -1)
cv2.imshow('im',im)
if key == ord("q"):
break
vs.stop()
cv2.destroyAllWindows()
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'
)
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)
font = cv2.FONT_HERSHEY_SCRIPT_COMPLEX
if len(faces) == 0:
text = 'No face'
elif len(faces) == 1:
text = 'A face'
else:
text = '{} faces :)'.format(len(faces))
cv2.putText(frame, text, (10, 100), font, 4, (80, 129, 225), 2)
# 取得した座標情報を元に、cv2.rectangleを使ってframe上に
# 顔の位置を描画する
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 255, 0), 2)
# frameを戻り値として返す
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'
)
def __del__(self):
self.vs.stop()
def get_frame(self):
# 開始時刻
start = time.clock()
# frameに描画レイヤーを書き足していく
frame = self.flip_if_needed(self.vs.read())
frame = self.process_image(frame)
ret, jpeg = cv2.imencode('.jpg', frame)
# 処理時間計測
get_image_time = int((time.clock() - start) * 1000)
# 1フレーム取得するのにかかった時間を表示
cv2.putText(frame,
str(get_image_time) + "ms", (10, 10), 1, 1, (0, 255, 0))
return jpeg.tobytes()
def flip_if_needed(self, frame):
if self.flip:
return np.flip(frame, 0)
return frame
def process_image(self, frame):
# opencvでframe(カラー画像)をグレースケールに変換
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# 上記でグレースケールに変換したものをインスタンス化した顔分類器の
# detectMultiScaleメソッドで処理し、認識した顔の座標情報を取得する
faces = self.face_cascade.detectMultiScale(gray, 1.3, 3)
# 取得した座標情報を元に、cv2.rectangleを使ってframe上に
# 顔の位置を描画する
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
# frameを戻り値として返す
return frame
class MotionDetector(object):
def __init__(self, flip=True):
self.vs = PiVideoStream(resolution=(400, 304), framerate=16).start()
self.flip = flip
time.sleep(2.0)
self.avg = None
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=min(500, frame.shape[1]))
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (21, 21), 0)
if self.avg is None:
print('Starting background model...')
self.avg = gray.copy().astype('float')
return frame
cv2.accumulateWeighted(gray, self.avg, 0.5)
#frameDelta = cv2.absdiff(gray, cv2.convertScaleAbs(self.avg))
frameDelta = cv2.absdiff(blue, cv2.convertScaleAbs(self.avg))
thresh = cv2.threshold(frameDelta, 5, 255, cv2.THRESH_BINARY)[1]
thresh = cv2.dilate(thresh, None, iterations=2)
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[0] if imutils.is_cv2() else cnts[1]
for c in cnts:
if cv2.contourArea(c) < 5000:
continue
(x, y, w, h) = cv2.boundingRect(c)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
return frame
class RPiCamera(object):
def __init__(self):
self.stream = PiVideoStream().start()
sleep(2.0)
def __del__(self):
self.stream.stop()
def get_frame(self):
frame = self.stream.read()
result, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
class VideoCamera(object):
def __init__(self, flip=False):
self.vs = PiVideoStream().start()
self.vs.camera.rotation = 270
self.flip = flip
self.vs.framerate = 10
self.vs.resolution = 90
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
#Grab an image and rotate to ensure it is in the proper orientation
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()
newframe = imutils.rotate(frame, -90)
#img = cv2.imread('photo-1507003211169-0a1dd7228f2d.jpg')
gray = cv2.cvtColor(newframe, cv2.COLOR_BGR2GRAY)
objects = classifier.detectMultiScale(gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30))
if len(objects) > 0:
found_objects = True
# Draw a rectangle around the objects
for (x, y, w, h) in objects:
frame2 = cv2.rectangle(newframe, (x, y), (x + w, y + h),
(255, 0, 0), 2)
#t = TempImage()
#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, newframe)
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 startCameraSequence():
resolution = (1200, 1008
) #Max resolution (3280,2464), Min resolution (64,64)
framerate = 10
vs = PiVideoStream(resolution, framerate).start()
time.sleep(2.0)
fps = FPS().start()
start_time = time.time()
wait_again = True
#Loop over frames using threaded stream
while wait_again:
#Gets timestamp
now = datetime.datetime.now()
now_print = now.strftime("%H:%M:%S.%f")
#Reads the current frame at capture thread
frame = vs.read()
#Writes the frame into folder with time stamp
#Change "/home/pi/Desktop/camera_test/" with desired saving folder"
cv2.imwrite("/home/pi/Desktop/camera_test/" + now_print + ".jpg",
frame)
#Update FPS counter
fps.update()
pressed_again = GPIO.input(18)
if (pressed_again):
wait_again = False
#Stop the timer and display FPS information
fps.stop()
vs.stop()
#Updates time taking pictures
end_time = time.time()
elapsed = end_time - start_time
#Writes the elapsed time of capture
#Change "/home/pi/Desktop/camera_test/" with desired saving folder"
f = open("/home/pi/Desktop/camera_test/sequenceResults.txt", "w+")
f.write("Done. Elapsed time (s): " + str(elapsed))
f.close()
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
# 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
# update the FPS counter
fps.update()
# 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()
vs.stop()
