def diffeoaction_comm_distance(a1, a2, action_distance):
"""
Returns the commutation-distance between two DiffeoActions
which is d(a1a2, a2a1).
"""
a1a2 = DiffeoAction.compose(a1, a2)
a2a1 = DiffeoAction.compose(a2, a1)
return action_distance(a1a2, a2a1)
def diffeoaction_comm_distance(a1, a2, action_distance):
"""
Returns the commutation-distance between two DiffeoActions
which is d(a1a2, a2a1).
"""
a1a2 = DiffeoAction.compose(a1, a2)
a2a1 = DiffeoAction.compose(a2, a1)
return action_distance(a1a2, a2a1)
def compute_action(self, plan):
if len(plan) == 0:
shape = self.dds.actions[0].diffeo.get_shape()
identity_cmd = np.array([0, 0])
return DiffeoAction.identity('id', shape, identity_cmd) # XXX
last = self.dds.actions[plan[-1]]
if len(plan) == 1:
return last
else:
rest = self.compute_action(plan[:-1])
return DiffeoAction.compose(last, rest)
def compute_action(self, plan):
if len(plan) == 0:
shape = self.dds.actions[0].diffeo.get_shape()
identity_cmd = np.array([0, 0])
return DiffeoAction.identity('id', shape, identity_cmd) # XXX
last = self.dds.actions[plan[-1]]
if len(plan) == 1:
return last
else:
rest = self.compute_action(plan[:-1])
return DiffeoAction.compose(last, rest)
def diffeosystem_display_products(dds, report, nsteps):
# XXX: make separate
for i, a in enumerate(dds.actions):
f = report.figure('cmd%s' % i, cols=nsteps)
A = a
for k in range(nsteps):
A = DiffeoAction.compose(A, a)
rgb = A.get_diffeo2d_forward().get_rgb_info()
f.data_rgb('%s_%s' % (i, k), rgb)
def diffeosystem_display_products(dds, report, nsteps):
# XXX: make separate
for i, a in enumerate(dds.actions):
f = report.figure('cmd%s' % i, cols=nsteps)
A = a
for k in range(nsteps):
A = DiffeoAction.compose(A, a)
rgb = A.get_diffeo2d_forward().get_rgb_info()
f.data_rgb('%s_%s' % (i, k), rgb)
def get_value(self):
'''
Returns the estimated DiffeoAction.
'''
diffeo = self.est.get_value()
diffeo_inv = self.est_inv.get_value()
name = 'uninterpreted'
action = DiffeoAction(name, diffeo, diffeo_inv, original_cmd=None)
return action
def consistency_based_uncertainty(action, normalize_distance):
'''
Update the uncertainties for the action by the improved uncertainty
classification based on comparing the diffeomorphism with its inverse.
'''
# print('Using length score function %s' % length_score)
d1 = action.diffeo.d
d2 = action.diffeo_inv.d
v1, v2 = consistency_based_uncertainty2(d1, d2, normalize_distance)
D1 = Diffeomorphism2D(d1, v1)
D2 = Diffeomorphism2D(d2, v2)
a = DiffeoAction(label=action.label,
diffeo=D1,
diffeo_inv=D2,
original_cmd=action.original_cmd)
return a
def DDSFromSymbolic(resolution, symdiffeosystem): # @UnusedVariable
"""
Creates a DiffeoSystem from synthetic diffeomorphisms.
"""
diffeo2s_config = get_diffeo2s_config()
diffeo2dds_config = get_diffeo2dds_config()
_, symdds = diffeo2dds_config.symdds.instance_smarter(symdiffeosystem)
logger.info('Creating symbolic diffeomorphism (resolution = %d)' %
resolution)
diffeoactions = []
for _, action in enumerate(symdds.actions):
id_diffeo, diffeo = parse_diffeo_spec(diffeo2s_config,
action['diffeo'])
label = action.get('label', id_diffeo)
original_cmd = np.array(action['original_cmd'])
logger.info('Getting symbolic diffeomorphism %r' % id_diffeo)
shape = (resolution, resolution)
viewport = SquareDomain([[-1, +1], [-1, +1]])
manifold = diffeo.get_topology()
D, Dinfo = diffeo_from_function_viewport(diffeo, manifold, viewport,
shape)
D2d = Diffeomorphism2D(D, Dinfo)
diffeo_inv = diffeo.get_inverse()
D_inv, Dinfo_inv = \
diffeo_from_function_viewport(diffeo_inv, manifold, viewport, shape)
D2d_inv = Diffeomorphism2D(D_inv, Dinfo_inv)
action = DiffeoAction(label=label,
diffeo=D2d,
diffeo_inv=D2d_inv,
original_cmd=original_cmd)
diffeoactions.append(action)
dds = DiffeoSystem('unnamed', actions=diffeoactions)
return dds
def make_hard_action(a):
label = a.label
diffeo = make_hard(a.get_diffeo2d_backward())
diffeo_inv = make_hard(a.get_diffeo2d_forward())
original_cmd = a.original_cmd
return DiffeoAction(label, diffeo, diffeo_inv, original_cmd)
