def __init__(self, gen): #generators self.__gen = gen #points labels = self.__gen.get_lod_zero_lb() points = self.__gen.get_lod_zero_pt() self.__base_points = pt.PointSet(labels, points) self.__curr_points = pt.PointSet(labels, points) #dims will be used for LODs and imits dimspan = range(0, self.__base_points.dims() ) all_dims = [ (did, did) for did in dimspan ] #LODs lod_objs = [0 for did in all_dims] self.__lod = mst.MdimStruct(lod_objs, all_dims) #Limits - start it_base = self.__base_points.get_labels().__iter__('ND') start_objs = deep( it_base.nd_index() ) self.__curr_abs_start = mst.MdimStruct(start_objs, all_dims) #Limits - end it_base.set_last() end_objs = deep( it_base.nd_index() ) self.__curr_abs_end = mst.MdimStruct(end_objs, all_dims) return
def __init__(self, objs, dims): self.__objs = deep(objs) self.__dims = deep(dims) return
def select_starting_tile(): global TILEMAP, TILEPOSITIONS, IMAGE #p("selecting starting tile...") for id in TILES: if not debug and part2: id = "3643" # <------------ hard coded solution for part 2 start_tile = TILES[id] pp(id, "trying this tile as starting", True) for variation in tile_variations(start_tile): #p("--trying variation") TILEMAP = deep(TILEMAP_clear) TILEPOSITIONS = deep(TILEPOSITIONS_clear) TILEMAP[0][0] = id IMAGE[0][0] = variation TILEPOSITIONS[id] = [0, 0] #ppp(TILEMAP, "current tilemap") if iterate_tilemap(): #p("Sucess iterating") return True break else: pass #p("Didn't work with ANY starting tile") return False
def testHeatVec(self): codmP2d = deep(self.codmP2d) domain = deep(self.dmP2d) sigvec = sp.cdmvec(codmP2d.fcval_at, domain)[1] vw.plot_heatvec(domain, sigvec, md = 'cartes') return
def replace(self, rhs, dst_dims, src_offs=0): new_objs = [] new_dims = [] #Before selected region lim = dst_dims[0] dst_did = 0 while (dst_did < lim): curr_dst_dims = self.get_dims(dst_did) dst_fcid = self.get_objid(curr_dst_dims) new_dims.append(curr_dst_dims) new_objs.append(deep(self.__objs[dst_fcid])) dst_did += ((curr_dst_dims[1] + 1) - curr_dst_dims[0]) lim = (dst_dims[1] + 1) - dst_dims[0] + src_offs #Selected region src_did = src_offs while (src_did < lim): curr_src_dims = rhs.get_dims(src_did) src_fcid = rhs.get_objid(curr_src_dims) curr_new_dims = (curr_src_dims[0] - src_offs + dst_dims[0], curr_src_dims[1] - src_offs + dst_dims[0]) new_dims.append(curr_new_dims) new_objs.append(deep(rhs.__objs[src_fcid])) src_did += ((curr_src_dims[1] + 1) - curr_src_dims[0]) lim = self.last_did() + 1 #After selected region dst_did = dst_dims[1] + 1 while (dst_did < lim): curr_dst_dims = self.get_dims(dst_did) dst_fcid = self.get_objid(curr_dst_dims) new_dims.append(curr_dst_dims) new_objs.append(deep(self.__objs[dst_fcid])) dst_did += ((curr_dst_dims[1] + 1) - curr_dst_dims[0]) #set new lists self.__dims = deep(new_dims) self.__objs = deep(new_objs) return
def measure_at(self, inds): bounds = deep(self.bounds) for end in bounds.get_end(): bounds.set_curr(0, [0, end[1] + 1], end[0][0] ) vol = self.volume res = deep( self.measure.measure_at(vol, bounds, inds) ) return res
def __init__(self, labels, coeffs, bsgens): self.labels = deep(labels) #coefficients of base functions self.coeffs = deep( coeffs) #Can be simple array, as product/replace etc. #is not supported for Signals. self.bsgens = deep(bsgens) #Generator object that maps a base #function to a given multidim. label. return
def __init__(self, samps = None, bounds = None, volume = None, measure = None, is_eq = True, bandlims = None): #TODO: remove this member self.is_eq = is_eq if samps is None: self.samps = gd.Grid() self.bounds = gd.Grid() else: self.samps = samps self.bounds = bounds self.ns = self.samps.get_curr_cards() if volume is None: self.volume = vol.Volume() else: self.volume = volume if measure is None: self.measure = ms.Measure() else: self.measure = measure if bandlims is None: bounds = deep(self.bounds) self.bandlims = deep(bounds.get_lims() ) else: self.bandlims = deep(bandlims) return
def volume_at(self, inds): bounds = self.bounds res = deep( self.volume.at(bounds, inds) ) return res
def reactiveCallback(self, move): if self.state is 'Reactive': liftState = self.movement.lift self.movement = Movement() self.movement = deep(move) self.movement.mag = 1 self.movement.lift = liftState
def ballCleanerCallback(self, move): if self.state is 'BallCleaner': liftState = self.movement.lift self.movement = Movement() self.movement = deep(move) self.movement.mag = 1 self.movement.lift = liftState
def bound_points(self, par, new_bounds, lod, rpoints, loc_did): res_points = None res_points = deep(rpoints) return res_points
def visualServoCallback(self, move): if self.state is 'VisualServo': liftState = self.movement.lift self.movement = Movement() self.movement = deep(move) self.movement.mag = 1 self.movement.lift = liftState
def mappingCallback(self, move): if self.state is 'Mapper': liftState = self.movement.lift self.movement = Movement() self.movement = deep(move) self.movement.mag = 1 self.movement.lift = liftState
def plotHeatMap(heat, color, axisOff, show, save, resize, resCo): #create copy of data heat = deep(heat) figure = plot.figure() #get window canvas figure.canvas.set_window_title('Heat Map') #set title #optional parameter #to remove padding if axisOff: ax = plot.Axes(figure, [0., 0., 1., 1.]) ax.set_axis_off() #remove other axes figure.add_axes(ax) #add new, fake axis #interpolation nearest makes the heat map discrete without gradient if axisOff: plot.imshow(mat(heat), cmap = color, interpolation = 'nearest', aspect = 'normal') else: plot.imshow(mat(heat), cmap = color, interpolation = 'nearest') #normal aspect setting if show: plot.show() #show the stuff out to the screen if save: plot.savefig(getTestSave() + '/' + color + '.png') #calculate tuple to resize the grayscale image res = (len(heat[0]) * resCo, len(heat) * resCo) #if OpenCV image if resize == True: image = Image.open(getTestSave() + '/' + color + '.png') #open image = image.resize(res, Image.NEAREST) #resize image to scale image.save(getTestSave() + '/' + color + '.png') #resave to file #close plot plot.close()
def triangleCallback(self, move): if self.state is 'Triangle': liftState = self.movement.lift self.movement = Movement() self.movement = deep(move) self.movement.mag = 1 self.movement.lift = liftState
def tangentBugCallback(self, move): if self.state is 'TangentBug': liftState = self.movement.lift self.movement = Movement() self.movement = deep(move) self.movement.mag = 1 self.movement.lift = liftState
def add(self, rhs): res = None labels = deep(self.labels) coeffs = deep(self.coeffs) bsgens = deep(self.bsgens) for bsinds in labels: coeffs[bsinds] += rhs.coeffs[bsinds] res = Signal(labels, coeffs, bsgens) return res
def scmult(self, sc): res = None labels = deep(self.labels) coeffs = deep(self.coeffs) bsgens = deep(self.bsgens) for bsinds in labels: coeffs[bsinds] *= sc res = Signal(labels, coeffs, bsgens) return res
def enumerate(sofar,remaining,count,total_list,fixed): if count == 0: new_tuple = tuple(deep(sofar)) total_list.append(new_tuple) return elif len(remaining) < count: return else: rest = deep(remaining[:]) for ind in range(len(remaining)): item = remaining[ind] rest.remove(item) sofar.append(item) new_count = count - 1 enumerate(sofar,rest,new_count,total_list,fixed) sofar.remove(item) return total_list
def gen_tree(griglia): griglia = NodoTris(griglia) for y in range(3): for x in range(3): if griglia.nome[y][x] == '' and casellevuote(griglia.nome, 0) % 2 != 0: griglia2 = deep(griglia.nome) griglia2[y][x] = 'o' griglia.lista_figli += [NodoTris(griglia2)] elif griglia.nome[y][x] == '' and casellevuote(griglia.nome, 0) % 2 == 0: griglia2 = deep(griglia.nome) griglia2[y][x] = 'x' griglia.lista_figli += [NodoTris(griglia2)] for k in griglia.lista_figli: k.lista_figli += [gen_tree(k.nome)] return griglia
def __init__(self, volmstr=None): if volmstr is None: volfcs = [cube] dims = [(0, 0)] else: volfcs = deep(volmstr._MdimStruct__objs) dims = deep(volmstr._MdimStruct__dims) self.__volstr = mst.MdimStruct(volfcs, dims) return
def __init__(self, measstr=None): if measstr is None: measfcs = [cube] fcsdims = [(0, 0)] else: measfcs = deep(measstr._MdimStruct__objs) fcsdims = deep(measstr._MdimStruct__dims) self.__measstr = mst.MdimStruct(measfcs, fcsdims) return
def rotate(tile, degrees): if degrees == 0: return tile newtile = deep(tile) width = len(tile) turns = degrees // 90 for i in range(turns): for line in range(width): for pixel in range(width): #if degrees == 90: newtile[line][pixel] = tile[width - 1 - pixel][line] tile = deep(newtile) return newtile
def joystickCallback(self, preJoyData): joyData = deep(preJoyData) # Switcher reminder: (Variables to help with naming conventions) leftButton = joyData.buttons[4] rightButton = joyData.buttons[5] start = joyData.buttons[7] # Start Button Logic if start == 1 and not self.startButtonDepressed: self.startButtonDepressed = True self.debugPrint("Start Button Pressed") if self.liftOn: self.debugPrint("Turning Thruster Off") self.liftOn = False self.switcher.lift = False else: self.debugPrint("Turning Thruster On") self.liftOn = True self.switcher.lift = True elif start == 0 and self.startButtonDepressed: self.startButtonDepressed = False # Left Button Logic if leftButton == 1 and not self.leftButtonDepressed: self.leftButtonDepressed = True self.debugPrint("Left Button Pressed") # Cycle left (JOYSTICK, TRIANGLE, REACTIVE, MAPPING, TANGENTBUG) self.switchState = 4 if self.switchState - 1 < 0 else self.switchState - 1 self.debugPrint("State is: " + str(self.switchState)) elif leftButton == 0 and self.leftButtonDepressed: self.leftButtonDepressed = False # Right Button Logic if rightButton == 1 and not self.rightButtonDepressed: self.rightButtonDepressed = True self.debugPrint("Right Button Pressed") # Cycle right (Joystick ,triangle, reactive) self.switchState = 0 if self.switchState + 1 > 4 else self.switchState + 1 self.debugPrint("State is: " + str(self.switchState)) elif rightButton == 0 and self.rightButtonDepressed: self.rightButtonDepressed = False # Translational Control Passthrough self.movement.xR = joyData.axes[3] self.movement.yR = joyData.axes[4] self.movement.xL = joyData.axes[0] self.movement.yL = joyData.axes[1] self.movement.bumperL = joyData.axes[2] self.movement.bumperR = joyData.axes[5] # Note: Flipped on purpose self.movement.xButton = joyData.buttons[1] self.movement.bButton = joyData.buttons[2] self.switcher.state = self.switchState
def transform(self, trf_par): res = deep(self) res.__fix_params.lim = trf_par.lim res.__fix_params.card = trf_par.card return res
def flip(tile): newtile = deep(tile) width = len(tile) for line in range(width): for pixel in range(width): newtile[line][pixel] = tile[line][width - 1 - pixel] return newtile
def preprocess(data, skip = True): #create copy of data data = deep(data) #store origin indices origins = {} for key, session in data.items(): #no GPS found yet originIdx = None best = float('inf') #get GPS with lowest accuracy for idx in range(len(session)): if session[idx]['type'] == 'absolute': if not skip: continue #without GPS accuracy = session[idx]['accuracy'] if originIdx is None or accuracy < best: best = accuracy originIdx = idx if originIdx is not None: left = transform(session[:originIdx+1][::-1]) right = transform(session[originIdx:]) session[originIdx]['x'] = session[originIdx]['east'] session[originIdx]['y'] = session[originIdx]['north'] #reassemble original session with fixes session = left[::-1] + [session[originIdx]] + right for idx in range(len(session)): #get rid of absolute type parameters if session[idx]['type'] == 'absolute': del session[idx]['north'] del session[idx]['east'] del session[idx]['zone'] del session[idx]['accuracy'] #get rid of parameters #that are now unnecessary del session[idx]['type'] del session[idx]['time'] #store origin index origins[key] = originIdx else: #originIdx None origins[key] = 0 #put session back in place data[key] = session #output fixed return data, origins
def test_bsgen(self): dm_t = deep(self.dm_t) dm_f = deep(self.dm_f) dm_tt = dm_t.prod(dm_t) dm_ff = dm_f.prod(dm_f) symb_tt = deep(self.symb_tt) symb_ff = deep(self.symb_ff) crtab = deep(self.crtab) pdtab = crtab.product(crtab) inds = [1, 2] bsgen = pdtab.get_bsgen(symb_tt, symb_tt) bsfc = bsgen.gen(dm_tt, inds) vres = sp.cdmvec(bsfc.fcval_at, dm_tt)[1] vw.plot_heatvec(dm_tt, vres) bsgen = pdtab.get_bsgen(symb_tt, symb_ff) bsfc = bsgen.gen(dm_ff, inds) vres = sp.cdmvec(bsfc.fcval_at, dm_tt)[1] vw.plot_heatvec(dm_tt, vres) bsgen = pdtab.get_bsgen(symb_ff, symb_tt) bsfc = bsgen.gen(dm_tt, inds) vres = sp.cdmvec(bsfc.fcval_at, dm_ff)[1] vw.plot_heatvec(dm_ff, vres) bsgen = pdtab.get_bsgen(symb_ff, symb_ff) bsfc = bsgen.gen(dm_ff, inds) vres = sp.cdmvec(bsfc.fcval_at, dm_ff)[1] vw.plot_heatvec(dm_ff, vres) return
def transform(self, trf_par): res = deep(self) res.__fix_params.T = trf_par.T res.__fix_params.dt = trf_par.dt res.__fix_params.shf = trf_par.shf_t return res
def for_to_agn_stance(stance): new_stance = copy.deep(stance) opposite_issue = DBIssue.getById(stance.issue).opposite if opposite_issue is not None: new_stance.issue = opposite_issue else: new_stance.side = "CON" if new_stance.side == "PRO" else "PRO" return new_stance
def __init__(self, t, shf, band): self.T = band[0] self.t = deep(t) self.per = len(t) self.shf_t = shf[0] return
def get_dims(self, did): res = None for elm in self.__dims: if ( (did == elm[0] ) and (did == elm[1] ) ) or\ ( (elm[0]<=did ) and (did <= elm[1] ) ): res = deep(elm) break return res
def gyroCallback(self, gyro): currentAngle = deep(gyro.angle) #Initialize the target angle to the angle of the #hovercraft when it first turns on (prevents #spinning when the craft is launched) if self.first: self.movement.theta = currentAngle self.initialHeading = currentAngle self.previousAngle = currentAngle self.first = False #Check to see if the magnitude is low. If so, #set the target angle to the current angle (so if #the joy isn't depressed anymore, it stops moving). #Should be hard coded to 1 for any input that didn't #originate from the left joystick. if self.movement.mag < .5: self.movement.theta = self.previousAngle else: self.previousAngle = self.movement.theta targetAngle = self.movement.theta #Determine how the target angle should be affected given theta #(see Movement.msg for details) if self.movement.modType == 'Add': targetAngle = currentAngle + self.movement.theta elif self.movement.modType is 'Set': targetAngle = self.movement.theta elif self.movement.modType is 'Bound': #NOTE: CHECK THIS LOGIC targetAngle = self.movement.theta #print ("%s: %f, Current: %f\tTarget: %f"%(self.movement.modType, self.movement.theta, currentAngle, targetAngle)) #Proportional and Derivative computations r = self.P*(targetAngle - currentAngle) r = r + self.D*((targetAngle - currentAngle)-self.previousError) self.previousError = targetAngle - currentAngle #Deadband if math.fabs(targetAngle - currentAngle) < 3: r = 0 self.debugPrint("PosPID: Theta:{:6.2f} TargetAngle:{:6.2f} GyroAngle:{:6.2f} " "Diff: {:6.2f} ModType: {:10s} GyroRate: {:6.2f}".format(self.movement.theta, targetAngle, currentAngle, self.previousError,self.movement.modType,gyro.rate )) #Ship message off to VelocityPID move = Movement() pub = rospy.Publisher('/angularPositionOut',Movement) move.theta = r move.lift = self.movement.lift move.x = self.movement.x move.y = self.movement.y pub.publish(move)
def sector(part_grid, inds): points = [] tmp_inds = deep(inds) for did in range(0, len(inds)): #TODO: it could be made more efficient, if the first vertex point #in the bounding volume was accessed only once start = part_grid.point(tmp_inds) tmp_inds[did] += 1 end = part_grid.point(tmp_inds) points.append(tuple((start, end))) return points
def simpleThresholdMap(uw, min, max, coeff, tracks): #create data copy uw = deep(uw) #calculate threshold number of tracks #based on original number of tracks input sig = tracks * coeff #significant value for i in range(len(uw)): for j in range(len(uw[i])): if uw[i][j] == 0: uw[i][j] == 0 elif uw[i][j] < min: uw[i][j] = 0 elif uw[i][j] > max: uw[i][j] = 1 elif uw[i][j] >= sig: uw[i][j] = 1 elif uw[i][j] < sig: uw[i][j] = 0 #output binary #based heatmap return uw
def transform_pt(self, trf_par, dims): ptgens = deep(self.__ptgens) for gen in ptgens: obj = gen[1] curr_dims = gen[0] if curr_dims == dims: new_obj = obj.transform(trf_par) rptgen = mst.MdimStruct([new_obj], [dims]) ptgens.replace(rptgen, dims, dims[0]) return ptgens
def createListOfGrids(self): b = 0 exWrong = False oldGrid = list() Indikator = 0 workerGrid = list() while True: workerGrid = self.getGridByName("pos") for rowIndex,row in enumerate(workerGrid): for nIndex,n in enumerate(row): if type(n) is list and exWrong is False: n = self.checkForColRow(workerGrid,nIndex,rowIndex,n) try: workerGrid[rowIndex][nIndex] = n[0] workerGrid[rowIndex] = self.raoRow(workerGrid[rowIndex],n[0]) workerGrid = self.raoCol(workerGrid,nIndex,n[0]) except: exWrong = True if workerGrid in oldGrid or exWrong: if b == 100000000: print("Out of Run") print(len(oldGrid)) break exWrong = False else: oldGrid.append(deep(workerGrid)) if v(workerGrid).shortValidator(): print("---------------------------------") print(self.prettyPrintGrid(workerGrid,"Valid Result")) print("Test Runs: " + str(b)) print("Grids: " + str(len(oldGrid))) self.count = b print("---------------------------------") break b += 1 Indikator += 1
def restrict(self, new_dims): tmp_objs = [] tmp_dims = [] did = new_dims[0] while (did < (new_dims[1] + 1)): dims_old = self.get_dims(did) ind = self.get_objid(dims_old) tmp_objs.append(deep(self.__objs[ind])) tmp_dims.append( (dims_old[0] - new_dims[0], dims_old[1] - new_dims[0])) did += ((dims_old[1] + 1) - dims_old[0]) res = MdimStruct(tmp_objs, tmp_dims) return res
def __next__(self): res = None if 'fwd' == self.__direction: if self.__index < len(self.__mdimstruct._MdimStruct__dims): dims = self.__mdimstruct._MdimStruct__dims[self.__index] res = deep((dims, self.__mdimstruct.get_obj(dims))) self.__index += 1 else: raise StopIteration elif 'bwd': #TODO pass return res
def boxThresholdMap(uw, cf): #create data copy uw = deep(uw) #flatten heat map array using list comprehension weights = [item for list in uw for item in list] weights = sorted([i for i in weights if i != 0]) #calculate appropriate statistics firstQuart = percentile(weights, .25) thirdQuart = percentile(weights, .75) interRange = thirdQuart - firstQuart outlier = firstQuart - cf * interRange for i in range(len(uw)): for j in range(len(uw[i])): if uw[i][j] == 0: uw[i][j] == 0 elif uw[i][j] < outlier: uw[i][j] = 0 else: uw[i][j] = 1 #turn pixel on #output binary #based heatmap return uw
def test_base_chg_unif(self): dm_t = deep(self.dm_t) dm_f = deep(self.dm_f) dm_tt = dm_t.prod(dm_t) dm_ff = dm_f.prod(dm_f) symb_tt = deep(self.symb_tt) symb_ff = deep(self.symb_ff) crtab = deep(self.crtab) pdtab = crtab.product(crtab) labels = deep(pdtab.bsubsp_labels) bsgen = pdtab.get_bsgen(symb_tt, symb_ff) coeffs = np.zeros(shape=(4, 4), dtype=np.complex64) coeffs[2, 2] = 0.7 + 1.2j sig_tt_ff = sp.Signal(labels, coeffs, bsgen) sig_ff_ff = pdtab.base_change(symb_tt, symb_ff, dm_ff, dm_tt, sig_tt_ff) vres = sp.sigvec(sig_ff_ff.fcval_at, dm_ff, dm_ff)[1] vw.plot_heatvec(dm_ff, vres) sig_tt_tt = pdtab.base_change(symb_ff, symb_tt, dm_ff, dm_ff, sig_ff_ff) vres = sp.sigvec(sig_tt_tt.fcval_at, dm_tt, dm_tt)[1] vw.plot_heatvec(dm_tt, vres) norm = op.vec_hsp_sc_prod(vres, vres, dm_tt) self.assertAlmostEqual(norm, (0.7 + 1.2j) * (0.7 - 1.2j), places=5) return
def plotCompare(oldData, newData, origins, bound, show): #create copy of data oldData = deep(oldData) newData = deep(newData) origins = deep(origins) #GPS data by old and new coords gpsData, gpsDataNew = {}, {} #rescale old data to origin for key, session in oldData.items(): x = oldData[key][origins[key]]['x'] y = oldData[key][origins[key]]['y'] #dictionary with GPS XY points gpsData[key] = {'x' : [], 'y' : []} for idx in range(len(session)): oldData[key][idx]['x'] -= x oldData[key][idx]['y'] -= y if oldData[key][idx]['type'] == 'absolute': gpsData[key]['x'].append(oldData[key][idx]['x']) gpsData[key]['y'].append(oldData[key][idx]['y']) #pre-compute arrays of X and Y to avoid wasteful looping oldData[key][0]['x'] = [i['x'] for i in oldData[key]] oldData[key][0]['y'] = [i['y'] for i in oldData[key]] #rescale new data to origin for key, session in newData.items(): x = newData[key][origins[key]]['x'] y = newData[key][origins[key]]['y'] #dictionary with GPS XY points gpsDataNew[key] = {'x' : [], 'y' : []} for idx in range(len(session)): newData[key][idx]['x'] -= x newData[key][idx]['y'] -= y if oldData[key][idx]['type'] == 'absolute': gpsDataNew[key]['x'].append(newData[key][idx]['x']) gpsDataNew[key]['y'].append(newData[key][idx]['y']) #pre-compute arrays of X and Y to avoid wasteful looping newData[key][0]['x'] = [i['x'] for i in newData[key]] newData[key][0]['y'] = [i['y'] for i in newData[key]] #draw plots for every session key for key in sorted(oldData.keys()): #instantiate two different subplots that share the XY axes f, (new, old) = plot.subplots(2, sharex = True, sharey = True) old.plot(oldData[key][0]['x'], oldData[key][0]['y'], 'bo') new.plot(newData[key][0]['x'], newData[key][0]['y'], 'go') old.plot(gpsData[key]['x'], gpsData[key]['y'], 'yo') new.plot(gpsDataNew[key]['x'], gpsDataNew[key]['y'], 'ro') old.plot(gpsDataNew[key]['x'], gpsDataNew[key]['y'], 'ro') #these are temporary arrays used for axis scaling x = oldData[key][0]['x'] + newData[key][0]['x'] y = oldData[key][0]['y'] + newData[key][0]['y'] #find max point values for X and Y rawMaxX = max([i for i in x]) rawMaxY = max([i for i in y]) #find max point values for X and Y rawMinX = min([i for i in x]) rawMinY = min([i for i in y]) #find scaled X and Y to define plotting ranges maxX = bound * math.ceil(rawMaxX / bound) maxY = bound * math.ceil(rawMaxY / bound) if maxX == 0: maxX += bound if maxY == 0: maxY += bound maxX += bound/2 maxY += bound/2 #scale minima based on maxima margin minX = rawMinX - (maxX - rawMaxX) minY = rawMinY - (maxY - rawMaxY) #set up gridlines with color and appropriate width old.grid(color = '#9932cc', linestyle = ':', linewidth = 1) new.grid(color = '#9932cc', linestyle = ':', linewidth = 1) #define axes for both old and new old.axis([minX, maxX, minY, maxY]) new.axis([minX, maxX, minY, maxY]) if show: plot.show() plot.close() #done
def interpretJoystick(self,preMove): ''' move = deep(preMove) publisher = rospy.Publisher('/angleIntegratorOut',Movement) xAxisL = move.xL yAxisL = move.yL xAxisR = move.xR yAxisR = move.yR xButton = move.xButton bButton = move.bButton leftBumperMag = move.bumperL rightBumperMag= move.bumperR #X/B button toggle logic if bButton == 1 and not self.bButtonDepressed: self.bButtonDepressed = True self.buttonTargetAngle += 90 elif xButton == 1 and not self.xButtonDepressed: self.xButtonDepressed = True self.buttonTargetAngle += -90 if bButton == 0 and self.bButtonDepressed: self.bButtonDepressed = False if xButton == 0 and self.xButtonDepressed: self.xButtonDepressed = False #Bumper logic (rotational spin using shoulders) #Right overrides left bumperMag = 0 if rightBumperMag != 1: bumperMag = (1 - rightBumperMag) elif leftBumperMag != 1: bumperMag = (1 - leftBumperMag) #Get the arctangent of xAxis/yAxis to get the angle in radians. #Convert it to degrees and make it so that it goes from 0-360 starting #at the positive y axis (to match with the front of the hovercraft). #Uses extreme deadzone to makesure accidental rotations don't happen. magnitudeThreshold = 1 magnitude = math.sqrt(xAxisL**2 + yAxisL**2) rotationalAngle = 0 if magnitude >= magnitudeThreshold: rotationalAngle = round(math.atan2(xAxisL,yAxisL)*(180.0/3.141593),4) if (rotationalAngle > 0): rotationalAngle = rotationalAngle - 360 rotationalAngle = math.fabs(rotationalAngle) magnitudeThreshold = 1 magnitude = math.sqrt(xAxisL**2 + yAxisL**2) rotationalAngle = xAxisL*10 #Ships off the message to the arbitrator #Joystick overrides button target commands moveOut = Movement() moveOut.theta =0 moveOut.modType = 'Bound' #Joystick Logic if magnitude >= magnitudeThreshold: #Reset button upon hitting the joystick self.buttonTargetAngle = 0 moveOut.theta = rotationalAngle moveOut.modType = 'Add' #Trigger absolute rotation if trigger/bumper is held down #print moveOut.theta if rightBumperMag != 1: #print "Right Trigger" self.rightBumperAngle = rightBumperMag self.buttonTargetAngle = 0 moveOut.theta = -.1 if self.rightBumperAngle < 0 else 0 moveOut.modType = 'Add' magnitude = 1 else: self.rightBumperAngle = 0 if leftBumperMag != 1: self.buttonTargetAngle = 0 self.leftBumperAngle = leftBumperMag moveOut.theta = .1 if self.leftBumperAngle < 0 else 0 moveOut.modType = 'Add' magnitude = 1 else: self.leftBumperAngle = 0 #For 90 degree button rotations if math.fabs(self.buttonTargetAngle) > 0: magnitude = 1 moveOut.theta = self.buttonTargetAngle moveOut.modType = 'Add' ''' move = deep(preMove) publisher = rospy.Publisher('/angleIntegratorOut',Movement) xAxisL = move.xL yAxisL = move.yL xAxisR = move.xR yAxisR = move.yR xButton = move.xButton bButton = move.bButton leftBumperMag = move.bumperL rightBumperMag= move.bumperR moveOut = Movement() moveOut.x = xAxisR moveOut.y = yAxisR moveOut.mag = math.fabs(xAxisL) if moveOut.mag > .5: if xAxisL < -.2: theta = -30 elif xAxisL > .2: theta = 30 else: theta = 0 moveOut.theta = theta moveOut.modType = 'Add' else: moveOut.theta = 0 moveOut.modType = 'Add' publisher.publish(moveOut) '''
deck2.append(card2) deck2.append(card1) pp("Player 2 wins this round", "Result") return deck1, deck2 def score(deck): score = 0 multiplier = len(deck) for i, card in enumerate(deck): score += card * (multiplier - i) return score turns = 0 deck1part1, deck2part1 = deep(deck1), deep(deck2) if not part2: while len(deck1part1) > 0 and len(deck2part1) > 0: turns += 1 pp(turns, "Turn") deck1part1, deck2part1 = turn(deck1part1, deck2part1) #pp(deck1part1), pp(deck2part1) if len(deck1part1) == 0: winner = "Player 2" winner_score = score(deck2part1) else: winner = "Player 1" winner_score = score(deck1part1)
def arbitratorCallback(self, move): self.movement = deep(move)
def manualJoyControl(self, move): if self.state is 'Manual': liftState = self.movement.lift self.movement = Movement() self.movement = deep(move) self.movement.lift = liftState
def cleanData(data, rotate, head = None): #create copy of data data = deep(data) #store data with #labels and GPS newData = {} #rotations rotCos = 0 rotSin = 0 #rot set or not rotSet = False for key, session in data.items(): session = sorted(session, key = timeSort) #sort events by time newData[key] = [] #relatives relIdx = 0 relId2 = 1 while session[relIdx]['type'] != 'relative': relIdx += 1 #loop through until found relId2 += 1 #use to find second reltv while session[relId2]['type'] != 'relative': relId2 += 1 #loop through until found xValue = session[relIdx]['absX'] yValue = session[relIdx]['absY'] stride = session[relIdx]['stride'] time = session[relIdx]['time'] label = session[relIdx]['start'] #auto-rotate if rotation is not set if (head is None) and (not rotSet): #get heading of the first step head = session[relId2]['heading'] #calculate rot trig values if (not rotSet) and (rotate): #figure out rotation matrix values rotCos = math.cos(math.radians(head)) rotSin = math.sin(math.radians(head)) #unset rotSet rotSet = True newData[key].append({ 'type' : 'relative', 'x' : xValue, 'y' : yValue, 'stride' : stride, 'label' : label, 'time' : time }) for idx in range(1, len(session)): if idx == relIdx: continue if session[idx]['type'] == 'label': if len(newData[key]) > 1: #don't overwrite start location newData[key][-1]['label'] = session[idx]['content'] elif session[idx]['type'] == 'absolute': #change type as an identifier newData[key][-1]['type'] = 'absolute' latitude = session[idx]['latitude'] longitude = session[idx]['longitude'] northing, easting, zone = toUTM(latitude, longitude) newData[key][-1]['north'] = northing #cartesian y-axis newData[key][-1]['east'] = easting #cartesian x-axis newData[key][-1]['zone'] = zone #UTM validity zone newData[key][-1]['accuracy'] = session[idx]['accuracy'] elif session[idx]['type'] == 'relative': xValue = session[idx]['absX'] yValue = session[idx]['absY'] stride = session[idx]['stride'] time = session[idx]['time'] newData[key].append({ 'type' : 'relative', 'x' : xValue, 'y' : yValue, 'stride' : stride, 'time' : time }) #rotates if rotate: newData[key][-1]['x'] = xValue * rotCos - yValue * rotSin newData[key][-1]['y'] = xValue * rotSin + yValue * rotCos #output organized return newData
def positionPIDCallback(self, move): self.movePass = deep(move)
def interpretJoystick(self,preMove): move = deep(preMove) publisher = rospy.Publisher('/angleIntegratorOut',Movement) xAxisL = move.xL yAxisL = move.yL xAxisR = move.xR yAxisR = move.yR xButton = move.xButton bButton = move.bButton leftBumperMag = move.bumperL rightBumperMag= move.bumperR #X/B button toggle logic if bButton == 1 and not self.bButtonDepressed: self.bButtonDepressed = True self.buttonTargetAngle += 90 elif xButton == 1 and not self.xButtonDepressed: self.xButtonDepressed = True self.buttonTargetAngle += -90 if bButton == 0 and self.bButtonDepressed: self.bButtonDepressed = False if xButton == 0 and self.xButtonDepressed: self.xButtonDepressed = False #Bumper logic (rotational spin using shoulders) #Right overrides left bumperMag = 0 if rightBumperMag != 1: bumperMag = (1 - rightBumperMag) elif leftBumperMag != 1: bumperMag = (1 - leftBumperMag) #Get the arctangent of xAxis/yAxis to get the angle in radians. #Convert it to degrees and make it so that it goes from 0-360 starting #at the positive y axis (to match with the front of the hovercraft). #Uses extreme deadzone to makesure accidental rotations don't happen. magnitudeThreshold = 1 magnitude = math.sqrt(xAxisL**2 + yAxisL**2) rotationalAngle = 0 if magnitude >= magnitudeThreshold: rotationalAngle = round(math.atan2(xAxisL,yAxisL)*(180.0/3.141593),4) if (rotationalAngle > 0): rotationalAngle = rotationalAngle - 360 rotationalAngle = math.fabs(rotationalAngle) #Ships off the message to the arbitrator #Joystick overrides button target commands moveOut = Movement() moveOut.modType = 'Bound' #Joystick Logic if magnitude >= magnitudeThreshold: #Reset button upon hitting the joystick self.buttonTargetAngle = 0 moveOut.theta = rotationalAngle moveOut.modType = 'Bound' #Trigger absolute rotation if trigger/bumper is held down if rightBumperMag != 1: self.rightBumperAngle = self.rightBumperAngle + (rightBumperMag * 100) self.buttonTargetAngle = 0 moveOut.theta = self.rightBumperAngle moveOut.modType = 'Add' magnitude = 1 else: self.rightBumperAngle = 0 if leftBumperMag != 1: self.buttonTargetAngle = 0 self.leftBumperAngle = self.leftBumperAngle + (leftBumperMag * 100) moveOut.theta = -1 * self.leftBumperAngle moveOut.modType = 'Add' magnitude = 1 else: self.leftBumperAngle = 0 #For 90 degree button rotations if math.fabs(self.buttonTargetAngle) > 0: magnitude = 1 moveOut.theta = self.buttonTargetAngle moveOut.modType = 'Add' moveOut.x = xAxisR moveOut.y = yAxisR moveOut.mag = magnitude publisher.publish(moveOut) #Prints all information related to the integrator if need be if (self.debug == 1): print("xL: %6.2f yL: %6.2f Angle: %6.2f Magnitude:%6.2f " "xR: %6.2f yR: %6.2f Theta: %6.2f Button Target: %6.2f" "rB: %6.2f lB: %6.2f rM: %6.2f lM: %6.2f " % (xAxisL,yAxisL,rotationalAngle,magnitude,xAxisR,yAxisR,moveOut.theta, self.buttonTargetAngle, self.rightBumperAngle, self.leftBumperAngle, rightBumperMag, leftBumperMag))
def transform(steps): #create copy of data steps = deep(steps) #coordinate frame origin = steps[0] originIdx = 0 #get origin rel and abs XY-coordinates originRel = (origin['x'], origin['y']) originAbs = (origin['east'], origin['north']) originZone = origin['zone'] #zone check #set current accuracy currentAcc = origin['accuracy'] #transform relative to absolute for idx in range(len(steps)): steps[idx]['x'] += originAbs[0] - originRel[0] steps[idx]['y'] += originAbs[1] - originRel[1] for idx in range(1, len(steps)): if steps[idx]['type'] == 'absolute': reading = (steps[idx]['east'], steps[idx]['north']) footfall = (steps[idx]['x'], steps[idx]['y']) #get new reading accuracy newAcc = steps[idx]['accuracy'] #discard if reading overlaps with previous reading if (distance(originAbs, reading) <= currentAcc + newAcc): continue #same thing, but with footfall and its corresponding GPS if (distance(footfall, reading) <= currentAcc + newAcc): continue #check if zones match, or continue if originZone != steps[idx]['zone']: continue #calculate linear matrix transformation for footfalls initialPoints = mat([list(originAbs), list(footfall)]).T finalPoints = mat([list(originAbs), list(reading)]).T try: #see if we can find a transformation matrix transform = finalPoints * initialPoints.I #this fires if initialPoints is singular except numpy.linalg.linalg.LinAlgError: #we could not continue #apply transformation to each point #that is located between readings for pos in range(originIdx, idx + 1): oldPt = (steps[pos]['x'], steps[pos]['y']) oldVec = mat([[oldPt[0], oldPt[1]]]).T newVec = transform * oldVec newPt = newVec.ravel().tolist()[0] (steps[pos]['x'], steps[pos]['y']) = newPt #calculate translation vector for reading footfallVec = mat([list(footfall)]).T readingVec = mat([list(reading)]).T translate = readingVec - footfallVec #apply translation to each point #that is subsequent to new reading for pos in range(idx + 1, len(steps)): oldPt = (steps[pos]['x'], steps[pos]['y']) oldVec = mat([[oldPt[0], oldPt[1]]]).T newVec = oldVec + translate newPt = newVec.ravel().tolist()[0] (steps[pos]['x'], steps[pos]['y']) = newPt #all of the stuff we did at the beginning #since the first point was the first origin anchor origin = steps[idx] originIdx = idx originRel = (origin['x'], origin['y']) originAbs = (origin['east'], origin['north']) #see discussion for why this changes currentAcc = origin['accuracy'] #return all but #first origin point return steps[1:]
def plotSuper(data, bound, show, save): #create copy of data data = deep(data) figure = plot.figure() #get the window canvas figure.canvas.set_window_title('Superimposed Paths') #keep track of seen points #we don't want duped labels seenLabels, x, y = [], [], [] for step in data: x.append(step['x']) y.append(step['y']) #plot point and corresponding label plot.plot(x[-1], y[-1], 'go') if 'label' in step: if step['label'] not in seenLabels: #store label temporarily label = step['label'] #set style of annotation box. this should be nice but unobtrusive box = dict(boxstyle = 'round, pad = 0.4', fc = 'cyan', alpha = 1.0) plot.annotate(label, xy = (x[-1], y[-1]), bbox = box) #add label to plot #append label to seen labels seenLabels.append(label) #find max point values for X and Y rawMaxX = max([i for i in x]) rawMaxY = max([i for i in y]) #find max point values for X and Y rawMinX = min([i for i in x]) rawMinY = min([i for i in y]) #find scaled X and Y to define plotting ranges maxX = bound * math.ceil(rawMaxX / bound) maxY = bound * math.ceil(rawMaxY / bound) if maxX == 0: maxX += bound if maxY == 0: maxY += bound maxX += bound/2 maxY += bound/2 #scale minima based on maxima margin minX = rawMinX - (maxX - rawMaxX) minY = rawMinY - (maxY - rawMaxY) #set up gridlines with color and appropriate width plot.grid(color = '#9932cc', linestyle = ':', linewidth = 1) plot.axis([minX, maxX, minY, maxY]) #define axis if show: plot.show() #show the stuff out to the screen if save: plot.savefig(getTestSave() + '/' + 'super.png') #close plot plot.close()
sub = types[i][-1] #identify points as corner types or not if sub == 'e': corr = ['s', 'e', 's'] elif sub == 's': corr = ['s', 's', 's'] elif sub == 'i': corr = ['s', 'i', 's'] elif sub == 't': corr = ['t', 't', 't'] #if we are drawing a filled type edge with no exts if I and II and III and IV and not exts: continue paths.append(edges[i]) corns.append(corr) #copy paths and corners orgPaths = deep(paths) orgCorns = deep(corns) idx = 0 #fake for loop while idx < len(orgPaths): found = True #init while found == True: found = False lastlen = 0 #try to stitch the point groups together for i in range(len(orgPaths)-1, idx, -1): #needs the algo extension if orgCorns[i][0] == 't':
def makeHeatMap(data, steps, pixel, alpha, function, frame): #floor pixel to one meter #to avoid bugs that occur if pixel > 1: pixel = 1 #create copy of data data = deep(data) steps = deep(steps) #make scaling coefficient coeff = round(1/pixel) minX, maxX = steps[0]['x'], steps[0]['x'] minY, maxY = steps[0]['y'], steps[0]['y'] #find min and max vals of X and Y #accounting for radius expansion for element in steps: #calculate the personal comfort radius #see TODO note above about this formula radius = element['stride'] * alpha * coeff if element['x'] - radius < minX: minX = element['x'] - radius if element['x'] + radius > maxX: maxX = element['x'] + radius if element['y'] - radius < minY: minY = element['y'] - radius if element['y'] + radius > maxY: maxY = element['y'] + radius #calculate XY ranges xRange = maxX - minX yRange = maxY - minY #rescale everything positive for key, session in data.items(): for idx in range(len(session)): data[key][idx]['x'] -= minX data[key][idx]['y'] -= minY #then scale X and Y ranges appropriately xRange, yRange = xRange * coeff, yRange * coeff xRange, yRange = math.ceil(xRange), math.ceil(yRange) #heatmap arrays heatmap = [] weighted = [] labels = [] #debug runtime issues #print(xRange, yRange) #initialize zero matrix for i in range(xRange): heatmap.append([]) weighted.append([]) labels.append([]) for j in range(yRange): heatmap[-1].append(0) weighted[-1].append(0) labels[-1].append(None) for key, session in data.items(): #track seen pixels seenPixels = [] for step in session: x = step['x'] * coeff y = step['y'] * coeff #preserve labels mapX = round(x) mapY = round(y) #calculate personal comfort radius #see TODO note above about this line radius = step['stride'] * alpha * coeff #make bounding box to find pixels #used in for loop, see below boundMinX = math.floor(x - radius) boundMaxX = math.ceil(x + radius) boundMinY = math.floor(y - radius) boundMaxY = math.ceil(y + radius) #only add label to array if label not set already if 'label' in step and labels[mapX][mapY] is None: labels[mapX][mapY] = step['label'] for i in range(boundMinX, boundMaxX + 1): for j in range(boundMinY, boundMaxY + 1): if distance((x, y), (i, j)) <= radius: if i in range(xRange) and j in range(yRange): #weight only if not weighted if (i, j) not in seenPixels: heatmap[i][j] += 1 seenPixels.append((i, j)) #calculate weighted function of heatmap weighted[i][j] = function(heatmap[i][j]) #rotate array CCW so it is oriented north weighted = mat(weighted).T[::-1].tolist() heatmap = mat(heatmap).T[::-1].tolist() labels = mat(labels).T[::-1].tolist() #add a frame of zero-weighted pixels on the top vertFrame = [[0] * len(weighted[0])] * frame weighted = mat(vertFrame + weighted + vertFrame).T.tolist() #do the same thing for our unweighted matrix vertFrame = [[0] * len(heatmap[0])] * frame heatmap = mat(vertFrame + heatmap + vertFrame).T.tolist() #do the same thing for our matrix of labels vertFrame = [[None] * len(labels[0])] * frame labels = mat(vertFrame + labels + vertFrame).T.tolist() #add a frame of zero-weighted pixels on the side sideFrame = [[0] * len(weighted[0])] * frame weighted = mat(sideFrame + weighted + sideFrame).T.tolist() #do the same thing for our unweighted matrix sideFrame = [[0] * len(heatmap[0])] * frame heatmap = mat(sideFrame + heatmap + sideFrame).T.tolist() #do the same thing for our matrix of labels sideFrame = [[None] * len(labels[0])] * frame labels = mat(sideFrame + labels + sideFrame).T.tolist() #output weights with unweighted return weighted, heatmap, labels
def fireThrusters(self, move): theta = deep(move.theta) x = deep(move.x) y = deep(move.y) #Translation coef=0.75 if y > .1: self.thrust.thruster2 = y self.thrust.thruster3 = y elif y < -.1: self.thrust.thruster1 = -y else: self.thrust.thruster1 = 0 self.thrust.thruster2 = 0 self.thrust.thruster3 = 0 ''' tr1x=0 tr2x=0 tr3x=0 tr1y=0 tr2y=0 tr3y=0 if -x>0: tr2x=1/0.866*(-x)*coef tr1x=0.5/0.866*(-x)*coef if -x<0: tr3x=1/0.866*x*coef tr1x=0.5/0.866*x*coef if y>0: tr2y=1*y*coef tr3y=1*y*coef if y<0: tr1y=1*(-y)*coef self.thrust.thruster1=tr1x+tr1y self.thrust.thruster2=tr2x+tr2y self.thrust.thruster3=tr3x+tr3y ''' if theta >0: #Turn on 4 self.thrust.thruster5 = 0 self.thrust.thruster4 = math.fabs(theta)/100.0 self.thrust.thruster4 = self.thrust.thruster4 if self.thrust.thruster4 < .7 else .7 elif theta<0: #Turn on 5 self.thrust.thruster4 = 0 self.thrust.thruster5 = math.fabs(theta)/100.0 self.thrust.thruster5 = self.thrust.thruster5 if self.thrust.thruster5 < .7 else .7 elif theta==0: #Turn off thrusters if theta is 0 self.thrust.thruster4 =0 self.thrust.thruster5 =0 if (self.debug == 1): print ("Thruster 1:%6.2f Thruster 2:%6.2f Thruster 3:%6.2f\nTheta:%6.2f Thruster 4:%6.2f Thruster 5:%6.2f Lift:%6.2f\nX: %6.2f Y: %6.2f" % (self.thrust.thruster1, self.thrust.thruster2, self.thrust.thruster3, theta, self.thrust.thruster4, self.thrust.thruster5, self.thrust.lift,x, y)) #Kill the thrusters if no lift is present if move.lift == False: self.thrust.thruster1 = 0 self.thrust.thruster2 = 0 self.thrust.thruster3 = 0 self.thrust.thruster4 = 0 self.thrust.thruster5 = 0 self.thrust.lift = 0 else: self.thrust.lift = self.liftPower pub = rospy.Publisher('/hovercraft/Thruster', Thruster) #if self.thrust.thruster1 > 0 or self.thrust.thruster2 > 0 or self.thrust.thruster3 > 0 or self.thrust.thruster4 > 0 or self.thrust.thruster5 > 0: # print self.thrust pub.publish(self.thrust)
def superimpose(data, label, split): #create copy of data data = deep(data) #list of compiled steps compiledData = [] #dic of compiled sessions compiledSessions = {} for key, session in data.items(): refX = 0 #reference x-coordinate refY = 0 #reference y-coordinate for idx in range(len(session)): if 'label' in session[idx]: if session[idx]['label'] == label: refX = session[idx]['x'] refY = session[idx]['y'] break #for efficiency sake for idx in range(len(session)): session[idx]['x'] -= refX session[idx]['y'] -= refY #append falls to split with first newSplitSession = [session[0]] #add intermediary extrapolations for idx in range(1, len(session)): dx = (session[idx]['x'] - session[idx-1]['x']) dy = (session[idx]['y'] - session[idx-1]['y']) #avoid zero if dx == 0: #define fake dy split length splitLength = dy / (split + 1) #calculate the extrapolations for i in range(1, split + 1): newSplitSession.append({ 'x' : session[idx-1]['x'], #value constant 'y' : session[idx-1]['y'] + i * splitLength, 'stride' : session[idx]['stride'], #use old }) #errors continue #define slope slope = dy/dx #define split length using dx splitLength = dx / (split + 1) #calculate the extrapolations for i in range(1, split + 1): newSplitSession.append({ 'x' : session[idx-1]['x'] + i * splitLength, 'y' : session[idx-1]['y'] + slope * i * splitLength, 'stride' : session[idx]['stride'], #use old stride }) #finally add actual step to session newSplitSession.append(session[idx]) #add steps to compiled list of steps for idx in range(len(newSplitSession)): compiledData.append(newSplitSession[idx]) #add session to compiled session list compiledSessions[key] = newSplitSession #our final lists of steps and sessions return compiledData, compiledSessions