def doCompute(self, drawer, situation): figureA = situation.agent("figure") landmarkA = situation.agent("landmark") figure = [(x, y) for x, y, theta in figureA.positions] landmark = [(x, y) for x, y, theta in landmarkA.positions] out = {} bborigin, (width, height) = math2d.boundingBox(figure) scale = pow(pow(width, 2) + pow(height, 2), 0.5) if scale == 0: bborigin, (width, height) = math2d.boundingBox(figure + landmark) scale = pow(pow(width, 2) + pow(height, 2), 0.5) pt = landmark[-1] dFigureStartToGround = math2d.dist(pt, figure[0]) dFigureEndToGround = math2d.dist(pt, figure[-1]) drawer.drawDistance("displacementFromGround", [pt, figure[0]]) drawer.drawDistance("displacementFromGround", [pt, figure[-1]]) out["endpointDist"] = math2d.dist(figure[-1], landmark[-1]) / scale out["startpointDist"] = math2d.dist(figure[0], landmark[0]) / scale out["displacementFromGround"] = (dFigureEndToGround - dFigureStartToGround) / scale return out
def nearestNeighbor(self, x_rand, tree): nodes = [n for n in tree.nodes()] x1, x2 = x_rand distances = [ math2d.dist(p1, x1) + math2d.dist(p2, x2) for p1, p2 in nodes ] minI, min = math2d.argMin(distances) return nodes[minI]
def doCompute(self, drawer, situation): distances = [] figure = situation.agent("figure") landmark = situation.agent("landmark") points = [(x, y) for x, y, theta in figure.positions + landmark.positions] (minX, minY), (scaleX, scaleY) = math2d.boundingBox(points) scale = math.pow(scaleX**2 + scaleY**2, 0.5) for t in range(situation.startTime, situation.endTime, 100): fx, fy, ftheta = figure.location(t) lx, ly, ltheta = landmark.location(t) floc = fx, fy lloc = lx, ly distances.append(math2d.dist(floc, lloc)) drawer.drawDistance("averageDistance", t, floc, lloc) drawer.drawDistance("stdDevOfDistance", t, floc, lloc) if len(distances) == 0: raise InsaneExample("Bad figure: " + `figure`) if scale == 0: scale = 0.000001 return {"averageDistance":scipy.mean(distances) / scale, "stdDevOfDistance":scipy.std(distances) / scale }
def data(self, midx, role=Qt.DisplayRole): engineData = self.currentEngineData() col = midx.column() idx = midx.row() #idx = midx.row() metadata = self.m4du.metadataForMatrixKey(engineData.idxForKey(idx), wantArgs=False) if role != Qt.DisplayRole: return QVariant() if col == COL_SCORE: return QVariant("%e" % engineData.data(idx)) elif col == COL_LANDMARK: return QVariant(metadata.groundName) elif col == COL_DIST_TO_ENDPOINTS: return QVariant(math2d.dist(metadata.sloc, metadata.eloc)) elif col == COL_SLOC: return QVariant("(%.3f, %.3f)" % tuple(metadata.sloc)) elif col == COL_ELOC: return QVariant("(%.3f, %.3f)" % tuple(metadata.eloc)) elif col == COL_IDX_TUPLE: return QVariant( ` metadata.key `) elif col == COL_ROW_NUM: return QVariant(idx) else: raise ValueError("Bad id: %s" % col)
def pixels(self, dist): """ Convert a distance in pixels to distance in the figure using the current data coordinates. """ p1 = self.axes.transData.inverted().transform((0, 0)) p2 = self.axes.transData.inverted().transform((0, dist)) return math2d.dist(p1, p2)
def compute(self, situation, offset): a1 = situation.agent(self.a1) a2 = situation.agent(self.a2) x1, y1, theta1 = a1.location(offset) x2, y2, theta2 = a2.location(offset) #if math2d.length(situation.shortestPath((x1, y1), (x2, y2))) < 10: if math2d.dist((x1, y1), (x2, y2)) < 5: return True else: return False
def doCompute(self, drawer, situation): out = {} figurePath = situation.agent("figure").asPath() bborigin, (width, height) = math2d.boundingBox(figurePath) scale = pow(pow(width, 2) + pow(height, 2), 0.5) drawer.drawDistance("netDisplacement", 0, figurePath[0], figurePath[-1]) out["netDisplacement"] = math2d.dist(figurePath[0], figurePath[-1]) return out
def compute(self, situation, offset): a1 = situation.agent(self.a1) dt = 100 x1, y1, theta1 = a1.location(offset) x2, y2, theta2 = a1.location(offset + dt) if math2d.dist((x1, y1), (x2, y2)) != 0: return True else: return False
def is_loc_visible_from_pose(loc_st, theta_st, loc_end, fov=None): """ Returns true if loc is visible from start_loc, start_theta with the given field of view """ abs_orient = atan2(loc_end[1] - loc_st[1], loc_end[0] - loc_st[0]) if math2d.dist(loc_st, loc_end) < 0.00000001: return True elif (0 >= tklib_normalize_theta(theta_st - fov / 2.0 - abs_orient) and 0 <= tklib_normalize_theta(theta_st + fov / 2.0 - abs_orient)): return True else: return False
def plotPaths(self, results=None): self.resultsModel.setEntries(results) if results == None: if self.cached_results != None: results = self.cached_results else: raise ValueError("Passed no results, and no cached results.") else: self.cached_results = results for p in self.path_plots: p.remove() self.path_plots = [] true_eloc_i = results[0].iCorrectElocs[0] topo_st, ang = self.m4du.viewpoints[true_eloc_i].split("_") true_eloc = self.m4du.tmap_locs[float(topo_st)] radius = self.radiusBox.value() plot = matplotlib.patches.Ellipse(true_eloc, radius*2, radius*2, facecolor='none', linewidth=5) self.axes.add_patch(plot) self.path_plots.append(plot) random.seed(3) total = 0.0 num_within_radius = 0.0 for e in results: for path in e.paths: eloc_topo_st, eloc_ang = path[-1].split("_") x, y = self.m4du.tmap_locs[float(eloc_topo_st)] x += random.uniform(-1, 1) y += random.uniform(-1, 1) p, = self.axes.plot([x], [y], "r^", markersize=15) self.path_plots.append(p) if math2d.dist((x, y), true_eloc) < radius: num_within_radius += 1 total += 1 sloc_topo_st, sloc_ang = path[0].split("_") x, y = self.m4du.tmap_locs[float(sloc_topo_st)] p, = self.axes.plot([x], [y], "g^", markersize=15) self.path_plots.append(p) self.fractionWithinCircleLabel.setText("%.3f" % (num_within_radius/total)) self.figure.canvas.draw()
def doCompute(self, drawer, landmark, figure, **args): boundary = math2d.computeBoundaryLine(landmark, figure) map = {} bborigin, (width, height) = math2d.boundingBox(figure) scale = pow(pow(width, 2) + pow(height, 2), 0.5) if scale == 0: bborigin, (width, height) = math2d.boundingBox(landmark) scale = pow(pow(width, 2) + pow(height, 2), 0.5) drawer.distanceFeature(map, "distStartLandmarkBoundary", "Boundary", "Figure Start", math2d.closestPointOnLine(boundary, figure[0]), figure[0], scale) drawer.distanceFeature(map, "distEndLandmarkBoundary", "Boundary", "Figure End", math2d.closestPointOnLine(boundary, figure[-1]), figure[-1], scale) map['averageDistStartEndLandmarkBoundary'] = na.mean([map['distStartLandmarkBoundary'], map['distEndLandmarkBoundary']]) drawer.drawLine('averageDistStartEndLandmarkBoundary', figure[-1], math2d.closestPointOnLine(boundary, figure[-1])) drawer.distanceFeature(map, "figureStartToEnd", "Start", "End", figure[0], figure[-1], scale) map['figureLength'] = math2d.length(figure) / scale drawer.drawPoint('figureLength', figure[0]) drawer.drawPoint('figureLength', figure[-1]) if math2d.length(figure) == 0: map['figureLengthByCrow'] = 0 else: map['figureLengthByCrow'] = math2d.dist(figure[0], figure[-1]) / math2d.length(figure) return map
def findSubsetOfFigure(landmark, figure): bestScore = None bestPath = figure d_f = math2d.length(figure)/100 for subpath in math2d.slideWindowAlongPath(figure, d_f, fractionSize=0.6): totalDist = 0.0 count = 0 for f1 in [x for x in math2d.stepAlongLine(figure, d_f)]: g1 = math2d.closestPointOnLine(math2d.polygonToLine(landmark), f1) totalDist += math2d.dist(f1, g1) count += 1 mean = totalDist / count if bestScore == None or mean <= bestScore: bestScore = mean bestPath = subpath clippedFigure = bestPath
def drawArrow(self, line, narrowness=4, length=5): self.drawLine(line) p1 = self.mtp(line[0]) p2 = self.mtp(line[-1]) pixSeg = [p1, p2] startP = math2d.pointOnSegment(pixSeg, math2d.dist(p1, p2) - length) segment = math2d.perpendicular(pixSeg, startP) sa1 = [startP, segment[0]] sa2 = [startP, segment[-1]] a1 = math2d.pointOnSegment(sa1, narrowness) a2 = math2d.pointOnSegment(sa2, narrowness) a3 = p2 self.p.drawLine(a1[0], a1[1], a3[0], a3[1]) self.p.drawLine(a2[0], a2[1], a3[0], a3[1])
def pack_get_srel_given_lmark_vpts_matrix(m4du): functions = [] tmap, tmap_cnt, tmap_locs = m4du.clusters.get_topological_map() engineMap = m4du.sr_class.engineMap globals()["m4du"] = m4du #sorted(m4du.tmap.keys()) tmap_keys = m4du.tmap_keys exampleCount = 0 for j, tmapKey_j in enumerate(tmap_keys): sloc = m4du.tmap_locs[tmapKey_j] for k, tmapKey_k in enumerate(tmap_keys): eloc = m4du.tmap_locs[tmapKey_k] if math2d.dist(sloc, eloc) <= 20: desc = "viewpoint %d, %d" % (j, k) functions.append( (desc, spatialRelationLoop, (sloc, eloc, j, k))) return functions
def updateTarget(self, timestamp): situation = self.agent.situation minDist = None minAgent = None hereX, hereY, hereTheta = self.agent.location(timestamp) for a in situation.agents: aX, aY, aTheta = a.location(timestamp) dist = math2d.dist((aX, aY), (hereX, hereY)) if (minDist == None or dist < minDist) and a != self.agent: minDist = dist minAgent = a print "agent", minDist, minAgent if minDist != None and minDist < 4: if minDist < 1: return None else: x, y, theta = minAgent.location(timestamp) return x, y else: return None
def get_transition_matrix(self, direction="straight", p_self=1.0): T_mat = zeros([ self.num_regions * self.num_viewpoints, self.num_regions * self.num_viewpoints ]) * 1.0 print print "direction", direction if (direction == "straight"): new_tmap = self.get_topological_map_viewpoint(pi, 0) elif (direction == "back"): new_tmap = self.get_topological_map_viewpoint(pi, pi) elif (direction == "right"): new_tmap = self.get_topological_map_viewpoint(pi, -1.0 * pi / 2.0) elif (direction == "left"): new_tmap = self.get_topological_map_viewpoint(pi, +1.0 * pi / 2.0) elif (direction == "face"): new_tmap = self.get_topological_map_viewpoint(None, 0) else: raise ValueError("Unexpected direction: " + ` direction `) #for each of the viewpoints for i in range(len(self.viewpoints)): connections = new_tmap[self.viewpoints[i]] #find the areas connected and if they are reasonable for conn in connections: cconn = conn #connofconn = [conn] #connofconn.extend(new_tmap[conn]) #for conn_i, cconn in enumerate(connofconn): #convert this into topo numbers topo_st, topo_st_ang = self.viewpoints[i].split("_") topo_end, topo_end_ang = cconn.split("_") if (cconn < 0 or self.viewpoints[i] == -1): continue loc1 = self.tmap_locs[float(topo_st)] loc2 = self.tmap_locs[float(topo_end)] #for each of the to-node's orientations, check its relative angle to # the from node's orientation and give it a relative probability # accordingly start_num = self.vpt_to_num[self.viewpoints[i]] end_num = self.vpt_to_num[cconn] #make this dependent on how much we turn in total debug = False if (start_num == 18 or start_num == 16) and end_num == 42 and False: print "***************", start_num, end_num debug = True orient_diff, d_turn = get_total_turn_amount( loc1[0], loc1[1], radians(float(topo_st_ang)), loc2[0], loc2[1], radians(float(topo_end_ang)), debug=debug) #going to end_num from i if (direction == 'straight'): if debug: print "val", max(-1.75 / pi * abs(orient_diff) + 1, 0.0) T_mat[end_num, start_num] = -abs(orient_diff) T_mat[end_num, start_num] = sigmoid(T_mat[end_num, start_num]) elif (direction == 'back'): diff_from_pi = tklib_normalize_theta(d_turn * orient_diff - pi) T_mat[end_num, start_num] = -abs(diff_from_pi) T_mat[end_num, start_num] = sigmoid(T_mat[end_num, start_num]) #T_mat[start_num][end_num] = max(-1.5/pi*abs(orient_diff)+1, 0.0) elif (direction == 'right' and d_turn < 0): diff_from_neg_pi2 = tklib_normalize_theta(d_turn * orient_diff + (pi / 2.0)) T_mat[end_num, start_num] = -abs(diff_from_neg_pi2) T_mat[end_num, start_num] = sigmoid(T_mat[end_num, start_num]) #T_mat[start_num][end_num] = max(-1.5/pi*abs(diff_from_neg_pi2)+1, 0.0) elif (direction == 'left' and d_turn > 0): diff_from_pi2 = tklib_normalize_theta(d_turn * orient_diff - (pi / 2.0)) T_mat[end_num, start_num] = -abs(diff_from_pi2) T_mat[end_num, start_num] = sigmoid(T_mat[end_num, start_num]) elif direction == "face": if math2d.dist(loc1, loc2) < 0.01: T_mat[end_num, start_num] = p_self else: T_mat[end_num, start_num] = 0 assert 0 <= T_mat[end_num, start_num] <= 1, T_mat[end_num, start_num] #T_mat[start_num][end_num] = max(-1.5/pi*abs(diff_from_pi2)+1, 0.0) #if(not conn == cconn): # T_mat[end_num,start_num] = T_mat[end_num,start_num]*0.3 #connect self transitions topo_st, topo_st_ang = self.viewpoints[i].split("_") if (direction == "straight"): T_mat[i, i] = p_self elif (direction == "right"): newang = mod( int(float(topo_st_ang)) - int(float(self.get_viewpoint_diff())), 360.0) * 1.0 T_mat[self.vpt_to_num[str(topo_st) + "_" + str(newang)], i] = p_self elif (direction == "left"): newang = mod( int(float(topo_st_ang)) + int(float(self.get_viewpoint_diff())), 360.0) * 1.0 T_mat[self.vpt_to_num[str(topo_st) + "_" + str(newang)], i] = p_self elif (direction == "back"): newang = mod(int(float(topo_st_ang)) + 180, 360) * 1.0 T_mat[self.vpt_to_num[str(topo_st) + "_" + str(newang)], i] = p_self return T_mat
def describe(self): figure = self.player_locs[self.figure_start:] if math2d.sorta_eq(math2d.length(figure), 0): return if (self.last_describe_loc != None and math2d.dist(self.last_describe_loc, figure[-1]) < 1): return landmark_i = self.pick_landmark(figure) if landmark_i == None: return object_name = self.m4du.obj_names[landmark_i] ground = self.m4du.createGroundFromPolygon(landmark_i) self.describe_window.generate(geometry={ "figure": figure, "ground": ground }) #verb_choices = [e.engine.name() # for e in self.describe_window.verbResultModel._data # if e.p_true > 0.7] verb_choices = ["straight"] print "choices", verb_choices if "straight" in verb_choices or True: verb_name = "straight" else: if len(verb_choices) == 0: return else: verb = self.describe_window.verbResultModel.get(0) verb_name = verb.engine.name() verb_str = random.choice(verb_forms[verb_name]) print "object name", object_name, landmark_i object_str = random.choice(object_forms[object_name]) sr_choices = [] for e in self.describe_window.srResultModel._data: if e.p_true > 0.7: sr_choices.append(e) if len(sr_choices) == 0: return engine_names = [e.engine.name() for e in sr_choices] if "through" in engine_names: sr = sr_choices[engine_names.index("through")] else: sr = random.choice(sr_choices) next_segment = "%s %s the %s." % ( verb_str, sr.engine.name(), object_str, ) connectors = ["Next", "Then", "", "After that"] connector = random.choice(connectors) if len(self.segments) >= 1 and connector != "": next_segment = "%s %s" % (connector, next_segment) else: next_segment = next_segment.capitalize() self.segments.append(next_segment) self.descriptionLabel.setText(" ".join(self.segments)) bar = self.labelScrollArea.verticalScrollBar() #bar.setSliderPosition(bar.maximum() + 100) self.last_describe_time = datetime.now() self.last_describe_loc = figure[-1] self.figure_start = len(figure) - 1 self.plot_landmark(landmark_i)
def doCompute(self, drawer, landmark, figure, **args): line = self._lineFunction(landmark, figure) for x in self.names(): drawer.drawLine(x, line) if line == None: raise InsaneExample("Couldn't get line: %s %s" % (landmark, figure)) else: steps = 100 figure = math2d.trimLine(figure, line[0], line[-1]) if len(figure) <= 1: print "degenerate figure", figure, landmark raise InsaneExample("Figure was too short: %s" % figure) d_f = math2d.length(figure) / float(steps) fpoints = [x for x in math2d.stepAlongLine(figure, d_f)] distances = [ math2d.dist(f1, math2d.closestPointOnLine(line, f1)) for f1 in fpoints ] start, stop = math2d.smallestWindow(distances, int(len(distances) * 0.75)) distances = [] maxDist = 0.0 maxp1 = None maxp2 = None bborigin, (width, height) = math2d.boundingBox(figure) scaleFactor = pow(pow(width, 2) + pow(height, 2), 0.5) for f1 in fpoints[start:stop]: g1 = math2d.closestPointOnLine(line, f1) drawer.drawSegment("averageDistToAxes", f1, g1) drawer.drawSegment("stdDevToAxes", f1, g1) d = math2d.dist(f1, g1) distances.append(d / scaleFactor) if d > maxDist: maxDist = d maxp1 = f1 maxp2 = g1 if len(distances) == 0: map = {} centroid = math2d.centroid(landmark) for x in self.names(): drawer.drawText(x, centroid, "Couldn't find axes.") map[x] = -1 return map mean = math2d.mean(distances) stdDev = math2d.stdDeviation(distances) whitenedMean = math2d.mean([x - mean for x in distances]) drawer.drawSegment("peakDistToAxes", maxp1, maxp2) f1 = math2d.closestPointOnLine(figure, line[0]) f2 = math2d.closestPointOnLine(figure, line[-1]) distF1F2 = math2d.distBetweenPointsAlongLine(figure, f1, f2) if distF1F2 != 0: x = math.fabs(distF1F2 / math2d.length(line)) relativeLength = min(x, 1.0 / x) #relativeLength = 1.0/x #x = math2d.length(line) / math2d.length(figure) #relativeLength = min(x, 1.0/x) else: relativeLength = -1 drawer.drawPoint("relativeLength", f1) drawer.drawPoint("relativeLength", f2) drawer.drawLine("relativeLength", line) return { "averageDistToAxes": mean, "whitenedAverageDist": whitenedMean, "peakDistToAxes": maxDist / scaleFactor, "stdDevToAxes": stdDev, "relativeLength": relativeLength }
def doCompute(self, drawer, landmark, figure, **args): major, minor = computeAxes(landmark, figure) if (major, minor) == (None, None): centroid = math2d.centroid(landmark) for x in self.names(): drawer.drawText(x, centroid, "Couldn't find axes.") return None else: map = {} origin = math2d.intersectSegment(major, minor) centroid = math2d.centroid(landmark) bborigin, (width, height) = math2d.boundingBox(landmark + figure) scale = pow(pow(width, 2) + pow(height, 2), 0.5) drawer.distanceFeature(map, "centroidToAxesOrigin", "Centroid", "Axes Origin", centroid, origin, scale) drawer.drawAxes("centroidToAxesOrigin", (major, minor)) sampledFig = [ x for x in math2d.stepAlongLine(figure, math2d.length(figure) / 100) ] figureCentroid = math2d.centerOfMass(sampledFig) drawer.distanceFeature(map, "figureCenterOfMassToAxesOrigin", "Figure Center of Mass", "Axes Origin", figureCentroid, origin, scale) drawer.drawAxes("figureCenterOfMassToAxesOrigin", (major, minor)) drawer.distanceFeature(map, "figureCenterOfMassToLandmarkCentroid", "Figure Center of Mass", "Centroid", figureCentroid, centroid, scale) drawer.distanceFeature( map, "axesStartToLandmark", "Landmark", "Start of minor axis", math2d.closestPointOnPolygon(landmark, minor[0]), minor[0], scale) drawer.drawAxes("axesStartToLandmark", (major, minor)) drawer.distanceFeature( map, "axesEndToLandmark", "Landmark", "End of minor axis", math2d.closestPointOnPolygon(landmark, minor[-1]), minor[-1], scale) drawer.drawAxes("axesEndToLandmark", (major, minor)) map['axesToLandmarkSum'] = map['axesEndToLandmark'] + map[ 'axesStartToLandmark'] drawer.drawAxes("axesToLandmarkSum", (major, minor)) map['figureLengthByCrow'] = math2d.ratioLengthByCrow(figure) drawer.drawDistance("figureLengthByCrow", figure[0], figure[-1], "Start", "End") m1 = minor[0] f1 = figure[0] m2 = minor[-1] f2 = figure[-1] d1 = math2d.dist(m1, f1) + math2d.dist(m2, f2) d2 = math2d.dist(m1, f2) + math2d.dist(m2, f1) if (math.fabs(d1 - d2) > math2d.threshold and d1 > d2): f1 = figure[-1] f2 = figure[0] drawer.distanceFeature(map, "axesStartToFigureStart", "Axes Start", "Figure start", m1, f1, scale) drawer.distanceFeature(map, "axesEndToFigureEnd", "Axes End", "Figure End", m2, f2, scale) map['axesToFigureSum'] = map['axesEndToFigureEnd'] + map[ 'axesStartToFigureStart'] drawer.drawDistance('axesToFigureSum', m2, f2, 'Axes End', 'Figure End') # from Rao at Winston's group meeting 12-9-2008 map['distAlongLandmarkBtwnAxes'] = \ math2d.distBetweenPointsAlongPolygon(landmark, minor[0], minor[-1]) / math2d.perimeter(landmark) drawer.drawAxes("distAlongLandmarkBtwnAxes", (major, minor)) drawer.drawPoint("distAlongLandmarkBtwnAxes", figure[0], "", Qt.green, 30) drawer.drawPoint("distAlongLandmarkBtwnAxes", figure[-1], "", Qt.red, 30) map['ratioFigureToAxes'] = \ math2d.dist(figure[0], figure[-1]) / math2d.length(minor) drawer.drawAxes("ratioFigureToAxes", (major, minor)) drawer.drawDistance("ratioFigureToAxes", figure[0], figure[-1], "Figure Start", "Figure End") drawer.drawDistance("ratioFigureToAxes", minor[0], minor[-1], "Minor Start", "Minor End") map['ratioLengthFigureToAxes'] = \ math2d.length(figure) / math2d.length(minor) drawer.drawAxes("ratioLengthFigureToAxes", (major, minor)) return map
def makeTable(data, engine, tagLayer, useFarAway=False): table = orange.ExampleTable(engine.domain()) if engine.name() in skipMap: skipList = skipMap[engine.name()] else: skipList = [] labeledCount = 0 negativeCount = 0 farAwayCount = 0 for engineName, landmarkName, geometry in data: #geometry["landmark"] = createLandmarkPt(math2d.centroid(geometry["landmark"])) if not (engineName in skipList): # or True: try: geometry["landmark"] = geometry["ground"] ex = engine.makeExample(**geometry) except preposition.InsaneExample: continue except: print "dc", engineName print "dc", geometry print "dc", landmarkName raise if engineName == engine.name(): if engineName == "down" and False: print "doing down differently" if landmarkName == "hallway": cls = "True" labeledCount += 1 else: continue #cls = "False" #negativeCount -= 1 else: cls = "True" labeledCount += 1 else: cls = "False" negativeCount += 1 ex['class'] = cls ex['sourceEngineName'] = engineName ex['engineName'] = engine.name() ex['landmarkName'] = landmarkName ex['farAway'] = False table.append(ex) if useFarAway and engine.name() != "through" and engine.name() != "down": for name, landmark in tagLayer: centroid1 = math2d.centroid(landmark) for engineName, landmarkName, geometry in data: if engineName == engine.name(): centroid2 = math2d.centroid(geometry["landmark"]) d1 = math2d.dist(centroid1, centroid2) d2 = math2d.length(geometry["figure"]) if d1 > d2: ex = engine.makeExample(figure=geometry["figure"], landmark=landmark) ex['class'] = "False" ex['landmarkName'] = landmarkName ex['sourceEngineName'] = engineName ex['engineName'] = engine.name() ex['farAway'] = True table.append(ex) farAwayCount += 1 if farAwayCount >= 100: break for ex in table: ex['drawMap'] = None #ex['geometry'] = None print "counts" print labeledCount, "labeled examples." print negativeCount, "negative examples." print farAwayCount, "far away examples." return table
def get_vertical_transition_matrix(self, direction="stay", p_self=1.0): assert direction in ["stay", "up", "down"] T_mat = zeros([ self.num_regions * self.num_viewpoints, self.num_regions * self.num_viewpoints ]) * 1.0 new_tmap = self.get_topological_map_viewpoint(None, 0) print "verticaldirection", direction print "vpt", 18, [ self.vpt_to_num[x] for x in new_tmap[self.viewpoints[18]] ] #for each of the viewpoints for i in range(len(self.viewpoints)): connections = new_tmap[self.viewpoints[i]] #find the areas connected and if they are reasonable for conn in connections: cconn = conn #connofconn = [conn] #connofconn.extend(new_tmap[conn]) #for conn_i, cconn in enumerate(connofconn): #convert this into topo numbers topo_st, topo_st_ang = self.viewpoints[i].split("_") topo_end, topo_end_ang = cconn.split("_") if (cconn < 0 or self.viewpoints[i] == -1): continue x1, y1, z1 = self.tmap_locs_3d[float(topo_st)] x2, y2, z2 = self.tmap_locs_3d[float(topo_end)] #for each of the to-node's orientations, check its relative angle to # the from node's orientation and give it a relative probability # accordingly start_num = self.vpt_to_num[self.viewpoints[i]] end_num = self.vpt_to_num[cconn] #going to end_num from i if direction == 'stay': if z1 == z2: val = 1.0 else: val = 1e-6 elif direction == 'up': if z1 < z2: val = 1.0 elif z1 == z2: val = 0.2 else: val = 1e-6 if math2d.dist((x1, y1), (x2, y2)) > 0.5: val = 0.9 * val elif direction == 'down': if z2 < z1: val = 1.0 elif z1 == z2: val = 0.2 else: val = 1e-6 if math2d.dist((x1, y1), (x2, y2)) > 0.5: val = 0.9 * val else: raise ValueError("Bad direction: " + ` direction `) T_mat[end_num, start_num] = val #connect self transitions topo_st, topo_st_ang = self.viewpoints[i].split("_") if (direction == "stay"): T_mat[i, i] = p_self return T_mat
def distanceFeature(self, valueMap, key, p1Desc, p2Desc, start, end, scale): valueMap[key] = math2d.dist(start, end) / float(scale) self.drawDistance(key, start, end, p1Desc, p2Desc)
def nearestNeighbor(self, x_rand, tree): nodes = [n for n in tree.nodes()] distances = [math2d.dist(n, x_rand) for n in nodes] minI, min = math2d.argMin(distances) return nodes[minI]
def get_topological_map_viewpoint(self, fov, turn_amount): tmap_new = {} #iterate through all the viewpoints for i in range(len(self.viewpoints)): #get the start location tf, tfor = self.viewpoints[i].split("_") tf = float(tf) loc_st = self.tmap_locs[tf] st_orient = float(tfor) * pi / 180.0 tmap_new[self.viewpoints[i]] = [] #iterate through all the viewpoints for j in range(len(self.viewpoints)): #get the end location tt, ttor = self.viewpoints[j].split("_") tt = float(tt) loc_end = self.tmap_locs[tt] end_orient = float(ttor) * pi / 180.0 #absolute difference in orientation abs_orient = atan2(loc_end[1] - loc_st[1], loc_end[0] - loc_st[0]) #if we're connected and we're in the fov if i == 40 and j == 42 and True: print i, j print "vp1", self.viewpoints[i] print "vp2", self.viewpoints[j] print "l1", loc_st, "=>", loc_end print print "tt", tt in self.tmap[tf] if fov != None: print "fov/2.0", math.degrees(fov / 2.0) print "c1", (0 >= tklib_normalize_theta( st_orient - fov / 2.0 - abs_orient + turn_amount)) print "c2", (0 <= tklib_normalize_theta( st_orient + fov / 2.0 - abs_orient + turn_amount)) print "c1 angle", math.degrees(st_orient - fov / 2.0 - abs_orient + turn_amount) print "c2 angle", math.degrees(st_orient + fov / 2.0 - abs_orient + turn_amount) print "normalized" print "c1 angle", tklib_normalize_theta( math.degrees(st_orient - fov / 2.0 - abs_orient + turn_amount)) print "c2 angle", tklib_normalize_theta( math.degrees(st_orient + fov / 2.0 - abs_orient + turn_amount)) else: print "fov is None" print print "st_orient", math.degrees(st_orient) print "abs_orient", abs_orient print "turn_amount", turn_amount print if tt in self.tmap[tf]: append = False if fov == None: append = True elif (0 >= tklib_normalize_theta(st_orient - fov / 2.0 - abs_orient + turn_amount) and 0 <= tklib_normalize_theta(st_orient + fov / 2.0 - abs_orient + turn_amount)): append = True elif math2d.dist(loc_st, loc_end) < 0.00001: append = True if append: tmap_new[self.viewpoints[i]].append(self.viewpoints[j]) return tmap_new