def once():
global depth, rgb
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
rgb = dataset.rgb
else:
opennpy.sync_update()
depth, _ = opennpy.sync_get_depth()
rgb, _ = opennpy.sync_get_video()
main.update_frame(depth, rgb)
blockdraw.clear()
if 'RGB' in stencil.__dict__:
blockdraw.show_grid('occ', grid.occ, color=grid.color)
else:
blockdraw.show_grid('occ', grid.occ, color=np.array([1, 0.6, 0.6, 1]))
window.clearcolor = [0, 0, 0, 0]
window.flag_drawgrid = True
if 'R_correct' in main.__dict__:
window.modelmat = main.R_display
g = blockcraft.translated_rotated(main.R_correct, grid.occ)
talk_to_minecraft(g)
window.Refresh()
pylab.waitforbuttonpress(0.005)
import sys
sys.stdout.flush()
def once():
global depth, rgb
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
rgb = dataset.rgb
else:
opennpy.sync_update()
depth,_ = opennpy.sync_get_depth()
rgb,_ = opennpy.sync_get_video()
def from_rect(m,rect):
(l,t),(r,b) = rect
return m[t:b,l:r]
global mask, rect, modelmat
try:
(mask,rect) = preprocess.threshold_and_mask(depth,config.bg)
except IndexError:
return
cv.ShowImage('mask',mask.astype('u1')*255)
global label_image
label_image = classify.predict(depth)
cv.ShowImage('label_image', ((label_image[0]+1)*100*mask).astype('u1'))
pylab.waitforbuttonpress(0.03)
def once():
global depth, rgb
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
rgb = dataset.rgb
else:
opennpy.sync_update()
depth,_ = opennpy.sync_get_depth()
rgb,_ = opennpy.sync_get_video()
def from_rect(m,rect):
(l,t),(r,b) = rect
return m[t:b,l:r]
global mask, rect, modelmat
try:
(mask,rect) = preprocess.threshold_and_mask(depth,config.bg)
except IndexError:
return
cv.ShowImage('mask',mask.astype('u1')*255)
global label_image
label_image = classify.predict(depth)
cv.ShowImage('label_image', ((label_image[0]+1)*100*mask).astype('u1'))
pylab.waitforbuttonpress(0.03)
def once():
global depth, rgb
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
rgb = dataset.rgb
else:
opennpy.sync_update()
depth,_ = opennpy.sync_get_depth()
rgb,_ = opennpy.sync_get_video()
main.update_frame(depth, rgb)
blockdraw.clear()
if 'RGB' in stencil.__dict__:
blockdraw.show_grid('occ', grid.occ, color=grid.color)
else:
blockdraw.show_grid('occ', grid.occ, color=np.array([1,0.6,0.6,1]))
window.clearcolor=[0,0,0,0]
window.flag_drawgrid = True
if 'R_correct' in main.__dict__:
window.modelmat = main.R_display
g = blockcraft.translated_rotated(main.R_correct, grid.occ)
talk_to_minecraft(g)
window.Refresh()
pylab.waitforbuttonpress(0.005)
import sys
sys.stdout.flush()
def start(dset=None, frame_num=0):
main.initialize()
if not FOR_REAL:
if dset is None:
dataset.load_random_dataset()
else:
dataset.load_dataset(dset)
while dataset.frame_num < frame_num:
dataset.advance()
name = dset
name = os.path.split(name)[1]
custom = os.path.join('data/sets/', name, 'gt.txt')
if os.path.exists(custom):
# Try dataset directory first
fname = custom
else:
import re
# Fall back on generic ground truth file
match = re.match('.*_z(\d)m_(.*)', name)
number = int(match.groups()[0])
fname = 'data/experiments/gt/gt%d.txt' % number
with open(fname) as f:
GT = grid.gt2grid(f.read())
grid.initialize_with_groundtruth(GT)
else:
config.load('data/newest_calibration')
opennpy.align_depth_to_rgb()
dataset.setup_opencl()
def start(dset=None, frame_num=0):
main.initialize()
if not FOR_REAL:
if dset is None:
dataset.load_random_dataset()
else:
dataset.load_dataset(dset)
while dataset.frame_num < frame_num:
dataset.advance()
name = dset
name = os.path.split(name)[1]
custom = os.path.join('data/sets/', name, 'gt.txt')
if os.path.exists(custom):
# Try dataset directory first
fname = custom
else:
import re
# Fall back on generic ground truth file
match = re.match('.*_z(\d)m_(.*)', name)
number = int(match.groups()[0])
fname = 'data/experiments/gt/gt%d.txt' % number
with open(fname) as f:
GT = grid.gt2grid(f.read())
grid.initialize_with_groundtruth(GT)
else:
config.load('data/newest_calibration')
opennpy.align_depth_to_rgb()
dataset.setup_opencl()
def once():
dataset.advance()
depthL, depthR = dataset.depthL, dataset.depthR
maskL, rectL = preprocess.threshold_and_mask(depthL, config.bgL)
maskR, rectR = preprocess.threshold_and_mask(depthR, config.bgR)
show_mask('maskL', maskL.astype('f'), rectL)
show_mask('maskR', maskR.astype('f'), rectR)
pylab.waitforbuttonpress(0.01)
def once():
dataset.advance()
depthL, depthR = dataset.depthL, dataset.depthR
maskL, rectL = preprocess.threshold_and_mask(depthL, config.bgL)
maskR, rectR = preprocess.threshold_and_mask(depthR, config.bgR)
show_mask("maskL", maskL.astype("f"), rectL)
show_mask("maskR", maskR.astype("f"), rectR)
pylab.waitforbuttonpress(0.01)
def run_normals():
global ds
ds = []
try:
shutil.rmtree(out_path)
except:
pass
os.mkdir(out_path)
for i in range(1):
dataset.load_random_dataset()
dataset.advance()
name = 'dataset_%s' % str(i)
d = dict(name=name)
folder = os.path.join(out_path, name)
os.mkdir(folder)
depthL = dataset.depthL.astype('f')
pylab.figure(0)
pylab.clf()
pylab.imshow(depthL)
pylab.savefig(os.path.join(folder,'depth.jpg'))
dt = timeit.timeit(lambda: normals.normals_numpy(depthL),
number=1)
d['numpy'] = dt
n,w = normals.normals_numpy(depthL)
pylab.clf()
show_normals(n, w)
pylab.savefig(os.path.join(folder,'normals_numpy.jpg'))
dt = timeit.timeit(lambda: normals.normals_c(depthL),
number=1)
d['c'] = dt
n,w = normals.normals_c(depthL)
pylab.clf()
show_normals(n, w)
pylab.savefig(os.path.join(folder,'normals_c.jpg'))
rect = ((0,0),(640,480))
mask = np.zeros((480,640),'bool')
mask[1:-1,1:-1] = 1
normals.opencl.set_rect(rect, ((0,0),(0,0)))
dt = timeit.timeit(lambda:
normals.normals_opencl(depthL, mask, rect).wait(),
number=1)
d['opencl'] = dt
nw,_ = normals.opencl.get_normals()
n,w = nw[:,:,:3], nw[:,:,3]
pylab.clf()
show_normals(n,w)
pylab.savefig(os.path.join(folder,'normals_opencl.jpg'))
ds.append(d)
def run_grid():
datasets = glob.glob('data/sets/study_*')
try:
shutil.rmtree(out_path)
except:
pass
os.mkdir(out_path)
for name in datasets:
#for name in ('data/sets/cube',):
dataset.load_dataset(name)
name = os.path.split(name)[1]
d = dict(name=name)
folder = os.path.join(out_path, name)
os.mkdir(folder)
global modelmat
modelmat = None
main.initialize()
import re
number = int(re.match('.*_z(\d)m_.*', name).groups()[0])
with open('data/experiments/gt/gt%d.txt' % number) as f:
GT = grid.gt2grid(f.read())
grid.initialize_with_groundtruth(GT)
total = 0
output = []
try:
while 1:
try:
dataset.advance()
except (IOError, ValueError):
break
if dataset.frame_num % 30 == 0:
print name, dataset.frame_num
t1 = time.time()
once()
t2 = time.time()
total += t2-t1
output.append((main.R_correct.copy(), grid.occ.copy()))
except Exception as e:
print e
d['frames'] = dataset.frame_num
d['time'] = total
d['output'] = output
with open(os.path.join(folder, 'output.pkl'),'w') as f:
pickle.dump(d, f)
with open(os.path.join(folder, 'final_output.txt'),'w') as f:
f.write(grid.grid2gt(grid.occ))
def run_grid():
datasets = glob.glob('data/sets/study_*')
try:
shutil.rmtree(out_path)
except:
pass
os.mkdir(out_path)
for name in datasets:
#for name in ('data/sets/cube',):
dataset.load_dataset(name)
name = os.path.split(name)[1]
d = dict(name=name)
folder = os.path.join(out_path, name)
os.mkdir(folder)
global modelmat
modelmat = None
main.initialize()
import re
number = int(re.match('.*_z(\d)m_.*', name).groups()[0])
with open('data/experiments/gt/gt%d.txt' % number) as f:
GT = grid.gt2grid(f.read())
grid.initialize_with_groundtruth(GT)
total = 0
output = []
try:
while 1:
try:
dataset.advance()
except (IOError, ValueError):
break
if dataset.frame_num % 30 == 0:
print name, dataset.frame_num
t1 = time.time()
once()
t2 = time.time()
total += t2 - t1
output.append((main.R_correct.copy(), grid.occ.copy()))
except Exception as e:
print e
d['frames'] = dataset.frame_num
d['time'] = total
d['output'] = output
with open(os.path.join(folder, 'output.pkl'), 'w') as f:
pickle.dump(d, f)
with open(os.path.join(folder, 'final_output.txt'), 'w') as f:
f.write(grid.grid2gt(grid.occ))
def start(dset=None, frame_num=0):
if not FOR_REAL:
if dset is None:
dataset.load_random_dataset()
else:
dataset.load_dataset(dset)
while dataset.frame_num < frame_num:
dataset.advance()
else:
config.load('data/newest_calibration')
dataset.setup_opencl()
def start(dset=None, frame_num=0):
if not FOR_REAL:
if dset is None:
dataset.load_random_dataset()
else:
dataset.load_dataset(dset)
while dataset.frame_num < frame_num:
dataset.advance()
else:
config.load('data/newest_calibration')
dataset.setup_opencl()
def run_grid():
datasets = glob.glob('data/sets/study_*')
try:
os.mkdir(out_path)
except OSError:
print "Couldn't make create output directory [%s], it may already exist." % out_path
print "Remove it and try again."
return False
for name in datasets:
dataset.load_dataset(name)
name = os.path.split(name)[1]
d = dict(name=name)
folder = os.path.join(out_path, name)
os.mkdir(folder)
main.initialize()
import re
number = int(re.match('.*_z(\d)m_.*', name).groups()[0])
with open('data/experiments/gt/gt%d.txt' % number) as f:
GT = grid.gt2grid(f.read())
grid.initialize_with_groundtruth(GT)
total = 0
output = []
try:
while 1:
try:
dataset.advance()
except (IOError, ValueError):
break
if dataset.frame_num % 30 == 0:
print name, dataset.frame_num
t1 = time.time()
once()
t2 = time.time()
total += t2-t1
output.append((main.R_correct.copy(), grid.occ.copy()))
except Exception as e:
print e
d['frames'] = dataset.frame_num
d['time'] = total
d['output'] = output
with open(os.path.join(folder, 'output.pkl'),'w') as f:
pickle.dump(d, f)
with open(os.path.join(folder, 'final_output.txt'),'w') as f:
f.write(grid.grid2gt(grid.occ))
def once():
global depth, rgb
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
rgb = dataset.rgb
else:
opennpy.sync_update()
depth, _ = opennpy.sync_get_depth()
rgb, _ = opennpy.sync_get_video()
main.update_frame(depth, rgb)
blockdraw.clear()
try:
c, _ = hashalign.find_best_alignment(grid.occ, 0 * grid.occ,
target_model, ~target_model)
except ValueError:
pass
else:
tm = hashalign.apply_correction(target_model, *c)
tm = np.ascontiguousarray(tm)
not_filled = tm & ~grid.occ
correct = tm & grid.occ
incorrect = ~tm & grid.occ
try:
next_layer = np.min(np.nonzero(not_filled)[1])
except ValueError:
blockdraw.show_grid('0',
grid.occ,
color=np.array([0.2, 1, 0.2, 1]))
else:
blockdraw.show_grid('1', incorrect, color=np.array([1, 1, 0.1, 1]))
nf = not_filled * 0
nf[:, next_layer, :] = 1
nf = nf & not_filled
blockdraw.show_grid('2', nf, color=np.array([1, 0.2, 1.0, 1]))
blockdraw.show_grid('3',
correct,
color=np.array([0.1, 0.3, 0.1, 1]))
window.clearcolor = [0, 0, 0, 0]
window.flag_drawgrid = False
if 'R_correct' in main.__dict__:
window.modelmat = main.R_display
#show_rgb(rgb)
window.Refresh()
pylab.waitforbuttonpress(0.005)
sys.stdout.flush()
def start(dset=None, frame_num=0):
main.initialize()
if not FOR_REAL:
if dset is None:
dataset.load_random_dataset()
else:
dataset.load_dataset(dset)
while dataset.frame_num < frame_num:
dataset.advance()
else:
config.load('data/newest_calibration')
opennpy.align_depth_to_rgb()
dataset.setup_opencl()
def start(dset=None, frame_num=0):
main.initialize()
if not FOR_REAL:
if dset is None:
dataset.load_random_dataset()
else:
dataset.load_dataset(dset)
while dataset.frame_num < frame_num:
dataset.advance()
else:
config.load('data/newest_calibration')
opennpy.align_depth_to_rgb()
dataset.setup_opencl()
def start(dset=None, frame_num=0):
if not FOR_REAL:
if dset is None:
dataset.load_random_dataset()
else:
dataset.load_dataset(dset)
while dataset.frame_num < frame_num:
dataset.advance()
else:
config.load("data/newest_calibration")
dataset.setup_opencl()
global R_correct
if "R_correct" in globals():
del R_correct
def once():
global depth, rgb
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
rgb = dataset.rgb
else:
opennpy.sync_update()
depth,_ = opennpy.sync_get_depth()
rgb,_ = opennpy.sync_get_video()
main.update_frame(depth, rgb)
blockdraw.clear()
try:
c,_ = hashalign.find_best_alignment(grid.occ,0*grid.occ,
target_model,~target_model)
except ValueError:
pass
else:
tm = hashalign.apply_correction(target_model, *c)
tm = np.ascontiguousarray(tm)
not_filled = tm & ~grid.occ
correct = tm & grid.occ
incorrect = ~tm & grid.occ
try:
next_layer = np.min(np.nonzero(not_filled)[1])
except ValueError:
blockdraw.show_grid('0', grid.occ, color=np.array([0.2,1,0.2,1]))
else:
blockdraw.show_grid('1', incorrect,
color=np.array([1,1,0.1,1]))
nf = not_filled*0
nf[:,next_layer,:] = 1
nf = nf & not_filled
blockdraw.show_grid('2', nf,
color=np.array([1,0.2,1.0,1]))
blockdraw.show_grid('3', correct, color=np.array([0.1,0.3,0.1,1]))
window.clearcolor=[0,0,0,0]
window.flag_drawgrid = False
if 'R_correct' in main.__dict__:
window.modelmat = main.R_display
#show_rgb(rgb)
window.Refresh()
pylab.waitforbuttonpress(0.005)
sys.stdout.flush()
def once():
if not FOR_REAL:
dataset.advance()
global depth
depth = dataset.depth
else:
opennpy.sync_update()
depth,_ = opennpy.sync_get_depth()
def from_rect(m,rect):
(l,t),(r,b) = rect
return m[t:b,l:r]
global mask, rect
(mask,rect) = preprocess.threshold_and_mask(depth,config.bg)
# Compute the surface normals
normals.normals_opencl(depth, mask, rect)
# Find the lattice orientation and then translation
global R_oriented, R_aligned, R_correct
R_oriented = lattice.orientation_opencl()
R_aligned = lattice.translation_opencl(R_oriented)
global modelmat
if modelmat is None:
modelmat = R_aligned.copy()
else:
modelmat,_ = grid.nearest(modelmat, R_aligned)
global face, Xo, Yo, Zo
_,_,_,face = np.rollaxis(opencl.get_modelxyz(),1)
Xo,Yo,Zo,_ = np.rollaxis(opencl.get_xyz(),1)
global cx,cy,cz
cx,cy,cz,_ = np.rollaxis(np.frombuffer(np.array(face).data,
dtype='i1').reshape(-1,4),1)
R,G,B = [np.abs(_).astype('f') for _ in cx,cy,cz]
window.update_xyz(Xo,Yo,Zo,COLOR=(R,G,B,R*0+1))
window.clearcolor = [1,1,1,0]
window.Refresh()
pylab.waitforbuttonpress(0.005)
def once():
if not FOR_REAL:
dataset.advance()
global depth
depth = dataset.depth
else:
opennpy.sync_update()
depth, _ = opennpy.sync_get_depth()
def from_rect(m, rect):
(l, t), (r, b) = rect
return m[t:b, l:r]
global mask, rect
(mask, rect) = preprocess.threshold_and_mask(depth, config.bg)
# Compute the surface normals
normals.normals_opencl(depth, mask, rect)
# Find the lattice orientation and then translation
global R_oriented, R_aligned, R_correct
R_oriented = lattice.orientation_opencl()
R_aligned = lattice.translation_opencl(R_oriented)
global modelmat
if modelmat is None:
modelmat = R_aligned.copy()
else:
modelmat, _ = grid.nearest(modelmat, R_aligned)
global face, Xo, Yo, Zo
_, _, _, face = np.rollaxis(opencl.get_modelxyz(), 1)
Xo, Yo, Zo, _ = np.rollaxis(opencl.get_xyz(), 1)
global cx, cy, cz
cx, cy, cz, _ = np.rollaxis(
np.frombuffer(np.array(face).data, dtype='i1').reshape(-1, 4), 1)
R, G, B = [np.abs(_).astype('f') for _ in cx, cy, cz]
window.update_xyz(Xo, Yo, Zo, COLOR=(R, G, B, R * 0 + 1))
window.clearcolor = [1, 1, 1, 0]
window.Refresh()
pylab.waitforbuttonpress(0.005)
def start(dset=None, frame_num=0):
main.initialize()
#with open('data/experiments/collab/2011.txt') as f:
global target_model
with open('data/experiments/collab/block.txt') as f:
target_model = grid.gt2grid(f.read())
#grid.initialize_with_groundtruth(GT)
if not FOR_REAL:
if dset is None:
dataset.load_random_dataset()
else:
dataset.load_dataset(dset)
while dataset.frame_num < frame_num:
dataset.advance()
else:
config.load('data/newest_calibration')
opennpy.align_depth_to_rgb()
dataset.setup_opencl()
def once():
global depth, rgb
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
rgb = dataset.rgb
else:
opennpy.sync_update()
depth, _ = opennpy.sync_get_depth()
rgb, _ = opennpy.sync_get_video()
main.update_frame(depth, rgb)
blockdraw.clear()
#blockdraw.show_grid('o1', main.occvac.occ, color=np.array([1,1,0,1]))
if 'RGB' in stencil.__dict__:
blockdraw.show_grid('occ', grid.occ, color=grid.color)
else:
blockdraw.show_grid('occ', grid.occ, color=np.array([1, 0.6, 0.6, 1]))
#blockdraw.show_grid('vac', grid.vac,
# color=np.array([0.6,1,0.6,0]))
if 0 and lattice.is_valid_estimate():
window.clearcolor = [0.9, 1, 0.9, 0]
else:
window.clearcolor = [0, 0, 0, 0]
#window.clearcolor=[1,1,1,0]
window.flag_drawgrid = True
if 1:
update_display()
if 'R_correct' in main.__dict__:
window.modelmat = main.R_display
#show_rgb(rgb)
window.Refresh()
pylab.waitforbuttonpress(0.005)
sys.stdout.flush()
def once():
global depth, rgb
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
rgb = dataset.rgb
else:
opennpy.sync_update()
depth,_ = opennpy.sync_get_depth()
rgb,_ = opennpy.sync_get_video()
main.update_frame(depth, rgb)
blockdraw.clear()
blockdraw.show_grid('o1', main.occvac.occ, color=np.array([1,1,0,1]))
if 'RGB' in stencil.__dict__:
blockdraw.show_grid('occ', grid.occ, color=grid.color)
else:
blockdraw.show_grid('occ', grid.occ, color=np.array([1,0.6,0.6,1]))
#blockdraw.show_grid('vac', grid.vac,
# color=np.array([0.6,1,0.6,0]))
if 0 and lattice.is_valid_estimate():
window.clearcolor=[0.9,1,0.9,0]
else:
window.clearcolor=[0,0,0,0]
#window.clearcolor=[1,1,1,0]
window.flag_drawgrid = True
if 1:
update_display()
if 'R_correct' in main.__dict__:
window.modelmat = main.R_display
show_rgb(rgb)
window.Refresh()
pylab.waitforbuttonpress(0.005)
sys.stdout.flush()
def once():
global depth
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
else:
opennpy.sync_update()
depth,_ = opennpy.sync_get_depth()
def from_rect(m,rect):
(l,t),(r,b) = rect
return m[t:b,l:r]
global mask, rect, modelmat
(mask,rect) = preprocess.threshold_and_mask(depth,config.bg)
global n,w
if 0:
n,w = normals.normals_numpy(depth)
show_normals(n, w, 'normals_numpy')
if 0:
n,w = normals.normals_c(depth)
show_normals(n, w, 'normals_c')
if 1:
normals.opencl.set_rect(rect)
dt = timeit.timeit(lambda:
normals.normals_opencl(depth, mask, rect).wait(),
number=1)
#print dt
nw = normals.opencl.get_normals()
n,w = nw[:,:,:3], nw[:,:,3]
#show_normals(n, w, 'normals_opencl')
show_normals_sphere(n, w)
pylab.waitforbuttonpress(0.01)
def once():
global depth
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
else:
opennpy.sync_update()
depth, _ = opennpy.sync_get_depth()
def from_rect(m, rect):
(l, t), (r, b) = rect
return m[t:b, l:r]
global mask, rect, modelmat
(mask, rect) = preprocess.threshold_and_mask(depth, config.bg)
global n, w
if 0:
n, w = normals.normals_numpy(depth)
show_normals(n, w, 'normals_numpy')
if 0:
n, w = normals.normals_c(depth)
show_normals(n, w, 'normals_c')
if 1:
normals.opencl.set_rect(rect)
dt = timeit.timeit(
lambda: normals.normals_opencl(depth, mask, rect).wait(), number=1)
#print dt
nw = normals.opencl.get_normals()
n, w = nw[:, :, :3], nw[:, :, 3]
#show_normals(n, w, 'normals_opencl')
show_normals_sphere(n, w)
pylab.waitforbuttonpress(0.01)
def once():
global depth
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
else:
opennpy.sync_update()
depth, _ = opennpy.sync_get_depth()
def from_rect(m, rect):
(l, t), (r, b) = rect
return m[t:b, l:r]
global mask, rect
try:
(mask, rect) = preprocess.threshold_and_mask(depth, config.bg)
except IndexError:
return
normals.opencl.set_rect(rect)
normals.normals_opencl(depth, mask, rect).wait()
# Find the lattice orientation and then translation
global R_oriented, R_aligned, R_correct
R_oriented = lattice.orientation_opencl()
if "R_correct" in globals():
# Correct the lattice ambiguity for 90 degree rotations just by
# using the previous estimate. This is good enough for illustrations
# but global alignment is preferred (see hashalign)
R_oriented, _ = grid.nearest(R_correct, R_oriented)
R_aligned = lattice.translation_opencl(R_oriented)
R_correct = R_aligned
# Find the color based on the labeling from lattice
global face, Xo, Yo, Zo
_, _, _, face = np.rollaxis(opencl.get_modelxyz(), 1)
global cx, cy, cz
cx, cy, cz, _ = np.rollaxis(np.frombuffer(np.array(face).data, dtype="i1").reshape(-1, 4), 1) - 1
global R, G, B
R, G, B = [np.abs(_).astype("f") for _ in cx, cy, cz]
if 0:
G *= 0
R *= 0
B *= 0
else:
pass
# Draw the points collected on a sphere
nw = normals.opencl.get_normals()
global n, w
n, w = nw[:, :, :3], nw[:, :, 3]
if 1: # Point cloud position mode
X, Y, Z, _ = np.rollaxis(opencl.get_xyz(), 1)
else:
X, Y, Z = n[:, :, 0], n[:, :, 1], n[:, :, 2]
X, Y, Z = map(lambda _: _.copy(), (X, Y, Z))
# Render the points in 'table space' but colored with the axes from flatrot
window.update_xyz(X, Y, Z, COLOR=(R, G * 0, B, R * 0 + w.flatten()))
window.clearcolor = [1, 1, 1, 0]
window.Refresh()
# pylab.imshow(1./depth)
pylab.waitforbuttonpress(0.01)
def test_tablecalib():
dataset.load_random_dataset()
dataset.advance()
def once():
global depth
if not FOR_REAL:
dataset.advance()
depth = dataset.depth
else:
opennpy.sync_update()
depth, _ = opennpy.sync_get_depth()
def from_rect(m, rect):
(l, t), (r, b) = rect
return m[t:b, l:r]
global mask, rect
try:
(mask, rect) = preprocess.threshold_and_mask(depth, config.bg)
except IndexError:
return
normals.opencl.set_rect(rect)
normals.normals_opencl(depth, mask, rect).wait()
# Find the lattice orientation and then translation
global R_oriented, R_aligned, R_correct
R_oriented = lattice.orientation_opencl()
if 'R_correct' in globals():
# Correct the lattice ambiguity for 90 degree rotations just by
# using the previous estimate. This is good enough for illustrations
# but global alignment is preferred (see hashalign)
R_oriented, _ = grid.nearest(R_correct, R_oriented)
R_aligned = lattice.translation_opencl(R_oriented)
R_correct = R_aligned
# Find the color based on the labeling from lattice
global face, Xo, Yo, Zo
_, _, _, face = np.rollaxis(opencl.get_modelxyz(), 1)
global cx, cy, cz
cx, cy, cz, _ = np.rollaxis(
np.frombuffer(np.array(face).data, dtype='i1').reshape(-1, 4), 1) - 1
global R, G, B
R, G, B = [np.abs(_).astype('f') for _ in cx, cy, cz]
if 0:
G *= 0
R *= 0
B *= 0
else:
pass
# Draw the points collected on a sphere
nw = normals.opencl.get_normals()
global n, w
n, w = nw[:, :, :3], nw[:, :, 3]
if 1: # Point cloud position mode
X, Y, Z, _ = np.rollaxis(opencl.get_xyz(), 1)
else:
X, Y, Z = n[:, :, 0], n[:, :, 1], n[:, :, 2]
X, Y, Z = map(lambda _: _.copy(), (X, Y, Z))
# Render the points in 'table space' but colored with the axes from flatrot
window.update_xyz(X, Y, Z, COLOR=(R, G * 0, B, R * 0 + w.flatten()))
window.clearcolor = [1, 1, 1, 0]
window.Refresh()
#pylab.imshow(1./depth)
pylab.waitforbuttonpress(0.01)
def test_tablecalib():
dataset.load_random_dataset()
dataset.advance()
table_calibration.finish_table_calib()
