def get_busses_in_circle(self, key, lat, lng, dist): cherrypy.response.headers["Access-Control-Allow-Origin"] = "*" circle = Point(float(lat), float(lng)).buffer(float(dist)) ourRoutes = [] city_data = [] with open(os.path.join(PATH, 'stops.pickle'), 'rb') as f: stops = pickle.load(f) for stopid, stop in stops.items(): point = Point(float(stop.lat), float(stop.lng)) if circle.contains(point): ourRoutes.extend(stop.routes) ten = [] while (len(ourRoutes) > 10): ten.append(ourRoutes.pop()) print ten if (len(ten) == 10): url = "http://www.ctabustracker.com/bustime/api/v1/getvehicles?key=" + keys[ 0] + "&rt=" + ",".join( ten) + "&format=json&diagnostics=true&callback=" r = requests.get(url) i = 0 while (r.text.find("exceeded") != -1): url = "http://www.ctabustracker.com/bustime/api/v1/getvehicles?key=" + keys[ i] + "&rt=" + ",".join( ten) + "&format=json&diagnostics=true&callback=" r = requests.get(url) i = i + 1 ten = [] j = r.json() for bus in j['bustime-response'][0]['vehicle']: city_data.append(bus) url = "http://www.ctabustracker.com/bustime/api/v1/getvehicles?key=" + keys[ 0] + "&rt=" + ",".join( ourRoutes) + "&format=json&diagnostics=true&callback=" r = requests.get(url) i = 0 while (r.text.find("exceeded") != -1): url = "http://www.ctabustracker.com/bustime/api/v1/getvehicles?key=" + keys[ i] + "&rt=" + ",".join( ourRoutes) + "&format=json&diagnostics=true&callback=" r = requests.get(url) i = i + 1 j = r.json() for bus in j['bustime-response'][0]['vehicle']: city_data.append(bus) ret_busses = [] for bus in city_data: point = Point(float(bus['lat']), float(bus['lon'])) if circle.contains(point): ret_busses.append(bus) return json.dumps(ret_busses)
def update_after_explosion(self, explosion_point, explosion_radius): left_ground = [] explosion_circle = Point(explosion_point).buffer( explosion_radius).boundary max_left = max(0, explosion_point[0] - explosion_radius) max_right = min(display_width, explosion_point[0] + explosion_radius) for i in range(max_left, max_right): ground_line = LineString([[i, display_height], self.points[i]]) intersection = explosion_circle.intersection(ground_line) if explosion_point[1] + explosion_radius > display_height: left_start = explosion_point[1] - explosion_radius if self.points[i][1] < left_start: left_ground.append([[i, left_start], [i, self.points[i][1]]]) self.points[i][1] = display_height else: self.points[i][1] = display_height elif isinstance(intersection, MultiPoint): first_point = intersection.geoms[0] second_point = intersection.geoms[1] fst_coordinate = i, min(int(first_point.coords[0][1]), int(second_point.coords[0][1])) snd_coordinate = i, max(int(first_point.coords[0][1]), int(second_point.coords[0][1])) left_length = fst_coordinate[1] - self.points[i][1] if left_length > 0: left_ground.append([[i, fst_coordinate[1]], [i, self.points[i][1]]]) self.points[i][1] = snd_coordinate[1] elif isinstance(intersection, Point): if not explosion_circle.contains(intersection): self.points[i][1] = int(intersection.coords[0][1]) return left_ground
def get_busses_in_circle(self,key,lat,lng,dist): cherrypy.response.headers["Access-Control-Allow-Origin"] = "*" circle = Point(float(lat),float(lng)).buffer(float(dist)) ourRoutes = [] city_data = [] with open(os.path.join(PATH, 'stops.pickle'), 'rb') as f: stops = pickle.load(f) for stopid, stop in stops.items(): point = Point(float(stop.lat), float(stop.lng)) if circle.contains(point): ourRoutes.extend(stop.routes) ten = [] while (len(ourRoutes) > 10): ten.append(ourRoutes.pop()) print ten if (len(ten) == 10): url = "http://www.ctabustracker.com/bustime/api/v1/getvehicles?key="+keys[0]+"&rt="+",".join(ten)+"&format=json&diagnostics=true&callback=" r = requests.get(url) i=0 while (r.text.find("exceeded") != -1): url = "http://www.ctabustracker.com/bustime/api/v1/getvehicles?key="+keys[i]+"&rt="+",".join(ten)+"&format=json&diagnostics=true&callback=" r = requests.get(url) i=i+1 ten = [] j = r.json() for bus in j['bustime-response'][0]['vehicle']: city_data.append(bus) url = "http://www.ctabustracker.com/bustime/api/v1/getvehicles?key="+keys[0]+"&rt="+",".join(ourRoutes)+"&format=json&diagnostics=true&callback=" r = requests.get(url) i=0 while (r.text.find("exceeded") != -1): url = "http://www.ctabustracker.com/bustime/api/v1/getvehicles?key="+keys[i]+"&rt="+",".join(ourRoutes)+"&format=json&diagnostics=true&callback=" r = requests.get(url) i=i+1 j = r.json() for bus in j['bustime-response'][0]['vehicle']: city_data.append(bus) ret_busses = [] for bus in city_data: point = Point(float(bus['lat']), float(bus['lon'])) if circle.contains(point): ret_busses.append(bus) return json.dumps(ret_busses)
def get_nearby_stations(self, lat, lng, dist): cherrypy.response.headers["Access-Control-Allow-Origin"] = "*" r = requests.get('http://www.divvybikes.com/stations/json/') jsonData = r.json() stations = jsonData['stationBeanList'] ret_stations = [] circle = Point(float(lat), float(lng)).buffer(float(dist)) for station in stations: point = Point(station['latitude'], station['longitude']) if circle.contains(point): ret_stations.append(station) return json.dumps(ret_stations)
def get_nearby_stations(self, lat, lng, dist): cherrypy.response.headers["Access-Control-Allow-Origin"] = "*" r = requests.get('http://www.divvybikes.com/stations/json/') jsonData = r.json() stations = jsonData['stationBeanList'] ret_stations = [] circle = Point(float(lat),float(lng)).buffer(float(dist)) for station in stations: point = Point(station['latitude'], station['longitude']) if circle.contains(point): ret_stations.append(station) return json.dumps(ret_stations)
def test_binary_predicates(self): point = Point(0.0, 0.0) self.assertTrue(point.disjoint(Point(-1.0, -1.0))) self.assertFalse(point.touches(Point(-1.0, -1.0))) self.assertFalse(point.crosses(Point(-1.0, -1.0))) self.assertFalse(point.within(Point(-1.0, -1.0))) self.assertFalse(point.contains(Point(-1.0, -1.0))) self.assertFalse(point.equals(Point(-1.0, -1.0))) self.assertFalse(point.touches(Point(-1.0, -1.0))) self.assertTrue(point.equals(Point(0.0, 0.0)))
def get_candidate_centerlines(avm, traj, city_name): """ Returns nearby closest centerlines to given trajectory """ #region ROI roi_center = traj[-1] roi_radius = 20 roi = Point(roi_center).buffer(roi_radius) #endregion line_ids = avm.get_lane_ids_in_xy_bbox( roi_center[0], roi_center[1], city_name, query_search_range_manhattan=roi_radius) traj_direction = vector_direction(displacement_vector(traj)) line_ids = [ id for id in line_ids if any([ roi.contains(Point(p)) for p in avm.get_lane_segment_centerline(id, city_name) ]) ] lines = [[(id, avm.get_lane_segment_centerline(id, city_name)[:, :2]) for id in ids] for ids in combine_lines( line_ids, avm.city_lane_centerlines_dict[city_name])] lines = [process_line(avm, traj[-1], line, city_name) for line in lines] # Distance cutting distance_threshold = 15 lines = [ line for line in lines if len(line) > 1 and LineString(line).distance(Point(traj[-1])) < distance_threshold ] limit = 6 lines = sorted(lines, key=lambda line: (LineString(line).distance(Point(traj[-1])), direction_difference( traj_direction, vector_direction(displacement_vector(line)))))[:limit] return lines, roi.exterior.coords
def rrt_goalBias(self): G = nx.Graph() G.add_node(0, pos=self.start) self.s_id = 0 free_nodes = [] time_nodes = [[self.start, 0]] count = 0 free_nodes.append(self.start) i = 1 while count < self.max_iter: point = self.sample_point(count) edge, point, time_node = self.add_edge(free_nodes, point, time_nodes) is_connectable = False if self.speed: is_connectable = self.is_timed_free(edge, time_node) else: is_connectable = self.is_connectable(edge) if is_connectable: id_t = self.get_node_id(G, edge[1]) circle = Point(self.goal[0], self.goal[1]).buffer(self.eps) p = Point(point[0], point[1]) if circle.contains(p): self.g_id = i G.add_node(i, pos=self.goal) p1 = Point(self.goal[0], self.goal[1]) p2 = Point(edge[1][0], edge[1][1]) G.add_edge( i, id_t, ) return G, free_nodes, time_nodes p1 = Point(edge[0][0], edge[0][1]) p2 = Point(edge[1][0], edge[1][1]) G.add_node(i, pos=edge[0]) G.add_node(id_t, pos=edge[1]) G.add_edge(i, id_t, weight=p1.distance(p2)) if self.plot_tree: plt.scatter(point[0], point[1], s=5, c="y") x, y = list(zip(*edge)) plt.plot(x, y, c="y") plt.pause(0.001) free_nodes.append(point) i += 1 time_nodes.append(time_node) count += 1 return G, free_nodes, time_nodes
def _sensor_nodes(mitte, fog_nodes, sigma=0.03) -> List[Dict]: for i in count(): position = (random.gauss(13.39, sigma), random.gauss(52.522297, sigma)) if not mitte.contains(Point(position)): continue radius = Point(position).buffer(0.015) edges = [] node = Sensor(name=str(i)) for fog in fog_nodes: point = Point(*fog["pos"]) if radius.contains(point): edges.append({ "source": node, "target": fog["id"], "link": Link4G() }) if len(edges) > 0: yield {"id": node, "pos": position}, edges
class Unit: def __init__(self, Power, UnitsForIncrement, AddedPower, MaxUnits): self.CoherencyRange = None self.Units = [] self.Abilities = [] self.Keywords = [] self.FactionKeywords = [] self.Points = 0 self.SquadPosition = -1 self.TeamPosition = -1 self.Power = Power self.PowerStage = -1 self.UnitsForIncrement = UnitsForIncrement self.PowerAdded = AddedPower self.MaxUnits = MaxUnits def calculate_points(self): self.Points = 0 for unit in self.Units: self.Points += unit.Points def add_soldier(self, unit): if len(self.Units) < self.MaxUnits: self.Units.append(unit) if self.UnitsForIncrement is not None: for i in range(len(self.UnitsForIncrement)): if len( self.Units ) >= self.UnitsForIncrement[i] and i > self.PowerStage: self.Power += self.PowerAdded[i] self.PowerStage = i break self.calculate_points() else: print(Messages.MaxSoldiers) def info(self): print('Name: ', self.__class__.__name__) print('Points: ', self.Points) print('Power: ', self.Power) print('Models: ') [ print('\t' + str(i) + ': ' + model.__class__.__name__) for i, model in enumerate(self.Units) ] print('Abilities: ') [ print('\t' + str(i) + ': ' + ability) for i, ability in enumerate(self.Abilities) ] print('FactionKeywords: ') [ print('\t' + str(i) + ': ' + factionKeyword) for i, factionKeyword in enumerate(self.FactionKeywords) ] print('Keywords: ') [ print('\t' + str(i) + ': ' + keyword) for i, keyword in enumerate(self.Keywords) ] print('Available Methods: ') [ print('\t' + func + '()') for func in dir(self) if callable(getattr(self, func)) and '__' not in func ] def init_positions_randomly(self, x, y): self.Units[0].set_position(x=0 + x, y=0 + y) self.CoherencyRange = Point( self.Units[0].Position.x, self.Units[0].Position.y).buffer(self.Units[0].BodyInfo['radius'] + 2) for index, unit in enumerate(self.Units): if index > 0: minX, minY, maxX, maxY = self.CoherencyRange.bounds ok = False overlap = True pnt = None while not ok or overlap: pnt = Point(numpy.random.uniform(minX, maxX), numpy.random.uniform(minY, maxY)) if self.CoherencyRange.contains(pnt): ok = True overlap = False for point in self.Units: if not point.Body.intersection( Point(pnt.x, pnt.y).buffer( self.Units[index].BodyInfo['radius']) ).is_empty: overlap = True self.Units[index].set_position(x=pnt.x, y=pnt.y) auxCohesion = Point(self.Units[index].Position.x, self.Units[index].Position.y).buffer( self.Units[index].BodyInfo['radius'] + 2) self.CoherencyRange = self.CoherencyRange.union(auxCohesion) def update_coherency_range(self, index): if index == 0: self.CoherencyRange = Point( self.Units[0].Position.x, self.Units[0].Position.y).buffer( self.Units[0].BodyInfo['radius'] + 2) else: auxCoherency = Point(self.Units[index].Position.x, self.Units[index].Position.y).buffer( self.Units[index].BodyInfo['radius'] + 2) self.CoherencyRange = self.CoherencyRange.union(auxCoherency) def move_models(self, board, target): self.Units[0].move(model=self.Units[0], objectsBoard=board.Objects, target=target, isSergeant=True) # For testing overlap = [] for unit in self.Units: overlap.append(unit.Body) self.update_coherency_range(0) if len(self.Units) > 1: for i, model in enumerate(self.Units[1:]): overlap.pop(i + 1) model.move(model=model, coherencyRegion=self.CoherencyRange, objectsBoard=board.Objects, overlapRange=overlap, target=target) self.update_coherency_range(i + 1) overlap = [] for unit in self.Units: overlap.append(unit.Body)
(24.953510, 60.170104), (24.950958, 60.169990)] poly = Polygon(coords) # In[2]: print(p1) # In[3]: print(p2) # In[4]: print(poly) # In[5]: p1.within(poly) # In[6]: p2.within(poly) # In[7]: p1.contains(poly) # In[8]: p2.contains(poly)
sCircle = Point(circleX, circleY) sCircle = sCircle.buffer(circleRadius, 16) pointList = [] for i in range(numberOfPoints): x = random.randint(0, gridWidth) y = random.randint(0, gridHeight) pointList.append((x, y)) iPoint = Point(x, y) iPoint.idx = i # set our custom attribute. (if this doesnt work I have other ways) shapePoints.append(iPoint) matchingPoints = [] searchBench = time.time() for idx, point in enumerate(shapePoints): if sCircle.contains(point): matchingPoints.append(idx) searchBench = time.time() - searchBench print "There were %d points within the circle [%d, %d] - r[%d]\n" % (len(matchingPoints), circleX, circleY, circleRadius) print "Calculation Took %s seconds for %s points" % (searchBench, numberOfPoints) print "Saving Graph to %s" % (filename) #_------------------------------------------------------------------------------- # DRAW A REPRESENTATION OF THE LOGIC ABOVE: import matplotlib matplotlib.use('Agg') # Do NOT attempt to open X11 instance from pylab import * from matplotlib.patches import Circle
def get_goals(self, observation: ip.Observation, threshold: float = 2.0) -> List[ip.Goal]: """Retrieve all possible goals reachable from the current position on the map in any direction. If more than one goal is found on a single lane, then only choose the one furthest along the midline of the lane. Args: observation: Observation of the environment threshold: The goal checking threshold """ # TODO Replace with box goals that cover all lanes in same direction scenario_map = observation.scenario_map state = observation.frame[self.agent_id] view_circle = Point(*state.position).buffer(self.view_radius) # Retrieve relevant roads and check intersection of its lanes' midlines possible_goals = [] for road in scenario_map.roads.values(): if not road.boundary.intersects(view_circle): continue for lane_section in road.lanes.lane_sections: for lane in lane_section.all_lanes: if lane.id == 0 or lane.type != "driving": continue new_point = None # First check if the lane intersects the view boundary anywhere intersection = lane.midline.intersection(view_circle.boundary) if not intersection.is_empty: if isinstance(intersection, Iterable): max_distance = np.inf for point in intersection: if lane.distance_at(point) < max_distance: new_point = point else: new_point = intersection # If not, and the lane is completely within the circle then choose the lane end-point elif view_circle.contains(lane.boundary): # if lane.link.predecessor is None: # new_point = lane.midline.coords[-1] if lane.link.successor is None: new_point = lane.midline.coords[-1] else: continue else: continue # Do not add point if within threshold distance to an existing goal if not any([np.allclose(new_point, g.center, atol=threshold) for _, g in possible_goals]): new_goal = ip.PointGoal(np.array(new_point), threshold=threshold) possible_goals.append((lane, new_goal)) # Group goals that are in neighbouring lanes goals = [] used = [] for lane, goal in possible_goals: if goal in used: continue neighbouring_goals = [goal] for other_lane, other_goal in possible_goals: if goal == other_goal: continue if lane.parent_road == other_lane.parent_road and np.abs(lane.id - other_lane.id) == 1: neighbouring_goals.append(other_goal) used.append(other_goal) if len(neighbouring_goals) > 1: goals.append(ip.PointCollectionGoal(neighbouring_goals)) else: goals.append(goal) return goals
class Landmark: ''' Contains information about user-defined landmarks.''' log = getLogger('landmarks') def __init__(self, name, shortname=None, points=None, query=None, hashtags=None, phrase=None, is_area=False, query_suffix=None): self.name = name self.shortname = shortname self.is_area = is_area if not points and not query: query = name.lstrip('the ') if ((query_suffix and query) and query_suffix.lower() not in query.lower()): query = '{} {}'.format(query, query_suffix) self.location = None if query: self.query_location(query) elif points: try: length = len(points) if length > 2: self.location = Polygon(points) elif length == 2: self.location = box(points[0][0], points[0][1], points[1][0], points[1][1]) elif length == 1: self.location = Point(*points[0]) except TypeError: raise ValueError('points must be a list/tuple of lists/tuples' ' containing 2 coordinates each') if not self.location: raise ValueError('No location provided for {}. Must provide' ' either points, or query.'.format(self.name)) elif not isinstance(self.location, (Point, Polygon, LineString)): raise NotImplementedError('{} is a {} which is not supported' .format(self.name, self.location.type)) self.south, self.west, self.north, self.east = self.location.bounds # very imprecise conversion to square meters self.size = self.location.area * 12100000000 if phrase: self.phrase = phrase elif is_area: self.phrase = 'in' else: self.phrase = 'at' self.hashtags = hashtags def __contains__(self, coordinates): """determine if a point is within this object range""" lat, lon = coordinates if (self.south <= lat <= self.north and self.west <= lon <= self.east): return self.location.contains(Point(lat, lon)) return False def query_location(self, query): def swap_coords(geojson): out = [] for x in geojson: if isinstance(x, list): out.append(swap_coords(x)) else: return geojson[1], geojson[0] return out nom = Nominatim() try: geo = nom.geocode(query=query, geometry='geojson', timeout=3).raw geojson = geo['geojson'] except (AttributeError, KeyError): raise FailedQuery('Query for {} did not return results.'.format(query)) self.log.info('Nominatim returned {} for {}'.format(geo['display_name'], query)) geojson['coordinates'] = swap_coords(geojson['coordinates']) self.location = shape(geojson) def get_coordinates(self): if isinstance(self.location, Polygon): return tuple(self.location.exterior.coordinates) else: return self.location.coords[0] def generate_string(self, coordinates): if coordinates in self: return '{} {}'.format(self.phrase, self.name) distance = self.distance_from_point(coordinates) if distance < 50 or (self.is_area and distance < 100): return '{} {}'.format(self.phrase, self.name) else: return '{:.0f} meters from {}'.format(distance, self.name) def distance_from_point(self, coordinates): point = Point(*coordinates) if isinstance(self.location, Point): nearest = self.location else: nearest = self.nearest_point(point) return get_distance(coordinates, nearest.coords[0]) def nearest_point(self, point): '''Find nearest point in geometry, measured from given point.''' if isinstance(self.location, Polygon): segs = self.pairs(self.location.exterior.coords) elif isinstance(self.location, LineString): segs = self.pairs(self.location.coords) else: raise NotImplementedError('project_point_to_object not implemented' "for geometry type '{}'.".format( self.location.type)) nearest_point = None min_dist = float("inf") for seg_start, seg_end in segs: line_start = Point(seg_start) line_end = Point(seg_end) intersection_point = self.project_point_to_line( point, line_start, line_end) cur_dist = point.distance(intersection_point) if cur_dist < min_dist: min_dist = cur_dist nearest_point = intersection_point return nearest_point @staticmethod def pairs(lst): """Iterate over a list in overlapping pairs.""" i = iter(lst) prev = next(i) for item in i: yield prev, item prev = item @staticmethod def project_point_to_line(point, line_start, line_end): '''Find nearest point on a straight line, measured from given point.''' line_magnitude = line_start.distance(line_end) u = (((point.x - line_start.x) * (line_end.x - line_start.x) + (point.y - line_start.y) * (line_end.y - line_start.y)) / (line_magnitude ** 2)) # closest point does not fall within the line segment, # take the shorter distance to an endpoint if u < 0.00001 or u > 1: ix = point.distance(line_start) iy = point.distance(line_end) if ix > iy: return line_end else: return line_start else: ix = line_start.x + u * (line_end.x - line_start.x) iy = line_start.y + u * (line_end.y - line_start.y) return Point([ix, iy])
def is_done(self, point): circle = Point(self.goal[0], self.goal[1]).buffer(self.eps) p = Point(point[0], point[1]) if circle.contains(p): return True return False
# check points in each circle for id_circle, coordinate in enumerate(listCircle): # narrow the field of grids to almost one circle mask = (lon2d > coordinate[0]-0.1) & (lon2d < coordinate[0]+0.1) &\ (lat2d > coordinate[1]-0.1) & (lat2d < coordinate[1]+0.1) # draw circle (r=0.1 deg ~ 12 km) circle = Point(coordinate).buffer(0.1) # get center point of grids in rectangle (0.1 * 0.1) listPoint = np.stack((lon2d[mask], lat2d[mask]), axis=-1) # get index of chosen grid's center points in each circle index = [] for id, position in enumerate(listPoint): point = Point(position) if circle.contains(point): index.append(id) # average of profiles in each circle d = plevel.shape[0] for l in np.arange(d): species_mean[l, id_circle] = np.nanmean(species_nearest[l][mask][index]) # filter nan of WRF-Chem nonan_wrf_index = np.argwhere( ~(np.isnan(species_mean[:, id_circle]))).ravel() start = nonan_wrf_index[0] end = nonan_wrf_index[-1] # Calculate averaging kernel (A = I - Cx*Ca^-1) Ca = np.zeros((d, d))
# Add the points to a python list of lists pointList.append((x, y)) # Create a Shapely point object iPoint = Point(x, y) iPoint.idx = i # set our custom attribute. (if this doesnt work I have other ways) shapePoints.append(iPoint) # Add the point to an RTREE index # index.add(id=id, (left, bottom, right, top)) # Note that this would work if the RtreeIndex.add(i, (x, y, x, y)) matchingPoints = [] searchBench = time.time() for idx, point in enumerate(shapePoints): if sCircle.contains(point): matchingPoints.append(idx) searchBench = time.time() - searchBench #------------------------------------------------------------------------------- # NOW TEST RTREE RtreeBench = time.time() RtreeIndex rtreeMatches = list( RtreeIndex.intersection((boxLeft, boxBottom, boxRight, boxTop))) RtreeBench = time.time() - RtreeBench print("\n\n") print(
class Landmark: ''' Contains information about user-defined landmarks.''' def __init__(self, name, shortname=None, points=None, query=None, hashtags=None, phrase=None, is_area=False, query_suffix=None): self.name = name self.shortname = shortname self.is_area = is_area if not points and not query: query = name.lstrip('the ') if ((query_suffix and query) and query_suffix.lower() not in query.lower()): query = '{q} {qs}'.format(q=query, qs=query_suffix) self.location = None if query: self.query_location(query) elif points: try: if len(points) > 2: self.location = Polygon(points) elif len(points) == 2: self.location = box(points[0][0], points[0][1], points[1][0], points[1][1]) elif len(points) == 1: self.location = Point(*points[0]) except (TypeError, IndexError): raise ValueError('points must be a list/tuple of lists/tuples' ' containing 2 coordinates each') if not self.location: raise ValueError('No location provided for {}. Must provide' ' either points, or query.'.format(self.name)) elif not isinstance(self.location, (Point, Polygon, LineString)): raise NotImplementedError('{n} is a {t} which is not ' 'supported.'.format( n=self.name, t=self.location.type)) # very imprecise conversion to square meters self.size = self.location.area * 12100000000 if phrase: self.phrase = phrase elif is_area: self.phrase = 'in' else: self.phrase = 'at' self.hashtags = hashtags def query_location(self, query): def swap_coords(coordinates): out = [] for iterable in coordinates: if isinstance(iterable, list): out.append(swap_coords(iterable)) else: return (coordinates[1], coordinates[0]) return out nom = Nominatim() try: geo = nom.geocode(query=query, geometry='geojson').raw geojson = geo['geojson'] except (AttributeError, KeyError): raise FailedQuery( 'Query for {} did not return results.'.format(query)) print(geo['display_name']) geojson['coordinates'] = swap_coords(geojson['coordinates']) self.location = shape(geojson) def get_coordinates(self): if isinstance(self.location, Polygon): return tuple(self.location.exterior.coordinates) elif isinstance(self.location, Point): return self.location.coords[0] else: return self.location def generate_string(self, coordinates): if self.contains(coordinates): return '{p} {n}'.format(p=self.phrase, n=self.name) distance = self.distance_from_point(coordinates) if (self.is_area and distance < 100) or distance < 40: return '{} {}'.format(self.phrase, self.name) else: return '{:.0f} meters from {}'.format(distance, self.name) def contains(self, coordinates): """determine if a point is within this object range""" return self.location.contains(Point(*coordinates)) def distance_from_point(self, coordinates): if self.contains(coordinates): return 0 point = Point(*coordinates) if isinstance(self.location, Point): nearest = self.location else: nearest = self.nearest_point(point) return get_distance(point.coords[0], nearest.coords[0]) def nearest_point(self, point): '''Find nearest point in geometry, measured from given point.''' def pairs(lst): """Iterate over a list in overlapping pairs.""" i = iter(lst) prev = next(i) for item in i: yield prev, item prev = item def project_point_to_line(point, line_start, line_end): '''Find nearest point on a straight line, measured from given point.''' line_magnitude = line_start.distance(line_end) u = (((point.x - line_start.x) * (line_end.x - line_start.x) + (point.y - line_start.y) * (line_end.y - line_start.y)) / (line_magnitude**2)) # closest point does not fall within the line segment, # take the shorter distance to an endpoint if u < 0.00001 or u > 1: ix = point.distance(line_start) iy = point.distance(line_end) if ix > iy: return line_end else: return line_start else: ix = line_start.x + u * (line_end.x - line_start.x) iy = line_start.y + u * (line_end.y - line_start.y) return Point([ix, iy]) nearest_point = None min_dist = float("inf") if isinstance(self.location, Polygon): for seg_start, seg_end in pairs( tuple(self.location.exterior.coords)): line_start = Point(seg_start) line_end = Point(seg_end) intersection_point = project_point_to_line( point, line_start, line_end) cur_dist = point.distance(intersection_point) if cur_dist < min_dist: min_dist = cur_dist nearest_point = intersection_point elif isinstance(self.location, LineString): for seg_start, seg_end in pairs(list(self.location.coords)): line_start = Point(seg_start) line_end = Point(seg_end) intersection_point = project_point_to_line( point, line_start, line_end) cur_dist = point.distance(intersection_point) if cur_dist < min_dist: min_dist = cur_dist nearest_point = intersection_point else: raise NotImplementedError('project_point_to_object not implemented' "for geometry type '{}'.".format( self.location.type)) return nearest_point
tt = [] h1 = [] h2 = [] h3 = [] h4 = [] h5 = [] for i in range(0, len(tcmonth)): tc = tcmonth[i] ver = tc[0] fecha = tc[0, 0] fecha = fecha[0:4] locx = float(ver[1]) locy = float(ver[2]) pt = Point(locx, locy) if fecha >= str(yearini): if pos.contains(pt) == True: tcloc.extend(tc) tcloc.extend(nx) k.append(1) vermax = np.max(tc[:, 3].astype('float')) if vermax < 34: # para DT tcolor = [0.00000, 1.00000, 1.00000] dt.append(1) print('year: ', fecha[2::], 'cat: DT') elif vermax >= 34 and vermax <= 63: tcolor = [0.00000, 0.20000, 1.00000] tt.append(1) print('year: ', fecha[2::], 'cat: TT') elif vermax >= 64 and vermax <= 82: tcolor = [1.00000, 1.00000, 0.00000] h1.append(1)