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 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 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