def _setup_renderer(self):
self._actors = Bunch()
self._data = Bunch()
ren = vtk.vtkRenderer()
ren.SetBackground(1., 1., 1.)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(ren)
self.SetRenderWindow(render_window)
picker = vtk.vtkPointPicker()
picker.SetTolerance(0.01)
picker.AddObserver('EndPickEvent', self._observe_pick)
iren = self.GetInteractor()
iren.SetPicker(picker)
style = vtk.vtkInteractorStyleImage()
style.SetInteractionModeToImage3D()
style.SetCurrentRenderer(ren)
iren.SetInteractorStyle(style)
_p = locals()
del _p['self']
self._p = Bunch(_p)
self._add_image()
self._add_mesh()
self._add_constraints((227, 26, 28), 'user', 4.0)
self._add_constraints((255, 255, 51), 'silhouette', 2.0)
self._add_points((255, 255, 51), 'silhouette_points', 5.0)
self._add_points((255, 127, 0), 'preimage_points', 5.0)
def setup(self, U, L, D=0):
self._s = Bunch()
self._s.Vb = ([self.V0.copy()] +
map(lambda i: np.zeros_like(self.V0), xrange(D)))
self._s.s = map(lambda i: np.r_[1.].reshape(-1,1), xrange(self.N))
self._s.Xg = map(lambda i: np.r_[0., 0., 0.].reshape(-1,3), xrange(self.N))
self._s.Vd = map(lambda i: np.r_[0., 0., 0.].reshape(-1,3), xrange(self.N))
self._s.y = map(lambda i: np.ones(D, dtype=np.float64).reshape(-1, 1),
xrange(self.N))
self._s.U = map(np.copy, U)
self._s.L = map(np.copy, L)
def setup(self, **kwargs):
self._s = Bunch()
self._s.V = self.V0.copy()
self._s.V1 = make_list_of_arrays(self._s.V.shape, self.n)
for v in self._s.V1:
v.flat = self.V0.flat
self._setup_global_rotations(**kwargs)
self._setup_rotations(**kwargs)
self._s.s = make_list_of_arrays((1, 1), self.n, value=1.0)
self._s.U = []
self._s.L = []
for s in self.S:
self._s.U.append(np.zeros((s.shape[0], 2), dtype=np.float64))
self._s.L.append(np.zeros(s.shape[0], dtype=np.int32))
self._s.Xg0 = np.zeros((1, 3), dtype=np.float64)
self._s.X0 = np.zeros((self.V0.shape[0], 3), dtype=np.float64)
self._s.sp = make_list_of_arrays((1, 1), self.n - 1, value=1.0)
self._s.Xgp = make_list_of_arrays((1, 3), self.n - 1, value=0.0)
self._s.Xp = make_list_of_arrays((self.V0.shape[0], 3),
self.n - 1,
value=0.0)
self._setup_lambdas()
def export_states(self, states, output_dir):
Z = map(lambda i: [], xrange(self.N))
for n, s in enumerate(states):
s = Bunch(s)
for i in xrange(self.N):
V = s.Vb[0]
if s.y[i].size > 0:
V = V + reduce(add, map(mul, s.y[i], s.Vb[1:]))
q = quaternion.quat(s.Xg[i].ravel())
R = quaternion.rotationMatrix(q)
Rt = np.transpose(R)
V = s.s[i][0][0] * np.dot(V, Rt) + s.Vd[i][0]
Q = geometry.path2pos(V, self.T, s.L[i], s.U[i])
d = dict(T=self.T, V=V,
C=self.C[i], P=self.P[i],
Q=Q, S=self.S[i],
image=self.frames[i],
s=s.s[i], Xg=s.Xg[i].ravel())
Z[i].append(d)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
for i, z in enumerate(Z):
output_path = os.path.join(output_dir, '%d.dat' % i)
print '-> %s' % output_path
dump(output_path, dict(has_states=True, states=z))
def _setup_renderer(self):
self._actors = Bunch()
self._data = Bunch()
rens = []
ren = vtk.vtkRenderer()
ren.SetBackground(1., 1., 1.)
ren.SetViewport(0.0, 0.0, 0.5, 1.0)
rens.append(ren)
ren = vtk.vtkRenderer()
ren.SetBackground(1., 1., 1.)
ren.SetViewport(0.5, 0.0, 1.0, 1.0)
rens.append(ren)
camera = rens[0].GetActiveCamera()
rens[1].SetActiveCamera(camera)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(rens[0])
render_window.AddRenderer(rens[1])
self.SetRenderWindow(render_window)
style = InteractorStyle()
style.SetMagnification(2.)
style.SetCurrentRenderer(rens[1])
iren = self.GetInteractor()
iren.SetInteractorStyle(style)
_p = locals()
del _p['self']
self._p = Bunch(_p)
self._q = [Bunch(), Bunch()]
self._add_mesh(0)
self._add_mesh(1)
self._add_image(0)
self._add_image(1)
def save_state(output_dir, **kwargs):
if not os.path.exists(output_dir):
os.makedirs(output_dir)
make_path = lambda f: os.path.join(output_dir, f)
output_file = make_path('core.npz')
b = Bunch(kwargs)
print '-> %s' % output_file
pickle_.dump(
output_file,
dict(T=b.T,
V=b.V,
lambdas=b.lambdas,
preconditioners=b.preconditioners,
piecewise_polynomial=b.piecewise_polynomial,
solver_options=b.solver_options,
max_restarts=b.max_restarts,
narrowband=b.narrowband,
uniform_weights=b.uniform_weights,
find_circular_path=b.find_circular_path,
frames=b.frames,
indices=b.indices))
for l, index in enumerate(b.indices):
Q = geometry.path2pos(b.V1[l], b.T, b.L[l], b.U[l])
d = dict(T=b.T,
V=b.V1[l],
Xg=b.Xg[l],
s=b.instScales[l],
X=b.X[l],
L=b.L[l],
U=b.U[l],
Q=Q,
S=b.S[l],
C=b.C[l],
P=b.P[l],
lambdas=b.lambdas,
preconditioners=b.preconditioners,
index=index)
if b.frames[l] is not None:
d['image'] = b.frames[l]
output_file = make_path('%d.npz' % index)
print '-> %s' % output_file
pickle_.dump(output_file, d)
def _setup_renderer(self):
self._actors = Bunch()
self._data = Bunch()
ren = vtk.vtkRenderer()
ren.SetBackground(1., 1., 1.)
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(ren)
self.SetRenderWindow(render_window)
style = InteractorStyle()
style.SetMagnification(2.)
style.SetCurrentRenderer(ren)
iren = self.GetInteractor()
iren.SetInteractorStyle(style)
_p = locals()
del _p['self']
self._p = Bunch(_p)
self._add_mesh()
self._add_image()
def _setup_rotations(self, **kwargs):
self.ki = kwargs.pop('ki')
self.initial_Xb = kwargs.pop('initial_Xb', None)
ki_inst, ki_basis, ki_coeff, ki_lookup = parse_k(self.ki)
self.ki_info = Bunch(inst=ki_inst,
basis=ki_basis,
coeff=ki_coeff,
lookup=ki_lookup)
# initialise X, Xb, y to 0.
self._s.X = make_list_of_arrays((len(ki_inst), 3), self.n)
self._s.Xb = np.zeros((len(ki_basis), 3), dtype=np.float64)
self._s.y = make_list_of_arrays((len(ki_coeff), 1), self.n)
if self.initial_Xb is not None:
if self.initial_Xb.shape != (len(ki_basis), 3):
raise ValueError
for i, xb in enumerate(self.initial_Xb):
self._s.Xb[i].flat = xb.flat
def _setup_global_rotations(self, **kwargs):
self.kg = kwargs.pop('kg')
self.initial_Xgb = kwargs.pop('initial_Xgb', None)
kg_inst, kg_basis, kg_coeff, kg_lookup = parse_k(self.kg)
self.kg_info = Bunch(inst=kg_inst,
basis=kg_basis,
coeff=kg_coeff,
lookup=kg_lookup)
# initialise Xg, Xgb, yg to 0.
self._s.Xg = make_list_of_arrays((1, 3), len(kg_inst))
self._s.Xgb = make_list_of_arrays((1, 3), len(kg_basis))
self._s.yg = make_list_of_arrays((1, 1), len(kg_coeff))
if self.initial_Xgb is not None:
if self.initial_Xgb.shape != (len(kg_basis), 3):
raise ValueError
for i, xgb in enumerate(self.initial_Xgb):
self._s.Xgb[i].flat = xgb.flat
def save_state(_output_dir, **kwargs):
# TODO: Ensure that enough state is saved for each output so that
# EVERYTHING is recoverable
if not os.path.exists(_output_dir):
os.makedirs(_output_dir)
make_path = lambda f: os.path.join(_output_dir, f)
output_file = make_path('core.npz')
b = Bunch(kwargs)
print '-> %s' % output_file
core_dictionary = b.args.__dict__.copy()
core_dictionary.update(T=b.T,
V=b.V,
s=b.instScales,
kg=b.kg,
Xgb=b.Xgb,
yg=b.yg,
Xg=b.Xg,
ki=b.ki,
Xb=b.Xb,
y=b.y,
X=b.X)
pickle_.dump(output_file, core_dictionary)
for l, index in enumerate(b.indices):
Q = geometry.path2pos(b.V1[l], b.T, b.L[l], b.U[l])
m = b.kg_lookup[l]
n = b.kg[m]
if n == 0:
Xg = np.r_[0., 0., 0.].reshape(1, 3)
elif n == -1:
Xg = b.Xg[b.kg[m + 1]]
else:
Xg = reduce(
safe_ax_add,
(b.yg[b.kg[m + 1 + 2 * ii + 1]] * b.Xgb[b.kg[m + 1 + 2 * ii]]
for ii in xrange(n))).reshape(1, 3)
output_dictionary = b.args.__dict__.copy()
output_dictionary.update(T=b.T,
V=b.V1[l],
S=b.S[l],
Q=Q,
L=b.L[l],
U=b.U[l],
C=b.C[l],
P=b.P[l],
s=b.instScales[l],
Xg=Xg,
ki=b.ki,
Xb=b.Xb,
y=b.y[l],
X=b.X[l])
if b.frames[l] is not None:
output_dictionary['image'] = b.frames[l]
output_file = make_path('%d.npz' % index)
print '-> %s' % output_file
pickle_.dump(output_file, output_dictionary)
class BareLBSSolver(object):
def __init__(self, T, V0, S, SN, C, P, frames):
self.T = T
self.V0 = V0
self.S = S
self.SN = SN
self.C = C
self.P = P
self.frames = frames
self.N = len(frames)
def setup(self, U, L, D=0):
self._s = Bunch()
self._s.Vb = ([self.V0.copy()] +
map(lambda i: np.zeros_like(self.V0), xrange(D)))
self._s.s = map(lambda i: np.r_[1.].reshape(-1,1), xrange(self.N))
self._s.Xg = map(lambda i: np.r_[0., 0., 0.].reshape(-1,3), xrange(self.N))
self._s.Vd = map(lambda i: np.r_[0., 0., 0.].reshape(-1,3), xrange(self.N))
self._s.y = map(lambda i: np.ones(D, dtype=np.float64).reshape(-1, 1),
xrange(self.N))
self._s.U = map(np.copy, U)
self._s.L = map(np.copy, L)
def add_basis(self):
self._s.Vb.append(np.zeros_like(self.V0))
y1 = []
for y in self._s.y:
y1.append(np.r_['0,2', y, [0.]])
self._s.y = y1
def _copy_state(self):
s = {}
for key, list_ in self._s.iteritems():
s[key] = map(np.copy, list_)
return s
def __call__(self, lambdas, preconditioners, max_restarts=10, narrowband=2,
**kwargs):
solver_options = DEFAULT_SOLVER_OPTIONS.copy()
solver_options.update(kwargs)
states = []
def save_state_callback(iteration, computeDerivatives):
if not computeDerivatives:
return
states.append(self._copy_state())
t1 = time()
status = None
for i in xrange(max_restarts):
status = solve_multiple(
self.T,
self._s.Vb,
self._s.s, self._s.Xg, self._s.Vd,
self._s.y, self._s.U, self._s.L,
self.C, self.P, self.S, self.SN,
np.require(lambdas, dtype=np.float64),
np.require(preconditioners, dtype=np.float64),
narrowband,
debug=False,
callback=save_state_callback,
**kwargs)
print status[1]
if status[0] not in (0, 4):
break
t2 = time()
return status[0], states, t2 - t1
def export_states(self, states, output_dir):
Z = map(lambda i: [], xrange(self.N))
for n, s in enumerate(states):
s = Bunch(s)
for i in xrange(self.N):
V = s.Vb[0]
if s.y[i].size > 0:
V = V + reduce(add, map(mul, s.y[i], s.Vb[1:]))
q = quaternion.quat(s.Xg[i].ravel())
R = quaternion.rotationMatrix(q)
Rt = np.transpose(R)
V = s.s[i][0][0] * np.dot(V, Rt) + s.Vd[i][0]
Q = geometry.path2pos(V, self.T, s.L[i], s.U[i])
d = dict(T=self.T, V=V,
C=self.C[i], P=self.P[i],
Q=Q, S=self.S[i],
image=self.frames[i],
s=s.s[i], Xg=s.Xg[i].ravel())
Z[i].append(d)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
for i, z in enumerate(Z):
output_path = os.path.join(output_dir, '%d.dat' % i)
print '-> %s' % output_path
dump(output_path, dict(has_states=True, states=z))