def setFrame(frame):
global State, mats, movieFilenames, primitives
global movies, primitives2D, deinterlacing, detectingWands, dot_detections, track3d, prev_frame, booting, trackGraph
key = State.getKey('dotParams/attrs')
skipping, prev_frame = (frame != prev_frame
and frame - 1 != prev_frame), frame
booting = 10 if skipping else booting - 1
p0, p1 = [], []
if True: #dot_detections is None:
for pair in enumerate(movies):
pts = process_frame(deinterlacing, detectingWands, frame, key,
pair)
p0.append(pts[0])
p1.append(pts[1])
def make_bounds(lens):
return np.array([sum(lens[:x]) for x in xrange(len(lens) + 1)],
dtype=np.int32)
data0 = np.array(np.concatenate(p0),
dtype=np.float32).reshape(-1, 2), make_bounds(
map(len, p0))
data1 = np.array(np.concatenate(p1),
dtype=np.float32).reshape(-1, 2), make_bounds(
map(len, p1))
else:
#dot_detections = movies_to_detections(movies, [frame], deinterlacing, key)
data0, data1 = dot_detections[frame] if dot_detections.has_key(
frame) else dot_detections.values()[0]
for ci, md in enumerate(movies):
try:
MovieReader.readFrame(md, seekFrame=frame)
except:
print 'oops', frame
return None, None
#img = np.frombuffer(md['vbuffer'],dtype=np.uint8).reshape(md['vheight'],md['vwidth'],3)
QApp.view().cameras[ci + 1].invalidateImageData()
data0 = data0[0].copy(), data0[
1] # so that undistort doesn't modify the raw detections
data1 = data1[0].copy(), data1[1]
# TODO, move this to the viewer...
data0 = ViconReader.frameCentroidsToDets(data0, mats)
data1 = ViconReader.frameCentroidsToDets(data1, mats)
primitives2D[0].setData(data0[0], data0[1])
primitives2D[1].setData(data1[0], data1[1])
#print x2ds_labels
if len(movieFilenames) is not 1:
if 1:
#x2ds_data, x2ds_splits = data0 # dark points only
x2ds_data, x2ds_splits = data1 # light points only
if skipping:
x3ds, x3ds_labels = track3d.boot(x2ds_data, x2ds_splits)
#trackGraph = Label.TrackGraph()
else:
x3ds, x3ds_labels = track3d.push(x2ds_data, x2ds_splits)
# coarse bounding box
if False:
for xi, x in zip(x3ds_labels, x3ds):
if x[0] < -200 or x[0] > 200 or x[1] < 800 or x[
1] > 1200 or x[2] < -50 or x[2] > 300:
track3d.x2ds_labels[np.where(
track3d.x2ds_labels == xi)[0]] = -1
x[:] = 0
primitives[0].setData(x3ds)
#trackGraph.push(x3ds,x3ds_labels)
#primitives[0].graph = trackGraph.drawing_graph()
elif False:
Ps = np.array([m[2] / (m[0][0, 0]) for m in mats],
dtype=np.float32)
data = data0 # dark points
#data = data1 # light points
x3ds, x2ds_labels = Recon.intersect_rays(data[0],
data[1],
Ps,
mats,
tilt_threshold=0.003,
x2d_threshold=0.02,
x3d_threshold=5.0,
min_rays=2)
primitives[0].setData(x3ds)
if detectingTiara:
global c3d_frames
frame = c3d_frames[(frame - 55) % len(c3d_frames)]
which = np.where(frame[:, 3] == 0)[0]
x3ds = frame[which, :3]
#print frame,'len',len(x3ds)
primitives[1].setData(x3ds)
QApp.app.refreshImageData()
QApp.app.updateGL()
def intersectRaysCB(fi):
global x2d_frames, mats, Ps, c3d_frames, view, primitives, primitives2D, track3d, prev_frame, track_orn, orn_graph, boot, g_all_skels, md, orn_mapper, mar_mapper
skipping = prev_frame is None or np.abs(fi - prev_frame) > 10
prev_frame = fi
view = QApp.view()
points, altpoints = primitives
g2d = primitives2D[0]
frame = x2d_frames[fi]
x2ds_data, x2ds_splits = ViconReader.frameCentroidsToDets(frame, mats)
g2d.setData(x2ds_data, x2ds_splits)
if skipping:
x3ds, x3ds_labels = track3d.boot(x2ds_data, x2ds_splits)
#trackGraph = Label.TrackGraph()
boot = -10
else:
x3ds, x3ds_labels = track3d.push(x2ds_data, x2ds_splits)
if False:
boot = boot + 1
if boot == 0:
x2d_threshold_hash = 0.01
penalty = 10.0 # the penalty for unlabelled points. this number should be about 10. to force more complete labellings, set it higher.
maxHyps = 500 # the number of hypotheses to maintain.
print "booting:"
numLabels = len(orn_graph[0])
l2x = -np.ones(numLabels, dtype=np.int32)
label_score = ISCV.label_from_graph(x3ds, orn_graph[0],
orn_graph[1], orn_graph[2],
orn_graph[3], maxHyps, penalty,
l2x)
clouds = ISCV.HashCloud2DList(x2ds_data, x2ds_splits,
x2d_threshold_hash)
which = np.array(np.where(l2x != -1)[0], dtype=np.int32)
pras_score, x2d_labels, vels = Label.project_assign(
clouds,
x3ds[l2x[which]],
which,
Ps,
x2d_threshold=x2d_threshold_hash)
print fi, label_score, pras_score
labelled_x3ds = x3ds[l2x[which]]
print track_orn.bootPose(x2ds_data, x2ds_splits, x2d_labels)
if boot > 0:
track_orn.push(x2ds_data, x2ds_splits, its=4)
#x3ds,x2ds_labels = Recon.intersect_rays(x2ds_data, x2ds_splits, Ps, mats, seed_x3ds = None)
points.setData(x3ds)
if c3d_frames != None:
c3ds = c3d_frames[(fi - 832) / 2]
true_labels = np.array(np.where(c3ds[:, 3] == 0)[0], dtype=np.int32)
x3ds_true = c3ds[true_labels, :3]
altpoints.setData(x3ds_true)
ci = view.cameraIndex() - 1
if True: #ci == -1:
MovieReader.readFrame(md, seekFrame=max((fi - 14) / 4, 0))
QApp.app.refreshImageData()
(orn_skel_dict, orn_t) = g_all_skels['orn']
orn_mesh_dict, orn_skel_mesh, orn_geom_mesh = orn_t
orn_anim_dict = orn_skel_dict['anim_dict']
orn_skel_dict['chanValues'][:] = orn_anim_dict['dofData'][fi]
Character.updatePoseAndMeshes(orn_skel_dict, orn_skel_mesh, orn_geom_mesh)
(mar_skel_dict, mar_t) = g_all_skels['mar']
mar_anim_dict = mar_skel_dict['anim_dict']
mar_mesh_dict, mar_skel_mesh, mar_geom_mesh = mar_t
Character.updatePoseAndMeshes(mar_skel_dict, mar_skel_mesh, mar_geom_mesh,
mar_anim_dict['dofData'][fi])
from PIL import Image
#orn_geom_mesh.setImage((md['vbuffer'],(md['vheight'],md['vwidth'],3)))
#orn_geom_mesh.refreshImage()
w, h = 1024, 1024
cam = view.cameras[0]
cam.refreshImageData(view)
aspect = float(max(1, cam.bindImage.width())) / float(
cam.bindImage.height()) if cam.bindImage is not None else 1.0
orn_mapper.project(orn_skel_dict['geom_Vs'], aspect)
data = Opengl.renderGL(w, h, orn_mapper.render, cam.bindId)
orn_geom_mesh.setImage(data)
mar_mapper.project(mar_skel_dict['geom_Vs'], aspect)
data = Opengl.renderGL(w, h, mar_mapper.render, cam.bindId)
mar_geom_mesh.setImage(data)
#image = Image.fromstring(mode='RGB', size=(w, h), data=data)
#image = image.transpose(Image.FLIP_TOP_BOTTOM)
#image.save('screenshot.png')
if 0:
global g_screen
image = Opengl.renderGL(1920, 1080, Opengl.quad_render,
(cam.bindId, g_screen))
import pylab as pl
pl.imshow(image)
pl.show()
view.updateGL()