def location_by_coordinate(r, lat, lon):
""" calculate distance from the most upstream rnode to the given coordinates
**Limitation :**
it supports calculation of the location on the same corridor
which the most upstream rnode belongs
:type r: pyticas.ttypes.Route
:type lat: float
:type lon: lon
:rtype: float
"""
upstream_rnode = r.rnodes[0]
corr = upstream_rnode.corridor
(upnode, dnnode) = geo.find_updown_rnodes(lat, lon, corr.rnodes, d_limit=1)
if not upnode:
return False
f_done = False
# check to downstream
dist = distutil.distance_in_mile_with_coordinate(upnode.lat, upnode.lon,
lat, lon)
cur_node = upstream_rnode
for next_node in geo.iter_to_downstream(upstream_rnode):
dist += distutil.distance_in_mile(cur_node, next_node)
if upnode == next_node:
f_done = True
break
cur_node = next_node
if not f_done:
# check to upstream
dist = distutil.distance_in_mile_with_coordinate(
dnnode.lat, dnnode.lon, lat, lon)
cur_node = upstream_rnode
for next_node in geo.iter_to_upstream(upstream_rnode):
dist += distutil.distance_in_mile(cur_node, next_node)
if dnnode == next_node:
f_done = True
break
cur_node = next_node
if f_done:
dist = -1 * dist
if f_done:
return dist
else:
return False
def find_nearby_sites(s_lat, s_lon):
""" return RWIS site list order by distance (from nearest)
:type s_lat: float
:type s_lon: float
:return: RWIS site list
:rtype: list[RWISSiteInfo]
"""
sites = []
for gr in cfg.RWIS_SITE_INFO:
for st in gr['sites']:
d = distance.distance_in_mile_with_coordinate(
s_lat, s_lon, st['lat'], st['lon'])
sites.append(
RWISSiteInfo({
'group_id': gr['id'],
'group_name': gr['name'],
'site_id': st['id'],
'site_name': st['name'],
'lat': st['lat'],
'lon': st['lon'],
'distance_to_target': d
}))
return sorted(sites, key=lambda s: s.distance_to_target)
def route_length(route):
starting_r_node = route.rnodes[0]
ending_r_node = route.rnodes[-1]
distance = distance_util.distance_in_mile_with_coordinate(
starting_r_node.lat, starting_r_node.lon, ending_r_node.lat,
ending_r_node.lon)
return distance
def _find_iris_data(iris_data_bucket, cad_incident_info):
"""
:type iris_data_bucket: dict[str, list[pyticas_tetres.ttypes.IrisIncidentInfo]]
:type cad_incident_info: pyticas_tetres.ttypes.CADIncidentInfo
:rtype: pyticas_tetres.ttypes.IrisIncidentInfo
"""
evt_date = cad_incident_info.str2datetime(
cad_incident_info.cdts).strftime('%Y-%m-%d')
iris_data_list = iris_data_bucket.get(evt_date, [])
if not iris_data_list:
return None
for iris_data in iris_data_list:
distance = distutil.distance_in_mile_with_coordinate(
iris_data.lat, iris_data.lon, cad_incident_info.lat,
cad_incident_info.lon)
if distance > DISTANCE_THRESHOLD_FOR_SAME_EVENT:
continue
timediff = iris_data.str2datetime(
iris_data.event_date) - cad_incident_info.str2datetime(
cad_incident_info.cdts)
if (timediff.seconds / 60 < TIMEDIFF_THRESHOLD_FOR_SAME_EVENT):
return iris_data
return None
def _find_iris_data(iris_data_bucket, cad_incident_info):
"""
:type iris_data_bucket: dict[str, list[pyticas_tetres.ttypes.IrisIncidentInfo]]
:type cad_incident_info: pyticas_tetres.ttypes.CADIncidentInfo
:rtype: pyticas_tetres.ttypes.IrisIncidentInfo
"""
evt_date = cad_incident_info.str2datetime(cad_incident_info.cdts).strftime('%Y-%m-%d')
iris_data_list = iris_data_bucket.get(evt_date, [])
if not iris_data_list:
return None
for iris_data in iris_data_list:
try:
iris_description = iris_data.description
iris_classification = iris_description.split()[1]
except:
iris_classification = ""
cad_classification = cad_incident_info.iris_class
if cad_classification and iris_classification:
if str(cad_classification).lower() != str(iris_classification).lower():
continue
distance = distutil.distance_in_mile_with_coordinate(iris_data.lat, iris_data.lon, cad_incident_info.lat,
cad_incident_info.lon)
if distance > DISTANCE_THRESHOLD_FOR_SAME_EVENT:
continue
timediff = iris_data.str2datetime(iris_data.event_date) - cad_incident_info.str2datetime(cad_incident_info.cdts)
if (timediff.seconds / 60 < TIMEDIFF_THRESHOLD_FOR_SAME_EVENT):
return iris_data
return None
def find_close_rnode(lat, lon, RNODE_CACHE, **kwargs):
corridor_name = kwargs.get('cooridor_name', None)
min_dist = sys.maxsize
min_rnode = None
for rnode in RNODE_CACHE.values():
if corridor_name and corridor_name not in rnode.corridor.name:
continue
d = distance_in_mile_with_coordinate(lat, lon, rnode.lat, rnode.lon)
if d < min_dist:
min_dist = d
min_rnode = rnode
return min_rnode
def minimum_distance(r, lat, lon):
"""
:type r: pyticas.ttypes.Route
:type lat: float
:type lon: lon
:rtype: float
"""
min_distance = sys.maxsize
for rn in r.rnodes:
d = distutil.distance_in_mile_with_coordinate(rn.lat, rn.lon, lat, lon)
if d < min_distance:
min_distance = d
return min_distance
def find_nearby_station(lat, lon, dt, station_list):
"""
:type lat: float
:type lon: float
:type dt: datetime.date
:type station_list: list[pyticas_noaa.isd.isdtypes.ISDStation]
:return: list of (distance, ISDStation) tuple from nearby station
:rtype: list[(float, pyticas_noaa.isd.isdtypes.ISDStation)]
"""
res = []
for st in station_list:
if st.begin > dt or st.end < dt:
continue
d = distance.distance_in_mile_with_coordinate(lat, lon, st.lat, st.lon)
res.append((d, st))
return sorted(res, key=lambda item: item[0])
def nearby_sensors(lat, lon):
"""
:param lat:
:param lon:
:rtype: (list[WeatherSensor], list[float])
"""
sensors = []
for v in WeatherSensor:
d = distance.distance_in_mile_with_coordinate(lat, lon, v.get_lat(),
v.get_lon())
sensors.append({'distance': d, 'sensor': v})
sorted_list = sorted(sensors, key=lambda s: s['distance'])
return [v['sensor']
for v in sorted_list], [v['distance'] for v in sorted_list]
def nearby_rnode(lat, lon, rnodes, d_limit=1):
"""
:type lat: float
:type lon: float
:type rnodes: list[pyticas.ttypes.RNodeObject]
:type d_limit: float
:rtype: pyticas.ttypes.RNodeObject, float
"""
min_dist = 999999
min_dist_rnode = None
for rn in rnodes:
d = distutil.distance_in_mile_with_coordinate(lat, lon, rn.lat, rn.lon)
if d < min_dist and d <= d_limit:
min_dist = d
min_dist_rnode = rn
return min_dist_rnode, min_dist
