def print_trip_story(device_id): bssid_map = {} has_unmapped_bssid = False with open(os.path.join(settings.BASE_DIR, 'algorithm', 'data', 'manual_bssid_map.txt'), 'r') as f: content = f.readlines() for line in content: line = line.strip('\n') if line and line[0] != '#': bssid_map[line.split(' ', 1)[0]] = line.split(' ', 1)[1] reports3 = analysis.models.Report.objects.filter(device_id = device_id).order_by('timestamp') prev_loc = None prev_has_bssid = False for report in reports3: #has_bssid = bssid in [x.key for x in report.get_wifi_set_all()] has_bssid = 'S-ISRAEL-RAILWAYS' in [x.SSID for x in report.get_wifi_set_all()] if prev_has_bssid != has_bssid: if has_bssid: start_time = ot_utils.get_localtime(report.timestamp) else: print start_time.date(), start_time.strftime("%H:%M:%S"), ot_utils.get_localtime(report.timestamp).strftime("%H:%M:%S"), report.device_id, has_bssid stop_bssids = [x.key for x in report.get_wifi_set_all() if x.SSID == 'S-ISRAEL-RAILWAYS'] if not all(x in bssid_map for x in stop_bssids): has_unmapped_bssid = True stop_bssids = [bssid_map[x] if x in bssid_map else x for x in stop_bssids] if stop_bssids: print ot_utils.get_localtime(report.timestamp).strftime("%H:%M:%S"), sorted(stop_bssids) #print ot_utils.get_localtime(report.timestamp), report.device_id, bssid, has_bssid, lat, lon, int(dist) #print report.timestamp, ot_utils.get_localtime(report.timestamp), report.device_id, bssid, has_bssid, lat, lon, int(dist) prev_loc = report.get_my_loc() prev_has_bssid = has_bssid if has_unmapped_bssid: print 'HAS UNMAPPED BSSID!!!' else: print 'All bssids mapped'
def PrintBSSIDReportsOnMap(bssid): #display_utils.draw_map() wifi_reports = analysis.models.SingleWifiReport.objects.filter(key = bssid) reports = list(set(x.report for x in wifi_reports)) #t = [((x.timestamp - x.get_my_loc().timestamp).total_seconds(), x.get_my_loc().accuracy) for x in reports] #t = sorted(t) #t = np.array(t) #a = [x.get_my_loc().accuracy for x in reports] ts = sorted([x.timestamp for x in reports]) import common.ot_utils as ot_utils sorted_reports = sorted(zip(ts, reports)) sorted_reports = [x[1] for x in sorted_reports] for x in sorted_reports: print x.id, x, ot_utils.get_localtime(x.timestamp), x.my_loc.lat, x.my_loc.lon ot_utils.get_localtime(ts[0]) ot_utils.get_localtime(ts[-1]) #plt.plot(t) #plt.plot(a) for i, report in enumerate(reports): print i if hasattr(report, 'my_loc'): plt.scatter(report.my_loc.lon, report.my_loc.lat, s=10) plt.show print 'done'
def print_stoptimes(self): stop_times = self.get_stop_times() print 'trip ' + self.gtfs_trip_id for stop in stop_times: arrival_str = ot_utils.get_localtime(stop.exp_arrival).strftime('%H:%M:%S') if ot_utils.get_localtime(stop.exp_arrival) is not None else '--:--:--' departure_str = ot_utils.get_localtime(stop.exp_departure).strftime('%H:%M:%S') if ot_utils.get_localtime(stop.exp_departure) is not None else '--:--:--' #delta_str = delta.strftime('%M:%S') if departure is not None else '--:--' print '%s %s %s' % (arrival_str, departure_str, stop.stop.stop_name)
def get_timestamp_israel_time(self): #local_time_delta = datetime.timedelta(0,2*3600) #return self.timestamp + local_time_delta from common.ot_utils import get_localtime timestamp = get_localtime(self.timestamp) timestamp = timestamp.replace(microsecond=0) return timestamp
def GetRedisData(redis_key, day=None): if day: redis_key += ':' + _DayToDayStr(day) if redis_key in redis_cache: return redis_cache[redis_key] data_json = load_by_key(redis_key) data = json.loads(data_json,object_hook=json_hook_dt) import dateutil.parser if type(data) == dict: for trip_id in data.keys(): if type(data[trip_id]) == dict and 'start_time' in data[trip_id].keys(): data[trip_id]['start_time'] = ot_utils.get_localtime(dateutil.parser.parse(data[trip_id]['start_time'])) data[trip_id]['end_time'] = ot_utils.get_localtime(dateutil.parser.parse(data[trip_id]['end_time'])) for stop_id in data[trip_id]['stops']: stop_data = data[trip_id]['stops'][stop_id] #stop_data[1] = ot_utils.get_localtime(dateutil.parser.parse(stop_data[1])) #stop_data[2] = ot_utils.get_localtime(dateutil.parser.parse(stop_data[2])) data[trip_id]['stops'][stop_id] = stop_data redis_cache[redis_key] = data return data
def load_from_gtfs(gtfs_stop_time, date): arrival = ot_utils.get_localtime(gtfs_stop_time.exp_arrival) departure = ot_utils.get_localtime(gtfs_stop_time.exp_departure) return DetectedStopTime(gtfs_stop_time.stop.gtfs_stop_id, arrival, departure)
def load_from_gtfs(gtfs_stop_time, date): arrival = ot_utils.db_time_to_datetime(gtfs_stop_time.arrival_time, date) arrival = ot_utils.get_localtime(arrival) departure = ot_utils.db_time_to_datetime(gtfs_stop_time.departure_time, date) departure = ot_utils.get_localtime(departure) return DetectedStopTime(gtfs_stop_time.stop.stop_id, arrival, departure)
def get_matched_trips(tracker_id, detected_stop_times, day): if len(detected_stop_times) == 0: return None detected_stop_ids = [x.stop_id for x in detected_stop_times] trip_datastore = TripDatastore(day) costops = trip_datastore.costop_matrix # beseder stop_ids = [x.stop_id for x in detected_stop_times] stop_ids_inds = [all_stops.id_list.index(x) for x in stop_ids] trips_with_visited_stops = trip_datastore.GetTripsByStops(stop_ids_inds) # beseder trip_in_right_direction = [] arrival_delta_abs_means_seconds = [] trips_filtered_by_stop_order = [] trips_filtered_by_stop_order_detected_stop_inds = [] for i, t in enumerate(trips_with_visited_stops): stops_dict = trip_datastore.trip_datastore[t]['stops'] start_time = trip_datastore.trip_datastore[t]['start_time'] end_time = trip_datastore.trip_datastore[t]['end_time'] detected_stop_times_in_time_range = [] for i, x in enumerate(detected_stop_times): arrival = x.arrival if start_time <= arrival and arrival <= end_time: detected_stop_times_in_time_range.append(x) filtered_detected_stop_times_stop_inds = [all_stops.id_list.index(x.stop_id) for x in detected_stop_times_in_time_range] impossible_stops_inds = trip_datastore.GetImpossibleCostops(filtered_detected_stop_times_stop_inds) # beseder impossible_stops_ids = [all_stops.id_list[x] for x in impossible_stops_inds] has_impossible_stops = bool([x for x in impossible_stops_ids if x in stops_dict]) if has_impossible_stops: continue gtfs_sequence_of_detected_stops = [] filtered_detected_stop_times = [] filtered_detected_stop_times_inds = [] for i, x in enumerate(detected_stop_times): # if checks for: # - stops that are detected and are in trip: # - stops that are in trip time range: arrival = x.arrival if ((x.stop_id in stops_dict and arrival <= end_time and ((stops_dict[x.stop_id][0] != 1 and start_time <= arrival) or (stops_dict[x.stop_id][0] == 1 and x.departure)))): # first stop in trip gtfs_sequence_of_detected_stops.append(stops_dict[x.stop_id][0]) filtered_detected_stop_times.append(x) filtered_detected_stop_times_inds.append(i) # filter by stop order and at least two detected stops: #4900 Tel Aviv HaHagana #3600 Tel Aviv - University #3700 Tel Aviv Center - Savidor #4600 Tel Aviv HaShalom has_tel_aviv_stop = bool([x for x in filtered_detected_stop_times if x.stop_id in [4900, 3600, 3700, 4600]]) non_tel_aviv_stops = len([x for x in filtered_detected_stop_times if x.stop_id not in [4900, 3600, 3700, 4600]]) stop_count_with_tel_aviv_as_one_stop = non_tel_aviv_stops + int(has_tel_aviv_stop) if stop_count_with_tel_aviv_as_one_stop >= 2: if is_increasing(gtfs_sequence_of_detected_stops): trips_filtered_by_stop_order.append(t) trips_filtered_by_stop_order_detected_stop_inds.append(filtered_detected_stop_times_inds) # calc deviation from gtfs arrival time: arrival_delta_abs_sum = 0 for detected_stop_time in filtered_detected_stop_times: stop_and_arrival_gtfs = stops_dict.get(detected_stop_time.stop_id) if stop_and_arrival_gtfs: exp_arrival = ot_utils.get_localtime(dateutil.parser.parse(stop_and_arrival_gtfs[1])) if stop_and_arrival_gtfs[0] == 1: # first stop in trip - compare departures arrival_delta_seconds = exp_arrival - detected_stop_time.departure else: arrival_delta_seconds = exp_arrival - detected_stop_time.arrival arrival_delta_abs_sum += abs(arrival_delta_seconds).total_seconds() arrival_delta_abs_mean = arrival_delta_abs_sum/len(filtered_detected_stop_times_inds) arrival_delta_abs_means_seconds.append(arrival_delta_abs_mean) trip_delays_ids = sorted(zip(arrival_delta_abs_means_seconds, trips_filtered_by_stop_order, trips_filtered_by_stop_order_detected_stop_inds)) trip_delays_ids_temp = trip_delays_ids trip_delays_ids_list_of_lists = [] while len(trip_delays_ids_temp) > 0: trip_delay_id_root = trip_delays_ids_temp[0] del trip_delays_ids_temp[0] if trip_delay_id_root[0] > 1800: # half an hour continue trip_delays_ids_list = [trip_delay_id_root] intersecting_trip_delays_ids = [x for x in trip_delays_ids_temp if trip_datastore.DoTripsIntersect(trip_delay_id_root[1], x[1])] trip_delays_ids_list += intersecting_trip_delays_ids trip_delays_ids_list_of_lists.append(trip_delays_ids_list) trip_delays_ids_temp = [x for x in trip_delays_ids_temp if x not in intersecting_trip_delays_ids] print trip_delays_ids_list_of_lists return trip_delays_ids_list_of_lists