def detect_face_cv2_webcam():
cap = VideoCapture(0)
classifier = CascadeClassifier('haarcascade_frontalface_default.xml')
# Check if the webcam is opened correctly
if not cap.isOpened():
raise IOError("Cannot open webcam")
while True:
ret, frame = cap.read()
frame = flip(frame, 1)
gray = cvtColor(frame, COLOR_BGR2GRAY)
faces = classifier.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
# flags=cv2.cv.CV_HAAR_SCALE_IMAGE
)
for (x, y, w, h) in faces:
rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
imshow("Video", frame)
if waitKey(1) == ord('q'):
break
cap.release()
destroyAllWindows()
def get_screenshot(self, carNo, show_view=True):
"""
截图一帧
:param carNo:
:param show_view:
:return:
"""
try:
# 打开rtsp
cap = VideoCapture(self.URL)
ret, frame = cap.read()
if not ret:
consoleLog(self.logPre, "未捕获到帧")
imencode('.jpg', frame)[1].tofile(self.img_path.format(carNo=carNo, now=fmt_date(fmt=FMT_DATETIME)))
if show_view:
# 预览窗口
namedWindow('view', WINDOW_NORMAL | WINDOW_KEEPRATIO)
imshow("view", frame)
waitKey(5 * 1000)
except Exception as e:
consoleLog(self.logPre, "保存截图异常:", repr(e))
finally:
if cap:
cap.release()
destroyAllWindows()
def main():
"""run the main loop"""
# %%
pygame.mixer.init()
cam = VideoCapture(CAMERA_IDX) # get camera handle
detector = SlouchDetector(SLOUCH_THRESHOLD, do_store_imgs=STORE_IMGS)
try:
while True:
img = _capture_img(cam)
# an (color) image is just a Width x Height x NumChannels 'matrix',
# really a rank-3 tensor
# channels are Blue, Green, Red (CV2 ideasyncratic ordering...)
# print( type(img), img.shape ) # => <ndarray> (480, 640, 3)
# Convert into grayscale
# an grayscale image is just a Width x Height x NumChanels matrix,
# really a rank-2 tensor
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# print(type(gray), gray.shape) # => <ndarray> (480, 640)
detector.detect(gray)
time.sleep(1)
except Exception as exc:
cam.release() # close the webcam
raise exc
def videoconvert(inp):
capture = VideoCapture(inp)
inp_ext = inp.split(".")
fpsin = capture.get(CAP_PROP_FPS)
count = 0
success = 1
while success:
success, image = capture.read()
if (success == False and image == None):
pass
else:
imwrite("zzimg%d.jpg" % count, image)
count += 1
outfile = inp_ext[0] + '_output.mp4'
fourcc = VideoWriter_fourcc(*'DIVX')
fpsout = fpsin
img = imread("zzimg0.jpg")
height, width, layers = img.shape
size = (width, height)
out = VideoWriter(outfile, fourcc, fpsout, size, 0)
for i in range(count):
img = imread("zzimg%d.jpg" % i, 0)
out.write(img)
print(
"Video Converted to Grayscale, Please check the folder for the output file: ",
outfile)
out.release()
capture.release()
return outfile
def start():
'''
'''
#Load splash screen
splScr = splash()
found = []
#find connected cameras
for num in range(10):
cam = VideoCapture(num)
cam.open
#show progress bar 'movement' while the main program find cameras
splScr.update()
if not cam.read()[0]:
del(cam)
else:
cam.release()
found.append(num)
while gtk.events_pending():
gtk.main_iteration()
#destroy splash screen when all cameras are finded
splScr.destroy()
print 'connected cameras:', len(found)
#run main program
main_gui(found)
gtk.main()
return
def cv_write_video_stream(videosrc: cv2.VideoCapture, width: int,
height: int, videoname: str):
"""Writes cv2.VideoCapture feed to a file.
Args:
videosrc: A VideoCapture object.
width: Video width.
height: Video height.
videoname: Name of video file to be output.
Returns:
No values, runs stream to file until key is pressed.
"""
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
out = cv2.VideoWriter('%s.avi' % videoname, fourcc, 30,
(width, height))
while True:
ret, frame = videosrc.read()
if ret is True:
out.write(frame)
else:
break
videosrc.release()
out.release()
class CameraStream:
def __init__(self,camera=0,video_file=None,video=False):
from cv2 import VideoCapture
if(video):
# Use a video file as input.
self.stream = VideoCapture(video_file)
else:
# Use a camera as input.
self.stream = VideoCapture(camera)
# Check if we were successful in opening stream.
if(self.stream.isOpened() == False):
name = video_file if video else camera
raise IOError("Error opening video stream or file '{}'".format(name))
def __del__(self):
""" Destructor to close everything. """
# When everything done, release the video capture object
self.stream.release()
def get_frame(self):
""" Retrieve frame. """
# Read until video is completed
while(self.stream.isOpened()):
# Capture frame-by-frame
ret,frame = self.stream.read()
if(ret == True):
yield frame
class Camera(object):
def get_settings(self):
if not hasattr(self, '_video_capture'):
raise Exception("Start video capture before getting settings")
settings = []
for prop in global_camera_properties:
prop_value = self._video_capture.get(prop['value'])
if prop_value >= 0:
settings.append({'name': prop['name'], 'value': prop_value})
return settings
def set_setting(self, setting, value):
if not hasattr(self, '_video_capture'):
raise Exception("Start video capture before setting a setting")
setting_id = filter(lambda x: x['name'] == setting,
global_camera_properties)
if len(setting_id) == 1:
setting_id = setting_id[0]['value']
else:
raise Exception("Setting {} not available".format(setting))
self._video_capture.set(setting_id, value)
def read(self):
(retVal, image) = self._video_capture.read()
return image
def start(self):
self._video_capture = VideoCapture(0)
self.shape = self.read().shape
def stop(self):
self._video_capture.release()
def open_camera(cam='/dev/psEye', w=320, h=240, fps=100):
"""
Opens camera and configures height, width, and fps settings.
INPUTS
(optional)
cam -- str/int -- camera descriptor for VideoCapture; '/dev/psEye'
w -- int -- width (px) to set camera frame; 320
h -- int -- height (px) to set camera frame; 240
fps -- int -- frames per second to set camera; 100
OUTPUTS
cv2.VideoCapture object
EXCEPTIONS
Raises RuntimeError when unable to open camera
"""
if type(cam) not in (str, int):
raise TypeError('\'cam\' must be int or str')
if type(w) != int:
raise TypeError('\'w\' must be int')
if type(h) != int:
raise TypeError('\'h\' must be int')
if type(fps) != int:
raise TypeError('\'fps\' must be int')
cap = VideoCapture(cam)
if not cap.isOpened():
cap.release()
raise RuntimeError('failed to open camera \'%s\'' % cam)
cap.set(CAP_PROP_FRAME_HEIGHT, h)
cap.set(CAP_PROP_FRAME_WIDTH, w)
cap.set(CAP_PROP_FPS, fps)
return cap
def read_images(photos_path, video_path):
cap = VideoCapture(
video_path) # Reproducir video para realizar la captura por frames
fps = cap.get(CAP_PROP_FPS) # Optener los fps del video
print(f'fps: {fps}')
mkdir(photos_path)
currentFrame = 0
while True:
_, frame = cap.read() # Obtener 1 frame
try:
len(frame)
except:
break
# Salvar la catura
name = prt(photos_path, currentFrame)
imwrite(name, frame)
currentFrame += 1 # Indice de la imagen
# Cerrar el video
cap.release()
destroyAllWindows()
def Extract_Frames(source, fps=1, dest=None):
'''Extracts frames from a given source animation, with optional fps and destination'''
from Webscraping import USER
from pathlib import Path
from cv2 import VideoCapture, imencode, CAP_PROP_POS_FRAMES
path = Path(source)
if dest is None:
dest = USER / 'Pictures' / 'Screenshots' / path.stem
if dest.exists():
for file in dest.iterdir():
file.unlink()
dest.mkdir(exist_ok=1)
vidcap = VideoCapture(source)
success, frame = vidcap.read()
while success:
if ((vidcap.get(CAP_PROP_POS_FRAMES) % fps) - 1) in (-1, 0):
image = dest / f'{vidcap.get(CAP_PROP_POS_FRAMES)}.jpg'
image.write_bytes(imencode('.jpg', frame)[-1])
success, frame = vidcap.read()
else: vidcap.release()
def getMP4Length(x):
cap = VideoCapture(x)
fps = cap.get(CAP_PROP_FPS) # OpenCV2 version 2 used "CV_CAP_PROP_FPS"
frame_count = int(cap.get(CAP_PROP_FRAME_COUNT))
cap.release()
duration = frame_count / fps
return duration
def make_video(photos_path, video_path, video_name):
cap = VideoCapture(v_path)
fps = cap.get(CAP_PROP_FPS)
cap.release()
mkdir(video_path)
images_cnt = jpgcount(photos_path)
print(f'{images_cnt} imagenes')
img = []
# Cargar las imágenes
for i in range(images_cnt):
img.append(imread(photos_path + '/frame' + str(i) + '.jpg'))
height, width, _ = img[1].shape
# Inicializar el video
video = VideoWriter(video_path + '/' + video_name + '.mp4',
VideoWriter_fourcc(*'MP4V'), fps, (width, height))
print('Codificando video')
# Insertar cada imagen
for j in range(images_cnt):
video.write(img[j])
# Cerrar proceso
destroyAllWindows()
video.release()
print('Video Codificado')
def getEpisodeInfo(self, names, season):
for number, name in enumerate(names, 1):
if number in self.episodeNumbers:
input_file = self.path + 'episodio-' + str(number) + '.mp4'
videoInfo = VideoCapture(input_file)
fps = videoInfo.get(CAP_PROP_FPS)
frameCount = videoInfo.get(CAP_PROP_FRAME_COUNT)
duration = self.getCorretDuration(
int(round(frameCount / fps, 0)))
quality = videoInfo.get(4)
episodeData = {
'temporada': season + 1,
'episodio': number,
'nome': name,
'duracao': duration,
'thumb': 'thumb-' + str(number) + '.png',
'qualidade': str(quality)[:-2] + 'p'
}
self.episodeInfoList.append(episodeData)
videoInfo.release()
class Camera_from_url(object):
"""Camera_from_url captures video from a <url>.mjpg source
using open cv2 "VideoCapture" and encodes it as jpeg using imencode
:param object: <URL>.mjpg
:type object: mjpg
:return: jpeg in raw bytes
:rtype: bytes
"""
def __init__(self):
nothing_to_do = "yes"
def init_teststand(self, url):
if url is None:
self.video = None
elif url is not None:
self.video = VideoCapture(url)
def __del__(self):
if self.video is None:
nothing_to_do = "yes"
else:
self.video.release()
def get_frame(self):
_, image = self.video.read()
image = resize(image, (1920, 1080))
_, jpeg = imencode('.jpg', image)
return jpeg.tobytes()
def WebCam_OnOff(device_num: int, cam: cv2.VideoCapture = None):
"""
WebCameraを読み込む関数
Args:
device_num(int): カメラデバイスを番号で指定
0:PC内臓カメラ
1:外部カメラ
cam(cv2.VideoCapture optional): 接続しているカメラ情報
Returns:
response(int): 動作終了を表すフラグ
0: connect
1: release
2: NotFound
capture(cv2.VideoCapture): 接続したデバイス情報を返す
cv2.VideoCapture: connect
None: release or NotFound
"""
if cam is None: # カメラが接続されていないとき
cam = cv2.VideoCapture(device_num)
# カメラに接続できなかった場合
if not cam.isOpened():
return 2, None
# 接続できた場合
else:
return 0, cam
else: # カメラに接続されていたとき
cam.release()
return 1, None
class Camera(object):
def get_settings(self):
if not hasattr(self, '_video_capture'):
raise Exception("Start video capture before getting settings")
settings = []
for prop in global_camera_properties:
prop_value = self._video_capture.get(prop['value'])
if prop_value >= 0:
settings.append({'name': prop['name'], 'value': prop_value})
return settings
def set_setting(self, setting, value):
if not hasattr(self, '_video_capture'):
raise Exception("Start video capture before setting a setting")
setting_id = filter(lambda x: x['name'] == setting, global_camera_properties)
if len(setting_id) == 1:
setting_id = setting_id[0]['value']
else:
raise Exception("Setting {} not available".format(setting))
self._video_capture.set(setting_id, value)
def read(self):
(retVal, image) = self._video_capture.read()
return image
def start(self):
self._video_capture = VideoCapture(0)
self.shape = self.read().shape
def stop(self):
self._video_capture.release()
class Processer:
def __init__(self, input_file, output_file, FPS=30, max_count=-1):
self.vidcap = VideoCapture(input_file)
success, self.image = self.vidcap.read()
self.width = int(self.vidcap.get(4))
self.height = int(self.vidcap.get(3))
fourcc = VideoWriter_fourcc(*'XVID')
self.videoWriter = VideoWriter(output_file, fourcc, float(FPS),
(self.height, self.width))
self.max_count = max_count
def run(self, proc_func, end_proc=None):
count = 0
success = True
while success and (count < self.max_count or self.max_count == -1):
result = proc_func(self.image, count, self.width, self.height)
self.videoWriter.write(result)
success, self.image = self.vidcap.read()
print('Count:', count)
count += 1
if end_proc is not None:
end_proc(self.videoWriter)
self.videoWriter.release()
self.vidcap.release()
print('Total count:', count)
def stream():
prepare_stream()
global net, cap
cap = VideoCapture(2)
time.sleep(1)
while(True):
# Load frame from he camera
ret, frame = cap.read()
# Image pre-processing
frame = mx.nd.array(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)).astype('uint8')
# Apply GluonCV pre-processing
#rgb_nd, scaled_frame = gcv.data.transforms.presets.yolo.transform_test(frame, short=608, max_size=1024)
rgb_nd, scaled_frame = gcv.data.transforms.presets.ssd.transform_test(frame, short=512, max_size=1024)
# Run inference on the frame
class_IDs, scores, bounding_boxes = net(rgb_nd.as_in_context(mx.gpu(0)))
scale = 1.0 * frame.shape[0] / scaled_frame.shape[0]
img = gcv.utils.viz.cv_plot_bbox(frame.asnumpy(), bounding_boxes[0], scores[0], class_IDs[0],
class_names=klasses, scale=scale)
gcv.utils.viz.cv_plot_image(img)
# Display frame
#cv2.imshow('frame', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def main(filename, win_size, win_name, screen_fit=False, speed=1):
'''
opens window and responds to user input
closes when user presses "q"
'''
cap = VideoCapture(filename)
namedWindow(win_name, 1)
follow = None
while cap.isOpened():
if follow == 'q':
break
if follow in binds:
follow = play(binds[follow][0],
binds[follow][1],
cap,
win_size=win_size,
win_name=win_name,
speed=speed,
screen_fit=screen_fit)
else:
follow = wait(cap,
win_size=win_size,
win_name=win_name,
screen_fit=screen_fit)
cap.release()
destroyAllWindows()
def main(args):
apg1.add_argument("--subtitle", type=FileType("r"), help="subtitle file for -text")
apg1.add_argument("--subtitle-placeholder", type=str, default="#", help="placeholder for subtitle")
apg1.add_argument("--mon-background", type=str, default=None, help="replacement back-color for mon (default -key-color)")
readSrt = lambda it: srt.parse(it.read())
cfg = app.parse_args(args)
cfg.font = ImageFont.truetype(cfg.font, cfg.font_size) if cfg.font != None else ImageFont.load_default()
cfg.key_color = colorFromHtml(cfg.key_color)
print(f"{cfg.font_size}px, {cfg.key_color} ±{cfg.key_thres} {cfg.spacing}")
cfg.calc_draw_color = lambda c: None if isColorNearTo(cfg.key_color, cfg.key_thres, c) else c
for path in cfg.images:
(name, ext) = fileExtNameSplit(path)
if ext in "mp4 webm mkv flv".split(" "):
cap = VideoCapture(path)
(fps, count, width, height) = cv2VideoInfo(cap)
print(f"{fps}fps*{count} {width}x{height}")
mon = Montage(cfg, (width, height) )
playCvMontage(cap, mon, filename=f"{name}_mon.avi", subtitle=let(readSrt, cfg.subtitle), placeholder=cfg.subtitle_placeholder)
cap.release()
else:
image = Image.open(path)
mon = Montage(cfg, image.size)
mon.runOn(image).save(f"{name}_mon.png")
def camera(camflag, s4):
global vloop
#global camflag
try:
caps = VideoCapture(camflag)
_, fram = caps.read()
except:
s4.sendall(str.encode(b'cambusy'))
print('cam busy')
vloop = False
return 0
caps.release()
width, height, _ = fram.shape
caps = VideoCapture(camflag)
s4.sendall(str.encode(str(width) + ':' + str(height)))
while vloop:
ret, frame = caps.read()
a = gzip.compress(pickle.dumps(frame), 9)
s4.sendall(str.encode(str(len(a))))
while a:
chk = a[:3072]
s4.sendall(chk)
a = a[3072:]
time.sleep(0.4)
caps.release()
s4.close()
del s4
def draw_speed(video_path: str, speed_path: str, output_video: str) -> None:
reader = VideoCapture(video_path)
writer = VideoWriter(
output_video,
VideoWriter_fourcc(*"mp4v"),
20,
(640, 480),
)
data = loadtxt(speed_path, delimiter="\n", dtype="float32")
frame_id = 0
while reader.isOpened():
ret, frame = reader.read()
if not ret:
break
putText(
frame,
f"{data[frame_id]:0.3f}",
(250, 420),
FONT_HERSHEY_SIMPLEX,
0.7,
(255, 255, 255),
2,
)
writer.write(frame)
frame_id += 1
if frame_id == data.shape[0]:
break
reader.release()
writer.release()
def web_cam(face_detector=default_face_detector,
emotion_classifier=default_emotion_classifier):
video_capture = VideoCapture(0)
while True:
on_failed_to_load_camera(video_capture)
_, frame = video_capture.read()
face_bounding_boxes = face_detector.detect(image=frame)
draw_bounding_boxes(image=frame, bouding_boxes=face_bounding_boxes)
faces = extract_objects(
image=frame,
bounding_boxes=face_bounding_boxes,
)
if len(faces) != 0:
results = emotion_classifier.predict(images=faces, verbose=1)
for r, bbox in zip(results, face_bounding_boxes):
cv2.putText(frame,
str(r[0][0]), (bbox[0], bbox[-1]),
cv2.FONT_HERSHEY_SIMPLEX,
.5, (255, 255, 255),
lineType=cv2.LINE_AA)
if waitKey(1) & 0xFF == ord('q'):
break
imshow('Web Camera Emotion Classification', frame)
video_capture.release()
destroyAllWindows()
def captureImage(image_dir, number_of_images=3):
img_files_count = len([
name for name in os.listdir(image_dir)
if os.path.isfile(os.path.join(image_dir, name))
])
image_files = []
for i in range(0, number_of_images):
camera = VideoCapture(0)
if not camera.isOpened():
with open(LOGS_DIR + "error.log", "a") as f:
f.write("[Error " +
str(datetime.now().strftime("%b %d, %Y %H:%M:%S")) +
"] Could not open video device\n")
return_value, image = camera.read()
camera.release()
if not return_value:
continue
img_file = datetime.now().strftime(image_dir + "/image_%d%b%y-" +
str(img_files_count) + ".jpg")
imwrite(img_file, image)
image_files.append(img_file)
img_files_count += 1
sleep(3)
return image_files
def main():
if len(sys.argv) > 1:
casc_path = sys.argv[1]
else:
casc_path = "/usr/local/share/OpenCV/haarcascades/haarcascade_frontalface_default.xml" # Path on fedora 25
video_capture = VideoCapture(0)
face_detector = FaceDetector(casc_path, min_face_dim=(200, 200))
w, h = 0, 0
while True:
# Capture frame-by-frame
ret, frame = video_capture.read()
gray = cvtColor(frame, COLOR_RGB2GRAY)
faces = face_detector.detect(gray)
# Draw a rectangle around the faces
for (x, y, w, h) in faces:
rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
print(w, h)
if w > 300 and h > 300 and len(
faces) == 1 and GetCoffeeThread.nb_instance == 0:
imwrite("/tmp/face.png", frame[y:y + h, x:x + w])
GetCoffeeThread(GATEWAY_ROUTE, "/tmp/face.png").start()
# Display the resulting frame
imshow('Video', frame)
if waitKey(1) & 0xFF == ord('q'):
break
# When everything is done, release the capture
video_capture.release()
def extractFrames(frames, src, dst):
reader = VideoCapture(src)
frame_num = 1
while reader.isOpened():
running, frame = reader.read()
if not running:
break
if frame_num > frames:
break
#Extract face, with 25 pixels margin
loc = face_recognition.face_locations(frame)
if (len(loc) == 0):
face = frame
else:
loc = sorted(
loc,
key=cmp_to_key(lambda x, y: (y[2] - y[0]) * (y[1] - y[3]) -
(x[2] - x[0]) * (x[1] - x[3])))
face = frame[loc[0][0] - 25:loc[0][2] + 25,
loc[0][3] - 25:loc[0][1] + 25]
face = cv2.resize(face, (299, 299))
imwrite(join(dst, '%d.jpg' % frame_num), face)
frame_num += 1
reader.release()
def GetFrames(fileName, redFact=0.5, skipLength=1, debug=False):
'''
returns numpy array of frames
'''
cap = VideoCapture(fileName)
frameList = []
cnt = -1
if debug:
print("Started creating Frame List")
while True:
retval, image = cap.read()
cnt = (cnt + 1) % skipLength
if (cnt != 0):
continue
if not retval:
break
image = cv2.resize(image, None, fx=redFact, fy=redFact)
image = image[:, :, ::-1]
image = np.array(image, dtype=np.uint8)
frameList.append(image)
cap.release()
if debug:
print("Finished creating Frame List")
frameList = np.array(frameList)
print("该视频总共抽取了", frameList.shape[0], "个帧文件")
return frameList
def main():
# 画像サイズ
img_shape = (224, 224, 3)
# 日本語辞書の読み込み
ja_labels = load_japanese_labels('src/imagenet_class_index_ja.json')
# カメラの初期化
cam = VideoCapture(0)
# モデルの読み込み
model = load_mobilenet(img_shape)
width = cam.get(CAP_PROP_FRAME_WIDTH)
height = cam.get(CAP_PROP_FRAME_HEIGHT)
fps = cam.get(CAP_PROP_FPS)
print("Image Capture FPS: %d" % (fps))
print('Image Capture Size: width=%d height=%d' % (width, height))
# Julisu へ接続
sock = connect_julius()
# Hello, Raspberry Pi!
call_jtalk("おはようございます。")
try:
while True:
data = receive_voice(sock, cam)
if data != "":
execute_command(data, cam, model, ja_labels)
except KeyboardInterrupt:
print("Bye.")
cam.release()
def videoGetter(filename,
outdir='out/prepro/',
update_rate=50):
DEST_IMG_SIZE = (270, 480)
cap = VideoCapture(filename)
frameCount = int(cap.get(CAP_PROP_FRAME_COUNT))
frameWidth = int(cap.get(CAP_PROP_FRAME_WIDTH))
frameHeight = int(cap.get(CAP_PROP_FRAME_HEIGHT))
status = Progbar(frameCount, text=filename)
# Note that for some reason, cv2 reads images hieght and then width
buf = empty(
(frameCount, DEST_IMG_SIZE[1], DEST_IMG_SIZE[0], 3), dtype('int8'))
raw = empty((frameWidth, frameHeight, 3), dtype('uint8'))
middle = empty((DEST_IMG_SIZE[1], DEST_IMG_SIZE[0], 3), dtype('uint8'))
fc = 0
ret = True
while (fc < frameCount and ret):
ret, temp = cap.read()
middle[:, :, :] = resize(
raw, None, fx=0.25, fy=0.25, interpolation=INTER_AREA)
buf[fc] = (middle.astype('int8') - 255 // 2)
if fc % update_rate == 0:
status.update(fc)
fc += 1
cap.release()
del cap, raw, middle
filename = filename.rsplit('/', 1)[1]
outpath = outdir + filename.rsplit('.', 1)[0] + '.npy'
return save(outpath, buf)
def video2imgs(self, video, size):
from cv2 import VideoCapture
from cv2 import cvtColor, resize
from cv2 import COLOR_BGR2GRAY
from cv2 import INTER_AREA
img_list = []
# 从指定文件创建一个VideoCapture对象
cap = VideoCapture(video)
# 如果cap对象已经初始化完成了，就返回true，换句话说这是一个 while true 循环
while cap.isOpened():
# cap.read() 返回值介绍：
# ret 表示是否读取到图像
# frame 为图像矩阵，类型为 numpy.ndarry.
ret, frame = cap.read()
if ret:
# 转换成灰度图，也可不做这一步，转换成彩色字符视频。
gray = cvtColor(frame, COLOR_BGR2GRAY)
# resize 图片，保证图片转换成字符画后，能完整地在命令行中显示。
img = resize(gray, size, interpolation=INTER_AREA)
# 分帧保存转换结果
img_list.append(img)
else:
break
# 结束后释放空间
cap.release()
return img_list
def WebCam_OnOff(device_num: int,
cam: cv2.VideoCapture = None) -> cv2.VideoCapture:
"""
WebCameraを読み込む関数
Args:
device_num (int):
カメラデバイスを番号で指定
0: PC内臓カメラ
1: 外部カメラ
cam (cv2.VideoCapture):
接続しているカメラ情報
Return:
response (int):
動作終了を表すフラグ
0: カメラを開放した
1: カメラに接続した
-1: エラー
cam (cv2.VideoCapture):
接続したデバイス情報を返す
"""
if cam is None: # カメラが接続されていないとき
cam = cv2.VideoCapture(device_num)
# カメラに接続できなかった場合
if not cam.isOpened():
return -1, None
# 接続できた場合
else:
return 1, cam
else: # カメラに接続されていたとき
cam.release()
return 0, None
def load_background(self):
try:
bg = np.load(self.fh.make_path('background.npz',mode=self.fh.BL))
background = bg['computations']
background_image = bg['image']
except:
blmov = VideoCapture(self.fh.get_path(self.fh.BL,self.fh.MOV))
valid, background, ts = self.get_frame(blmov, n=-1, blur=True)
blmov.release()
blmov = VideoCapture(self.fh.get_path(self.fh.BL,self.fh.MOV))
valid, background_image, ts = self.get_frame(blmov, n=-1, blur=False)
blmov.release()
np.savez(self.fh.make_path('background.npz',mode=self.fh.BL), computations=background, image=background_image)
self.background, self.background_image = background, background_image
def caputure():
# open Camera
cam = VideoCapture(0)
if not cam.isOpened():
LOGGER.debug('FAILED to open camera!!!')
return None
# capture image
for i in range(100):
status, img = cam.read()
if not status:
LOGGER.debug('FAiLED to capture image!!!')
return None
cam.release()
return img
def video_loop(aframes_queue,person_queue):
vc = VideoCapture(0)
rval, frame = vc.read()
people = {}
colors = ((0,0,255),(255,255,0))
while True:
rval, frame = vc.read()
if frame is None:
c = waitKey(10)
continue
aframe = NP.asarray(frame[:,:])
im = Image.fromarray(frame)
draw = ImageDraw.Draw(im)
while not person_queue.empty():
name,rect,name_size = person_queue.get()
people[name] = {'rect' : rect, 'name_size' : name_size,
'time_found' : time.time()}
name_counter = 0
for name in people.keys():
if name_counter < 2:
draw_name(draw, people[name], name, name_counter, colors[name_counter])
name_counter += 1
if time.time()>people[name]['time_found']+2:
# stop displaying after 2 seconds
people.pop(name)
frame2 = NP.array(im)
imshow('frame',frame2)
if aframes_queue.empty():
aframes_queue.put(aframe)
c = waitKey(1)
if c == 27: # exit on ESC
break
vc.release()
destroyAllWindows()
def load_background(self):
try:
bg = np.load(os.path.join(self.background_dir,'%s_background.npz'%self.background_name))
background = bg['computations']
background_image = bg['image']
except:
#print "Acquiring background information..."
#print os.path.join(self.background_dir, self.background_name+'-cam0.avi')
try:
blmov = VideoCapture(os.path.join(self.background_dir, self.background_name+'-cam.avi'))
except:
blmov = VideoCapture(os.path.join(self.background_dir, self.background_name+'-cam0.avi'))
valid, background = self.get_frame(blmov, n=-1, blur=True)
blmov.release()
try:
blmov = VideoCapture(os.path.join(self.background_dir, self.background_name+'-cam.avi'))
except:
blmov = VideoCapture(os.path.join(self.background_dir, self.background_name+'-cam0.avi'))
valid, background_image = self.get_frame(blmov, n=-1, blur=False)
blmov.release()
np.savez(os.path.join(self.background_dir,'%s_background'%self.background_name), computations=background, image=background_image)
return background, background_image
class camera(object):
'''
Object containing camera information
Call-able, retrieve current frame in camera buffer
User accessible attributes:
device system device number
resolution camera resolution
BGRimage image in BGR format
HSVimage image in HSV format
RGBimage image in RGB format
FPS camera speed in FPS
User accessible methods:
close close camera device
'''
def __init__(self, cam_num = -1, resolution = (640, 480)):
'''
create camera object
cam_num device number (integer)
resolution image resolution (tuple width x height)
'''
self.device = cam_num
self.resolution = resolution
self.BGRimage = []
self.HSVimage = []
self.RGBimage = []
self.FPS = [0, 0]
self.__avr = 0
#assign and open device
self.__capture = VideoCapture(cam_num)
self.__capture.set(CV_CAP_PROP_FRAME_WIDTH,resolution[0])
self.__capture.set(CV_CAP_PROP_FRAME_HEIGHT,resolution[1])
self.__capture.open
self.__flag = False
t0 = time()
self.__flag, self.BGRimage = self.__capture.read()
self.FPS[0] = 1/(time()-t0)
self.FPS[1] = self.FPS[0]
self.__avr = self.FPS[0]
print "camera", self.device, "ready @", self.FPS[0], "fps"
return
def __call__(self, frame_delay = 0, fast = False):
'''
retrieve current frame in camera buffer
frame_delay delay the frame decoding (integer)
fast if true don't decode image to RGB format (logic)
'''
#set timer to meassure fps
self.__avr = self.FPS[1]
t0 = time()
#try to retrieve current frame
while not self.__flag:
if frame_delay > 0:
for i in xrange(frame_delay + 1):
self.__capture.grab()
self.__flag, self.BGRimage = self.__capture.retrieve()
del i
else:
self.__flag, self.BGRimage = self.__capture.read()
self.__flag = False
#decode bgr format to hsv
self.HSVimage = cvtColor(self.BGRimage, CV_BGR2HSV)
if fast:
self.FPS[0] = 1/(time()-t0)
self.FPS[1] = (self.FPS[0]+self.__avr)/2
return
#decode bgr format to rgb
self.RGBimage = cvtColor(self.BGRimage, CV_BGR2RGB)
self.FPS[0] = 1/(time()-t0)
self.FPS[1] = (self.FPS[0]+self.__avr)/2
return
def __str__(self):
'''
return camera information;
device number
device resolution
instant speed
average speed
'''
tmp = "camera object @ dev "+str(self.device)+", resolution: "+str(self.resolution)
tmp = tmp +", fps: "+str(self.FPS[0])+", Avr. fps: "+str(self.FPS[1])
return tmp
def __del__(self):
'''
when the object is deleted, it closes the device
'''
self.close()
return
def close(self):
'''
close device, making it available to use
'''
#if the device is open then close it
if self.__capture.isOpened():
self.__capture.release()
print "camera", self.device, "closed"
return
print "At frame: ", video.get(1)
print "Total frames: ", frame_count, "vs. ", video.get(7)
# sleep(10)
width,height = frame_count, int(np.ceil(frame_count/(16.0/9)))
# barcode = Image.new('RGB', (width, height), (255,255,255))
# draw = ImageDraw.Draw(barcode)
# f = open("barcode.jpg", 'w')
f = open("color_codes.txt", 'a')
condition,frame = video.read()
while condition:
print "Processing frame %d" % count
# color = findColor(frame)
if count % 3 == 0:
color = findColor(frame)
f.write(str(color) + "\n")
# draw.line([(count/3,0), (count/3,height)], fill=tuple(color), width=1)
count += 1
condition,frame = video.read()
# if count == 2:
# break
print "%0.3f % complete." % (video.get(1)/video.get(7))
# barcode.save(f)
# print "Saved."
# plt.clf()
# plt.imshow(barcode)
# plt.show()
# barcode.save(f)
f.close()
video.release()
print "Total time: %0.5f seconds." % (time() - t)
class Camera(object):
''' Communicate with the camera.
Class governing the communication with the camera.
Parameters
-----------
camera : int
the index of the camera, best taken from func lookForCameras,
from eyetracker.camera.capture
dic : dic{propID value}
to check corresponding propIDs check
opencv documentation under the term VideoCapture.
They will be set in the moment of object creation.
Defines
--------
self.camera : index of the camera
self.cap : capturing object
self.frame : returns a frame from camera
self.close : closes cap
self.reOpen : reopens cap
'''
def __init__(self, camera, dic=None):
self.camera = int(camera)
self.cap = VideoCapture(self.camera)
if dic:
for propID, value in dic.iteritems():
self.cap.set(propID, value)
first_frame = self.frame()
def frame(self):
''' Read frame from camera.
Returns
--------
frame : np.array
frame from camera
'''
if self.cap.isOpened:
return self.cap.read()[1]
else:
print 'Cap is not opened.'
return None
def set(self, **kwargs):
''' Set camera parameters.
Parameters
-----------
kwargs : {propID : value}
'''
for propID, value in kwargs.iteritems():
self.cap.set(propID, value)
def close(self):
''' Closes cap, you can reopen it with self.reOpen.
'''
self.cap.release()
def reOpen(self, cameraIndex):
''' Reopens cap.
'''
self.cap.open(self.camera)
first_frame = self.frame()
class MouseTracker(object):
def __init__(self, mouse, mode, data_directory='.', diff_thresh=100, resample=8, translation_max=100, smoothing_kernel=19, consecutive_skip_threshold=2, selection_from=[]):
self.mouse = mouse
self.data_dir = data_directory
self.mode = mode
self.selection_from = selection_from
# Parameters (you may vary)
self.diff_thresh = diff_thresh
self.resample = resample
self.translation_max = translation_max
self.kernel = smoothing_kernel
self.consecutive_skip_threshold = (37./self.resample) * consecutive_skip_threshold
# Parameters (you should not vary)
self.duration = 1
self.cth1 = 0
self.cth2 = 0
plat = sys.platform
if 'darwin' in plat:
self.fourcc = CV_FOURCC('m','p','4','v')
elif plat[:3] == 'win':
self.fourcc = 1
else:
self.fourcc = -1
fh = FileHandler(self.data_dir, self.mouse)
self.background_name = fh[mode][BACKGROUND][NAME]
self.background_dir = fh[mode][BACKGROUND][DIR]
self.trial_name = fh[mode][TRIAL][NAME]
self.trial_dir = fh[mode][TRIAL][DIR]
self.background, self.background_image = self.load_background()
self.height, self.width = np.shape(self.background)
timefile = os.path.join(self.trial_dir, self.trial_name+'-timestamps.json')
self.time = json.loads(open(timefile,'r').read())
vidfile = os.path.join(self.trial_dir, self.trial_name+'-cam.avi')
if not os.path.exists(vidfile):
vidfile = os.path.join(self.trial_dir, self.trial_name+'-cam0.avi')
if not os.path.exists(vidfile):
raise Exception('Movie %s not found.'%vidfile)
self.mov = VideoCapture(vidfile)
self.results = {}
self.results['centers'] = []
self.results['centers_all'] = []
self.results['left'] = 0
self.results['right'] = 0
self.results['middle'] = 0
self.results['left_assumed'] = 0
self.results['right_assumed'] = 0
self.results['middle_assumed'] = 0
self.results['skipped'] = 0
self.results['heat'] = np.zeros(np.shape(self.background))
self.results['n_frames'] = 0
self.results['params'] = [self.diff_thresh, self.kernel, self.translation_max, self.resample]
self.results['params_key'] = ['diff_thresh','kernel','translation_max','resample']
self.path_l, self.path_r, self.path_c, self.rooms_mask, self.paths_ignore, self.last_center = self.get_pt_selections()
def end(self):
np.savez(os.path.join(self.trial_dir,'%s_tracking'%self.trial_name), **self.results)
savemat(os.path.join(self.trial_dir,'%s_tracking'%self.trial_name), self.results)
self.mov.release()
destroyAllWindows()
def get_pt_selections(self):
valid,first = self.get_frame(self.mov, blur=False, n=30)
try: #did they select for this trial
pts = np.load(os.path.join(self.trial_dir, '%s_selections.npz'%self.trial_name))
pts_l = pts['pts_l']
pts_r = pts['pts_r']
pts_c = pts['pts_c']
pts_mouse = pts['pts_mouse']
regions_ignore = pts['regions_ignore']
except:
found_rooms = False
found_ignore = False
for sf in self.selection_from:
fh = FileHandler(self.data_dir, sf)
s_trial_name = fh[self.mode][TRIAL][NAME]
s_trial_dir = fh[self.mode][TRIAL][DIR]
try:
pts = np.load(os.path.join(s_trial_dir, '%s_selections.npz'%s_trial_name))
if not found_rooms:
pts_l = pts['pts_l']
pts_r = pts['pts_r']
pts_c = pts['pts_c']
plimshow(first, cmap=mpl_cm.Greys_r)
title('Good room corners? If so, click image, otherwise, close window.')
scatter(pts_l[:,0], pts_l[:,1], c='b', marker='o')
scatter(pts_r[:,0], pts_r[:,1], c='r', marker='o')
scatter(pts_c[:,0], pts_c[:,1], c='g', marker='o')
use_rooms = ginput(1)
close()
if use_rooms.any():
found_rooms = True
if not found_ignore:
plimshow(first, cmap=mpl_cm.Greys_r)
title('Good ignore regions? If so, click image, otherwise, close window.')
regions_ignore = pts['regions_ignore']
[scatter(ptsi[:,0], ptsi[:,1], c='k',marker='x') for ptsi in regions_ignore]
use_ignore = ginput(1)
close()
if use_ignore.any():
found_ignore = True
if found_rooms and found_ignore:
break
except:
pass
plimshow(first, cmap=mpl_cm.Greys_r)
title("Select mouse (4 pts).")
pts_mouse = ginput(4)
if not found_rooms:
title("Select left room- around the corners in order.")
pts_l = ginput(4)
title("Select right room- around the corners in order.")
pts_r = ginput(4)
title("Select middle room- around the corners in order.")
pts_c = ginput(4)
if not found_ignore:
valid,frame = self.get_frame(self.mov)
diff = absdiff(frame,self.background)
_, diff = threshold(diff, self.diff_thresh, 1, THRESH_BINARY)
plimshow(np.ma.masked_where(diff==0, diff), cmap=mpl_cm.jet)
regions_ignore = []
pts_ignore = [1]
title("Select cups and any other region to ignore. (10 pts per)")
while True:
pts_ignore = ginput(10)
if not pts_ignore.any():
break
regions_ignore.append(pts_ignore)
regions_ignore = np.array(regions_ignore)
close()
np.savez(os.path.join(self.trial_dir, '%s_selections'%self.trial_name), pts_l=pts_l, pts_r=pts_r, pts_c=pts_c, pts_mouse=pts_mouse, regions_ignore=regions_ignore)
savemat(os.path.join(self.trial_dir, '%s_selections'%self.trial_name), dict(pts_l=pts_l, pts_r=pts_r, pts_c=pts_c, pts_mouse=pts_mouse, regions_ignore=regions_ignore)) #THIS LINE
path_l, path_r, path_c = [mpl_path.Path(pts) for pts in [pts_l,pts_r,pts_c]]
last_center = np.round(np.mean(pts_mouse, axis=0)).astype(int)
paths_ignore = [mpl_path.Path(pts) for pts in regions_ignore]
rooms_mask = np.zeros(np.shape(self.background))
for row in range(self.height):
for col in range(self.width):
pt = [col,row]
rooms_mask[row][col] = path_l.contains_point(pt) or path_r.contains_point(pt) or path_c.contains_point(pt)
return (path_l, path_r, path_c, rooms_mask, paths_ignore, last_center)
def load_background(self):
try:
bg = np.load(os.path.join(self.background_dir,'%s_background.npz'%self.background_name))
background = bg['computations']
background_image = bg['image']
except:
#print "Acquiring background information..."
#print os.path.join(self.background_dir, self.background_name+'-cam0.avi')
try:
blmov = VideoCapture(os.path.join(self.background_dir, self.background_name+'-cam.avi'))
except:
blmov = VideoCapture(os.path.join(self.background_dir, self.background_name+'-cam0.avi'))
valid, background = self.get_frame(blmov, n=-1, blur=True)
blmov.release()
try:
blmov = VideoCapture(os.path.join(self.background_dir, self.background_name+'-cam.avi'))
except:
blmov = VideoCapture(os.path.join(self.background_dir, self.background_name+'-cam0.avi'))
valid, background_image = self.get_frame(blmov, n=-1, blur=False)
blmov.release()
np.savez(os.path.join(self.background_dir,'%s_background'%self.background_name), computations=background, image=background_image)
return background, background_image
def get_frame(self, mov, n=1, skip=0, blur=True):
for s in range(skip):
valid,fr = mov.read()
if not valid:
return (False, None)
if n==-1:
n = 1e10
def get():
valid, frame = mov.read()
if not valid:
return (False, None)
frame = frame.astype(np.float32)
frame = cvtColor(frame, CV_RGB2GRAY)
if blur:
frame = GaussianBlur(frame, (self.kernel,self.kernel), 0)
return valid,frame
valid,frame = get()
i = 1
while valid and i<n:
valid,new = get()
i += 1
if valid:
frame += new
if frame is not None:
frame = frame/i
return (valid, frame)
def run(self, show=False, save=False, tk_var_frame=None):
if show:
namedWindow('Movie')
namedWindow('Tracking')
if save:
bgs = np.shape(self.background)
fsize = (bgs[0], bgs[1]*2)
writer = VideoWriter()
writer.open(os.path.join(self.trial_dir,'%s_tracking_movie'%self.trial_name),self.fourcc,37.,frameSize=(fsize[1],fsize[0]),isColor=True)
self.results['n_frames'] = 0
consecutive_skips = 0
while True:
valid,frame = self.get_frame(self.mov,skip=self.resample-1)
if not valid:
break
diff = absdiff(frame,self.background)
_, diff = threshold(diff, self.diff_thresh, 1, THRESH_BINARY)
diff = diff*self.rooms_mask
edges = Canny(diff.astype(np.uint8), self.cth1, self.cth2)
contours, hier = findContours(edges, RETR_EXTERNAL, CHAIN_APPROX_TC89_L1)
contours = [c for c in contours if not any([pa.contains_point(contour_center(c)) for pa in self.paths_ignore])]
if consecutive_skips>self.consecutive_skip_threshold:
consecutive_skips=0
possible = contours
else:
possible = [c for c in contours if dist(contour_center(c),self.last_center)<self.translation_max]
if len(possible) == 0:
center = self.last_center
self.results['skipped'] += 1
consecutive_skips+=1
if self.path_l.contains_point(center):
self.results['left_assumed']+=1
if self.path_r.contains_point(center):
self.results['right_assumed']+=1
if self.path_c.contains_point(center):
self.results['middle_assumed']+=1
else:
chosen = possible[np.argmax([contourArea(c) for c in possible])]
center = contour_center(chosen)
self.results['centers'].append(center)
self.results['heat'][center[1],center[0]] += 1
if self.path_l.contains_point(center):
self.results['left']+=1
if self.path_r.contains_point(center):
self.results['right']+=1
if self.path_c.contains_point(center):
self.results['middle']+=1
self.results['centers_all'].append(center)
#display
if show or save:
showimg = np.copy(frame).astype(np.uint8)
if self.path_l.contains_point(center):
color = (0,0,0)
elif self.path_r.contains_point(center):
color = (255,255,255)
else:
color = (120,120,120)
circle(showimg, tuple(center), radius=10, thickness=5, color=color)
if show:
cv2imshow('Movie',showimg)
cv2imshow('Tracking', diff)
waitKey(1)
#/display
if save:
save_frame = np.zeros([fsize[0], fsize[1], 3],dtype=np.uint8)
save_frame[:,:np.shape(frame)[1]] = cvtColor(showimg.astype(np.float32), CV_GRAY2RGB)
save_frame[:,np.shape(frame)[1]:] = cvtColor((diff*255).astype(np.float32), CV_GRAY2RGB)
writer.write(save_frame)
self.results['n_frames'] += 1
self.last_center = center
if tk_var_frame != None:
tk_var_frame[0].set('%i/%i'%(self.results['n_frames'], len(self.time)/float(self.resample) ))
tk_var_frame[1].update()
#pbar.update(self.results['n_frames'])
#pbar.finish()
if save:
writer.release()
self.end()
ret, temp = video_capture.read()
#temp = pyrDown(temp)
frame2 = _putmoustache_(temp)
frame3 = _putglass_(frame2)
frame3 = pyrDown(frame3)
#frame3 = pyrDown(frame3)
height, width = frame3.shape[:2]
for i in range(1, height, 4):
for j in range(1, width, 4):
if background[i][j][0] - backgroundTreshold <= frame3[i][j][0] <= background[i][j][0] + backgroundTreshold:
if background[i][j][0] - backgroundTreshold <= frame3[i][j][1] <= background[i][j][1] + backgroundTreshold:
if background[i][j][0] - backgroundTreshold <= frame3[i][j][2] <= background[i][j][2] + backgroundTreshold:
for x in range(-2, 2):
for y in range(-2, 2):
frame3[i+x][j+y][0] = beach[i+x][j+y][0]
frame3[i+x][j+y][1] = beach[i+x][j+y][1]
frame3[i+x][j+y][2] = beach[i+x][j+y][2]
#frame3 = pyrUp(frame3)
frame3 = pyrUp(frame3)
imshow("Video", frame3)
waitKey(100)
video_capture.release()
destroyAllWindows()
def captureTStamp(files, duration, cod, fps=0, verbose=True):
'''
guarda por un tiempo en minutos (duration) el video levantado desde la
direccion indicada en el archvo indicado. tambíen archivos con los time
stamps de cada frame.
files = [ur, saveVideoFile, saveDateFile, saveMillisecondFile]
duration = time in mintes
cod = codec
fps = frames per second for video to be saved
verbose = print messages to screen
si fpscam=0 trata de llerlo de la captura. para fe hay que especificarla
para opencv '2.4.9.1'
Examples
--------
from cameraUtils import captureTStamp
# para la FE
duration = 1 # in minutes
files = ['rtsp://192.168.1.48/live.sdp',
"/home/alumno/Documentos/sebaPhDdatos/vca_test_video.avi",
"/home/alumno/Documentos/sebaPhDdatos/vca_test_tsFrame.txt"]
fpsCam = 12
cod = 'XVID'
captureTStamp(files, duration, cod, fps=fpsCam)
# %% para la PTZ
duration = 0.2 # in minutes
files = ["rtsp://192.168.1.49/live.sdp",
"/home/alumno/Documentos/sebaPhDdatos/ptz_test_video.avi",
"/home/alumno/Documentos/sebaPhDdatos/ptz_test_tsFrame.txt"]
fpsCam = 20
cod = 'XVID'
captureTStamp(files, duration, cod, fpsCam)
'''
fcc = fourcc(cod[0],cod[1],cod[2],cod[3]) # Códec de video
if verbose:
print(files)
print("Duration",duration,"minutes")
print("fps",fps)
print("codec",cod)
# Inicializacion
tFin = datetime.datetime.now() + datetime.timedelta(minutes=duration)
ts = list() # timestamp de la captura
# abrir captura
cap = VideoCapture(files[0])
while not cap.isOpened():
cap = VideoCapture(files[0])
print("capture opened")
# configurar writer
w = int(cap.get(frame_width))
h = int(cap.get(frame_height))
if not fps:
fps = cap.get(prop_fps)
#para fe especificar los fps pq toma cualquier cosa con la propiedad
out = VideoWriter(files[1], fcc, fps,( w, h), True)
if verbose:
print("capture open",cap.isOpened())
print("frame size",w,h)
print("output opened",out.isOpened())
if not out.isOpened() or not cap.isOpened():
out.release()
cap.release()
# exit function if unable to open cap or out
return
s0 = getsize(files[1]) # initial filesize before writing frame
# Primera captura
ret, frame = cap.read()
if ret:
t = datetime.datetime.now()
ts.append(t)
out.write(frame)
if verbose:
print("first frame captured")
# Segunda captura
ret, frame = cap.read()
if ret:
t = datetime.datetime.now()
ts.append(t)
out.write(frame)
if verbose:
print("second frame captured")
# Tercera captura
ret, frame = cap.read()
if ret:
t = datetime.datetime.now()
ts.append(t)
out.write(frame)
if verbose:
print("third frame captured")
s1 = getsize(files[1]) # size after saving 3 frames
if s1==s0:
out.release()
cap.release()
print("error when saving 3 frames, exiting")
return 1 # error while saving first frame to file
print(tFin)
# loop
while (t <= tFin):
ret, frame = cap.read()
if ret:
t = datetime.datetime.now()
ts.append(t)
out.write(frame)
if verbose:
print(tFin,t)
print("seconds elapsed",cap.get(pos_msec)/1000)
print(frame.size)
# end of loop
# release and save
out.release()
cap.release()
if verbose:
print('loop exited, cap, out released, times saved to files')
savetxt(files[2],ts, fmt= ["%s"])
return 0 # success
fontColor = (250,250,250)
gender1 = gender1+1
count = gender1 + gender2
dt = datetime.datetime.now()
time_milli_secs = unix_time(dt)
json = {'timestamp' : time_milli_secs, 'gender' : gender, 'count' : count, 'gender1' : gender1, 'gender2' : gender2}
insert_into_mongo(json)
x1, y1, w1, h1 = faceRegions[indx]
rectangle(img0,
(x1,y1),
(x1+w1,y1+h1),
(100,255,0),2)
putText(img=img0,
text='Gender: ' + gender,
org=(x1,y1+h1-10),
fontFace=CV_FONT_HERSHEY_DUPLEX,
fontScale=0.75,
color=fontColor)
imshow('appDemo', img0)
keyPressed = waitKey(2)
destroyAllWindows()
capture.release()
class MouseTracker(object):
def __init__(self, mouse, n=1, data_dir='.', diff_thresh=80, resample=1, translation_max=50, smoothing_kernel=19, consecutive_skip_threshold=0.08, selection_from=[], point_mode='auto'):
self.mouse = mouse
self.n = n
self.data_dir = data_dir
# Parameters (you may vary)
self.diff_thresh = diff_thresh
self.resample = resample
self.translation_max = translation_max
self.kernel = smoothing_kernel
# Parameters (you should not vary)
self.cth1 = 0
self.cth2 = 0
plat = sys.platform
if 'darwin' in plat:
self.fourcc = CV_FOURCC('m','p','4','v')
elif plat[:3] == 'win':
self.fourcc = 1
else:
self.fourcc = -1
self.fh = FileHandler(self.data_dir, self.mouse, self.n)
self.framei = 0
self.load_time()
self.consecutive_skip_threshold = (self.fs/self.resample) * consecutive_skip_threshold
self.load_background()
self.height, self.width = self.background.shape
self.mov = VideoCapture(self.fh.get_path(self.fh.TRIAL, self.fh.MOV))
self.mov.read();self.time=self.time[1:]
#self.get_frame(self.mov,n=40) #MUST ADJUST TIME IF USING THIS
self.load_pts(mode=point_mode)
self.make_rooms()
def end(self):
self.results = dict(pos=self.pos, time=np.array(self.t)-self.t[0], guess=self.guess, heat=self.heat, contour=self.contour, pct_xadj=self.pct_xadj)
np.savez(self.fh.make_path('tracking.npz'), **self.results)
savemat(self.fh.make_path('tracking.mat'), self.results)
self.mov.release()
destroyAllWindows()
def man_update(self, d):
for k,v in d.items():
setattr(self,k,v)
def make_rooms(self):
self.path_x = mpl_path.Path(self.pts[np.array([self.xmli,self.xoli,self.xori,self.xmri])])
self.path_y = mpl_path.Path(self.pts[np.array([self.ymli,self.yoli,self.yori,self.ymri])])
self.path_z = mpl_path.Path(self.pts[np.array([self.zmli,self.zoli,self.zori,self.zmri])])
#experimental: hand in frame on x room
self.path_x_adj = mpl_path.Path(self.pts[np.array([self.xoli,self.xoli_adj,self.xori_adj,self.xori])])
self.xadj_mask = np.zeros((self.height,self.width))
for iy in xrange(self.xadj_mask.shape[0]):
for ix in xrange(self.xadj_mask.shape[1]):
self.xadj_mask[iy,ix] = self.path_x_adj.contains_point([ix,iy])
self.xadj_idxs = np.squeeze(np.argwhere(self.xadj_mask==True))
self.border_mask = np.zeros((self.height,self.width))
pthpts = self.pts[np.array([self.yoli_adj,self.yori_adj,self.ymri,self.ycri,self.zmli,self.zoli_adj,self.zori_adj,self.zmri,self.zcri,self.xmli,self.xoli_adj,self.xori_adj,self.xmri,self.xcri,self.ymli])]
pth = mpl_path.Path(pthpts)
for iy in xrange(self.border_mask.shape[0]):
for ix in xrange(self.border_mask.shape[1]):
self.border_mask[iy,ix] = pth.contains_point([ix,iy])
def classify_pts(self):
#stored in (x,y)
#c: center
#m: middle
#o: out
#x: bottom arm, y: left arm, z: right arm
#l: left when going down arm, r: right when going down arm
#pt is: [x/y/z c/m/o l/r]
X,Y = 0,1
def nn(pidx,n,ex=[]):
#idxs of n closest pts to p, excluding all idxs in ex
p = self.pts[pidx]
ds = np.array([dist(pp,p) for pp in self.pts])
idxs = np.argsort(ds)
idxs = np.array([i for i in idxs if i not in ex])
return idxs[:n]
def sortby(pidxs, dim):
pts = self.pts[np.array(pidxs)]
return pidxs[np.argsort(pts[:,dim])]
dists = np.array([dist(self.pts_c, p) for p in self.pts])
c3i = self.c3i[np.argsort(self.pts[self.c3i][:,0])]
m6i = self.m6i
o6i = self.o6i
#classify them:
xcri=ycli=c3i[0]
ycri=zcli=c3i[1]
zcri=xcli=c3i[2]
temp = nn(xcri, 2, ex=c3i)
ymli,xmri = sortby(temp, Y)
temp = nn(ycri, 2, ex=c3i)
ymri,zmli = sortby(temp, X)
temp = nn(zcri, 2, ex=c3i)
zmri,xmli = sortby(temp, Y)
cm9 = [xcri,ycri,zcri,xmri,xmli,ymri,ymli,zmri,zmli]
xoli = nn(xmli, 1, ex=cm9)[0]
xori = nn(xmri, 1, ex=cm9)[0]
yoli = nn(ymli, 1, ex=cm9)[0]
yori = nn(ymri, 1, ex=cm9)[0]
zoli = nn(zmli, 1, ex=cm9)[0]
zori = nn(zmri, 1, ex=cm9)[0]
#accounting for inner wall reflections:
zol,zml = np.array([self.pts[zoli],self.pts[zmli]]).astype(np.int32)
dd = np.sqrt(np.sum((zol-zml)**2))
cup_dd = 0.80*dd
#z cup:
zol,zml = np.array([self.pts[zoli],self.pts[zmli]]).astype(np.int32)
d_zl = zol-zml
theta_zl = np.arctan2(*d_zl)
l2 = zml + cup_dd * np.array([np.sin(theta_zl),np.cos(theta_zl)])
zor,zmr = np.array([self.pts[zori],self.pts[zmri]]).astype(np.int32)
d_zr = zor-zmr
theta_zr = np.arctan2(*d_zr)
r2 = zmr + cup_dd * np.array([np.sin(theta_zr),np.cos(theta_zr)])
zr2,zl2 = r2,l2
#y cup:
yol,yml = np.array([self.pts[yoli],self.pts[ymli]]).astype(np.int32)
d_yl = yol-yml
theta_yl = np.arctan2(*d_yl)
l2 = yml + cup_dd * np.array([np.sin(theta_yl),np.cos(theta_yl)])
yor,ymr = np.array([self.pts[yori],self.pts[ymri]]).astype(np.int32)
d_yr = yor-ymr
theta_yr = np.arctan2(*d_yr)
r2 = ymr + cup_dd * np.array([np.sin(theta_yr),np.cos(theta_yr)])
yr2,yl2 = r2,l2
#x cup:
xol,xml = np.array([self.pts[xoli],self.pts[xmli]]).astype(np.int32)
d_xl = xol-xml
theta_xl = np.arctan2(*d_xl)
l2 = xml + cup_dd * np.array([np.sin(theta_xl),np.cos(theta_xl)])
xor,xmr = np.array([self.pts[xori],self.pts[xmri]]).astype(np.int32)
d_xr = xor-xmr
theta_xr = np.arctan2(*d_xr)
r2 = xmr + cup_dd * np.array([np.sin(theta_xr),np.cos(theta_xr)])
xr2,xl2 = r2,l2
self.pts = np.rint(np.concatenate((self.pts, [zr2,zl2,yr2,yl2,xr2,xl2])))
pts_dict = dict(pts=self.pts,xcri=xcri,ycli=ycli,ycri=ycri,zcli=zcli,zcri=zcri,xcli=xcli,xmri=xmri,ymli=ymli,ymri=ymri,zmli=zmli,xmli=xmli,zmri=zmri,xoli=xoli,xori=xori,yoli=yoli,yori=yori,zoli=zoli,zori=zori,zori_adj=-6,zoli_adj=-5,yori_adj=-4,yoli_adj=-3,xori_adj=-2,xoli_adj=-1)
self.man_update(pts_dict)
np.savez(self.fh.make_path('pts.npz', mode=self.fh.BL), **pts_dict)
def verify_pts(self, add_to_all=True):
if add_to_all:
self.all_possible_pts += list(self.pts)
if len(self.pts) < 15:
return False
if len(self.pts) > 25:
return False
elif len(self.pts) > 15:
allperms = np.array(list(it.combinations(range(len(self.pts)), 15)))
if len(allperms)>200:
totryi = np.random.choice(range(len(allperms)),200,replace=False)
totryi = allperms[totryi]
else:
totryi = allperms
elif len(self.pts) == 15:
totryi = [range(15)]
for ptsi in totryi:
pts = self.pts[ptsi]
self.pts_c = np.mean(pts,axis=0)
dists = np.array([dist(self.pts_c, p) for p in pts])
c3i = np.argsort(dists)[:3]
m6i = np.argsort(dists)[3:9]
o6i = np.argsort(dists)[9:]
good = True
#test dists from center
if np.std(dists[c3i]) > 1. or np.std(dists[m6i]) > 1. or np.std(dists[o6i]) > 2.5:
good = False
#x = self.background.copy()
#for pt in pts:
# cv2.circle(x, tuple(pt), 4, (255,255,255), thickness=3)
#pl.figure(2);pl.imshow(x)
#raw_input()
##
#test outer dists from each other
o6 = pts[o6i]
omindists = np.array([np.min(np.array([dist(p,pp) for p in o6])) for pp in o6])
if np.std(omindists) > 0.6:
good = False
#test middle dists from each other
m6 = pts[m6i]
mmindists = np.array([np.min(np.array([dist(p,pp) for p in m6])) for pp in m6])
if np.std(mmindists) > 0.6:
good = False
if good:
self.c3i = c3i
self.m6i = m6i
self.o6i = o6i
self.pts = pts
return True
return False
def permute_pts(self):
#NOT IN USE
apts = np.array(self.all_possible_pts)
unpts = []
for pt in apts:
if len(unpts)==0:
unpts.append(pt)
else:
dists = np.sqrt(np.sum((pt-np.array(unpts))**2,axis=1))
mindist = np.min(dists)
if mindist > 5:
unpts.append(pt)
unpts = np.array(unpts)
if len(unpts)<15:
return False
for _ in xrange(10000):
testpts = np.random.choice(np.arange(len(unpts)),15, replace=False)
testpts = unpts[testpts]
self.pts = testpts
##
#x = self.background.copy()
#for pt in self.pts:
# cv2.circle(x, tuple(pt), 4, (255,255,255), thickness=3)
#pl.figure(2);pl.imshow(x)
##
if self.verify_pts(add_to_all=False):
return True
return False
def load_pts(self, mode='auto'):
try:
self.man_update(np.load(self.fh.make_path('pts.npz', mode=self.fh.BL)))
except:
if mode == 'auto':
self.all_possible_pts = []
invalid = True
attempts = 0
while invalid:
if attempts > 500:
raise Exception('Pts cannot be found.')
img = self.background_image.copy()
lp_ksizes = [13,15,17,19,21,23,25] #from 5-15 before
lp_ksize = rand.choice(lp_ksizes)
sbd_areas = [range(3,20), range(61,140)] #8,26 46,55
sbd_area = [rand.choice(sbd_areas[0]), rand.choice(sbd_areas[1])]
sbd_circs = [np.arange(0.05,0.35), range(1000,1001)]#0.19,0.35 1000
sbd_circ = [rand.choice(sbd_circs[0]), rand.choice(sbd_circs[1])]
subtr_rowmeans = rand.choice([True,False])
if subtr_rowmeans:
img = img-np.mean(img,axis=1)[:,None]
img = cv2.Laplacian(img, cv2.CV_32F, ksize=lp_ksize)
img += abs(img.min())
img = img/img.max() *255
img = img.astype(np.uint8)
#pl.figure(1);pl.imshow(img,cmap=pl.cm.Greys_r)
params = cv2.SimpleBlobDetector_Params()
params.filterByArea = True
params.filterByCircularity = True
params.minArea,params.maxArea = sbd_area
params.minCircularity,params.maxCircularity = sbd_circ
detector = cv2.SimpleBlobDetector(params)
fs = detector.detect(img)
pts = np.array([f.pt for f in fs])
pts = np.round(pts).astype(np.uint32)
x = img.copy()
for pt in pts:
cv2.circle(x, tuple(pt), 4, (255,255,255), thickness=3)
#pl.figure(2);pl.imshow(x);raw_input()
self.pts = pts
invalid = not self.verify_pts()
attempts += 1
elif mode == 'manual':
pl.imshow(self.background_image, cmap=pl.cm.Greys_r)
pl.title('center3->middle6->outer6')
pts = pl.ginput(n=15, timeout=-1)
pts = np.round(pts).astype(np.uint32)
self.pts = np.array(pts)
pl.close()
# note that verify is being skipped
self.c3i,self.m6i,self.o6i = np.arange(0,3),np.arange(3,9),np.arange(9,15)
self.pts_c = np.mean(self.pts, axis=0)
self.classify_pts()
def load_time(self):
with open(self.fh.get_path(self.fh.TRIAL,self.fh.TIME),'r') as f:
self.time = np.array(json.loads(f.read()))
self.Ts = np.mean(self.time[1:]-self.time[:-1])
self.fs = 1/self.Ts
def load_background(self):
try:
bg = np.load(self.fh.make_path('background.npz',mode=self.fh.BL))
background = bg['computations']
background_image = bg['image']
except:
blmov = VideoCapture(self.fh.get_path(self.fh.BL,self.fh.MOV))
valid, background, ts = self.get_frame(blmov, n=-1, blur=True)
blmov.release()
blmov = VideoCapture(self.fh.get_path(self.fh.BL,self.fh.MOV))
valid, background_image, ts = self.get_frame(blmov, n=-1, blur=False)
blmov.release()
np.savez(self.fh.make_path('background.npz',mode=self.fh.BL), computations=background, image=background_image)
self.background, self.background_image = background, background_image
def get_frame(self, mov, n=1, skip=0, blur=True):
for s in range(skip):
mov.read()
self.framei += 1 #the number of frames that have been read
if n==-1:
n = 99999999999999999.
def get():
valid, frame = mov.read()
if not valid:
return (False, None, None)
ts = self.time[self.framei]
self.framei += 1
frame = frame.astype(np.float32)
frame = cvtColor(frame, CV_RGB2GRAY)
if blur:
frame = GaussianBlur(frame, (self.kernel,self.kernel), 0)
return valid,frame,ts
valid,frame,ts = get()
i = 1
while valid and i<n:
valid,new,ts = get()
i += 1
if valid:
frame += new
if frame is not None:
frame = frame/i
return (valid, frame, ts)
def find_possible_contours(self, frame, consecutive_skips):
self.diff = absdiff(frame,self.background)
_, self.diff = threshold(self.diff, self.diff_thresh, 1, THRESH_BINARY)
diff_raw = self.diff.copy()
self.diff = self.diff*self.border_mask
edges = Canny(self.diff.astype(np.uint8), self.cth1, self.cth2)
contours, hier = findContours(edges, RETR_EXTERNAL, CHAIN_APPROX_TC89_L1)
#contours = [c for c in contours if not any([pa.contains_point(contour_center(c)) for pa in self.paths_ignore])]
if consecutive_skips>self.consecutive_skip_threshold:
consecutive_skips=0
possible = contours
else:
possible = [c for c in contours if dist(contour_center(c),self.last_center)<self.translation_max]
return possible, diff_raw
def choose_best_contour(self, possible):
chosen = possible[np.argmax([cv2.arcLength(c,False) for c in possible])] #arcLength or contourArea
center = contour_center(chosen,asint=True)[0]
return chosen,center
def label_frame(self, frame, center):
showimg = np.copy(frame).astype(np.uint8)
if self.path_x.contains_point(center):
color = (0,0,0)
elif self.path_y.contains_point(center):
color = (210,210,210)
elif self.path_z.contains_point(center):
color = (100,100,100)
else:
color = (255,255,255)
circle(showimg, tuple(center), radius=10, thickness=5, color=color)
for pt in self.pts.astype(int):
circle(showimg, tuple(pt), radius=4, thickness=3, color=(0,0,0))
return showimg
def show_frame(self, frame, wait=1):
cv2imshow('Tracking',frame)
waitKey(wait)
def run(self, show=False, save=False, tk_var_frame=None, wait=1, start_pos='none'):
#interfaces
if show or save:
fsize = (self.width*2, self.height)
save_frame = np.zeros([self.height, self.width*2, 3], dtype=np.uint8)
if show:
namedWindow('Tracking')
if save:
writer = VideoWriter()
writer.open(self.fh.make_path('tracking.avi'),self.fourcc,round(self.fs),frameSize=fsize,isColor=True)
#run
self.framei = 0
self.pos = []
self.t = []
self.guess = []
self.contour = []
self.pct_xadj = []
self.heat = np.zeros((self.height,self.width))
consecutive_skips = 0
if start_pos == 'x':
start_pts = [self.xori_adj, self.xoli_adj]
elif start_pos == 'y':
start_pts = [self.yori_adj, self.yoli_adj]
elif start_pos == 'z':
start_pts = [self.zori_adj, self.zoli_adj]
elif start_pos == 'c':
start_pts = [self.zori, self.xori, self.yori]
elif start_pos == 'none':
start_pts = [self.zori, self.xori, self.yori]
consecutive_skips = self.consecutive_skip_threshold+1
self.last_center = np.mean(self.pts[np.array(start_pts)],axis=0).astype(int)
self.last_contour = np.array([self.last_center])
valid,frame,ts = self.get_frame(self.mov,skip=self.resample-1)
while valid:
possible,diff_raw = self.find_possible_contours(frame,consecutive_skips)
self.pct_xadj.append(np.mean( diff_raw[self.xadj_idxs[:,0],self.xadj_idxs[:,1]]))
if len(possible) == 0:
center = self.last_center
contour = self.last_contour
self.guess.append(True)
consecutive_skips+=1
else:
contour,center = self.choose_best_contour(possible)
self.guess.append(False)
consecutive_skips = 0
self.pos.append(center)
self.contour.append(contour)
self.t.append(ts)
self.heat[center[1],center[0]] += 1
if show or save:
lframe = self.label_frame(frame, center)
save_frame[:,:self.width, :] = cvtColor(lframe.astype(np.float32), CV_GRAY2RGB)
save_frame[:,self.width:, :] = cvtColor((self.diff*255).astype(np.float32), CV_GRAY2RGB)
if show:
self.show_frame(save_frame, wait=wait)
if save:
writer.write(save_frame)
self.last_center = center
self.last_contour = contour
valid,frame,ts = self.get_frame(self.mov,skip=self.resample-1)
if tk_var_frame != None:
tk_var_frame[0].set('%i/%i'%(self.results['n_frames'], len(self.time)/float(self.resample) ))
tk_var_frame[1].update()
if save:
writer.release()
self.end()
