def __init__(self):
#Get camera id
camerasettings = CameraSettings()
self.id_device = int(camerasettings.read_id())
#Width and heigth of Handibox capture window
self.width = 320
self.height = 240
#Capture from selected camera
self.capture = cv.CreateCameraCapture(self.id_device)
#Set width and height of current capture
if self.width is None:
self.width = int(cv.GetCaptureProperty(capture, cv.CV_CAP_PROP_FRAME_WIDTH))
else:
cv.SetCaptureProperty(self.capture,cv.CV_CAP_PROP_FRAME_WIDTH,self.width)
if self.height is None:
self.height = int(cv.GetCaptureProperty(self.capture, cv.CV_CAP_PROP_FRAME_HEIGHT))
else:
cv.SetCaptureProperty(self.capture,cv.CV_CAP_PROP_FRAME_HEIGHT,self.height)
result = cv.CreateImage((self.width,self.height),cv.IPL_DEPTH_8U,3)
#Instantiate FaceTraking Class, return framed face and move mouse pointer
faceTraking = FaceTracking()
#show capture loop, show image with framed face
while True:
image = cv.QueryFrame(self.capture)
show = faceTraking.detectFace(image)
faceTraking.updateMousePos()
cv.ShowImage("HandiMouse", image)
k = cv.WaitKey(10);
if k == 'f':
break
def getCurrentCameraSettings(self):
cs = CameraSettings()
cam = self.graphicsFrameWidget.ren.GetActiveCamera()
# print "GET cam=",cam
cs.position = cam.GetPosition()
cs.focalPoint = cam.GetFocalPoint()
cs.viewUp = cam.GetViewUp()
# cs.viewPlaneNormal=
cs.clippingRange = cam.GetClippingRange()
cs.distance = cam.GetDistance()
cs.viewAngle = cam.GetViewAngle()
cs.parallelScale = cam.GetParallelScale()
return cs
def getCurrentCameraSettings(self):
cs=CameraSettings()
cam = self.graphicsFrameWidget.ren.GetActiveCamera()
# print "GET cam=",cam
cs.position=cam.GetPosition()
cs.focalPoint=cam.GetFocalPoint()
cs.viewUp=cam.GetViewUp()
# cs.viewPlaneNormal=
cs.clippingRange=cam.GetClippingRange()
cs.distance=cam.GetDistance()
cs.viewAngle=cam.GetViewAngle()
cs.parallelScale=cam.GetParallelScale()
return cs
def __init__(self, file_name, camera_settings, camera_memory):
self.name = "StreamFileVideo:%s" % (file_name)
self.logger = logging.getLogger(__name__)
self.file_cam = cv2.VideoCapture(file_name) # setup stream
time.sleep(0.2)
self.camera_settings = CameraSettings(self.file_cam, camera_settings)
self.camera_memory = CameraMemory(
camera_memory) # remember memory type and camera settings
self.starttime = 0 # keep track of some metrics
self.stoptime = 0
self.stopped = True
self.frame_count = 0
if self.file_cam.isOpened() == False:
self.logger.error(self.name + " couldn't open file:" + file_name)
self.camera_memory.write((-2, None))
return
def config(self, params):
# params is dict like: {'camera_type': 'camera', 'camera_name': '0', 'camera_memory': ['deque', ' 100', '1'],
# 'camera_settings': [['CAP_PROP_AUTO_EXPOSURE', '.75']], 'read_fps': 30.0, 'width': 1280, 'height': 720}
if params == None:
return
self.camera_type = params['camera_type']
self.camera_name = int(params['camera_name'])
self.camera_memory = None
self.camera_memory = CameraMemory(
camera_memory=params['camera_memory'])
self.camera_settings = None
cs = params['camera_settings']
self.camera_settings = CameraSettings(
self.stream, camera_settings=params['camera_settings'])
self.read_fps = float(params['read_fps'])
self.width = int(params['width'])
self.height = int(params['height'])
self.stream.set(cv2.CAP_PROP_FRAME_HEIGHT, self.height)
self.stream.set(cv2.CAP_PROP_FRAME_WIDTH, self.width)
self.stream.set(cv2.CAP_PROP_FPS, self.read_fps)
return
def __init__(self,
camera_name='0',
camera_settings=None,
camera_memory=None):
self.logger = logging.getLogger(__name__)
self.logger.info(__name__)
self.stream = cv2.VideoCapture(int(camera_name)) # setup stream
self.camera_memory = CameraMemory(
camera_memory) # remember memory type and camera settings
self.camera_settings = CameraSettings(self.stream, camera_settings)
self.starttime = 0 # keep track of some metrics
self.stoptime = 0
self.stopped = True
self.frame_count = 1
self.width = 640
self.height = 480
self.read_fps = 30.0
if self.stream.isOpened() == False:
self.logger.error("couldn't open camera:" + camera_name)
self.camera_memory.write((-2, None, ""))
return
class StreamCameraVideo(): #--------------------------------
def __init__(self,
camera_name='0',
camera_settings=None,
camera_memory=None):
self.logger = logging.getLogger(__name__)
self.logger.info(__name__)
self.stream = cv2.VideoCapture(int(camera_name)) # setup stream
self.camera_memory = CameraMemory(
camera_memory) # remember memory type and camera settings
self.camera_settings = CameraSettings(self.stream, camera_settings)
self.starttime = 0 # keep track of some metrics
self.stoptime = 0
self.stopped = True
self.frame_count = 1
self.width = 640
self.height = 480
self.read_fps = 30.0
if self.stream.isOpened() == False:
self.logger.error("couldn't open camera:" + camera_name)
self.camera_memory.write((-2, None, ""))
return
def config(self, params):
# params is dict like: {'camera_type': 'camera', 'camera_name': '0', 'camera_memory': ['deque', ' 100', '1'],
# 'camera_settings': [['CAP_PROP_AUTO_EXPOSURE', '.75']], 'read_fps': 30.0, 'width': 1280, 'height': 720}
if params == None:
return
self.camera_type = params['camera_type']
self.camera_name = int(params['camera_name'])
self.camera_memory = None
self.camera_memory = CameraMemory(
camera_memory=params['camera_memory'])
self.camera_settings = None
cs = params['camera_settings']
self.camera_settings = CameraSettings(
self.stream, camera_settings=params['camera_settings'])
self.read_fps = float(params['read_fps'])
self.width = int(params['width'])
self.height = int(params['height'])
self.stream.set(cv2.CAP_PROP_FRAME_HEIGHT, self.height)
self.stream.set(cv2.CAP_PROP_FRAME_WIDTH, self.width)
self.stream.set(cv2.CAP_PROP_FPS, self.read_fps)
return
def start(self):
# start the thread to read frames from the video stream
t = Thread(target=self.update, name='StreamCameraVideo', args=())
t.daemon = True
self.starttime = time.time()
t.start()
time.sleep(1)
return self
def stop(self):
# indicate that the thread should be stopped
self.stopped = True
time.sleep(0.2)
self.stream.release()
return
def update(self):
self.stopped = False
# Loop
while True:
if self.stopped:
break
(ret, self.frame) = self.stream.read()
if not ret:
self.camera_memory.write((-1, self.frame, ""))
break
# always store frame number and timestamp with frame as Tuple (,,)
timestamp = datetime.datetime.now().strftime(
"%Y%m%d.%H%M%S") + ".%07d" % self.frame_count
self.camera_memory.write((self.frame_count, self.frame, timestamp))
self.frame_count += 1
# stopped
self.stoptime = time.time()
def read(self):
# return the frame most recently read from memory
return self.camera_memory.read()
def settings(self, camera_settings=None):
res = self.camera_settings.settings(camera_settings)
#time.sleep(0.1)
return res
def memory(self, camera_memory=None):
res = self.camera_memory.memory(camera_memory)
#time.sleep(0.1)
return res
def stats(self):
duration = self.stoptime - self.starttime
fps = self.frame_count / duration
return 'stats:%s, duration:%f, frame_count:%d, FPS:%.2f' % (
__name__, duration, self.frame_count, fps)
class StreamFileVideo: #---------------
def __init__(self, file_name, camera_settings, camera_memory):
self.name = "StreamFileVideo:%s" % (file_name)
self.logger = logging.getLogger(__name__)
self.file_cam = cv2.VideoCapture(file_name) # setup stream
time.sleep(0.2)
self.camera_settings = CameraSettings(self.file_cam, camera_settings)
self.camera_memory = CameraMemory(
camera_memory) # remember memory type and camera settings
self.starttime = 0 # keep track of some metrics
self.stoptime = 0
self.stopped = True
self.frame_count = 0
if self.file_cam.isOpened() == False:
self.logger.error(self.name + " couldn't open file:" + file_name)
self.camera_memory.write((-2, None))
return
def start(self):
# start a thread to read frames from the file video stream
t = Thread(target=self.update, args=())
t.daemon = True
self.starttime = time.time()
t.start()
time.sleep(0.2)
return self
def update(self):
# keep looping infinitely
self.stopped = False
# Loop
while True:
if self.stopped:
break
(ret, self.frame) = self.file_cam.read()
if not ret:
self.frame = None
self.camera_memory.write((-1, None))
break
# always store frame number with frame as Tuple (,)
self.frame_count += 1
self.camera_memory.write((self.frame_count, self.frame))
# stopped
self.stoptime = time.time()
def read(self):
# return the frame most recently read
return self.camera_memory.read()
def stats(self):
duration = self.stoptime - self.starttime
fps = self.frame_count / duration
return {
"duration": round(duration, 2),
"frame_count": self.frame_count,
"FPS": round(fps, 2)
}
def settings(self, camera_settings=None):
ret = self.camera_settings.settings(camera_settings)
time.sleep(0.1)
return ret
def memory(self, camera_memory=None):
ret = self.camera_memory.memory(camera_memory)
time.sleep(0.1)
return ret
def stop(self):
# indicate that the thread should be stopped
self.stopped = True
time.sleep(0.2)
self.file_cam.release()
#Enable or disable Screen Magnifier
def screen_magnifier(self, button, active):
screenMagnifier = ScreenMagnifier()
if button.get_active():
screenMagnifier.enable_ScreenMagnifier()
else:
screenMagnifier.disable_ScreenMagnifier()
#Enable or disable Screen Keyboard
def screen_keyboard(self, button, active):
screenKeyboard = ScreenKeyboard()
if button.get_active():
screenKeyboard.enable_ScreenKeyboard()
else:
screenKeyboard.disable_ScreenKeyboard()
#View Settings
def view_settings(self, widget):
handiboxsettings = HandiboxSettings()
handiboxsettings.show_all()
camerasettings = CameraSettings()
camerasettings.checkconfig()
camerasettings.initcamera()
handiboxmain = HandiboxMain()
handiboxmain.connect("delete-event", Gtk.main_quit)
handiboxmain.show_all()
Gtk.main()
