def fill_empty_adjacent_ids(test, Selected_station_configuration): test.loc[test['up_station_id'].isnull(), 'up_station_id'] = test['down_station_id'].shift(1) test.loc[test['down_station_id'].isnull(), 'down_station_id'] = test['up_station_id'].shift(-1) # ffill and backfill station ids test['up_station_id_ffill'] = test['up_station_id'].fillna(method='ffill', axis=0) test['up_station_id_backfill'] = test['up_station_id'].fillna(method='backfill', axis=0) test.loc[test['up_station_id_ffill'].isnull(), 'up_station_id_ffill'] = test['up_station_id_backfill'] test.loc[test['up_station_id_backfill'].isnull(), 'up_station_id_backfill'] = test['up_station_id_ffill'] # check the distance between segment start with ffill id, backfill id. test = test.join(Selected_station_configuration[['station_id', 'longitude', 'latitude']].set_index('station_id'), on='up_station_id_ffill', rsuffix='_ffill') test = test.join(Selected_station_configuration[['station_id', 'longitude', 'latitude']].set_index('station_id'), on='up_station_id_backfill', rsuffix='_backfill') test['up_distance_ffill'] = distance(test, 'StartLong', 'StartLat', 'longitude', 'latitude') test['up_distance_backfill'] = distance(test, 'StartLong', 'StartLat', 'longitude_backfill', 'latitude_backfill') # fill the up_station_id and down_station_id based on the condition of up_distance_ffill and up_distance_backfill test['up_station_id'] = np.where(test['up_distance_ffill'] <= test['up_distance_backfill'], test['up_station_id_ffill'], test['up_station_id_backfill']) test.loc[test['down_station_id'].isnull(), 'down_station_id'] = test['up_station_id'].shift(-1) test.loc[test['down_station_id'].isnull(), 'down_station_id'] = test['up_station_id'] # exclude additional variables test = test.drop(['up_station_id_ffill', 'up_station_id_backfill', 'longitude', 'latitude', 'longitude_backfill', 'latitude_backfill', 'up_distance_ffill', 'up_distance_backfill'], axis=1) test = test.join(Selected_station_configuration[['station_id', 'id7']].set_index('station_id'), on='up_station_id', rsuffix='_up') test = test.join(Selected_station_configuration[['station_id', 'id7']].set_index('station_id'), on='down_station_id', rsuffix='_down') # identify the segment type, internal (0) or external (1) test['internal_external'] = np.where(test['Tmc'].str.contains('|'.join(['N', 'P'])), 0, 1) return test
def getNearest(loc, data, n): if (n == 'all'): result = [] for k, v in iter(data.items()): result.append(distance(loc, (v['location']['lat'], v['location']['lng']))) #print('Returning ' + str(result)) return result h = [] if (0): #print('dists') #startTime = time.time() dists = [] for k, v in iter(data.items()): dists.append(distance(loc, (v['location']['lat'], v['location']['lng']))) #print('elapsedTime = ' + str(time.time() - startTime)) #print('heap') #startTime = time.time() for d in dists: #heapq.heappush(h, distance(loc, (v['location']['lat'], v['location']['lng']))) heapq.heappush(h, d) #print('elapsedTime = ' + str(time.time() - startTime)) else: for k, v in iter(data.items()): heapq.heappush(h, distance(loc, (v['location']['lat'], v['location']['lng']))) return [heapq.heappop(h) for i in range(n)]
def __lies_between(A, B, C): def distance(A, B): return math.sqrt((A[0] - B[0])**2 + (A[1] - B[1])**2) a = distance(B, C) b = distance(C, A) c = distance(A, B) return a**2 + b**2 >= c**2 and a**2 + c**2 >= b**2
def search(text, long, lat, page): lst_dict = [] add = normal(text) lst_text = split_tag(add) for i in coll.find(): tag = str(i['store_name']) + " " + str(i['store_address']) tag = normal(tag) lst_tag = split_tag(tag) p = len(set(lst_text) & set(lst_tag)) if (p == len(lst_text)): i['_id'] = str(i['_id']) lst_dict.append(i) if not lst_dict: for i in coll.find(): tag = str(i['store_name']) + " " + str(i['store_address']) tag = normal(tag) lst_tag = split_tag(tag) p = len(set(lst_text) & set(lst_tag)) lst_cat = split_tag(i['category'].lower()) p_cat = len(set(lst_text) & set(lst_cat)) if (p_cat > 0 or p >= 2): i['_id'] = str(i['_id']) lst_dict.append(i) for i in lst_dict: i['km'] = distance(i['longitude'], i['latitude'], long, lat) lst_dict = sorted(lst_dict, key=lambda d: d['km']) if page is None: return lst_dict else: return lst_dict[0:50]
def sum_of_distances(individual): broken_bots = [position[bot] for bot in individual["path"]] return sum([ distance(bot_1, bot_2) for (bot_1, bot_2) in zip(broken_bots, broken_bots[1:] + [broken_bots[0]]) ])
def main(): home = {"lng": -92.019850, "lat": 30.213028} start = time.time() locations = [] tries = 0 while len(locations) < 10: tries += 1 print("Try {}: fetching locations".format(tries)) r = query() for location in r: location["dist"] = distance(home, location) location["href"] = permalink(location) r.sort(key=operator.itemgetter("dist")) r = itertools.takewhile(lambda x: x["dist"] < 100000, r) r = list(r) locations.extend(r) print("Try {}: found {} locatings within 100km, have {}".format( tries, len(r), len(locations))) dur = time.time() - start print("Took {:,.0f}s to find {} locations within 100km".format( dur, len(locations))) locations.sort(key=operator.itemgetter("dist")) for location in locations: print("{0[dist]: =10,.0f}m {0[formatted_address]} {0[href]}".format( location))
def node_distance(node1, node2, min_distance, max_distance): """[summary] Calulcates whether a naptan node distance in meters, using geodesic formulate Arguments: node1 {[type]} -- [description] node2 {[type]} -- [description] min_distance -- the min distance in meters that should be between two nodes. max_dist {[float]} -- the max distance in meters that can be between the nodes Returns: Distance [str] -- [description] """ lat_n1, lon_n1 = node1.Latitude, node1.Longitude lat_n2, lon_n2 = node2.Latitude, node2.Longitude distance = distance((lat_n1.values[0], lon_n1.values[0]), (lat_n2.values[0], lon_n2.values[0])).meters if (distance >= max_distance): return ('Nodes are too far away.') if (distance <= min_distance): return ('Nodes are too close.') else: return (f'Stop is within; {distance:.2f} meters.')
def cate(long, lat, page): lstcat = predict() lst = [] for i in coll.find({}, {'_id': 0}): if (i['category'].lower() in lstcat): i['km'] = distance(i['longitude'], i['latitude'], long, lat) lst.append(i) lst = sorted(lst, key=lambda d: d['km']) return lst[(page - 1) * 15:page * 15 - 1]
def parser(client, userdata, message): global uid global p print(message.payload) if message.topic == "/user/cancel": payload = message.payload payload = str(payload) p.uuid = str(p.uuid) p.euid = str(p.euid) print(payload) if str(payload.split("::")[0]) == str(p.uuid) and str( payload.split("::")[1]) == str(p.euid): try: p.stop() # magic.gpio.display("Event resolved") # time.sleep(5) # magic.gpio.display("") p = None except: pass elif message.topic == "/user/events": try: payload = json.loads(message.payload) except: payload = json.loads(str(message.payload, "utf8")) if not distance( [self_lat, self_long], payload["location"]) > conf["l" + str(payload["level"])]: m = MapGenerator( [{ "lat": self_lat, "long": self_long, "style": "round", "color": "", "size": "", "content": "" }, { "lat": payload["location"][0], "long": payload["location"][1], "color": ["rd", "or", "gn"][payload["level"] - 1], "style": "pm2", "size": "l", "content": "" }], { "lang": "ru_RU", "width": 320 if THIS_PI else 650, "height": 240 if THIS_PI else 450, "type": "map" }).get_file() if THIS_PI: p = PicDisplayerFbi(m) else: p = PicDisplayerPygame(m) p.euid = payload["euid"] p.uuid = payload["uuid"]
def neighbor_dectection_with_longlat(latitude, longitude, data): distances = [] long_ = float(longitude) lat_ = float(latitude) for i in range(len(data)): if (data.loc[i].latitude != -1 and data.loc[i].longitude != -1): distances.append( distance(lat_, long_, data.loc[i].latitude, data.loc[i].longitude)) distances = np.array(distances) return data.loc[np.argsort(distances)[:30]]
def dist_to_segment(x, ab, distance=geopy.distance.great_circle ) -> Tuple[float, float]: # Compute lengths xa = distance(x, ab[0]).m xb = distance(x, ab[1]).m ab = distance(ab[0], ab[1]).m if (ab == 0): return (xa, 0) # Heron's formula for the area-squared s = (xa + xb + ab) / 2 AA = s * (s - xa) * (s - xb) * (s - ab) # Height h = math.sqrt(max(0, AA)) / ab * 2 # From base edngpoints to base of the height ah = math.sqrt(max(0, xa**2 - h**2)) bh = math.sqrt(max(0, xb**2 - h**2)) # Distance and relative coordinate (d, t) = max([(bh, (xa, 0)), (ah, (xb, 1)), (ab, (h, ah / ab))])[1] return (d, t)
def get_distance_weight(where_query, poi): where_coordinates = YandexAPI().get_coordinates(where_query) poi_coordinates = MongoDB().get_poi_by_id(str(poi['_id'])) dist = distance(float(where_coordinates['lat']), float(where_coordinates['lon']), float(poi_coordinates['lat']), float(poi_coordinates['lon'])) if WEIGHT.FIRST_DISTANCE_RANGE_MAX <= dist <= WEIGHT.FIRST_DISTANCE_RANGE_MIN: return distance_range(WEIGHT.FIRST_DISTANCE_POINT_MIN, WEIGHT.FIRST_DISTANCE_POINT_MAX, WEIGHT.FIRST_DISTANCE_RANGE_MIN, WEIGHT.FIRST_DISTANCE_RANGE_MAX, dist) elif WEIGHT.SECOND_DISTANCE_RANGE_MAX <= dist <= WEIGHT.SECOND_DISTANCE_RANGE_MIN: return distance_range(WEIGHT.SECOND_DISTANCE_POINT_MIN, WEIGHT.SECOND_DISTANCE_POINT_MAX, WEIGHT.SECOND_DISTANCE_RANGE_MIN, WEIGHT.SECOND_DISTANCE_RANGE_MAX, dist) elif WEIGHT.THIRD_DISTANCE_RANGE_MAX <= dist <= WEIGHT.THIRD_DISTANCE_RANGE_MIN: return distance_range(WEIGHT.THIRD_DISTANCE_POINT_MIN, WEIGHT.THIRD_DISTANCE_POINT_MAX, WEIGHT.THIRD_DISTANCE_RANGE_MIN, WEIGHT.THIRD_DISTANCE_RANGE_MAX, dist) else: return 0
def reprojection_error(X): global min_err, best_h # Camera Matrix and Distortion Coefficients f_x, f_y, c_x, c_y, k1, k2, p1, p2 = X mtx = np.array([[f_x, 0, c_x], [0, f_y, c_y], [0, 0, 1]], dtype=np.float64) dist = np.array([[k1, k2, p1, p2]], dtype=np.float64) # Undistort detection points # https://stackoverflow.com/questions/22027419/bad-results-when-undistorting-points-using-opencv-in-python undistorted_points = cv2.undistortPoints(distorted_points.reshape( -1, 1, 2), mtx, dist, P=mtx) # Compute Homography choices = np.random.randint(0, len(distorted_points), size=10) h, status = cv2.findHomography(undistorted_points[choices], gps_points[choices], cv2.RANSAC) if type(h) != type(None): # Compute New Projections # https://stackoverflow.com/questions/55055655/how-to-use-cv2-perspectivetransform-to-apply-homography-on-a-set-of-points-in gps_projections = cv2.perspectiveTransform(undistorted_points, h) gps_projections = gps_projections.reshape(-1, 2) # Compute Average Projection Distance Error ERR = [] for i in range(len(gps_projections)): ERR.append(distance(gps_projections[i], gps_points[i])) RMSE = (sum([err**2 for err in ERR]) / len(ERR))**.5 if RMSE < min_err: min_err = RMSE best_camera_params["Homography"] = h best_camera_params["Distortion Coefficients"] = dist best_camera_params["Intrinsic Matrix"] = mtx fig = Figure() canvas = FigureCanvas(fig) ax = fig.gca() ax.scatter(gps_projections[:, 0], gps_projections[:, 1], c=ERR / max(ERR), cmap="Reds") ax.scatter(gps_points[:, 0], gps_points[:, 1], marker="x") #,c=colors,cmap="bwr") canvas.print_figure("output.png") frame = plt.imread("output.png") image_without_alpha = frame[:, :, :3] frame = np.uint8(255 * image_without_alpha) out.write(frame) return RMSE else: return 10e10
def latStepsFromLngSteps(bounds, lng_steps): xstart = bounds['southwest']['lng'] xend = bounds['northeast']['lng'] ystart = bounds['southwest']['lat'] yend = bounds['northeast']['lat'] xdist = distance((ystart, xstart), (ystart, xend)) ydist = distance((ystart, xstart), (yend, xstart)) lat_steps = int((ydist / xdist) * lng_steps) #print('lng_steps = ' + str(lng_steps)) #print('lat_steps = ' + str(lat_steps)) #print('aspect ratio = ' + str(ydist / xdist)) #print('xdist = ' + str(xdist)) #print('xincr = ' + str(xdist / lng_steps)) #print('ydist = ' + str(ydist)) #print('yincr = ' + str(ydist / lat_steps)) #xstep = (xend - xstart) / lng_steps #ystep = xstep * xdist / ydist return lat_steps
def finder(ll, lats, longs, APIs, pad, max_dist=0.05): """ Determine which lats and longs are within the criteria distance of ll to be included in the same pad The function is designed for use in a recursive program :input ll: latitude and longitude of a point to be considered :input lats: a sorted array of latitudes :input longs: an array of longitudes associated with lats :input APIs: an array of API values of the wells :input pad: a list of wells grouped into pads. :input max_dist: maximum distance to the nearest well to be considered a pad (km) :return: none """ pad.append(ll) if len(lats) < 1: return minind = binary_find_min(ll[0], lats) # preliminary fast culling of distant wells if crude_lat_dist(ll[0], lats[minind]) > max_dist * 10: return else: cond = [] temp = minind while temp >= 0 and \ crude_lat_dist(ll[0], lats[temp]) <= max_dist * 10: cond.append(temp) temp -= 1 temp = minind + 1 while temp < len(lats) and \ crude_lat_dist(ll[0], lats[temp]) <= max_dist * 10: cond.append(temp) temp += 1 cond.sort(reverse=True) # final selection of nearby wells to be included in the pad la = [lats[l] for l in cond] lo = [longs[l] for l in cond] distances = distance(np.array(list(zip(la, lo))), ll) cond2 = np.where(distances < max_dist)[0] if len(cond) == 0: return winners = [] for c2 in cond2: winners.append([lats[cond[c2]], longs[cond[c2]], APIs[cond[c2]]]) del (lats[cond[c2]]) del (longs[cond[c2]]) del (APIs[cond[c2]]) for w in winners: finder(w, lats, longs, APIs, pad)
def user(user_id, long, lat): transList = list(db['tran'].find({'user_id': Int64(user_id)}, {'_id': 0})) merList = [] for i in transList: mer = coll.find_one({'store_id': Int64(i['store_id'])}, { '_id': 0, '': 0 }) if mer is not None: mer['amount'] = i['amount'] mer['km'] = distance(float(mer['longitude']), float(mer['latitude']), long, lat) merList.append(mer) return merList
def create_distance_matrix(locations): """Compute distance matrix for given locations. :param locations: a sequence of cordinates :type location: sequence of pairs of floats :returns: a matrix M of shape len(locations) x len(locations) such that M[i, j] is a distance between i-th and j-th location. :rtype: numpy.ndarray """ size = len(locations) result = numpy.zeros((size, size)) for i in range(size): for j in range(i + 1, size): result[i, j] = result[j, i] = distance(locations[i], locations[j]) return result
def main(args): if not args.output[-5:] == '.html': exit('ERROR Output file must be .html') heatmap_data = [] for gpx_file in get_gpx_files(args): if not args.quiet: print('Reading {}'.format(gpx_file)) with open(gpx_file, 'r') as file: last_point = None for line in file: if '<trkpt' in line: r = re.findall('[-]?[0-9]*[.]?[0-9]+', line) point = [float(r[0]), float(r[1])] if last_point is not None and distance(point, last_point) < args.skip_distance: continue heatmap_data.append(point) last_point = point if not args.quiet: print('Loaded {} trackpoints'.format(len(heatmap_data))) fmap = Map(tiles = 'CartoDB positron' if args.light_map else 'CartoDB dark_matter', location=args.center, zoom_start=11, prefer_canvas = True, max_zoom = HEATMAP_MAXZOOM) HeatMap(heatmap_data, radius = args.radius, blur = args.blur, gradient = HEATMAP_GRAD['light' if args.light_map else 'dark'], min_opacity = args.min_opacity, max_val = args.max_val).add_to(fmap) if args.center is None: fmap.fit_bounds(fmap.get_bounds()) fmap.save(args.output) if not args.quiet: print('Saved {}'.format(args.output)) if not args.quiet: webbrowser.open(args.output, new = 2, autoraise = True)
def inst_velocity(dataset, since, until): """ Calculating instantaneous velocity since some moment of time until another moment of time. Velocity is computed as distance change divided by time change. :param dataset: List of pandas.DataFrames, each corresponding to one moment of time. Each of these dataframes should have columns: "Lines", "Lon", "VehicleNumber", "Time", "Lat", "Brigade". :param since: index of list(dataset). It corresponds to the moment of time to start measuring velocity. :param until: index of list(dataset). It correspons to the moment of time to end measuring velocity. :return: dataframe containing two columns: VehicleNumber and Velocity. """ dist = distance(dataset, since, until) t_diff = time_difference(dataset, since, until) merged = pd.merge(dist, t_diff, on=["VehicleNumber"], how="inner") merged["Velocity"] = np.NaN updated = (merged["Time_difference"] != 0) merged["Velocity"][updated] = 3600 * (merged["Distance"][updated] / merged["Time_difference"][updated]) result = merged[["VehicleNumber", "Velocity"]] return result
def from_csv_record(row, mgc): ''' create a pipe from csv ''' pid = int(float(row['LINEID'])) f_junction = int(row['FRNODE']) t_junction = int(row['TONODE']) diameter = float(row['DIAMETER']) * .0254 f_node = (float(row['FRNODE_Y']), float(row['FRNODE_X'])) t_node = (float(row['TONODE_Y']), float(row['TONODE_X'])) length = distance(f_node, t_node) pipe = Pipe({ '_id': pid, 'f_junction': f_junction, 't_junction': t_junction, 'diameter': diameter, 'length': length }) return pipe
def wkmeans(values, k=None, centroids=None, steps=200): # initialize k points randomly centroids = values[np.random.choice(np.arange(len(values), ), k, False)] for step in range(max(steps, 1)): # compute distance between each pair of the two collections of inputs dists = scipy.spatial.distance.cdist(centroids, values, lambda u, v: distance(u, v)**2) # closest centroid to each point clusters = np.argmin(dists, axis=0) new_centroids = cluster_centroids(values, clusters, k) if np.array_equal(new_centroids, centroids): break centroids = new_centroids return clusters, centroids
def parser(client, userdata, message): global uid global p print(message.payload) if message.topic == "/user/cancel": payload = message.payload payload = str(payload) p.uuid = str(p.uuid) p.euid = str(p.euid) print(payload) if str(payload.split("::")[0]) == str(p.uuid) and str(payload.split( "::")[1]) == str(p.euid): try: p.stop() # magic.gpio.display("Event resolved") # time.sleep(5) # magic.gpio.display("") p = None except: pass elif message.topic == "/user/events": try: payload = json.loads(message.payload) except: payload = json.loads(str(message.payload, "utf8")) if not distance([self_lat, self_long], payload["location"]) > conf["l" + str(payload["level"])]: m = MapGenerator([{"lat": self_lat, "long": self_long, "style": "round", "color": "", "size": "", "content": ""}, {"lat": payload["location"][0], "long": payload["location"][1], "color": ["rd","or","gn"][payload["level"]-1], "style": "pm2", "size": "l", "content": ""}], {"lang": "ru_RU", "width": 320 if THIS_PI else 650, "height": 240 if THIS_PI else 450, "type": "map"}).get_file() if THIS_PI: p = PicDisplayerFbi(m) else: p = PicDisplayerPygame(m) p.euid = payload["euid"] p.uuid = payload["uuid"]
def update_text(selectedData): s = "" di = "" try: lat1 = selectedData['points'][0]['lat'] lon1 = selectedData['points'][0]['lon'] lat2 = selectedData['points'][1]['lat'] lon2 = selectedData['points'][1]['lon'] di = distance(lat1, lon1, lat2, lon2) except (TypeError, IndexError) as e: pass try: return html.H3('{} is within a {:.1f} mile radius from {}'.format( selectedData['points'][0]['text'], di, selectedData['points'][1]['text'])) except (TypeError, IndexError) as e: return html.H3( "Select two points on the map with the selection tool to see the distance." )
def check_polygon_lengths(polygon): """[summary] Get the longest side of a given polygon, in meters Arguments: polygon {[shapely.geometry.polygon.Polygon]} -- [the polygon of the given area, ] Raises: NotImplemented: [description] Returns: [type] -- [description] """ # get minimum bounding box around polygon box = polygon.minimum_rotated_rectangle # get coordinates of polygon vertices x, y = box.exterior.coords.xy # get length of bounding box longest edge edge_length = distance( Point(x[0], y[0]).distance(Point(x[1], y[1])), Point(x[1], y[1]).distance(Point(x[2], y[2]))).meters return edge_length raise NotImplementedError
def __score__(self, nb_occ, latitude, longitude, prefix): if nb_occ == 1: self.score = 1 else: if nb_occ >= 10: first_score = 0.1 else: first_score = 1 / nb_occ self.score = first_score if latitude is not None: self.score += getScoreOfDist( (1 - first_score) / 3, distance(latitude, longitude, self.latitude, self.longitude)) self.score += getScoreOfPop((1 - first_score) / 3, self.population) self.score += getScoreOfNameVsPrefix((1 - first_score) / 3, self.name, prefix) else: self.score += getScoreOfPop((1 - first_score) / 2, self.population) self.score += getScoreOfNameVsPrefix((1 - first_score) / 2, self.name, prefix) self.score = round(self.score, 1)
def least_distance(locations): if len(locations) == 1: return 0 elif len(locations) == 2: return distance(locations[0], locations[1]) elif len(locations) == 3: d = [] d[0] = distance(locations[0], locations[1]) d[1] = distance(locations[2], locations[1]) d[2] = distance(locations[2], locations[0]) d.sort() return d[0] + d[1] elif len(locations) == 4: l = list(itertools.permutations(locations)) d = [] for i in range(len(l)): d[i] = distance(l[i][0], l[i][1]) + distance( l[i][2], l[i][1]) + distance(l[i][2], l[i][3]) d.sort() return d[0] else: return 0
"name": name, "mass": mass, "fall": fall, "year": year(date), "location": location(lat, lng) } def distance(location): def inner(meteor): """ Distance between a location and a meteor """ return geopy.distance.vincenty((location.latitude, location.longitude), meteor['location']) return inner def get_location(): """ Find the user's location """ city=raw_input('Which city are you in?: ') country=raw_input('Which country are you in?: ') return geolocator.geocode(city + ' ' + country) with open('Meteorite_Landings.csv') as f: meteors = [meteor(line) for line in f.readlines()] location = get_location() meteor = min(meteors, key=distance(location)) print('the nearest meteor to you was {0} in {1}'.format(meteor['name'], meteor['year'])) webbrowser.open('https://www.google.co.uk/maps/place/{0[0]},{0[1]}'.format(meteor['location']))
def deltax(esp, variance): maximum = distance(esp - variance) minimum = distance(esp + variance) return (maximum - minimum) / 2
def trilateration(point_list, gateway_list, ref_point, filter): #filter: tuple(inner_filter,outer_filter) #read all point and gateway data data = trilat_extract_info(point_list, gateway_list, ref_point) #create a zero reference point to be used for the circle coordinate system total_lat = total_lon = c = 0 for gtw in data: total_lat += float(gtw['Lat']) total_lon += float(gtw['Lon']) c += 1 zero_point = total_lat / c, total_lon / c #print(zero_point) #print(data) gtw_pairs = [] intersect_points = [] #for every pair of gateways: for gtw1 in data: for gtw2 in data: if gtw1['EUI'] != gtw2['EUI']: #Every pair exists twice. Filter. gtw_pairs.append({'EUI1': gtw1['EUI'], 'EUI2': gtw2['EUI']}) #if the inverse pair does not exist yet if {'EUI1': gtw2['EUI'], 'EUI2': gtw1['EUI']} not in gtw_pairs: #print("Gateway pair: "+gtw1['EUI']+ " + "+gtw2['EUI']) ''' #testing my own functions against geopy. Test ok, almost corresponds to great circle p1_geopy = geopy.distance.great_circle((gtw1['Lat'],gtw1['Lon']),zero_point).km * 1000 p1_lat = coord_to_m('lat',zero_point[0]-gtw1['Lat'],gtw1['Lat']) p1_lon = coord_to_m('lon',zero_point[1]-gtw1['Lon'],gtw1['Lat']) p1_homemade = math.sqrt(p1_lat*p1_lat+p1_lon*p1_lon) print("Geopy distance: " + str(p1_geopy)) print("Own function dist: " + str(p1_homemade)) #Test: conversion to refcoords and back --> works print("Reference point: " + str(gtw1['Lat'])+", "+str(gtw1['Lon'])) banana = latlon_to_ref((gtw1['Lat'],gtw1['Lon']),zero_point) print("Point in reference coordinates: "+str(banana)) avocado = ref_to_latlon(banana,zero_point) print("Conversion back to lat/lon: " + str(avocado)) ''' #build rings with sigma_rings time the variance for param in range(0, 61): sigma_ring = 0.1 * param - 3 if distance(gtw1['ESP-mean']) < distance( gtw2['ESP-mean']): closer_gateway = gtw1['EUI'] further_gateway = gtw2['EUI'] closer_distance = distance(gtw1['ESP-mean']) closer_variance = distance(gtw1['ESP-var']) else: closer_gateway = gtw2['EUI'] further_gateway = gtw1['EUI'] closer_distance = distance(gtw2['ESP-mean']) closer_variance = distance(gtw2['ESP-var']) mean_distance = distance( (gtw1['ESP-mean'] + gtw2['ESP-mean']) / 2) mean_variance = distance( (gtw1['ESP-var'] + gtw2['ESP-var']) / 2) circle1 = latlon_to_ref( (gtw1['Lat'], gtw1['Lon']), zero_point) + ( distance(gtw1['ESP-mean'] + sigma_ring * gtw1['ESP-var']), ) circle2 = latlon_to_ref( (gtw2['Lat'], gtw2['Lon']), zero_point) + ( distance(gtw2['ESP-mean'] + sigma_ring * gtw2['ESP-var']), ) p1_refsystem, p2_refsystem = circle_intersection( circle1, circle2) if p1_refsystem != None: p1_latlon = ref_to_latlon(p1_refsystem, zero_point) p2_latlon = ref_to_latlon(p2_refsystem, zero_point) #check validity of the point (within 3 sigma of every gateway) valid1 = valid2 = True for g in data: #for every gateway, if distance point-gateway is bigger than dist+3sigma, point is invalid #only one gateway not fitting into the criteria is setting it to false. #outside circle if geopy.distance.vincenty( p1_latlon, (g['Lat'], g['Lon'])).km * 1000 > distance( g['ESP-mean'] - filter[1] * g['ESP-var']): valid1 = False if geopy.distance.vincenty( p2_latlon, (g['Lat'], g['Lon'])).km * 1000 > distance( g['ESP-mean'] - filter[1] * g['ESP-var']): valid2 = False #inside circle if geopy.distance.vincenty( p1_latlon, (g['Lat'], g['Lon'])).km * 1000 < distance( g['ESP-mean'] + filter[0] * g['ESP-var']): valid1 = False if geopy.distance.vincenty( p2_latlon, (g['Lat'], g['Lon'])).km * 1000 < distance( g['ESP-mean'] + filter[0] * g['ESP-var']): valid2 = False if (valid1): intersect_points.append({ 'Ref': ref_point, 'Gateways': (closer_gateway, further_gateway), 'Intersection': p1_latlon, 'Closer distance': closer_distance, 'Closer variance': closer_variance, 'Mean distance': mean_distance, 'Mean variance': mean_variance, 'Sigma ring': sigma_ring }) if (valid2): intersect_points.append({ 'Ref': ref_point, 'Gateways': (closer_gateway, further_gateway), 'Intersection': p2_latlon, 'Closer distance': closer_distance, 'Closer variance': closer_variance, 'Mean distance': mean_distance, 'Mean variance': mean_variance, 'Sigma ring': sigma_ring }) return intersect_points
distanceCountry[i][j] = distance.distance(locationList[i].coordinate, locationList[j].coordinate).km print("%12.3f km|" % distance.distance(locationList[i].coordinate, locationList[j].coordinate).km, end='') print('') # Kuala Lumpur --> Bangkok --> Beijing --> Seoul --> Tokyo --> Taipei --> Hong Kong --> Jakarta --> Kuala Lumpur # 13930.557 km # path = [0, 2, 6, 7, 5, 3, 4, 1, 0] path = [0, 2, 6, 7, 3, 4, 1, 5, 0] #path = [0, 3, 7, 6, 2, 1, 5, 4, 0] print(len(path)-1) def distance(path): sum = 0.0 for y in range (len(path)-1): sum = sum + distanceCountry[path[y]][path[y+1]] return sum print("The distance is ", end='') print(distance(path)) # Kuala Lumpur --> Bangkok --> Beijing --> Seoul --> Taipei --> Hong Kong --> Jakarta --> Tokyo --> Kuala Lumpur # The distance is 22059.093961229577 # [0, 1, 2, 3, 5, 6, 7, 4, 0] # Sentiment path # Kuala Lumpur --> Taipei --> Seoul --> Beijing --> Bangkok --> Jakarta --> Tokyo --> Hong Kong --> Kuala Lumpur # [0, 3, 7, 6, 2, 1, 5, 4, 0]
from itertools import chain import geopy.distance distance = geopy.distance.vincenty # shapefile baseFile = 'data/Oakland_parcels_queried/Oakland_parcels_queried' errorFile = 'data/Oakland_parcels_errors/Oakland_parcels_errors' # compute map boundscenter = (37.8058428, -122.2399758) # (lat, long), Armenian Church #center = geopy.Point(37.8058428, -122.2399758) # (lat, long), Armenian Church center = geopy.Point(37.79539889, -122.21547850) # (lat, long), rough geometric center of entire dataset #center = geopy.Point(37.759987, -122.221965) # (lat, long), rough geometric center of error dataset radius = 8.5 # in km #ur = distance(kilometers=radius).destination(center, +45) #ll = distance(kilometers=radius).destination(center, -135) ur = distance(kilometers=radius*2**0.5).destination(center, +45) ll = distance(kilometers=radius*2**0.5).destination(center, -135) ur = (ur.longitude, ur.latitude) ll = (ll.longitude, ll.latitude) extra = 0.01 # padding coords = list(chain(ll, ur)) w, h = coords[2] - coords[0], coords[3] - coords[1] m = Basemap( projection='tmerc', lon_0=-122., lat_0=37., ellps = 'WGS84', llcrnrlon=coords[0] - extra * w, llcrnrlat=coords[1] - extra * h,
for segment in track.segments: for point in segment.points: tudo.append([point.latitude, point.longitude, point.time]) #print(tudo) c = 0 d = 0 week = timedelta(weeks=1) week = week.total_seconds() for point in tudo: tempo = point[2] point[2] = ( point[2] - datetime.combine(get_first_dow(2018, point[2].isocalendar()[1]), datetime.min.time())).total_seconds() p1 = [point[0], point[1]] if distance(p1, casa) < 500: if (c != 1): if DEBUG: print('\n\n') print("++chegou a casa") print(tempo) casaF.append(point) if d == 1: time = (point[2] - deiF[-1][2]) if DEBUG: print('duracao: ', time) if time < 0: if DEBUG: print("--saiu do dei") print(week + time) deiF.append(week + time)
filename = 'Alameda County Parcel Boundaries.geojson' r = 0.5 # in km with open(filename, 'r') as fid: # store complete data fields within a certain distance of tempCenter objects = ijson.items(fid, 'features.item') data = {} # for (i, o) in zip(range(5000), objects) : for (i, o) in enumerate(objects): if i % 1000 == 0: if i % 10000 == 0: print('{}: {} records so far'.format(i, len(data))) else: print(i, end=' ') pos = o['geometry']['coordinates'][0][0][ 0] # get (long, lat) of first vertex # would be better to get centroid of the polygon pos = (pos[1], pos[0]) # switch to (lat, long) d = '{}'.format(distance(pos, center)) d = float(d[:-3]) # convert to a number that can be compared if d < 0.25: data[round(d, 6)] = o # 6th decimal place in lat,long is 0.1 m # print('Record {} is {} km away'.format(i, d)) print('{}: {} records so far'.format(i, len(data))) tempout.close()
import geopy import geopy.distance distance = geopy.distance.vincenty center = (37.8058428, -122.2399758) # (lat, long), Armenian Church center = (center[1], center[0]) data1 = {} #for (i, (k, v)) in zip(range(10), data.items()) : for (k, v) in data.items() : c = shp.shape(v['geometry']) # v['centroid'] = c.centroid.wkt # d = '{}'.format(distance(v['centroid'], center)) # distance can take a wkt format! v['centroid'] = (c.centroid.x, c.centroid.y) d = '{}'.format(distance(v['centroid'], center)) d = float(d[:-3]) # convert to a number that can be compared # print('Old distance: {} km, new distance: {} km'.format(k, round(d,6))) print('Difference = {:6.2f} m'.format(abs(k-round(d,6))*1000)) data1[round(d,6)] = v data = data1 del data1 #%% How to save key to file import pickle apifile = open('../private/API_keys.pkl', 'wb') a = pickle.Pickler(apifile)
filename = 'Alameda County Parcel Boundaries.geojson' r = 0.5 # in km with open(filename, 'r') as fid: # store complete data fields within a certain distance of tempCenter objects = ijson.items(fid, 'features.item') data = {} # for (i, o) in zip(range(5000), objects) : for (i, o) in enumerate(objects) : if i%1000 == 0: if i%10000 == 0 : print('{}: {} records so far'.format(i, len(data))) else : print(i, end=' ') pos = o['geometry']['coordinates'][0][0][0] # get (long, lat) of first vertex # would be better to get centroid of the polygon pos = (pos[1], pos[0]) # switch to (lat, long) d = '{}'.format(distance(pos, center)) d = float(d[:-3]) # convert to a number that can be compared if d < 0.25 : data[round(d,6)] = o # 6th decimal place in lat,long is 0.1 m # print('Record {} is {} km away'.format(i, d)) print('{}: {} records so far'.format(i, len(data))) tempout.close()
from mpl_toolkits.basemap import Basemap from shapely.geometry import Point, Polygon, MultiPoint, MultiPolygon from shapely.prepared import prep from descartes import PolygonPatch import fiona from itertools import chain import geopy.distance distance = geopy.distance.vincenty baseFile = 'data/Oakland_parcels/parcels' #baseFile = 'data/Oakland_parcels_queried/Oakland_parcels_queried' # radius of 500 m # compute map boundscenter = (37.8058428, -122.2399758) # (lat, long), Armenian Church center = geopy.Point(37.8058428, -122.2399758) # (lat, long), Armenian Church radius = 4 # in km ur = distance(kilometers=radius).destination(center, +45) ll = distance(kilometers=radius).destination(center, -135) ur = (ur.longitude, ur.latitude) ll = (ll.longitude, ll.latitude) extra = 0.01 # padding coords = list(chain(ll, ur)) w, h = coords[2] - coords[0], coords[3] - coords[1] m = Basemap(projection='tmerc', lon_0=-122., lat_0=37., ellps='WGS84', llcrnrlon=coords[0] - extra * w, llcrnrlat=coords[1] - extra * h, urcrnrlon=coords[2] + extra * w,
roadnet_data = pd.read_excel(f_path + 'Dec 9 2016 Roadnet Export Route 24 STL for comparison.xlsx', header=0, sheetname='Sheet') LOC,ADD,CITY,STATE,ZIP = roadnet_data['Location'].astype(str), roadnet_data['Address Line 1'].astype(str), roadnet_data['City'].astype(str), 'MO', roadnet_data['Postal Code'].astype(str) roadnet_data['Street'] = ADD roadnet_data['ExtendedAddress'] = LOC +', '+ ADD +', '+ CITY +', '+ STATE +', '+ ZIP +', '+ 'USA' roadnet_coordinates = roadnet_data['Coordinate'].astype(str) lat = [r.split(',')[0] for r in roadnet_coordinates] roadnet_data['Latitude'] = lat = [re.sub('[(]', '', l.strip()) for l in lat] lon = [r.split(',')[-1] for r in roadnet_coordinates] roadnet_data['Longitude'] = lon = [re.sub('[)]', '', l.strip()) for l in lon] print('Create distance matrix between both dataframes.') [distance(re.sub('[,()]',' ',r), re.sub('[,()]',' ',r)) for r in roadnet_coordinates] stop_candidates.merge(roadnet_data, on='Latitude') print('Conduct fuzzy match.') FUZZY = difflib.Differ() matches = list(FUZZY.compare(stop_candidates.Street, roadnet_data.Street)) pp = pprint.PrettyPrinter(indent=4)