def __init__(self, **kwargs): super(MainScreen, self).__init__(**kwargs) # hacky config file validation for bad or missing coords # we have to store or it would draw under the dials settings_modal = None try: pt = Point(self.config_latlon) except ValueError: pt = Point() settings_modal = SettingsScreen() settings_modal.config_friendlyname = '' if self.config_latlon != '': settings_modal.feedback.text =\ "Invalid location detected in config, please select a new location" self.config_latlon = '' self.dial_widget = DialWidget(latlon_point=pt) self.now_marker = NowMarker() self.season_dial = SeasonDial() self.add_widget(self.dial_widget) self.add_widget(self.now_marker) self.add_widget(self.season_dial) # workaround for kivy's LIFO draw order if settings_modal is not None: Clock.schedule_once(lambda dt: settings_modal.open(), 0.5)
def radius_filter(self, row): # afaik the DB doesn't have geocapability, so this is a favela-chic way of doing a bounding radius select. p = Point(row['lat'], row['lon'], row['alt']) me = Point(self.qst['lat'], self.qst['lon'], self.qst['alt']) dist = Distance.distance(p, me) if dist <= self.qst['search_radius']: return True
def __init__(self, host, port, tenant, device, latitude, longitude, movement): self.__logger = logging.getLogger('trackingsim.sim') self.__origin = Point(latitude, longitude) self.__current_position = Point(latitude, longitude) self.__mqttc = mqtt.Client("{}:{}".format(tenant, device)) self.__mqttc.username_pw_set("{}:{}".format( tenant, device)) # not necessary with iotagent-mosca self.__mqttc.connect(host=host, port=port) self.__mqttc.loop_start() self.__topic = "{0}:{1}/attrs".format(tenant, device) # self.__topic = "/{0}/{1}/attrs".format(tenant, device) # iotagent-mosca topic self.__sleep = np.random.uniform(self.__class__.MIN_SLEEP_TIME, self.__class__.MAX_SLEEP_TIME) self.__logger.info( "Starting simulation for device {0} with sleep time {1}".format( device, self.__sleep)) if movement == 'straight-line': self.__next_movement = self.__get_next_position_for_straight_line else: self.__next_movement = self.__get_next_random_position # bearing displacement used in the last movement. Start with random values self.__displacement = \ np.random.uniform(self.__class__.MIN_DISPLACEMENT, self.__class__.MAX_DISPLACEMENT) self.__bearing = \ np.random.uniform(self.__class__.MIN_BEARING, self.__class__.MAX_BEARING)
def assert_expected(expected): found = False for r in results['features']: passed = True properties = None if 'geocoding' in r['properties']: properties = r['properties']['geocoding'] else: properties = r['properties'] failed = properties['failed'] = [] for key, value in expected.items(): value = str(value) if not compare_values(str(properties.get(key)), value): # Value is not like expected. But in the case of # coordinate we need to handle the tolerance. if key == 'coordinate': coord = r['geometry']['coordinates'] lat, lon, max_deviation = map(float, value.split(",")) deviation = distance( Point(lat, lon), Point(coord[1], coord[0]) ) if int(deviation.meters) <= int(max_deviation): continue # Continue to other properties failed.append('distance') passed = False failed.append(key) if passed: found = True if not found: raise SearchException( params=params, expected=expected, results=results )
def optimal_path(nodes, origin, dest): nodes = [Point(lats, longs) for lats, longs in nodes] origin = Point(origin) dest = Point(dest) waypoint_collec = [waypoint(origin, (origin, dest))] waypoint_collec += [waypoint(node, (origin, dest)) for node in nodes] to_dest = waypoint(dest, (origin, dest)) waypoint_collec.append(to_dest) begin, remaining = waypoint_collec[0], waypoint_collec[1:] path = [] # Check for the rang to see if its the nearest to the start point for i in range(MAX_STEPS): nearer = begin.nearest(remaining) if nearer is None: break path.append(nearer) remaining = [pot for pot in remaining if pot != nearer] begin = nearer # Does the path provide the correct destination? if to_dest in path: path.remove(to_dest) return '|'.join(["via:{},{}".format(pot.pot.latitude, pot.pot.longitude) for pot in path])
def calc_azimuth(self, from_crestnode_index, to_crestnode_index): # convenience function to calculate the azimuth between two crestnodes # note: this has to be done with rather elaborate vincenty distance # calculations as latitude and longitude are not equal measures # Get the locations as lon, lat, z lon_A, lat_A, z_A = self.crestnodes[ from_crestnode_index].geom.GetPoint() lon_B, lat_B, z_B = self.crestnodes[to_crestnode_index].geom.GetPoint() # Calculate A to B azimuth by setting a fake point to calc x and y fakepoint = Point(longitude=lon_A, latitude=lat_B) realpoint_A = Point(longitude=lon_A, latitude=lat_A) realpoint_B = Point(longitude=lon_B, latitude=lat_B) distance_x = VincentyDistance(fakepoint, realpoint_B).m distance_y = VincentyDistance(fakepoint, realpoint_A).m # correct distances with positive and negative signs if (lon_B - lon_A) < 0.0: distance_x = -1.0 * distance_x if (lat_B - lat_A) < 0.0: distance_y = -1.0 * distance_y azimuth = math.atan2(distance_x, distance_y) azimuth = math.degrees(azimuth) # correct azimuths to 0-360 scale if azimuth < 0.0: azimuth = azimuth + 360.0 return azimuth
def resolve_tweet(self, tweet): # The Twitter API allows tweet['coordinates'] to both be absent # and None, such that the key exists but has a None value. # "tweet.get('coordinates', {})" would return None in the latter # case, with None.get() in turn causing an AttributeError. (None # or {}), on the other hand, is {}, and {}.get() is okay. tweet_coordinates = (tweet.get('coordinates') or {}).get('coordinates') if not tweet_coordinates: return None tweet_coordinates = Point(longitude=tweet_coordinates[0], latitude=tweet_coordinates[1]) closest_candidate = None closest_distance = float('inf') for cell in self._cells_for(tweet_coordinates.latitude, tweet_coordinates.longitude): for candidate in self.location_map[cell]: candidate_coordinates = Point(candidate.latitude, candidate.longitude) distance = geopy_distance(tweet_coordinates, candidate_coordinates).miles if closest_distance > distance: closest_candidate = candidate closest_distance = distance if closest_distance < self.max_distance: return (False, closest_candidate) return None
def __init__(self, name, north=None, south=None, west=None, east=None, center=None, hashtags=set(), phrase='at', secondary=None): if center: self.center = Point(latitude=center[0], longitude=center[1]) else: self.center = Point(latitude=(north + south) / 2, longitude=(east + west) / 2) self.north = north self.south = south self.west = west self.east = east try: self.hashtags = hashtags self.hashtags.update(config.HASHTAGS) except NameError: self.hashtags = hashtags self.name = name self.phrase = phrase
def __init__(self, host, port, tenant, device, latitude, longitude, movement): longitude = float(longitude) + np.random.uniform( self.__class__.RANGE_VARIATION_MIN, self.__class__.RANGE_VARIATION_MAX) latitude = float(latitude) + np.random.uniform( self.__class__.RANGE_VARIATION_MIN, self.__class__.RANGE_VARIATION_MAX) self.__logger = logging.getLogger('trackingsim.sim') self.__origin = Point(latitude, longitude) self.__current_position = Point(str(latitude), str(longitude)) self.__mqttc = mqtt.Client(str(threading.current_thread().ident)) self.__mqttc.connect(host=host, port=port) self.__mqttc.loop_start() self.__topic = "/{0}/{1}/attrs".format(tenant, device) self.__sleep = 10 self.__logger.info( "Starting simulation for device {0} with sleep time {1}".format( device, self.__sleep)) if movement == 'straight-line': self.__next_movement = self.__get_next_position_for_straight_line elif movement == 'static': self.__next_movement = self.__get_static_position else: self.__next_movement = self.__get_next_random_position # bearing displacement used in the last movement. Start with random values self.__displacement = \ np.random.uniform(self.__class__.MIN_DISPLACEMENT, self.__class__.MAX_DISPLACEMENT) self.__bearing = \ np.random.uniform(self.__class__.MIN_BEARING, self.__class__.MAX_BEARING)
def get_distance_from_arrakeen_m(location): """Return distance from arrakeen in meters.""" l = get_location(location) point_location = Point(l.latitude, l.longitude) point_arrakeen = Point(current_app.config['PAWEB_ARRAKEEN_LATITUDE'], \ current_app.config['PAWEB_ARRAKEEN_LONGITUDE']) return vincenty(point_location, point_arrakeen).m
def test_two_edge_path(self): first_start = data_factory.right_angle_start first_middle = data_factory.right_angle_middle first_end = data_factory.right_angle_end first_right_angled_road = data_factory.create_part( first_start, first_middle, first_end) second_start = first_end second_middle = Point('%.1f' % (first_end.latitude + 0.1), first_end.longitude) second_end = Point('%.1f' % (first_end.latitude + 0.1), '%.1f' % (first_end.longitude + 0.1)) second_right_angled_road = data_factory.create_part( second_start, second_middle, second_end) shapefile = data_factory.create_shapefile([first_right_angled_road] + [second_right_angled_road]) networkx = convert._to_networkx_graph(shapefile) G = convert.load_graph_from_shapefile_records(networkx) actual_distance = distance.using_route(G, first_start, second_end) self.assertTrue( abs(actual_distance - (data_factory.right_angle_distance * 2)) < 1 * ureg.metre)
def get_distance(a, b): """ origin (float, float): coordinates longitude, latitude, eg: (-122.7282, 45.5801) destination (float, float): coordinates return (float): in m """ return geodistance(Point(a[1], a[0]), Point(b[1], b[0])).meters
def best_path(nodes, origin, dest): # import pdb; pdb.set_trace() # I'll convert my own damn parameters. nodes = [Point(lat, lng) for lat, lng in nodes] origin = Point(origin) dest = Point(dest) waypoints = [Waypoint(origin, (origin, dest))] waypoints += [Waypoint(node, (origin, dest)) for node in nodes] to = Waypoint(dest, (origin, dest)) waypoints.append(to) start, remaining = waypoints[0], waypoints[1:] path = [] for i in range(MAX_STEPS): closer = start.closest(remaining) if closer is None: break path.append(closer) remaining = [pt for pt in remaining if pt != closer] start = closer # check to see if destination is in path if to in path: path.remove(to) return '|'.join( ["via:{},{}".format(pt.pt.latitude, pt.pt.longitude) for pt in path])
def get_pos(self): if self.speed > self.get_total_distance(): self._last_pos = self.destination self._last_step = len(self._step_keys)-1 if self.get_last_pos() == self.destination: return self.get_last_pos() distance = self.speed origin = Point(*self._last_pos) ((so_lat, so_lng), (sd_lat, sd_lng)) = self._step_dict[self._step_keys[self._last_step]] bearing = self._calc_bearing(so_lat, so_lng, sd_lat, sd_lng) while haversine.haversine(self._last_pos, (sd_lat, sd_lng))*1000 < distance: distance -= haversine.haversine(self._last_pos, (sd_lat, sd_lng))*1000 self._last_pos = (sd_lat, sd_lng) if self._last_step < len(self._step_keys)-1: self._last_step += 1 ((so_lat, so_lng), (sd_lat, sd_lng)) = self._step_dict[self._step_keys[self._last_step]] bearing = self._calc_bearing(so_lat, so_lng, sd_lat, sd_lng) origin = Point(so_lat, so_lng) lat, lng = self._calc_next_pos(origin, distance, bearing) if haversine.haversine(self._last_pos, (lat, lng))*1000 < distance: distance -= haversine.haversine(self._last_pos, (lat, lng))*1000 self._last_pos = (lat, lng) else: return self.get_last_pos() else: lat, lng = self._calc_next_pos(origin, distance, bearing) self._last_pos = (lat, lng) return self.get_last_pos()
def organize_file(filename, config): location = 'data/linkstream/' if not os.path.exists(location): os.makedirs(location) df = pd.read_csv(filename, header=0) if pd.__version__ >= '0.17.0': df.sort_values(by=['uid', 'timestamp'], ascending=[1, 1], inplace=True) else: df.sort(['uid', 'timestamp'], ascending=[1, 1], inplace=True) df = df.reset_index(drop=True).rename(index=str, columns={ "uid": "uid_alpha", "timestamp": "timestamp_alpha", "lat": "lat_alpha", "lon": "lon_alpha", "layer": "layer_alpha" }) df2 = df.shift(-1).rename(index=str, columns={ "uid_alpha": "uid_beta", "timestamp_alpha": "timestamp_beta", "lat_alpha": "lat_beta", "lon_alpha": "lon_beta", "layer_alpha": "layer_beta" }) df = pd.concat([df, df2], axis=1) df = df[df['uid_alpha'] == df['uid_beta']] df['distance'] = df.apply(lambda r: distance.distance( Point("%f %f" % (r['lat_alpha'], r['lon_alpha'])), Point("%f %f" % (r['lat_beta'], r['lon_beta']))).meters, axis=1) df['time_elapsed'] = df.apply( lambda r: abs(r['timestamp_alpha'] - r['timestamp_beta']), axis=1) if 'min_distance' in config.keys(): min_distance = config['min_distance'] else: min_distance = 500 if 'max_speed' in config.keys(): max_speed = 1 / config['max_speed'] else: max_speed = 0.036 # (1 / 100 Km/h) ~= (1 / 27.8 m/s) df = df[df['distance'] > min_distance] df = df[df['time_elapsed'] > max_speed * df['distance']] if 'filename' in config.keys(): df.to_csv(location + config['filename'], index=False) else: df.to_csv(location + IdGenerator.uuid4().hex + '.csv', index=False) return df
def worker(acc, bearing): destination = travelDistance.destination(point=start, bearing=bearing) distancePoint = gDistance.distance( Point(fromA['lat'], fromA['lng']), Point(destination.latitude, destination.longitude)).km if (distancePoint > acc['distance']): return {'bearing': bearing, 'distance': distancePoint} return acc
def test_unpickle_graph(self): G = nx.read_gpickle("/tmp/columbia.roads.pickle") expected_distance = 0.17716759526992643 * ureg.kilometres start = Point(-75.490017, +10.478256) end = Point(-75.488535, +10.480564) actual_distance = distance.using_route(G, start, end) self.assertEqual(actual_distance, expected_distance)
def get_bbox(position, radius): """ return (4 float): long west, lat north, long east, lat south """ nw = geodistance(meters=radius * 1.4).destination( Point(position[1], position[0]), 225) se = geodistance(meters=radius * 1.4).destination( Point(position[1], position[0]), 45) return nw[1], nw[0], se[1], se[0]
def is_inside_radius(latitude1, longitude1, latitude2, longitude2, radius): if latitude1 is not None and longitude1 is not None and latitude2 is not None and longitude2 is not None: point1 = Point(latitude1, longitude1) point2 = Point(latitude2, longitude2) result = distance.distance(point1, point2).miles if result <= radius: return True return False
def test_get_class_points(self): #should pass only if the flask server is up! small_polygon = build_polygon(35.3, 33.11, 35.35, 33.15) client_lib.set_working_polygon(small_polygon) points_list = [Point(35.32, 33.13), Point(35.31, 33.12)] points, patches = get_all_class_points_in_polygon( small_polygon, 2000, 'peaks', 0, 8) logging.info(points.shape) self.assertTupleEqual(points.shape, (1, 2))
def calculateDistance(startLon, startLat, endLon, endLat): try: p1 = Point(str(startLon) + ' ' + str(startLat)) p2 = Point(str(endLon) + ' ' + str(endLat)) dist = distance.distance(p1,p2).kilometers dist = str(dist)[:5] return dist except ValueError: return 0
def gps_distance(self): if self.tee_pos.latitude is 0 or self.basket_pos.latitude == 0: return False p1 = Point(self.tee_pos.latitude, self.tee_pos.longitude) p2 = Point(self.basket_pos.latitude, self.basket_pos.longitude) d = distance.distance(p1, p2) return '%i' % d.meters
def distance_to_point(p1, p2): """ Calculate distance from point to point :param p1: :param p2: :return: meters """ a = Point(latitude=p1[1], longitude=p1[0]) b = Point(latitude=p2[1], longitude=p2[0]) return distance(a, b).m
def flat_result(self, result): out = result['properties'] out['lat'] = result['geometry']['coordinates'][1] out['lon'] = result['geometry']['coordinates'][0] out['distance'] = '—' if 'coordinate' in self.expected: lat, lon, max_deviation = map(float, self.expected['coordinate'].split(',')) dist = distance(Point(lat, lon), Point(out['lat'], out['lon'])) out['distance'] = int(dist.meters) return out
def get_cluster_hotel(sender, lat, longi): global Rest for rest in Rest: p1 = Point(lat + " " + longi) dist = distance.distance(Point(rest['lat'] + " " + rest['long']), p1).kilometers #if(dist <= rest['radius']): key = 'Rest_cluster:' + rest['ID'] + ':' + rest['name'] restcluster = redList(redis=pot_con, key=key) restcluster.append(sender)
def getCellSize(lat_lng): lat_lng.sort() corner1 = Point(lat_lng[0]) #lat,lng of first corner of first cell (upper LH) corner2 = Point(lat_lng[1]) #lat,lng of second corner of first cell (upper RH) lat_lng.sort(key=lambda a: (a[1], a[0])) #sorts by longitude rather than latitude corner3 = Point(lat_lng[1]) #lat,lng of third corner of first cell (lower LH) cell_width = distance.great_circle(corner1,corner2).km cell_height = distance.great_circle(corner1,corner3).km return cell_width * cell_height
def calculate_distance_from_center(latitude, longitude): downtown_lat = 43.6426 downtown_lon = -79.3871 center = Point(downtown_lat, downtown_lon) p = Point(float(latitude), float(longitude)) d_center = distance.distance(p, center).kilometers return(d_center)
def get_context_data(self, *, object_list=None, **kwargs): context = super(IndexView, self).get_context_data(**kwargs) context['relations'] = RelationType.objects.all() query = FamillieList.objects.all() center = Point(48.9215, 24.70972) points = [] for q in query: point = Point(q.point.x, q.point.y) if geodesic(center, point).kilometers < 5: print(point) points.append(point) context['points'] = points return context
def build_vision_polygon(event_id, site_lat, site_lon, yaw, opening_angle, dist_km): """ This function allows to build the vision angle of a camera, ie. the zone covered by the detection device. It takes as input: - site_lat, the latitude of the detection device; - site_lon, the longitude of the detection device; - yaw, the orientation of the device expressed in degrees; - opening_angle, the width of the zone covered by the device expressed in degrees; - dist_km, the distance that the detection device is able to cover in kilometers. The function then builds and returns the zone covered by the detection device as a Dash Leaflet Polygon, which can be represented on the map. """ # The center corresponds the point from which the vision angle "starts" center = [site_lat, site_lon] points1 = [] points2 = [] for i in reversed(range(1, opening_angle + 1)): yaw1 = (yaw - i / 2) % 360 yaw2 = (yaw + i / 2) % 360 point = geodesic(kilometers=dist_km).destination( Point(site_lat, site_lon), yaw1) points1.append([point.latitude, point.longitude]) point = geodesic(kilometers=dist_km).destination( Point(site_lat, site_lon), yaw2) points2.append([point.latitude, point.longitude]) points = [center] + points1 + list(reversed(points2)) polygon = dl.Polygon(id={ 'type': 'vision_polygon', 'index': str(event_id) }, color="#ff7800", opacity=0.5, positions=points) return polygon
def get_scan_area(): """Returns the square kilometers for configured scan area""" lat1 = config.MAP_START[0] lat2 = config.MAP_END[0] lon1 = config.MAP_START[1] lon2 = config.MAP_END[1] p1 = Point(lat1, lon1) p2 = Point(lat1, lon2) p3 = Point(lat1, lon1) p4 = Point(lat2, lon1) width = distance.distance(p1, p2).kilometers height = distance.distance(p3, p4).kilometers area = int(width * height) return area