class OverlayBackground():
"""
Provides the background image for the overlay
window.
"""
def __init__(self, config):
"""
Initialises and configures class to provide a background image.
Image can be a WEISS logo, a blank image, or an image from an
OpenCV video source.
:param: A configuration dictionary
:raises: RunTimeError, KeyError
"""
self._video_loop_buffer = []
self._logo_maker = None
self._blank_image = None
if "source" in config:
self.source = VideoCapture(config.get("source"))
if not self.source.isOpened():
raise RuntimeError("Failed to open Video camera:" +
str(config.get("source")))
self.source_name = config.get("source")
if "loop" in config:
if config.get("loop"):
video_buffer = []
ret, image = self.source.read()
while ret:
video_buffer.append(image)
ret, image = self.source.read()
self._video_loop_buffer = cycle(video_buffer)
else:
if config.get("blank") or config.get("logo"):
if config.get("logo"):
self._logo_maker = WeissLogo()
else:
self._blank_image = zeros(shape=[512, 512, 3], dtype=uint8)
else:
raise KeyError("Configuration must contain a" +
"video source, blank, or logo")
def next_image(self):
"""
Returns a background image.
The behaviour is determined by the configuration
dictionary used at init.
"""
if self._video_loop_buffer:
image = next(self._video_loop_buffer)
else:
if self._logo_maker is not None:
image = self._logo_maker.get_noisy_logo()
else:
if self._blank_image is not None:
image = self._blank_image
else:
_, image = self.source.read()
return image
class WebcamVideoStream:
def __init__(self, src=0, time=0.01, name="WebcamVideoStream"):
self.stream = VideoCapture(src)
(self.grabbed, self.frame) = self.stream.read()
self.name = name
self.stopped = False
self.time = time
def start(self):
t = Thread(target=self.update, name=self.name, args=())
t.daemon = True
t.start()
return self
def update(self):
while True:
if self.stopped:
return
sleep(self.time)
(self.grabbed, self.frame) = self.stream.read()
def read(self):
return self.frame
def stop(self):
self.stopped = True
def solveFrameDifferences(self, cap: VideoCapture, crop: List[Rect],
fold) -> Iterator[Frame]:
require(cap.isOpened(), "failed to open capture")
postprocess = lambda mat, index: self.postprocessUMat(
self.cropUMat(mat, crop, index), index)
if self.is_crop_debug:
cv2NormalWin(ExtractSubtitles.WIN_LAST_IMAGE)
cv2NormalWin(ExtractSubtitles.WIN_LAST_FRAME)
reducer = fold(cap, crop)
index = 0
prev_frame, curr_frame = None, None
unfinished, img = cap.read()
prev_frame = postprocess(img, 0) #< initial (prev == curr)
while unfinished:
curr_frame = postprocess(img, index)
if self.is_crop_debug:
cv2.imshow(ExtractSubtitles.WIN_LAST_IMAGE, img)
cv2.imshow(ExtractSubtitles.WIN_LAST_FRAME,
curr_frame) #< must have single title, to animate
if cv2WaitKey() == 'q': break
if curr_frame is not None: # and prev_frame is not None
try:
diff = cv2.absdiff(curr_frame,
prev_frame) #< main algorithm goes here
yield Frame(index, curr_frame, np.sum(diff))
except cv2.error:
pass
prev_frame = curr_frame
unfinished, img = cap.read()
index = index + 1
reducer.accept(index)
reducer.finish()
def playVideo():
excesTime = 0
cap = VideoCapture('./badapple.mp4')
res, frame = cap.read()
while res:
startTime = time.time()
frame = resize(frame,(90,45))
height, width, channels = frame.shape
output = ""
for x in range (0,45):
for y in range(0,90):
color = frame[x,y]
if color[0] > 240 and color[1] > 240 and color[2] > 240:
output += u"\u2588"
else:
output += " "
if x != 62:
output += "\n"
system('cls')
print(output)
res, frame = cap.read()
if 1/FRAMERATE - (time.time() - startTime) - excesTime > 0:
time.sleep(1/FRAMERATE - (time.time() - startTime) - excesTime)
excesTime -= 1/FRAMERATE - (time.time() - startTime)
else:
time.sleep(0)
excesTime -= 1/FRAMERATE - (time.time() - startTime)
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()
class WebcamVideoStream:
def __init__(self, config: configparser.ConfigParser):
self.stream = VideoCapture(config.getint('frame', 'input_slot'))
self.stream.set(CAP_PROP_FRAME_WIDTH, int(config['frame']['width']))
self.stream.set(CAP_PROP_FRAME_HEIGHT, int(config['frame']['height']))
(self.grabbed, self.frame) = self.stream.read()
self.stopped = False
def start(self):
"""
Start the thread to read frames from the video stream
:return:
"""
Thread(target=self.update, args=()).start()
return self
def update(self):
# Infinite loop until th thread is stopped
while not self.stopped:
(self.grabbed, self.frame) = self.stream.read()
def read(self):
return self.frame
def stop(self):
self.stopped = True
def get_tags(driver, path, filter=False):
tags = set()
frames = []
video = path.suffix in ('.gif', '.webm', '.mp4')
if video:
tags.add('animated')
if path.suffix in ('.webm', '.mp4'):
try:
for stream in FFProbe(str(path)).streams:
if stream.codec_type == 'audio':
tags.add('audio')
break
except:
pass
temp_dir = tempfile.TemporaryDirectory()
vidcap = VideoCapture(str(path))
success, frame = vidcap.read()
while success:
temp = ROOT.parent / temp_dir.name / f'{next(tempfile._get_candidate_names())}.jpg'
temp.write_bytes(imencode('.jpg', frame)[-1])
frames.append(temp)
success, frame = vidcap.read()
else:
step = 90 * log((len(frames) * .002) + 1) + 1
frames = frames[::round(step)]
else:
frames.append(path)
for frame in frames:
driver.get('http://dev.kanotype.net:8003/deepdanbooru/')
driver.find('//*[@id="exampleFormControlFile1"]', str(frame))
driver.find('//button[@type="submit"]', click=True)
for _ in range(4):
html = bs4.BeautifulSoup(driver.page_source(), 'lxml')
try:
tags.update([
tag.text for tag in html.find('tbody').findAll(href=True)
])
break
except AttributeError:
if driver.current_url().endswith('deepdanbooru/'):
driver.find('//*[@id="exampleFormControlFile1"]',
str(frame))
driver.find('//button[@type="submit"]', click=True)
driver.refresh()
else:
if video: temp_dir.cleanup()
if filter: tags.difference_update(REMOVE)
return ' '.join(tags)
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 video_to_json(filename):
file_full_path = input_vid_dir + filename
start = clock()
size = round(path.getsize(file_full_path) / 1024 / 1024, 2)
video_pointer = VideoCapture(file_full_path)
frame_count = int(VideoCapture.get(video_pointer, int(CAP_PROP_FRAME_COUNT)))
width = int(VideoCapture.get(video_pointer, int(CAP_PROP_FRAME_WIDTH)))
height = int(VideoCapture.get(video_pointer, int(CAP_PROP_FRAME_HEIGHT)))
fps = int(VideoCapture.get(video_pointer, int(CAP_PROP_FPS)))
success, image = video_pointer.read()
video_hash = {}
while success:
frame_hash = average_hash(Image.fromarray(image))
video_hash[str(frame_hash)] = filename
success, image = video_pointer.read()
stop = clock()
time_taken = stop - start
print("Time taken for ", file_full_path, " is : ", time_taken)
data_dict = dict()
data_dict['size'] = size
data_dict['time_taken'] = time_taken
data_dict['fps'] = fps
data_dict['height'] = height
data_dict['width'] = width
data_dict['frame_count'] = frame_count
data_dict['filename'] = filename
data_dict['video_hash'] = video_hash
write_to_json(filename, data_dict)
return
def solveFrameDifferences(cap: cv2.VideoCapture, on_frame = lambda x: ()) -> Tuple[list, list]:
frames, frame_diffs = [], []
index = 0
prev_frame, curr_frame = None, None
unfinished, img = cap.read()
prev_frame = img #< initial (prev == curr)
cv2NormalWin(WIN_LAST_FRAME)
(n_frame, _, _, _) = cv2VideoProps(cap)
progress = ProgressBar(maxval=n_frame).start()
while unfinished:
curr_frame = cv2.cvtColor(img, cv2.COLOR_BGR2LUV) #luv
if curr_frame is not None: # and prev_frame is not None
diff = cv2.absdiff(curr_frame, prev_frame) #< main logic goes here
count = np.sum(diff)
frame_diffs.append(count)
frame = Frame(index, img, count)
#frames.append(frame)
on_frame(curr_frame)
prev_frame = curr_frame
index = index + 1
progress.update(index)
unfinished, img = cap.read()
if app_cfg.crop_debug:
cv2.imshow(WIN_LAST_FRAME, prev_frame) #< must have single name, to animate
if cv2WaitKey('q'): break
progress.finish()
return (frames, frame_diffs)
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 save_manual(src_cam: cv.VideoCapture,
dst_cam: cv.VideoCapture,
out_dir='.'):
c = 0
while True:
# read images from both cameras
is_ok, src_image = src_cam.read()
if not is_ok:
continue
is_ok, dst_image = dst_cam.read()
if not is_ok:
continue
# resize
if src_image.shape[0] != 480 or src_image.shape[1] != 640:
src_image = cv.resize(src_image, (640, 480))
if dst_image.shape[0] != 480 or dst_image.shape[1] != 640:
dst_image = cv.resize(dst_image, (640, 480))
cv.imshow("src", src_image)
cv.imshow("dst", dst_image)
key = cv.waitKey(10)
if key == 27:
break
elif key == 32:
save_image(src_image, dst_image, os.path.join(out_dir, str(c)))
c += 1
cv.destroyAllWindows()
class WebCamStream(object):
"""
A class that handles threaded video streaming through a USB webcam.
based on imutils library for python: https://github.com/jrosebr1/imutils
"""
def __init__(self, src=0):
"""
Initialize an object that controls a video
stream from a USB Webcam on a separate thread.
Args:
src: the source for the USB webcam, 0 is the default camera
"""
self.src = src
self.stream = VideoCapture(src) # initialize video source
self.grabbed, self.frame = self.stream.read() # grab initial frame
self.stopped = False
self.has_frame = Event()
def start(self):
"""
Start the video stream on a separate daemon thread once the
capturing device is opened.
"""
while not self.stream.isOpened(): # wait for I/O to come online
sleep(8) # 8 seconds = 1 successful re-open attempt
self.stream.open(self.src) # attempt to open again
thread = Thread(target=self.update, args=())
thread.daemon = True # set thread to daemon
thread.start() # start thread
def update(self):
"""
Continuously update the stream with the most recent frame
until stopped.
"""
while not self.stopped:
self.grabbed, self.frame = self.stream.read()
if self.grabbed:
self.has_frame.set() # notify
def read(self):
"""
Read the current frame in the video stream.
Returns:
The most recent frame captured
"""
self.has_frame.wait()
frame = self.frame
self.has_frame.clear()
return frame
def stop(self):
"""
Stop the video stream.
"""
self.stopped = True
self.stream.release() # close capturing device
def getFrame(vid):
print('Please wait...')
vidcap = VideoCapture(vid)
success, image = vidcap.read()
count = 0
while success:
imwrite("frames\\frame %d.jpg" % count, image)
success, image = vidcap.read()
count += 1
def video_jump(video_cap: cv2.VideoCapture, frame_id: int):
# IMPORTANT:
# - frame is a range actually
# - frame 1 's timestamp is the beginning of this frame
#
# video_jump(cap, 2) means: moving the pointer to the start point of frame 2 => the end point of frame 1
# another -1 for re-read
video_cap.set(cv2.CAP_PROP_POS_FRAMES, frame_id - 1 - 1)
video_cap.read()
def play(window):
vidcap = VideoCapture(argv[1])
success, image = vidcap.read()
while success:
for l in I2T(BytesIO(imencode(".jpg", resize(image, (144, 108), interpolation = 3))[1])).split("\n"):
# time.sleep(x) # Use this to change the fps
window.addstr(l + "\n")
window.refresh()
window.move(0, 0)
success, image = vidcap.read()
def get_frames(datum_path):
video_capture = VideoCapture(datum_path)
frames = []
success, frame = video_capture.read()
while success:
frames.append(frame)
success, frame = video_capture.read()
return frames
class image:
def __init__(self):
self.camera = VideoCapture(0)
def capture(self):
for i in range(20):
self.retval,self.im = self.camera.read()
self.retval,self.im = self.camera.read()
imwrite("E:/Project/known_people/temp.jpg",self.im)
del(self.camera)
def selectCropRects(
cap: VideoCapture,
title="Video (c:OK; q:finished, <:-; >:=)",
title_preview="Preview",
d_seek=5) -> Iterator[Tuple[int, Tuple[int, int, int, int]]]:
''' position&size (x, y, w, h) '''
index = 0
ltrd = None
def seek(n):
nonlocal index
index += n
cap.set(CAP_PROP_POS_FRAMES, index)
def handleSeek(key):
if key == '-': seek(-d_seek)
elif key == '=': seek(+d_seek)
def handleSelect():
nonlocal ltrd
area = guiSelectionUMat(img)
if area != None:
ltrd = area
return (index, rectLtrd2Xywh(*ltrd))
frame_ops = [lambda: seek(-1), lambda: seek(+1)]
unfinished, img = cap.read()
while unfinished:
imshow(title, img)
if ltrd != None: imshow(title_preview, cv2Crop(img, ltrd))
key = cv2WaitKey()
if key == 'c':
select = handleSelect()
if select != None: yield select
elif key == 'q': break
elif key in '-=': handleSeek(key)
elif key == ' ':
while True:
key1 = cv2WaitKey(0)
if key1 == ' ': break
elif key1 == 'c':
select = handleSelect()
if select != None: yield select
elif key1 in "-=89":
handleSeek(key1)
miniseek = ord(key1) - ord('8') #[89] to mimiseek
if miniseek in range(len(frame_ops)): frame_ops[miniseek]()
unfinished, img = cap.read()
imshow(title, img)
unfinished, img = cap.read()
index += 1
def VideoStream(video: Video) -> Generator[VideoFrame, None, None]:
from cv2 import VideoCapture
from numpy import ndarray
success: bool
img: ndarray
cap = VideoCapture(video.filename)
success, img = cap.read()
while success:
yield VideoFrame(img)
success, img = cap.read()
def get_frames(video, outpath):
print(video)
vidcap = VideoCapture(video)
success, image = vidcap.read()
count = 0
print(success)
while success:
# save frame as JPEG file
imwrite(outpath + "_frame%d.jpg" % count, image)
success, image = vidcap.read()
print('Read a new frame: ', success)
success = True
count += 1
def play(window):
try: from sys import _MEIPASS
except ImportError::
from os.path import abspath
_MEIPASS = abspath(".")
vidcap = VideoCapture(_MEIPASS + "/video.mp4")
success, image = vidcap.read()
while success:
for l in I2T(BytesIO(imencode(".jpg", resize(image, (144, 108), interpolation = 3))[1])).split("\n"):
window.addstr(l + "\n")
window.refresh()
window.move(0, 0)
success, image = vidcap.read()
def test_type_read_times(cap: cv2.VideoCapture, cam_index: int, num_reads: int,
show_values: bool):
# Read camera num_frames times and capture time taken per read.
times = []
prev = time()
for i in range(num_reads):
cap.read()
now = time()
times.append(now - prev)
prev = now
# Sort times taken low to high.
times.sort()
# Show basic output.
to_print = "Test type: read time" + \
"\n- Camera: " + str(cam_index) + \
"\n- Mean time to read frame: " + str(sum(times) / len(times)) + \
"\n- Median time to read frames: " + str(median(times)) + \
"\n- Range of times to read frames: " + str(min(times)) + " to " + str(max(times))
print(to_print)
# Create dictionary of intervals of 0.01 seconds.
intervals = dict()
i = 0
while i <= times[-1]:
i += .01
intervals[round(i, 3)] = list()
# Sort times taken into dictionary.
next_time = .01
next_time = round(next_time, 3)
for t in times:
while t > next_time:
next_time += .01
next_time = round(next_time, 3)
intervals[next_time].append(t)
# Output results.
prev_key = 0
for key in intervals:
if len(intervals[key]) > 0:
print("- Number of read times between {:.2f}".format(prev_key) +
" and {:.2f}".format(key) + " seconds:" +
str(len(intervals[key])) +
". Percentage in this range: {:.1f}".format(
len(intervals[key]) / num_reads * 100) + "%")
if show_values:
print(intervals[key])
prev_key = key
print("\n")
def iter_read_raw_video_images(video_capture: cv2.VideoCapture,
repeat: bool = False) -> Iterable[ImageArray]:
while True:
grabbed, image_array = video_capture.read()
if not grabbed:
LOGGER.info('video end reached')
if not repeat:
return
video_capture.set(cv2.CAP_PROP_POS_FRAMES, 0)
grabbed, image_array = video_capture.read()
if not grabbed:
LOGGER.info('unable to rewind video')
return
yield image_array
def capture_background_image(capturer: cv2.VideoCapture,
dimensions=(64, 64),
skip=15) -> np.ndarray:
"""
Captures and returns a single, still image from the webcam to use as the background.
Use this image as the initial training point for a cv2.BackgroundSubtractorMOG2 object.
`skip` is the number of frames to skip before capturing the image, to allow for pre-focusing.
"""
for i in range(skip):
capturer.read()
ret, frame = capturer.read()
image = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# image = cv2.resize(image, dsize=dimensions)
return image
def verify_video(vid_cap: cv2.VideoCapture) -> bool:
success, image = vid_cap.read()
while success:
success, image = vid_cap.read()
# If the video ended return false.
if not success:
vid_cap.release()
return False
# Return true if the frame contains Rick
if verify_image(image):
vid_cap.release()
return True
def run_video(process_frame=lambda im: im, fps=30, camera_num=0):
"""
Runs OpenCV video from a connected camera as Jupyter notebook output. Each frame from the camera
is given to process_frame before being displayed. The default does no processing. The display is
limited to the given number of frames per second (default 30). It can go below this, but will
bot go above it. If there is more than one camera connected, settings camera_num will select
which camera to use.
The video will continue being run until the code is interuppted with the stop button in Jupyter
notebook.
"""
from cv2 import VideoCapture, error, imencode
from IPython.display import Image, display
from time import time, sleep
delay = 1 / fps # the max number of seconds between frames
vc = VideoCapture(camera_num)
try:
if not vc.isOpened():
return # if we did not successfully gain access to the camera
# Try to get the first frame
is_capturing, frame = vc.read()
if frame is None: return # no first frame
# Process the frame, encode it as PNG, and display it
im = process_frame(bgr2rgb(frame))
disp = display(Image(imencode('.jpg', bgr2rgb(im))[1].tostring(),
width=im.shape[1],
height=im.shape[0]),
display_id=True)
while is_capturing:
# Keep getting new frames while they are available
try:
start = time()
# Get the next frame
is_capturing, frame = vc.read()
if frame is None: break # no next frame
# Process the frame, encode it as PNG, and display it
im = process_frame(bgr2rgb(frame))
disp.update(
Image(imencode('.jpg', bgr2rgb(im))[1].tostring(),
width=im.shape[1],
height=im.shape[0]))
# Wait for a small amount of time to avoid frame rate going to high
wait = delay - (time() - start)
if wait > 0: sleep(wait)
except KeyboardInterrupt:
break # lookout for a keyboard interrupt (stop button) to stop the script gracefully
return im
finally:
vc.release()
return None
def test_type_fps(cap: cv2.VideoCapture, cam_index: int, num_reads: int):
# Get time taken to read camera num_frames times with no other operations.
tracker = FPSTracker()
s = time()
for i in range(num_reads):
cap.read()
tracker.update_fps(datetime.now())
elapsed = time() - s
# Print results.
print("Test type: fps"
"\n- Camera:", cam_index, "\n- Num_frames:", num_reads,
"\n- Time_taken:", elapsed, "\n- tester says fps:",
num_reads / elapsed, " and tracker says:", tracker.get_fps())
print("\n")
class CaptureSource:
def __init__(self):
self._video = None
self._image = None
def get_resolution(self):
if (self._video):
return (int(self._video.get(CAP_PROP_FRAME_WIDTH)),
int(self._video.get(CAP_PROP_FRAME_HEIGHT)))
def camera(self, num_cams):
cam = Cameras()
cam.check_cameras(num_cams)
self._video = cam.show_and_select_camera()
def video(self, filename):
self._video = VideoCapture(filename)
def image(self, filename):
self._image = filename
def get_frame(self):
if self._video:
retval, frame = self._video.read()
return retval, frame
return True, imread(self._image)
def captureCamera(camera: cv2.VideoCapture,
tag: str = None,
resolution: list = None):
resolution = [
512, 512
] if resolution is None else resolution # Параметр по умолчанию
frame = np.zeros((512, 512, 3), np.uint8) # Пустой кадр
DATA[tag] = [True, "", "", frame] # Начальные результаты камеры
CAMERA_SETTINGS[tag] = {"HSV": False} # Дефолтные настройки камеры
yield None # Конец инициализации генератора самеры
if argv.debug and argv.show: #
cv2.namedWindow(tag)
cv2.setMouseCallback(tag, mouseCallback, param=tag)
while camera.isOpened():
if DATA[tag][0]:
flag, frame = camera.read()
if flag:
DATA[tag] = [
True,
getLetterFromFrame(frame),
getColorFromFrame(frame), frame
]
if argv.show:
frame = cv2.resize(frame, CAMERA_SIZE)
cv2.resizeWindow(tag, *CAMERA_SIZE)
if argv.debug and CAMERA_SETTINGS[tag]["HSV"]:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
DATA[tag][3] = frame
cv2.imshow(tag, frame)
yield None
def video_player(vc: cv2.VideoCapture, frame_title: str, skip_frames: int,
draw: callable([int, object])):
width, height, frameCount, fps = video_properties(vc)
duration = frameCount / fps
minutes = int(duration / 60)
seconds = int(duration % 60)
spf = 1 / fps
mspf = int(spf * 1000)
print('Duration = ' + str(minutes) + ':' + str(seconds) + ' (' +
str(duration) + ' seconds)')
frame_id = 0
while vc.isOpened():
# Capture frame-by-frame
ret, frame = vc.read()
if ret:
frame_id = frame_id + 1
if frame_id <= skip_frames:
continue
video_drawer(frame_id, frame)
draw(frame_id, frame)
# Display the resulting frame
cv2.imshow(frame_title, frame)
# Press Q on keyboard to exit
if cv2.waitKey(mspf) & 0xFF == ord('q'):
break
# Break the loop
else:
break
# Closes all the frames
cv2.destroyAllWindows()
return
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
class Camera(object):
"""
The class responsible for communicating with the actual camera and
getting images from it.
Attributes:
cam: An instance of an openCV VideoCapture.
"""
def __init__(self, device_num):
"""
Uses a device num in case the system has multiple cameras attached.
"""
self.cam = VideoCapture(device_num)
def get_image(self):
"""
Grab a frame from the camera. The cameraCommunicator is the caller,
and is responsible for lighting and location. The filename of the
image is returned.
Raises:
FatalCameraException: An image was not taken successfully.
"""
#create the systematic filename
timestamp = datetime.datetime.now()
filename = utils.get_image_dir() + str(timestamp.date()) + \
str(timestamp.hour) + str(timestamp.minute) + \
str(timestamp.second) + '.jpg'
#A series of reads to allow the camera to adjust to lighting
self.cam.read()
self.cam.read()
self.cam.read()
self.cam.read()
#only the last is saved
success, image = self.cam.read()
if not success:
raise FatalCameraException()
else:
imwrite(filename, image)
return timestamp, filename
class Window(object):
def __init__(self, title="Video Stream"):
''' Uses OpenCV 2.3.1 method of accessing camera '''
self.title = title
self.cap = VideoCapture(0)
self.prev = self.get_frame()
self.frame = self.get_frame()
namedWindow(title, 1)
def get_frame(self):
success, frame = self.cap.read()
return self.to_grayscale(frame) if success else False
def to_grayscale(self, frame):
return cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
def optical_flow(self): # FIXME
flow = CreateImage(GetSize(frame), 32, 2)
CalcOpticalFlowFarneback(self.prev, self.frame, flow, # takes 0.05s
pyr_scale=0.5, levels=3, winsize=15,
iterations=3, poly_n=5, poly_sigma=1.2, flags=0)
return flow
def disparity(self):
if self.left is None or self.right is None:
print "Capture left and right images using 'l' and 'r' keys before running disparity"
return None
hl, wl = self.left.shape
hr, wr = self.right.shape
disp_left = cv2.cv.CreateMat(hl, wl, cv2.cv.CV_16S)
disp_right = cv2.cv.CreateMat(hr, wr, cv2.cv.CV_16S)
state = cv2.cv.CreateStereoGCState(16,2)
# running the graph-cut algorithm
from cv2.cv import fromarray
cv2.cv.FindStereoCorrespondenceGC(fromarray(self.left), fromarray(self.right), disp_left, disp_right, state)
cv2.cv.Save( "left.png", disp_left) # save the map
cv2.cv.Save( "right.pgm", disp_right) # save the map
def mainloop(self):
while True:
self.prev = self.frame
self.frame = self.get_frame()
sift(self.frame) # takes ~0.14s!
imshow(self.title, self.frame)
k = waitKey(10)
if k == -1:
pass
elif chr(k) == 'l':
self.left = self.frame
elif chr(k) == 'r':
self.right = self.frame
elif chr(k) == 'd':
self.disparity()
elif k == 27:
break
class Camera_Capture():
"""
VideoCapture without uvc control using cv2.VideoCapture
"""
def __init__(self,src_id,size=(640,480),fps=None,timebase=None):
self.controls = None
self.cvId = src_id
self.name = "VideoCapture"
self.controls = None
###add cv videocapture capabilities
self.capture = VideoCapture(src_id)
self.set_size(size)
if timebase == None:
logger.debug("Capture will run with default system timebase")
self.timebase = c_double(0)
elif isinstance(timebase,c_double):
logger.debug("Capture will run with app wide adjustable timebase")
self.timebase = timebase
else:
logger.error("Invalid timebase variable type. Will use default system timebase")
self.timebase = c_double(0)
def get_frame(self):
s, img = self.capture.read()
timestamp = time()
return Frame(timestamp,img)
def set_size(self,size):
width,height = size
self.capture.set(3, width)
self.capture.set(4, height)
def get_size(self):
return self.capture.get(3), self.capture.get(4)
def set_fps(self,fps):
self.capture.set(5,fps)
def get_fps(self):
return self.capture.get(5)
def get_now(self):
return time()
def create_atb_bar(self,pos):
size = 0,0
return size
def kill_atb_bar(self):
pass
def close(self):
pass
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 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 grabImageFromUSB(cameraNumber=0):
'''Grabs a snapshot from the specified USB camera.
Returns bool, video frame decoded as a JPEG bytearray.
'''
from cv2 import VideoCapture, imencode
# initialize the camera
cam = VideoCapture(cameraNumber)
retVal, rawData = cam.read()
if not retVal:
# frame captured returns errors
return False, None
retVal, jpgData = imencode('.jpg', rawData)
if not retVal:
# image encode errors
return False, None
return retVal, bytearray(jpgData)
def check_cameras_linux(self, num=MAX_CAMERAS):
"""Comprueba las cámaras disponibles.
:Param num: máximo número de cámaras a comprobar
:Keyword num: 99 por defecto, ya que en Linux es lo permitido
:Param num: int
:Return: lista de cámaras disponibles
:Rtype: list of Capture
"""
n = 0
while len(self.cameras) < num and n <= MAX_CAMERAS:
camera = VideoCapture(n)
retval, frame = camera.read()
if retval:
self.cameras.append(camera)
n += 1
if num != MAX_CAMERAS and len(self.cameras) != num:
print("Found %d of %d cameras. " % (len(self.cameras), num))
exit()
return len(self.cameras)
class Camera_Capture():
"""
VideoCapture without uvc control using cv2.VideoCapture
"""
def __init__(self,src_id,size=(640,480),fps=None):
self.controls = None
self.cvId = src_id
self.name = "VideoCapture"
self.controls = None
###add cv videocapture capabilities
self.capture = VideoCapture(src_id)
self.set_size(size)
def get_frame(self):
s, img = self.capture.read()
timestamp = time()
return Frame(timestamp,img)
def set_size(self,size):
width,height = size
self.capture.set(3, width)
self.capture.set(4, height)
def get_size(self):
return self.capture.get(3), self.capture.get(4)
def set_fps(self,fps):
self.capture.set(5,fps)
def get_fps(self):
return self.capture.get(5)
def create_atb_bar(self,pos):
size = 0,0
return size
def kill_atb_bar(self):
pass
def close(self):
pass
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()
def main():
cap = VideoCapture("feng.mp4")
ret, frame = cap.read()
imwrite("feng1.jpg", frame)
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
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
class Camera_Capture(object):
"""docstring for uvcc_camera"""
def __init__(self, cam,size=(640,480),fps=30):
self.src_id = cam.src_id
self.uId = cam.uId
self.name = cam.name
self.controls = Controls(self.uId)
try:
self.controls['UVCC_REQ_FOCUS_AUTO'].set_val(0)
except KeyError:
pass
if '6000' in self.name and False: #on mac we dont have enough controls to use this right.
logger.info("adjusting exposure for HD-6000 camera")
try:
self.controls['UVCC_REQ_EXPOSURE_AUTOMODE'].set_val(1)
self.controls['UVCC_REQ_EXPOSURE_ABS'].set_val(156)
except KeyError:
pass
self.capture = VideoCapture(self.src_id)
self.set_size(size)
def get_frame(self):
s, img = self.capture.read()
timestamp = time()
return Frame(timestamp,img)
def set_size(self,size):
width,height = size
self.capture.set(3, width)
self.capture.set(4, height)
def get_size(self):
return self.capture.get(3), self.capture.get(4)
def set_fps(self,fps):
self.capture.set(5,fps)
def get_fps(self):
return self.capture.get(5)
def create_atb_bar(self,pos):
# add uvc camera controls to a separate ATB bar
size = (200,200)
self.bar = atb.Bar(name="Camera_Controls", label=self.name,
help="UVC Camera Controls", color=(50,50,50), alpha=100,
text='light',position=pos,refresh=2., size=size)
sorted_controls = [c for c in self.controls.itervalues()]
sorted_controls.sort(key=lambda c: c.order)
for control in sorted_controls:
name = control.atb_name
if control.type=="bool":
self.bar.add_var(name,vtype=atb.TW_TYPE_BOOL8,getter=control.get_val,setter=control.set_val)
elif control.type=='int':
self.bar.add_var(name,vtype=atb.TW_TYPE_INT32,getter=control.get_val,setter=control.set_val)
self.bar.define(definition='min='+str(control.min), varname=name)
self.bar.define(definition='max='+str(control.max), varname=name)
self.bar.define(definition='step='+str(control.step), varname=name)
elif control.type=="menu":
if control.menu is None:
vtype = None
else:
vtype= atb.enum(name,control.menu)
self.bar.add_var(name,vtype=vtype,getter=control.get_val,setter=control.set_val)
if control.menu is None:
self.bar.define(definition='min='+str(control.min), varname=name)
self.bar.define(definition='max='+str(control.max), varname=name)
self.bar.define(definition='step='+str(control.step), varname=name)
else:
pass
if control.flags == "inactive":
pass
# self.bar.define(definition='readonly=1',varname=control.name)
self.bar.add_button("refresh",self.controls.update_from_device)
self.bar.add_button("load defaults",self.controls.load_defaults)
return size
def kill_atb_bar(self):
pass
def close(self):
pass
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 Worker:
## Initialize Worker robot.
def __init__(self):
try:
self.camera = VideoCapture(CAMERA_INDEX)
self.camera.set(3,CAMERA_WIDTH)
self.camera.set(4,CAMERA_HEIGHT)
message = 'Success.'
except Exception:
message = 'Failure.'
print('[Setting up Camera]...' + message)
try:
self.arduino = serial.Serial(DEVICE, BAUD)
message = 'Success.'
except Exception:
message = 'Failure.'
print('[Setting up Controller]...' + message)
self.reset_worker()
## Capture image then identify Home.
def detect_green(self):
objects = []
x = 0
for cache in range(10):
(success, frame) = self.camera.read()
raw = Image.fromarray(frame)
BGR = raw.split()
B = array(BGR[0].getdata(), dtype=float32)
G = array(BGR[1].getdata(), dtype=float32)
R = array(BGR[2].getdata(), dtype=float32)
NDI_G = (BIAS*G + MINIMUM_COLOR)/(R + B + MINIMUM_COLOR)
matrix = NDI_G.reshape(CAMERA_HEIGHT,CAMERA_WIDTH)
columns = matrix.sum(axis=0)
high = numpy.mean(columns) + numpy.std(columns)
low = numpy.mean(columns)
while (x < CAMERA_WIDTH-1):
if (columns[x] > high):
start = x
while (columns[x] > low) and (x < CAMERA_WIDTH-1):
x += 1
end = x
size = (end - start)
offset = (start + (end - start)/2) - CAMERA_CENTER
if (size > MINIMUM_SIZE):
objects.append((size,offset))
else:
x += 1
return objects
## Detect
def detect_yellow(self):
objects = []
x = 0
for cache in range(30):
(success, frame) = self.camera.read()
raw = Image.fromarray(frame)
BGR = raw.split()
B = array(BGR[0].getdata(), dtype=float32)
G = array(BGR[1].getdata(), dtype=float32)
R = array(BGR[2].getdata(), dtype=float32)
NDI_G = BIAS*(G + R + MINIMUM_COLOR)/(2*B + MINIMUM_COLOR)
matrix = NDI_G.reshape(CAMERA_HEIGHT,CAMERA_WIDTH)
columns = matrix.sum(axis=0)
high = numpy.mean(columns) + numpy.std(columns)
low = numpy.mean(columns)
while (x < CAMERA_WIDTH-1):
if (columns[x] > high):
start = x
while (columns[x] > low) and (x < CAMERA_WIDTH-1):
x += 1
end = x
size = (end - start)
offset = (start + (end - start)/2) - CAMERA_CENTER
if (size > MINIMUM_SIZE):
objects.append((size,offset))
else:
x += 1
return objects
## Is Oriented? --> Boolean
def is_oriented(self):
for cache in range(10):
(success, frame) = self.camera.read()
grayscale = cv2.cvtColor(frame, cv.CV_BGR2GRAY)
blurred = cv2.GaussianBlur(grayscale, (0,0), 5) # (0,0), 5
colored = cv2.cvtColor(blurred,cv2.COLOR_GRAY2BGR)
(flag, thresholded) = cv2.threshold(blurred, 50, 255, cv2.THRESH_BINARY) # 50 and 255 WORKS
circles = cv2.HoughCircles(thresholded,cv2.cv.CV_HOUGH_GRADIENT,DP,MIN_DISTANCE,param1=EDGE_THRESHOLD, param2=CENTER_THRESHOLD, minRadius=MIN_RADIUS,maxRadius=MAX_RADIUS)
try:
for target in circles[0,:]:
x = target[0]
y = target[1]
r = target[2]
if (abs(CAMERA_CENTER - x) < CAMERA_THRESHOLD):
return True
else:
return False
except TypeError:
return False
## Connect to Server.
def connect(self):
if (self.connected_out == False) and (self.connected_in == False):
try:
self.socket_out = socket.socket(AF_INET, SOCK_STREAM)
self.socket_out.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket_out.bind((ADDRESS_OUT))
self.socket_out.listen(QUEUE_MAX)
(self.connection, self.address) = self.socket_out.accept()
self.connected_out = True
message = 'Success.'
except socket.error as message:
message = 'Failure.'
self.connected_out = False
self.socket_out.close()
pass
print('[Establishing Send Port]...' + str(message))
try:
self.socket_in = socket.socket(AF_INET,SOCK_STREAM)
self.socket_in.connect((ADDRESS_IN))
self.connected_in = True
message = 'Success.'
except socket.error as message:
self.socket_in.close()
self.connected_in = False
pass
print('[Establishing Receive Port]...' + str(message))
## Receives COMMAND from Server.
def receive_command(self):
try:
json_command = self.socket_in.recv(BUFFER_SIZE)
dict_command = json.loads(json_command)
self.command = dict_command['COMMAND']
message = str(json_command)
except socket.error as message:
pass #!
print('----------------------------------')
print('[Receiving COMMAND]...' + str(message))
## After receiving COMMAND, determine action.
def decide_action(self):
if (self.command == 'START'):
self.goal = 'STARTING'
self.start()
elif (self.command == 'CONTINUE'):
if (self.gathered < 4):
self.goal = 'GATHERING'
self.gather()
elif (not self.dumped):
self.goal = 'STACKING'
self.find_zone()
elif (not self.returning):
self.goal = 'RETURNING'
self.return_home()
else:
self.action = 'W'
elif (self.command == 'PAUSE'):
self.goal = 'PAUSING'
self.action = 'W'
elif (self.command == 'DISCONNECT'):
self.goal = 'DISCONNECTING'
self.action = 'W'
else:
self.action = 'W'
## Start Logic
def start(self):
self.action = 'H'
print('[Starting]...Helping Extend Rack.')
## Gather Logic
def gather(self):
objects = self.detect_green()
#1 There is an object in view...
try:
(size, offset) = max(objects)
#2 ...and it is small...
if (size < SIZE_GRAB_RANGE) and not (self.error_number == ERROR_LOAD):
#3 ...and I just tried avoiding to the left...
if (self.error_number == ERROR_AVOID_RIGHT):
message = 'Blocked After Avoiding Right -> Avoiding Left.'
self.action = 'J'
#3 ...and I just tried avoid to the right...
elif (self.error_number == ERROR_AVOID_LEFT):
message = 'Blocked After Avoiding Left --> Avoiding Right.'
self.action = 'I'
#3 ...and I just tried to turn right...
elif (self.error_number == ERROR_BLOCKED_LEFT):
message = 'Blocked After Turning Left --> Avoiding Right.'
self.action = 'I'
#3 ... and i just tried to turn left...
elif (self.error_number == ERROR_BLOCKED_LEFT):
message = 'Blocked After Turning Right --> Avoiding Left.'
self.action = 'J'
#3 ...and I just was blocked after moving...
elif (self.error_number == ERROR_CLOSE):
message = 'Blocked After Turning Right --> Avoiding Left.'
self.action = 'I'
#3 ...and I didn't make bad movements...
else:
#4 ...and it's to the right...
if (offset > CAMERA_THRESHOLD):
if (offset > 4*CAMERA_THRESHOLD):
message = '(Object in View -> 4 Right.'
self.action = 'T'
elif (offset > 3*CAMERA_THRESHOLD):
message = 'Object in View -> 3 Right.'
self.action = 'S'
elif (offset > 2*CAMERA_THRESHOLD):
message = 'Object in View -> 2 Right.'
self.action = 'R'
else:
message = 'Object in View -> 1 Right'
self.action = 'Q'
#4 ...and it's to the left.
elif (offset < -CAMERA_THRESHOLD):
if (offset < -4*CAMERA_THRESHOLD):
message = 'Object in View -> 4 Left'
self.action = 'N'
elif (offset < -3*CAMERA_THRESHOLD):
message = 'Object in View -> 3 Left'
self.action = 'M'
elif (offset < -2*CAMERA_THRESHOLD):
message = 'Object in View -> 2 Left'
self.action = 'L'
else:
message = 'Object in View -> 1 Left'
self.action = 'K'
#4 ...and it's in front...
else:
message = 'Too Small -> Out of Range'
self.action = 'F'
#2 ...and it is large...
elif (size > SIZE_GRAB_RANGE):
#3 ...and I was just trying to grab something...
if (self.error_number == ERROR_LOAD):
message = 'Load Failed -> Reversing.'
self.action = 'B'
#3 ...and I was not just trying to grab something...
else:
#4 ...and it is oriented...
if True: #! (self.is_oriented())
message = 'Large Enough -> In Range, Oriented -> Grab'
self.action = 'G'
self.gathered += 1
#4 ...but it is not oriented..
else:
#5 ...and I already tried to orbit left.
if (self.error_number == ERROR_ORBIT_LEFT):
message = 'Large Enough -> In Range, Not Oriented --> Orbiting Right.'
self.action = 'O'
#5 ...and I didn't just try to go around right.
elif (self.error_number == ERROR_ORBIT_RIGHT):
message = 'Large Enough -> In Range, Not Oriented & Blocked Right -> Orbiting Left.'
self.action = 'P'
#5 ... grab anyway.
else:
message = 'In Range, Not Oriented -> Attempting to Orbing .'
self.action = 'O'
#2
else:
self.action = 'W'
message = 'Confused -> Waiting.'
#1 There are no objects in view.
except ValueError:
message = 'No Objects Detected -> Searching Right.'
self.action = 'T'
print('[Gathering]...' + str(objects) + '...' + message)
print('[Remembering Action]...' )
self.previous_action = self.action # remember newest action
## Find Zone
def find_zone(self):
objects = self.detect_green()
# The Zone is in view...
try:
(size, offset) = max(objects)
#2 ... but not at the zone...
if (size < SIZE_HOME_RANGE):
#3 ... and it's to the right.
if (offset > CAMERA_THRESHOLD):
if (offset > 4*CAMERA_THRESHOLD):
message = '(Zone in View -> 4 Right.'
self.action = 'T'
elif (offset > 3*CAMERA_THRESHOLD):
message = 'Zone in View -> 3 Right.'
self.action = 'S'
elif (offset > 2*CAMERA_THRESHOLD):
message = 'Zone in View -> 2 Right.'
self.action = 'R'
else:
message = 'Zone in View -> 1 Right'
self.action = 'Q'
#3 ...and it's to the left.
elif (offset < -CAMERA_THRESHOLD):
if (offset < -4*CAMERA_THRESHOLD):
message = 'Zone in View -> 4 Left'
self.action = 'N'
elif (offset < -3*CAMERA_THRESHOLD):
message = 'Zone in View -> 3 Left'
self.action = 'M'
elif (offset < -2*CAMERA_THRESHOLD):
message = 'Zone in View -> 2 Left'
self.action = 'L'
else:
message = 'Zone in View -> 1 Left'
self.action = 'K'
#3 ...and it is straight ahead.
else:
#4 ...but it is blocked ahead.
if (self.error_number == ERROR_CLOSE):
message = 'Object in Way -> Avoiding Right.'
self.action = 'I'
#4 ...but it is blocked after turning right.
elif (self.error_number == ERROR_AVOID_RIGHT):
message = 'Failed to Turn Right -> Avoiding Left.'
self.action = 'J'
#4 ...but it is blocked after avoiding right.
elif (self.error_number == ERROR_AVOID_RIGHT):
message = 'Failed to Avoid Right -> Avoiding Left.'
self.action = 'J'
#4 ...but it is blocked to the left.
elif (self.error_number == ERROR_BLOCKED_LEFT):
message = 'Failed to Turn Left -> Avoiding Right.'
self.action = 'I'
#4 ...but it is blocked after avoiding right.
elif (self.error_number == ERROR_BLOCKED_RIGHT):
message = 'Failed to Avoid Left -> Avoiding Right.'
self.action = 'I'
#4 ...and isn't blocked.
else:
message = 'Zone Too Small -> Moving Forward.'
self.action = 'F'
#2 ..and have reached the zone.
else:
message = 'At Zone -> Dumping Bales.'
self.action = 'D'
self.dumped = True
#1 The Zone is not in view...
except ValueError:
message = 'Cannot See Zone -> Searching Left For Zone.'
self.action = 'N'
print('[Finding Zone]...' + message)
## Return Home
def return_home(self):
objects = self.detect_yellow()
#1 Home is in view...
try:
(size, offset) = max(objects)
#2 ... but not at the home...
if (size < SIZE_ZONE_RANGE):
#3 ... and it's to the right.
if (offset > CAMERA_THRESHOLD):
if (offset > 4*CAMERA_THRESHOLD):
message = 'Home in View -> 4 Right.'
self.action = 'T'
elif (offset > 3*CAMERA_THRESHOLD):
message = 'Home in View -> 3 Right.'
self.action = 'S'
elif (offset > 2*CAMERA_THRESHOLD):
message = 'Home in View -> 2 Right.'
self.action = 'R'
else:
message = 'Home in View -> 1 Right'
self.action = 'Q'
#3 ...and it's to the left.
elif (offset < -CAMERA_THRESHOLD):
if (offset < -4*CAMERA_THRESHOLD):
message = 'Home in View -> 4 Left'
self.action = 'N'
elif (offset < -3*CAMERA_THRESHOLD):
message = 'Home in View -> 3 Left'
self.action = 'M'
elif (offset < -2*CAMERA_THRESHOLD):
message = 'Home in View -> 2 Left'
self.action = 'L'
else:
message = 'Home in View -> 1 Left'
self.action = 'K'
#3 ...and it is straight ahead.
else:
#4 ...but it is blocked.
if ((self.error_number == ERROR_BLOCKED_LEFT) or (self.error_number == ERROR_CLOSE) or (self.error_number == ERROR_AVOID_LEFT)):
message = 'Object in Way Failed to go Left -> Avoiding Right.'
self.action = 'I'
elif ((self.error_number == ERROR_AVOID_RIGHT) or (self.error_number == ERROR_BLOCKED_RIGHT)):
message = 'Object in Way, Failed to go Right -> Avoiding Left.'
self.action = 'J'
else:
message = 'Home Too Small -> Moving Forward.'
self.action = 'F'
#2 ..and have reached the zone...
else:
message = 'At Home -> Parking.'
self.action = 'F'
self.returned = True
#1 Home is not in view...
except ValueError:
message = 'Cannot See Home -> Searching Left For Home.'
self.action = 'N'
print('[Finding Home]...' + message)
## Execute action with arduino.
def control_arduino(self):
### Send
try:
self.arduino.write(self.action)
message = self.action
except Exception:
message = 'Failure.'
print('[Sending ACTION]...' + message)
### Receive
try:
self.error_number = int(self.arduino.readline())
message = str(self.error_number)
except ValueError:
self.error_number = ERROR_PARSE
message = "ValueError: Failed to parse signal, retrying..."
except OSError:
self.error_number = ERROR_CONNECTION
message = "OSError: Connection lost, retrying..."
except SerialException:
self.error_number = ERROR_CONNECTION
message = "Serial Exception: Connection lost, retrying..."
except SyntaxError:
self.error_number = ERROR_PARSE
message = "Syntax Error: Failed to parse signal, retrying..."
except KeyError:
self.error_number = ERROR_PARSE
message = 'KeyError: Failed to parse signal, retrying...'
print('[Receiving ERROR from Controller]...' + message)
## Handle Errors from Arduino
def handle_error(self):
if (self.error_number == ERROR_NONE):
self.error = 'NONE'
elif (self.error_number == ERROR_CLOSE):
self.error = 'TOO CLOSE'
elif (self.error_number == ERROR_LOAD):
self.error = 'LOAD FAILED'
self.gathered -= 1
elif (self.error_number == ERROR_PARSE):
self.error = 'PARSE FAILED'
elif (self.error_number == ERROR_ACTION):
self.error = 'BAD ACTION'
elif (self.error_number == ERROR_BLOCKED_RIGHT):
self.error = 'BLOCKED AFTER RIGHT TURN'
elif (self.error_number == ERROR_BLOCKED_LEFT):
self.error = 'BLOCKED AFTER LEFT TURN'
elif (self.error_number == ERROR_ORBIT_RIGHT):
self.error = 'ORBIT RIGHT FAILED'
elif (self.error_number == ERROR_ORBIT_LEFT):
self.error = 'ORBIT LEFT FAILED'
elif (self.error_number == ERROR_AVOID_RIGHT):
self.error = 'AVOID RIGHT FAILED'
elif (self.error_number == ERROR_AVOID_LEFT):
self.error = 'AVOID LEFT FAILED'
else:
self.error = 'UNKNOWN ERROR'
print('[Handling ERRORS]...' + self.error)
## Send RESPONSE to Server
def send_response(self):
try:
json_response = json.dumps({'ACTION':self.action, 'ERROR':self.error, 'GATHERED':str(self.gathered), 'GOAL':self.goal})
self.connection.send(json_response)
message = str(json_response)
except Exception:
message = "Failure."
print('[Sending RESPONSE]...' + message)
## Disconnect from Server.
def disconnect(self):
try:
self.socket_in.close()
self.socket_out.close()
self.connection.close()
self.reset_worker()
message = 'Success.'
except Exception:
message = 'Failure.'
pass
print('[Disconnecting]...' + message)
## Reset Worker
def reset_worker(self):
try:
self.connected_out = False
self.connected_in = False
self.command = None
self.response = None
self.action = None
self.previous_action = None
self.error = None
self.error_number = None
self.gathered = 0
self.dumped = False
self.returned = False
self.x = 0
self.y = 0
self.orientation = 0
message = 'Success.'
except Exception:
message = 'Failure.'
print('[Resetting Worker]...' + message)
frame_count = int(np.ceil(video.get(7))/3)
internal = 0
# while internal < 2507:
# condition = video.grab()
# print "Skipping frame %d" % internal
# count += 1
# internal += 1
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()
class Camera_Capture(object):
"""docstring for uvcc_camera"""
def __init__(self, cam, size=(640, 480), fps=30):
self.src_id = cam.src_id
self.uId = cam.uId
self.name = cam.name
self.controls = Controls(self.uId)
try:
self.controls["UVCC_REQ_FOCUS_AUTO"].set_val(0)
except KeyError:
pass
self.capture = VideoCapture(self.src_id)
self.set_size(size)
def re_init(self, cam, size=(640, 480), fps=30):
self.src_id = cam.src_id
self.uId = cam.uId
self.name = cam.name
self.controls = Controls(self.uId)
try:
self.controls["UVCC_REQ_FOCUS_AUTO"].set_val(0)
except KeyError:
pass
self.capture = VideoCapture(self.src_id)
self.set_size(size)
# recreate the bar with new values
bar_pos = self.bar._get_position()
self.bar.destroy()
self.create_atb_bar(bar_pos)
def re_init_cam_by_src_id(self, src_id):
try:
cam = Camera_List()[src_id]
except KeyError:
logger.warning("could not reinit capture, src_id not valid anymore")
return
self.re_init(cam, self.get_size())
def get_frame(self):
s, img = self.capture.read()
timestamp = time()
return Frame(timestamp, img)
def set_size(self, size):
width, height = size
self.capture.set(3, width)
self.capture.set(4, height)
def get_size(self):
return self.capture.get(3), self.capture.get(4)
def set_fps(self, fps):
self.capture.set(5, fps)
def get_fps(self):
return self.capture.get(5)
def create_atb_bar(self, pos):
# add uvc camera controls to a separate ATB bar
size = (200, 200)
self.bar = atb.Bar(
name="Camera_Controls",
label=self.name,
help="UVC Camera Controls",
color=(50, 50, 50),
alpha=100,
text="light",
position=pos,
refresh=2.0,
size=size,
)
sorted_controls = [c for c in self.controls.itervalues()]
sorted_controls.sort(key=lambda c: c.order)
cameras_enum = atb.enum("Capture", dict([(c.name, c.src_id) for c in Camera_List()]))
self.bar.add_var("Capture", vtype=cameras_enum, getter=lambda: self.src_id, setter=self.re_init_cam_by_src_id)
for control in sorted_controls:
name = control.atb_name
if control.type == "bool":
self.bar.add_var(name, vtype=atb.TW_TYPE_BOOL8, getter=control.get_val, setter=control.set_val)
elif control.type == "int":
self.bar.add_var(name, vtype=atb.TW_TYPE_INT32, getter=control.get_val, setter=control.set_val)
self.bar.define(definition="min=" + str(control.min), varname=name)
self.bar.define(definition="max=" + str(control.max), varname=name)
self.bar.define(definition="step=" + str(control.step), varname=name)
elif control.type == "menu":
if control.menu is None:
vtype = None
else:
vtype = atb.enum(name, control.menu)
self.bar.add_var(name, vtype=vtype, getter=control.get_val, setter=control.set_val)
if control.menu is None:
self.bar.define(definition="min=" + str(control.min), varname=name)
self.bar.define(definition="max=" + str(control.max), varname=name)
self.bar.define(definition="step=" + str(control.step), varname=name)
else:
pass
if control.flags == "inactive":
pass
# self.bar.define(definition='readonly=1',varname=control.name)
self.bar.add_button("refresh", self.controls.update_from_device)
self.bar.add_button("load defaults", self.controls.load_defaults)
return size
def kill_atb_bar(self):
pass
def close(self):
self.control = None
logger.info("Capture released")
pass
from moustache import _putmoustache_
from itertools import count
backgroundTreshold = 35
beach = imread('manzara640.png', -1)
video_capture = VideoCapture(0)
if not video_capture.isOpened():
exit('The Camera is not opened')
counter = count(1)
for i in range(0, 50):
ret, background = video_capture.read()
imshow("Video", background)
waitKey(10)
print "!!! Step out of the frame !!!"
print "Background will be detected in %d seconds" % (7 - i)
ret, background = video_capture.read()
background = pyrDown(background)
#background = pyrDown(background)
while True:
print "Iteration %d" % counter.next()
ret, temp = video_capture.read()
#temp = pyrDown(temp)
frame2 = _putmoustache_(temp)
frame3 = _putglass_(frame2)
# HAAR cascades for face and eyes
faceCasc = CascadeClassifier(os.path.join(basedir,'cascadeFiles/haarcascade_frontalface_alt2.xml'))
eyeCasc = CascadeClassifier(os.path.join(basedir,'cascadeFiles/haarcascade_eye_tree_eyeglasses.xml'))
gender1 = 0
gender2 = 0
count = 0
# Important parameters for alignAtEyes()
sz = 210
offSetH = 0.25
offSetV = 0.25
keyPressed = -1
while(keyPressed != 27):
unused_retval, img0 = capture.read()
img1 = cvtColor(img0, COLOR_BGR2GRAY)
faceImgs, faceRegions = findFace(img1,faceCasc)
if faceImgs is None:
pass
else:
for indx, img in enumerate(faceImgs):
# Register the image with alignment at eyes
img = alignAtEyes(eyeCasc, img, name, sz, offSetH, offSetV)
# Get prediction and draw on img0
if img is None:
pass
from cv2 import VideoCapture, imwrite from datetime import datetime cam = VideoCapture(0) # 0 -> index of camera s, img = cam.read() if s: tm = datetime.now() filename = "date-"+str(tm.year)+"-"+ str(tm.month)+"-"+ str(tm.day)+"_time-"+ str(tm.hour)+"-"+ str(tm.minute)+"-"+ str(tm.second)+"-"+str(tm.microsecond)+".jpg" imwrite(filename,img)
