def testRunContext(self):
r = Random()
n = r.randint(1, 999)
c = RunContext(n)
t = Task(c.execute)
t.run(None)
self.assertEqual(n, t.result, "The result and generated random number must be equal")
def deactivate(self):
if self.active:
Task.deactivate(self)
self.cursor.visible = False
if self.outFile is not None and not self.outFile.closed:
self.outFile.close()
if self.showPoseWindow:
cv2.destroyWindow(self.windowName)
def __init__(self):
Task.__init__(self)
# * Initialize variables
self.pointer = HapticPointer() # TODO create tools directly in Main, just like tasks, and find them here?
# * Load scene fragments
self.context.scene.readXML(self.context.getResourcePath('data', 'PointerScene.xml'))
def deactivate(self):
if self.active:
Task.deactivate(self)
self.cursor.visible = False
if self.outFile is not None and not self.outFile.closed:
self.outFile.close()
if self.showPoseWindow:
cv2.destroyWindow(self.windowName)
def activate(self):
# * Find pointer actor in scene, reposition it and make it visible
self.pointerActor = self.context.scene.findActorById('pointer')
if self.pointerActor is None:
self.logger.warn("[HapticSelectTask] Pointer object not found in scene; task could not be initialized")
return
self.pointerActor.components['Transform'].translation = np.float32([0, 0, 80])
self.pointerActor.visible = True
Task.activate(self)
def testErrorFieldSet(self):
global errorFunction, result
t = Task(errorFunction)
try:
t.run(None)
self.fail("Exception not raised")
except:
pass
self.assertTrue(result, "Function not called")
self.assertEqual("Failed", "%s" % t.error, "Error field not set")
def testResultFieldUnset(self):
global errorFunction, result
t = Task(errorFunction)
try:
t.run(None)
self.fail("Exception not raised")
except:
pass
self.assertTrue(result, "Function not called")
self.assertEqual(None, t.result, "Result field set")
def testCallbackFail(self):
r = Random()
n = r.randint(1, 999)
c = FailCallback(n)
t = Task(c.execute, c.callback)
try:
t.run(None)
self.fail("The expected exception was not thrown")
except CallbackExecutionException as e:
self.assertEqual("Failure! %i" % n, "%s" % e, "Exception message not correct")
def testSuccessfulFlagFalse(self):
global errorFunction, result
t = Task(errorFunction)
try:
t.run(None)
self.fail("Exception not raised")
except:
pass
self.assertTrue(result, "Function not called")
self.assertFalse(t.successful, "Run flag not set")
async def test_dependency(self):
t1 = Task('t1')
dep_ = Dependency(t1)
assert t1 == dep_.get_custodian_task
t2 = Task('t1-1')
t3 = Task('t1-2')
t4 = Task('t1-3')
await dep_.add_tasks([t2, t3, t4])
assert len(dep_) == 3
def testCallbackSuccess(self):
r = Random()
n = r.randint(1, 999)
c = SuccessfulCallback(n)
t = Task(c.execute, c.callback)
try:
t.run(None)
self.assertEqual(n, t.result, "The result and generated random number must be equal")
self.assertEqual(n, c.result, "The callback-stored result and random number must be equal")
self.assertTrue(c.successful, "The callback must set the successful flag")
except Exception as e:
self.fail("Threw exception: %s" % e)
def __init__(self):
# NOTE Scene must be initialized at this point
Task.__init__(self)
self.cursor = None
self.outFile = None
self.poseRecordHeader = "frame\ttime\ttrans_x\ttrans_y\ttrans_z\trot_x\trot_y\trot_z\n"
self.poseRecordFormat = "{frameCount}\t{timeNow}\t{tvec[0]}\t{tvec[1]}\t{tvec[2]}\t{rvec[0]}\t{rvec[1]}\t{rvec[2]}\n"
self.lastFrameCount = -1
self.showPoseWindow = False # to be treated as a constant flag; may slow down recording
if self.showPoseWindow:
self.imageOut = np.zeros((50, 300, 3), dtype=np.uint8)
self.windowName = "Cursor pose"
def __init__(self):
# NOTE Scene must be initialized at this point
Task.__init__(self)
self.cursor = None
self.outFile = None
self.poseRecordHeader = "frame\ttime\ttrans_x\ttrans_y\ttrans_z\trot_x\trot_y\trot_z\n"
self.poseRecordFormat = "{frameCount}\t{timeNow}\t{tvec[0]}\t{tvec[1]}\t{tvec[2]}\t{rvec[0]}\t{rvec[1]}\t{rvec[2]}\n"
self.lastFrameCount = -1
self.showPoseWindow = False # to be treated as a constant flag; may slow down recording
if self.showPoseWindow:
self.imageOut = np.zeros((50, 300, 3), dtype=np.uint8)
self.windowName = "Cursor pose"
def activate(self):
self.cursor = self.context.scene.findActorById('cursor')
self.target = self.context.scene.findActorById('target')
if self.cursor is None or self.target is None:
self.logger.warn("[MatchTargetTask] Cursor or target object not found; task could not be initialized")
return
self.cursor.visible = True
self.target.visible = True
if self.showMatchWindow:
self.imageOut.fill(255)
cv2.imshow(self.windowName, self.imageOut)
cv2.waitKey(1)
Task.activate(self)
def testAlreadyRun(self):
r = Runner(100)
t = Task(r.execute)
try:
t.run(None)
except:
self.fail("Exception thrown where unexpected")
try:
t.run(None)
self.fail("Did not cause any exceptions")
except AlreadyRunException:
pass
def import_(cls, data_id, type_,*args, **kwargs):
"""
data import
including generate config, register a task, and fire a task
:param data_id: data id
:param type_: type of data import task, support database, hdfs, text-file
:param detail: configuration detail
:return: None
"""
data_path = cls.my_data_path(data_id)
config = cls.generate_config(data_path,*args,**kwargs)
task_id = Task.register(Task.TYPE.DATA_IMPORT)
DataImport(data_id= data_id, task_id= task_id, type_l= type_, config= config).save()
Task.fire(task_id)
def activate(self):
self.cursor = self.context.scene.findActorById('cube') # NOTE cube itself is the cursor object
if self.cursor is None:
self.logger.warn("[RecordPoseTask] Cursor object not found; task could not be initialized")
return
self.cursor.visible = True
self.outFile = open(self.context.getResourcePath("../out", "pose.dat"), "w") # TODO change to getOutputPath()?
self.outFile.write(self.poseRecordHeader)
self.lastFrameCount = -1
if self.showPoseWindow:
self.imageOut.fill(255)
cv2.imshow(self.windowName, self.imageOut)
cv2.waitKey(1)
Task.activate(self)
def __init__(self):
# NOTE Scene must be initialized at this point
Task.__init__(self)
# * Initialize variables
self.cursor = None
self.target = None
self.showMatchWindow = True # to be treated as a constant flag
if self.showMatchWindow:
self.imageOut = np.zeros((64, 128, 3), dtype=np.uint8)
self.windowName = "Match error"
# * Load scene fragments
self.context.scene.readXML(self.context.getResourcePath('data', 'DragonScene.xml')) # cursor
self.context.scene.readXML(self.context.getResourcePath('data', 'StaticDragonScene.xml')) # target
def activate(self):
self.cursor = self.context.scene.findActorById('cursor')
self.target = self.context.scene.findActorById('target')
if self.cursor is None or self.target is None:
self.logger.warn(
"[MatchTargetTask] Cursor or target object not found; task could not be initialized"
)
return
self.cursor.visible = True
self.target.visible = True
if self.showMatchWindow:
self.imageOut.fill(255)
cv2.imshow(self.windowName, self.imageOut)
cv2.waitKey(1)
Task.activate(self)
def __init__(self):
# NOTE Scene must be initialized at this point
Task.__init__(self)
# * Initialize variables
self.cursor = None
self.target = None
self.showMatchWindow = True # to be treated as a constant flag
if self.showMatchWindow:
self.imageOut = np.zeros((64, 128, 3), dtype=np.uint8)
self.windowName = "Match error"
# * Load scene fragments
self.context.scene.readXML(
self.context.getResourcePath('data', 'DragonScene.xml')) # cursor
self.context.scene.readXML(
self.context.getResourcePath('data',
'StaticDragonScene.xml')) # target
def activate(self):
self.cursor = self.context.scene.findActorById(
'cube') # NOTE cube itself is the cursor object
if self.cursor is None:
self.logger.warn(
"[RecordPoseTask] Cursor object not found; task could not be initialized"
)
return
self.cursor.visible = True
self.outFile = open(self.context.getResourcePath("../out", "pose.dat"),
"w") # TODO change to getOutputPath()?
self.outFile.write(self.poseRecordHeader)
self.lastFrameCount = -1
if self.showPoseWindow:
self.imageOut.fill(255)
cv2.imshow(self.windowName, self.imageOut)
cv2.waitKey(1)
Task.activate(self)
def testErrorFieldUnset(self):
global runFunction, result
t = Task(runFunction)
t.run(None)
self.assertTrue(result, "Function not called")
self.assertEqual(None, t.error, "Error field set")
def deactivate(self): Task.deactivate(self) self.pointerActor.visible = False self.pointer.close()
def __init__(self):
#sys.argv = ['Main.py', '../res/videos/test-14.mpeg', '--hide_input'] # [debug: run with set command-line args]
# * Initialize global context, passing in custom command line args (parsed by Context)
argParser = argparse.ArgumentParser(add_help=False)
showInputGroup = argParser.add_mutually_exclusive_group()
showInputGroup.add_argument(
'--show_input',
dest='show_input',
action="store_true",
default=True,
help="show input video (emulate see-through display)?")
showInputGroup.add_argument(
'--hide_input',
dest='show_input',
action="store_false",
default=False,
help="hide input video (show only virtual objects)?")
argParser.add_argument('--task',
default="Task",
help="task to run (maps to class name)")
argParser.add_argument(
'--scene',
dest="scene_files",
metavar='SCENE_FILE',
nargs='+',
help="scene fragment(s) to load (filenames in <res>/data/)")
self.context = Context.createInstance(
description="Tangible Data Exploration",
parent_argparsers=[argParser])
self.context.main = self # hijack global context to share a reference to self
# NOTE Most objects require an initialized context, so do this as soon as possible
# * Obtain a logger (NOTE Context must be initialized first since it configures logging)
self.logger = logging.getLogger(__name__)
self.logger.info("Resource path: {}".format(self.context.resPath))
if not haveCV:
self.logger.warn("OpenCV library not available")
# * Initialize GL rendering context and associated objects (NOTE order of initialization may be important)
self.context.renderer = Renderer()
self.context.controller = Controller()
# * Initialize scene and load base scene fragments, including tools
self.context.scene = Scene()
self.context.scene.readXML(
self.context.getResourcePath('data',
'CubeScene.xml')) # just the cube
#self.context.scene.readXML(self.context.getResourcePath('data', 'DragonScene.xml')) # Stanford Dragon
#self.context.scene.readXML(self.context.getResourcePath('data', 'BP3D-FMA7088-heart.xml')) # BodyParts3D heart model hierarchy
#self.context.scene.readXML(self.context.getResourcePath('data', 'RadialTreeScene.xml'))
#self.context.scene.readXML(self.context.getResourcePath('data', 'PerspectiveScene.xml'))
# ** Load scene fragments specified on commandline (only need to specify filename in data/ directory)
self.logger.info("Scene fragment(s): %s",
self.context.options.scene_files)
if self.context.options.scene_files is not None:
for scene_file in self.context.options.scene_files:
self.context.scene.readXML(
self.context.getResourcePath('data', scene_file))
# * Initialize task (may load further scene fragments, including task-specific tools)
try:
taskModule = import_module(
'task.' + self.context.options.task
) # fetch module by name from task package
taskType = getattr(
taskModule, self.context.options.task
) # fetch class by name from corresponding module (same name, by convention)
self.context.task = taskType(
) # create an instance of specified task class
except Exception as e:
self.logger.error("Task initialization error: {}".format(e))
self.context.task = Task() # fallback to dummy task
# * Finalize scene (resolves scene fragments into one hierarchy, builds ID-actor mapping)
self.context.scene.finalize(
) # NOTE should be called after all read*() methods have been called on scene
# * Find cube in scene
self.cubeActor = self.context.scene.findActorById('cube')
self.cubeComponent = self.cubeActor.components[
'Cube'] if self.cubeActor is not None else None
# * Open camera/input file
self.logger.info("Input device/file: {}".format(
self.context.options.input_source))
self.camera = cv2.VideoCapture(
self.context.options.input_source
) if not self.context.isImage else cv2.imread(
self.context.options.input_source)
# TODO move some more options (e.g. *video*) to context; introduce config.yaml-like solution with command-line overrides
self.options = {
'gui': self.context.options.gui,
'debug': self.context.options.debug,
'isVideo': self.context.isVideo,
'loopVideo': self.context.options.loop_video,
'syncVideo': self.context.options.sync_video,
'videoFPS': self.context.options.video_fps,
'isImage': self.context.isImage,
'cameraWidth': cameraWidth,
'cameraHeight': cameraHeight,
'windowWidth': windowWidth,
'windowHeight': windowHeight
}
self.context.videoInput = VideoInput(self.camera, self.options)
# TODO If live camera, let input image stabilize by eating up some frames, then configure camera
# e.g. on Mac OS, use uvc-ctrl to turn off auto-exposure:
# $ ./uvc-ctrl -s 1 3 10
# * Create image blitter, if input is to be shown
if self.context.options.show_input:
self.context.imageBlitter = FrameProcessorGL(
self.options
) # CV-GL renderer that blits (copies) CV image to OpenGL window
# TODO Evaluate 2 options: Have separate tracker and blitter/renderer or one combined tracker that IS-A FrameProcessorGL? (or make a pipeline?)
self.logger.info(
"Video see-through mode enabled; input video underlay will be shown"
)
else:
self.logger.info(
"Video see-through mode disabled; only virtual objects will be shown"
)
# * Setup tracking
self.context.cubeTracker = CubeTracker(
self.options
) # specialized cube tracker, available in context to allow access to cubeTracker's input and output images etc.
if self.cubeComponent is not None:
self.logger.info("Tracking setup: Cube has {} markers".format(
len(self.cubeComponent.markers)))
self.context.cubeTracker.addMarkersFromTrackable(
self.cubeComponent)
def testNoArgsJob(self):
# Tests that a job which isn't expecting args still works
j = NoArgsJob()
t = Task(j.do)
t.run(None)
self.assertTrue(j.run)
def deactivate(self):
Task.deactivate(self)
self.cursor.visible = False
self.target.visible = False
if self.showMatchWindow:
cv2.destroyWindow(self.windowName)
def deactivate(self):
Task.deactivate(self)
self.cursor.visible = False
self.target.visible = False
if self.showMatchWindow:
cv2.destroyWindow(self.windowName)
def testRunFlag(self):
global runFunction, result
t = Task(runFunction)
t.run(None)
self.assertTrue(result, "Function not called")
self.assertTrue(t.hasRun, "Run flag not set")
def testResultFieldSet(self):
global runFunction, result
t = Task(runFunction)
t.run(None)
self.assertTrue(result, "Function not called")
self.assertEqual(True, t.result, "Result field not set")
def testSuccessfulFlagTrue(self):
global runFunction, result
t = Task(runFunction)
t.run(None)
self.assertTrue(result, "Function not called")
self.assertTrue(t.successful, "Run flag not set")
