def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.toggle_startstop = wx.ToggleButton(self, label = "Not Recording")
self.running = False
self.orientationList = ['Top Left', 'Top Right', 'Bottom Left', 'Bottom Right']
self.orientationFlag = ['tl','tr','bl','br']
self.choice_orient = wx.Choice(self, choices = self.orientationList)
self.choice_orient.SetSelection(0)
self.toggle_smartclick = wx.CheckBox(self, label = "Smart Click")
self.textctrl_windowname = wx.TextCtrl(self)
sizer = wx.GridBagSizer(hgap = 1, vgap = 1)
sizer.Add(self.toggle_smartclick, pos = (1, 1), flag = wx.EXPAND)
sizer.Add(self.choice_orient,pos = (0, 1), flag = wx.EXPAND)
sizer.Add(self.toggle_startstop, pos = (0, 0), span = (2, 1), flag = wx.EXPAND)
self.Bind(wx.EVT_TOGGLEBUTTON, self.OnStartStop, self.toggle_startstop)
self.Bind(wx.EVT_CHOICE, self.OnChoice, self.choice_orient)
self.SetSizer(pack(wx.VERTICAL,
sizer,
(10, 10),
pack(wx.HORIZONTAL,
wx.StaticText(self, label = "window name: "),
self.textctrl_windowname)
)
)
def write_cache(entries,
stream,
extension_data=None,
ShaStreamCls=IndexFileSHA1Writer):
"""Write the cache represented by entries to a stream
:param entries: **sorted** list of entries
:param stream: stream to wrap into the AdapterStreamCls - it is used for
final output.
:param ShaStreamCls: Type to use when writing to the stream. It produces a sha
while writing to it, before the data is passed on to the wrapped stream
:param extension_data: any kind of data to write as a trailer, it must begin
a 4 byte identifier, followed by its size ( 4 bytes )"""
# wrap the stream into a compatible writer
stream = ShaStreamCls(stream)
tell = stream.tell
write = stream.write
# header
version = 2
write("DIRC")
write(pack(">LL", version, len(entries)))
# body
for entry in entries:
beginoffset = tell()
write(entry[4]) # ctime
write(entry[5]) # mtime
path = entry[3]
plen = len(path) & CE_NAMEMASK # path length
assert plen == len(
path), "Path %s too long to fit into index" % entry[3]
flags = plen | (entry[2] & CE_NAMEMASK_INV
) # clear possible previous values
write(
pack(">LLLLLL20sH", entry[6], entry[7], entry[0], entry[8],
entry[9], entry[10], entry[1], flags))
write(path)
real_size = ((tell() - beginoffset + 8) & ~7)
write("\0" * ((beginoffset + real_size) - tell()))
# END for each entry
# write previously cached extensions data
if extension_data is not None:
stream.write(extension_data)
# write the sha over the content
stream.write_sha()
def edge_quality(n, edges, Tstar, R):
good_edges = 0.0
bad_edges = 0.0
err_bad = 0.0
err_good = 0.0
for edge in edges:
if edge['weight'] < 0.01:
continue
sid = edge['src']
tid = edge['tgt']
Ti = Tstar[sid]
Tj = Tstar[tid]
Tij_gt = Tj.dot(inverse(Ti))
Rij_in = edge['R']
tij_in = edge['t']
Tij_in = pack(Rij_in, tij_in)
aerr_gt = angular_distance_np(Tij_in[np.newaxis, :3, :3],
Tij_gt[np.newaxis, :3, :3]).sum()
Rij = R[tid].dot(R[sid].T)
aerr = np.linalg.norm(Rij - Rij_in, 'fro')**2
if aerr_gt > 30.0:
bad_edges += edge['weight']
err_bad += aerr * edge['weight']
else:
good_edges += edge['weight']
err_good += aerr * edge['weight']
print('Edge Quality: #good=%f, #bad=%f, mean aerr=(%f, %f)' %
(good_edges, bad_edges, err_good / good_edges, err_bad / bad_edges))
def write_cache(entries,
stream,
extension_data=None,
ShaStreamCls=IndexFileSHA1Writer):
"""Write the cache represented by entries to a stream
:param entries: **sorted** list of entries
:param stream: stream to wrap into the AdapterStreamCls - it is used for
final output.
:param ShaStreamCls: Type to use when writing to the stream. It produces a sha
while writing to it, before the data is passed on to the wrapped stream
:param extension_data: any kind of data to write as a trailer, it must begin
a 4 byte identifier, followed by its size ( 4 bytes )"""
# wrap the stream into a compatible writer
stream = ShaStreamCls(stream)
# header
version = 2
stream.write("DIRC")
stream.write(pack(">LL", version, len(entries)))
# body
for entry in entries:
write_cache_entry(entry, stream)
# END for each entry
# write previously cached extensions data
if extension_data is not None:
stream.write(extension_data)
# write the sha over the content
stream.write_sha()
def write_cache(entries, stream, extension_data=None, ShaStreamCls=IndexFileSHA1Writer):
"""Write the cache represented by entries to a stream
:param entries: **sorted** list of entries
:param stream: stream to wrap into the AdapterStreamCls - it is used for
final output.
:param ShaStreamCls: Type to use when writing to the stream. It produces a sha
while writing to it, before the data is passed on to the wrapped stream
:param extension_data: any kind of data to write as a trailer, it must begin
a 4 byte identifier, followed by its size ( 4 bytes )"""
# wrap the stream into a compatible writer
stream = ShaStreamCls(stream)
# header
version = 2
stream.write("DIRC")
stream.write(pack(">LL", version, len(entries)))
# body
for entry in entries:
write_cache_entry(entry, stream)
# END for each entry
# write previously cached extensions data
if extension_data is not None:
stream.write(extension_data)
# write the sha over the content
stream.write_sha()
def handle(self, obj):
carry.Worker.handle(self, obj)
try:
dest = (obj.address['addr'], obj.address['port'])
obj.address['addr'], obj.address['port'] = (util.net.host(), self.__socket.getsockname()[1])
self.__socket.sendto(util.pack(obj), dest)
except:
pass
def write_cache(entries, stream, extension_data=None, ShaStreamCls=IndexFileSHA1Writer):
"""Write the cache represented by entries to a stream
:param entries: **sorted** list of entries
:param stream: stream to wrap into the AdapterStreamCls - it is used for
final output.
:param ShaStreamCls: Type to use when writing to the stream. It produces a sha
while writing to it, before the data is passed on to the wrapped stream
:param extension_data: any kind of data to write as a trailer, it must begin
a 4 byte identifier, followed by its size ( 4 bytes )"""
# wrap the stream into a compatible writer
stream = ShaStreamCls(stream)
tell = stream.tell
write = stream.write
# header
version = 2
write("DIRC")
write(pack(">LL", version, len(entries)))
# body
for entry in entries:
beginoffset = tell()
write(entry[4]) # ctime
write(entry[5]) # mtime
path = entry[3]
plen = len(path) & CE_NAMEMASK # path length
assert plen == len(path), "Path %s too long to fit into index" % entry[3]
flags = plen | (entry[2] & CE_NAMEMASK_INV) # clear possible previous values
write(pack(">LLLLLL20sH", entry[6], entry[7], entry[0],
entry[8], entry[9], entry[10], entry[1], flags))
write(path)
real_size = ((tell() - beginoffset + 8) & ~7)
write("\0" * ((beginoffset + real_size) - tell()))
# END for each entry
# write previously cached extensions data
if extension_data is not None:
stream.write(extension_data)
# write the sha over the content
stream.write_sha()
def from_base(cls, base):
"""
:return:
Minimal entry as created from the given BaseIndexEntry instance.
Missing values will be set to null-like values
:param base: Instance of type BaseIndexEntry"""
time = pack(">LL", 0, 0)
return IndexEntry((base.mode, base.binsha, base.flags, base.path, time, time, 0, 0, 0, 0, 0))
def from_base(cls, base):
"""
:return:
Minimal entry as created from the given BaseIndexEntry instance.
Missing values will be set to null-like values
:param base: Instance of type BaseIndexEntry"""
time = pack(">LL", 0, 0)
return IndexEntry((base.mode, base.binsha, base.flags, base.path, time, time, 0, 0, 0, 0, 0))
def reweightEdges(n, edges, R, t, sigma_r, sigma_t, plot=False):
theta1 = 4
terrs = []
if plot:
plots = []
for edge in edges:
i = edge['src']
j = edge['tgt']
Rij = edge['R']
tij = edge['t']
Tij_in = pack(Rij, tij)
Ti = pack(R[i], t[i])
Tj = pack(R[j], t[j])
Tij_rec = Tj.dot(inverse(Ti))
weight = edge['predicted_weight']
if weight < 0.01:
weight = 0.00
if weight > 1.0:
weight = 1.0
aerr_fro = np.linalg.norm(Tij_rec[:3, :3] - Tij_in[:3, :3],
'fro') * sigmoid((0.5 - weight) * 5)
terr_fro = np.linalg.norm(Tij_rec[:3, 3] - Tij_in[:3, 3], 2) * sigmoid(
(0.5 - weight) * 5)
#fro2 = aerr_fro ** 2 + terr_fro ** 2
edge['rotation_weight'] = (sigma_r**theta1) / (sigma_r**theta1 +
aerr_fro**(theta1))
edge['translation_weight'] = (sigma_t**theta1) / (sigma_t**theta1 +
terr_fro**(theta1))
if plot:
plots.append([aerr_fro, edge['rotation_weight']])
if plot:
plots = np.array(plots)
import matplotlib.pyplot as plt
plt.scatter(plots[:, 0], plots[:, 1])
plt.show()
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.button_max = wx.Button(self, label = "Maximize")
self.button_nor = wx.Button(self, label = "Normalize")
self.button_min = wx.Button(self, label = "Minimize")
self.input_windowname = wx.TextCtrl(self)
self.Bind(wx.EVT_BUTTON, self.Callback('max'), self.button_max)
self.Bind(wx.EVT_BUTTON, self.Callback('norm'), self.button_nor)
self.Bind(wx.EVT_BUTTON, self.Callback('min'), self.button_min)
self.SetSizer(pack(wx.VERTICAL,
pack(wx.HORIZONTAL,
self.button_max,
self.button_nor,
self.button_min),
pack(wx.HORIZONTAL,
wx.StaticText(self, label = "window name: "),
self.input_windowname)
)
)
def save_sync_data(): sync_path = config.options['data']['sync_path'] if not sync_path or sync_path == '': print 'sync path not specified, sync not performed' return turns_path = os.path.join(sync_path, 'turns/%s'%(db.getTurn(),)) nick = get_user_nickname() if not nick: print 'no users found, nothing to save' return print 'user nick is %s'%(nick,) outp = os.path.join(turns_path, nick) util.assureDirExist(outp) pt = os.path.join(config.options['data']['path'], str(db.getTurn())) if not os.path.exists(pt): return for f in os.listdir(pt): util.pack(os.path.join(pt, f), os.path.join(outp, f+".gz"))
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.button_checkpoint = wx.Button(self, label = "Checkpoint")
self.button_snap = wx.Button(self, label = "Snap")
self.input_windowname = wx.TextCtrl(self)
self.input_filename = wx.TextCtrl(self)
self.Bind(wx.EVT_BUTTON, self.OnCheckpoint, self.button_checkpoint)
self.Bind(wx.EVT_BUTTON, self.OnSnap, self.button_snap)
self.SetSizer(pack(wx.VERTICAL,
pack(wx.HORIZONTAL,
self.button_checkpoint,
self.button_snap),
pack(wx.HORIZONTAL,
wx.StaticText(self, label = "window name: "),
self.input_windowname),
pack(wx.HORIZONTAL,
wx.StaticText(self, label = "image name: "),
self.input_filename),
)
)
def write_cache_entry(entry, stream):
"""Write the given entry to the stream"""
beginoffset = stream.tell()
write = stream.write
write(entry[4]) # ctime
write(entry[5]) # mtime
path = entry[3]
plen = len(path) & CE_NAMEMASK # path length
assert plen == len(path), "Path %s too long to fit into index" % entry[3]
flags = plen | entry[2]
write(pack(">LLLLLL20sH", entry[6], entry[7], entry[0],
entry[8], entry[9], entry[10], entry[1], flags))
write(path)
real_size = ((stream.tell() - beginoffset + 8) & ~7)
write("\0" * ((beginoffset + real_size) - stream.tell()))
def write_cache_entry(entry, stream):
"""Write the given entry to the stream"""
beginoffset = stream.tell()
write = stream.write
write(entry[4]) # ctime
write(entry[5]) # mtime
path = entry[3]
plen = len(path) & CE_NAMEMASK # path length
assert plen == len(path), "Path %s too long to fit into index" % entry[3]
flags = plen | entry[2]
write(
pack(">LLLLLL20sH", entry[6], entry[7], entry[0], entry[8], entry[9],
entry[10], entry[1], flags))
write(path)
real_size = ((stream.tell() - beginoffset + 8) & ~7)
write("\0" * ((beginoffset + real_size) - stream.tell()))
def __get_label__(Rij, tij, Ti, Tj):
""" Measure Quality of Edge """
Ristar, tistar = decompose(Ti)
Rjstar, tjstar = decompose(Tj)
Tij_gt = Tj.dot(inverse(Ti))
Tij_in = pack(Rij, tij)
label = 0.0
err_R = angular_distance_np(Rij[np.newaxis, :, :],
Rjstar.dot(Ristar.T)[np.newaxis, :, :]).sum()
err_T = np.linalg.norm(Tij_gt[:3, 3] - Tij_in[:3, 3], 2)
if (err_R < 30.0) and (err_T < 0.2):
label = 1.0
else:
label = 0.0
return label
def bridge_enter_exit(user_id):
'''
On enter: Attempt to connect incoming call to one of the numbers in list.
On exit: Close the bridge with receiver.
'''
bridge_name = request.args.get('bridge_name')
caller_number = request.args.get('caller_number')
dialed_number = request.args.get('dialed_number')
numbers_to_try = request.args.get('numbers_to_try').split('+')
if DEBUG:
log_state('bridge_enter_exit', locals())
# Handle exit event
if request.form['Event'] == "ConferenceExit":
app.logger.info("caller has hung up?")
p.hangup_conference({'conference_name': bridge_name})
return "OK"
# Handle enter event
reference_name = 'call_request+{}'.format(bridge_name)
for number in numbers_to_try:
call_request = p.make_call({
'from': caller_number,
'to': number,
'answer_url': base_url_for(
'bridge_success',
user_id=user_id,
bridge_name=bridge_name,
caller_number=caller_number,
dialed_number=dialed_number,
success_number=number,
numbers_tried='+'.join(numbers_to_try)
)
})
if call_request[0] == 201:
# push call request data into redis
redis.lpush(reference_name, pack({
'request_uuid': call_request[1]['request_uuid'],
'number': number
}))
redis.expire(reference_name, 120)
return "OK"
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.button_resolution = wx.Button(self, label = "Resolution")
self.input_width = wx.TextCtrl(self, size = (20, -1))
self.input_height = wx.TextCtrl(self, size = (20, -1))
self.Bind(wx.EVT_BUTTON, self.OnResolution, self.button_resolution)
self.SetSizer(pack(wx.HORIZONTAL,
self.button_resolution,
wx.StaticText(self, label = "width: "),
self.input_width,
wx.StaticText(self, label = "height: "),
self.input_height)
)
def generate_synthetic(n, sigma):
T = np.zeros((n, 4, 4))
X = so.rvs(dim=3, size=n)
T[:, :3, :3] = X
# u, sigma, v = np.linalg.svd(T[0])
T[:, :3, 3] = np.random.randn(n, 3)
T[0, :3, 3] = 0.0
T[:, 3, 3] = 1
edges = []
for i in range(n):
for j in range(n):
if i <= j:
continue
Tij = T[j].dot(inverse(T[i]))
Rij, tij = decompose(Tij)
Rij = Rij + np.random.randn(3, 3) * sigma
Rij = project_so(Rij)
tij = tij + np.random.randn(3) * sigma
Tij = pack(Rij, tij)
edge = {'src': i, 'tgt': j, 'R': Rij, 't': tij, 'weight': 1.0}
edges.append(edge)
edges = np.array(edges)
return n, edges, T
def from_blob(cls, blob, stage=0):
""":return: Minimal entry resembling the given blob object"""
time = pack(">LL", 0, 0)
return IndexEntry((blob.mode, blob.binsha, stage << CE_STAGESHIFT,
blob.path, time, time, 0, 0, 0, 0, blob.size))
def IterativeTransfSync(n,
edges,
eps0=-1,
decay=0.8,
Tstar=None,
max_iter=10000,
cheat=False,
scheme='reweight'):
if scheme == 'reweight':
reweight = True
else:
reweight = False
if cheat:
for edge in edges:
#if edge['weight'] < 0.5:
# continue
sid = edge['src']
tid = edge['tgt']
Ti = Tstar[sid]
Tj = Tstar[tid]
Tij_gt = Tj.dot(inverse(Ti))
Rij = edge['R']
tij = edge['t']
Tij = pack(Rij, tij)
aerr = angular_distance_np(Tij[np.newaxis, :3, :3],
Tij_gt[np.newaxis, :3, :3]).sum()
terr = np.linalg.norm(Tij[:3, 3] - Tij_gt[:3, 3], 2)
#p = 0.9
if aerr > 30.0 or terr > 0.2:
weight = 0.0 #coin(0.02)
else:
weight = 1.0 #coin(0.9)
edge['predicted_weight'] = weight
edge['translation_weight'] = weight
edge['rotation_weight'] = weight
""" Edge Quality """
good_edges = 0.0
bad_edges = 0.0
err_bad = 0.0
err_good = 0.0
for edge in edges:
if edge['predicted_weight'] < 0.5:
continue
sid = edge['src']
tid = edge['tgt']
Ti = Tstar[sid]
Tj = Tstar[tid]
Tij_gt = Tj.dot(inverse(Ti))
Rij = edge['R']
tij = edge['t']
Tij = pack(Rij, tij)
aerr = angular_distance_np(Tij[np.newaxis, :3, :3],
Tij_gt[np.newaxis, :3, :3]).sum()
terr = np.linalg.norm(Tij[:3, 3] - Tij_gt[:3, 3], 2)
if aerr > 30.0 or terr > 0.2:
#print(sid, tid, edge['predicted_weight'])
bad_edges += 1
err_bad += aerr * edge['predicted_weight']
else:
good_edges += 1
err_good += aerr * edge['predicted_weight']
print('Edge Quality: #good=%f, #bad=%f' % (good_edges, bad_edges))
itr = 0
while itr < max_iter:
R, t, eigengap = TransfSync(n, edges)
#edge_quality(n, edges, Tstar, R)
T = np.array([pack(R[i], t[i]) for i in range(n)])
err_gt = -1.0
if Tstar is not None:
aerr_gt, terr_gt = error(T, Tstar)
if not reweight:
if eps0 < -0.5:
eps0 = max_existing_err(n, edges, R, t)
if reweight:
reweightEdges(n, edges, R, t, sigma_r=0.01, sigma_t=0.01)
else:
truncatedWeightPredict(n, edges, R, t, eps0)
mindeg, numedges, err_sum = computeStats(n, edges, R, t)
print(
'iter=%d, avg(err^2)=%f, eigengap=%f, #edges=%d, min_deg=%f, eps0=%f, aerr_gt=%f, terr_gt=%f'
% (itr, err_sum / numedges, eigengap, numedges, mindeg, eps0,
aerr_gt, terr_gt))
""" Skip idle iterations """
if reweight:
itr += 1
else:
max_err = max_existing_err(n, edges, R, t)
while (itr < max_iter) and (eps0 > max_err):
eps0 = eps0 * decay
itr += 1
if mindeg == 0:
break
if err_sum <= 1e-2:
break
return T
def from_blob(cls, blob, stage=0):
""":return: Minimal entry resembling the given blob object"""
time = pack(">LL", 0, 0)
return IndexEntry((blob.mode, blob.binsha, stage << CE_STAGESHIFT, blob.path, time, time, 0, 0, 0, 0, blob.size))
