def __getitem__(self, key):
if key in self.trip_ids:
if not self.trip_data:
return Trip(key,
self.driverSource.get_data_for_trip(self.Id, key))
else:
return Trip(key, self.trip_data[key - 1])
else:
return None
def conf_cancel_trip(message):
if message.text == "Да":
bot.send_message(message.chat.id, "Поиск отменен")
status_trip_pas = 4
Trip.change_trip_pas(chat_id, status_trip_pas)
Trip.START_TRIP(message)
else:
bot.send_message(message.chat.id,
"Введено не верно. Повторите попитку")
bot.register_next_step_handler(message, conf_cancel_trip)
def add_trip(self, depart, arrive, start, end, weekday, price, bus):
new_trip = Trip.Trip()
new_trip.departs_from = depart
new_trip.arrives_at = arrive
new_trip.start_time = start
new_trip.end_time = end
new_trip.weekday = weekday
new_trip.price = price
new_trip.bus = bus
Trip.Trip().add_trip(new_trip)
def trip_price(message):
global price
global chat_id
date_Create = time.strftime("%Y.%m.%d", time.localtime())
chat_id = message.chat.id
price = int(message.text)
bot.send_message(message.chat.id, "Поиск машины")
keyboard = types.ReplyKeyboardMarkup(row_width=1, resize_keyboard=True)
button_geo = types.KeyboardButton(text="Отменить")
keyboard.add(button_geo)
bot.send_message(message.chat.id,
"Для отмены нажмите кнопку... Отменить ",
reply_markup=keyboard)
Trip.trip_pas(dispatch, expectation, price, lon_pas, lat_pas, chat_id,
date_Create)
bot.register_next_step_handler(message, cancel_trip)
def submit():
#trip = Tk()
#trip.title('Hello')
viewDict = Trip.tripRecom(cityValue.get().encode('utf-8'))
for trip_name in range(len(viewDict)):
name = viewDict[trip_name][0]
Radiobutton(root, text=[name], variable=var, value=trip_name, command=lambda :selViewpoint(viewDict)).grid(row=2+trip_name,column=1)
def initTrips(calls):
"initialises trips deemed single journeys"
trips = []
items = calls.split(',')
for item in items:
trips.append(Trip.Trip(item))
return trips
def createTrip():
expectedParams = [
"creatorAccountID", "creatorAccountPassword", "tripName",
"tripMemberAccountIDs"
]
if not utils.hasExpectedParams(expectedParams, request):
tripSquadAPI.logger.error(
"createTrip -- Required params not found in request")
abort(400)
[creatorAccountID, creatorPassword, tripName,
tripMemberAccountIDsStr] = utils.parseParams(expectedParams, request)
tripMemberAccountIDs = utils.parseAPIList(tripMemberAccountIDsStr)
if not Account.validateAccount(creatorAccountID, creatorPassword):
tripSquadAPI.logger.error("createTrip -- %s User not validated" %
creatorAccountID)
abort(400)
newTrip = Trip.createTrip(tripMemberAccountIDs, tripName=tripName)
if not newTrip:
tripSquadAPI.logger.error("createTrip -- failure in db insertion")
abort(500)
response = {"tripID": newTrip.ID}
return json.jsonify(response)
def getTripTotal(tripID):
requiredParams = ["accountID", "password"]
if not utils.hasExpectedParams(requiredParams, request):
tripSquadAPI.logger.error(
"getTripTotal -- Required params not found in request")
abort(400)
[accountID, password] = utils.parseParams(requiredParams, request)
if not Account.validateAccount(accountID, password):
tripSquadAPI.logger.error("getTripTotal -- Incorrect password given.")
abort(400)
trip = Trip.getTripByID(tripID)
if not trip:
tripSquadAPI.logger.error("getTripTotal -- %s trip not valid" % tripID)
abort(400)
if not trip.includesAccount(accountID):
tripSquadAPI.logger.error("addPurchase -- %s ID not valid" % accountID)
abort(400)
tripPurchases = Purchase.getPurchasesByTripID(trip.ID)
# TODO: totalPurchasesByPerson = Purchases.getPurchasesByPerson(totalPurchases)
totalPurchaseSum = sum(
[int(purchase.purchaseAmount) for purchase in tripPurchases])
response = {"tripID": tripID, "total": totalPurchaseSum}
return json.jsonify(response)
def _ScheduleFirstTrip(self):
"""
_ScheduleFirstTrip -- schedule the first trip, this is a unique situation because the world time
might be in the middle of the current day, start the trip where the traveler would be at that time
"""
source = self.LocationKeyMap.ResolveLocationKey('home')
while self.EventList.MoreTripEvents():
tripev = self.EventList.PopTripEvent()
starttime = float(tripev.StartTime)
if starttime > self.Connector.WorldTime:
destination = self.LocationKeyMap.ResolveLocationKey(
tripev.DstName)
self.Connector.AddTripToEventQueue(
Trip.Trip(self, starttime, source, destination))
logger.info('Scheduled trip of to %s for %s from %s to %s',
tripev.DstName, self.Person.Name, source.Name,
destination.Name)
return
# this just allows us to start in the middle of the day, traveler at work
# will start at work rather than starting at home, we start wherever we
# supposedly ended the last trip
source = self.LocationKeyMap.ResolveLocationKey(tripev.DstName)
logger.info('No trip events for %s', self.Person.Name)
def _ScheduleNextTrip(self, source):
"""
_ScheduleNextTrip -- schedule the next trip for this traveler
"""
if not self.EventList:
return
# this builds out daily events up to one week in the future with
# the idea that we should be able to go through at least a full
# work week looking for something interesting to happen
for day in range(0, 7):
if self.EventList.MoreTripEvents(): break
self.BuildDailyEvents(self.Connector.WorldDay + day + 1)
tripev = self.EventList.PopTripEvent()
starttime = float(tripev.StartTime)
# there is a reasonable chance that this is a moot trip (for example, a person
# works at a coffee shop and gets their coffee there, if that happens then
# just skip this trip & schedule another one, an alternative would be to
# drop the work place from all choices of service destinations
destination = self.LocationKeyMap.ResolveLocationKey(tripev.DstName)
if source.Name == destination.Name:
return self._ScheduleNextTrip(source)
self.Connector.AddTripToEventQueue(
Trip.Trip(self, starttime, source, destination))
logger.info('Scheduled trip of to %s for %s from %s to %s',
tripev.DstName, self.Person.Name, source.Name,
destination.Name)
def location_drive(message, num, count):
global order1
global order2
global order3
global order4
global order5
order1, order2, order3, order4, order5 = Trip.active_search_passenger(
message, num, count, lon_dr, lat_dr)
def get_data_random_trip(self):
random_trip_data = None
random_trip_num = rnd.sample(self.trip_ids, 1)[0]
if self.trip_data is not None:
random_trip_data = self.trip_data[int(random_trip_num) - 1]
else:
random_trip_data = self.driverSource.get_data_for_trip(
self.Id, int(random_trip_num))[0]
rand_trip = Trip(random_trip_num, random_trip_data)
return rand_trip
def submit():
#trip = Tk()
#trip.title('Hello')
tripName = Trip.tripRecom(cityValue.get().encode('utf-8'))
for trip_name in range(shape(tripName['result'])[0]):
name = tripName['result'][trip_name]['title'].encode('utf-8')
Radiobutton(root,
text=[name],
variable=var,
value=trip_name,
command=lambda: selViewpoint(tripName)).grid(row=2 +
trip_name,
column=1)
def get_all_trips(self, find_matches=True):
if self.trip_data is None:
self.trip_data = self.driverSource.get_data_for_multiple_trips(
self.Id, self.trip_ids)
if find_matches:
if self.matching_trips is None:
self.build_matching_trip_set()
self.trip_object_list = [
Trip(id, data) for id, data in zip(self.trip_ids, self.trip_data)
]
return self.trip_object_list
def get_trip_ids_near_network_stops(trip_dict, network_layers, test_dist_m,
candidate_trip_ids=None):
"""Filter down to a list of trips that are within a max distance of any of
the network geometries passed in."""
comp_srs = osr.SpatialReference()
comp_srs.ImportFromEPSG(geom_utils.COMPARISON_EPSG)
stops_multipoint = ogr.Geometry(ogr.wkbMultiPoint)
for layer in network_layers:
# set up transform
tform = osr.CoordinateTransformation(
layer.GetSpatialRef(), comp_srs)
for stop_feat in layer:
tform_geom = stop_feat.GetGeometryRef()
tform_geom.Transform(tform)
stops_multipoint.AddGeometry(tform_geom)
layer.ResetReading()
bbox = stops_multipoint.GetEnvelope()
trip_ids_match_criteria = []
if not candidate_trip_ids:
candidate_trip_ids = trip_dict.iterkeys()
trips_srs = Trip.get_trips_srs()
tform_latlon_to_comp = osr.CoordinateTransformation(
trips_srs, comp_srs)
for trip_id in candidate_trip_ids:
trip = trip_dict[trip_id]
pt_o = trip[Trip.ORIGIN]
pt_d = trip[Trip.DEST]
geom_o = ogr.Geometry(ogr.wkbPoint)
geom_d = ogr.Geometry(ogr.wkbPoint)
geom_o.AddPoint(*pt_o)
geom_d.AddPoint(*pt_d)
geom_o.Transform(tform_latlon_to_comp)
geom_d.Transform(tform_latlon_to_comp)
pt_tform_o = geom_o.GetPoint()
pt_tform_d = geom_d.GetPoint()
if geom_utils.within_bbox(pt_tform_o, bbox) \
and geom_utils.within_bbox(pt_tform_d, bbox) \
and geom_o.Distance(stops_multipoint) < test_dist_m \
and geom_d.Distance(stops_multipoint) < test_dist_m:
trip_ids_match_criteria.append(trip_id)
geom_o.Destroy()
geom_d.Destroy()
return trip_ids_match_criteria
def addPurchase(tripID):
requiredParams = [
"purchaserAccountID", "purchaserAccountPassword", "purchaseAmount"
]
if not utils.hasExpectedParams(requiredParams, request):
tripSquadAPI.logger.error(
"addPurchase -- Required params not found in request")
abort(400)
allParams = requiredParams + ["description"]
[
purchaserAccountID, purchaserAccountPassword, purchaseAmountStr,
purchaseDescription
] = utils.parseParams(allParams, request)
purchaseAmount = 0
try:
purchaseAmount = int(purchaseAmountStr)
except ValueError:
tripSquadAPI.logger.error(
"addPurchase -- %s purchaseAmount not valid" % purchaseAmountStr)
abort(400)
if not Account.validateAccount(purchaserAccountID,
purchaserAccountPassword):
tripSquadAPI.logger.error("addPurchase -- %s User not validated" %
purchaserAccountID)
abort(400)
trip = Trip.getTripByID(tripID)
if not trip:
tripSquadAPI.logger.error("addPurchase -- %s trip not valid" % tripID)
abort(400)
if not trip.includesAccount(purchaserAccountID):
tripSquadAPI.logger.error("addPurchase -- %s ID not valid" %
purchaserAccountID)
abort(400)
tripMemberID = TripMember.getTripMemberID(purchaserAccountID, tripID)
newPurchase = Purchase.createPurchase(tripMemberID,
purchaseAmount,
description=purchaseDescription)
if not newPurchase:
tripSquadAPI.logger.error("addPurchase -- failure in db insertion")
abort(500)
response = {"purchaseID": newPurchase.ID}
return json.jsonify(response)
def get_data(self):
"""
Считывае параметры (KPI) всех траекторий водителя
"""
self.trips = []
self.kpis = pd.DataFrame(None)
trip_file_path = DRIVER_PATH + '/' + str(self.driver_num) + '/'
files = os.listdir(trip_file_path)
trips = [int(os.path.splitext(f)[0]) for f in files]
if DEBUG >= 1:
trips = random.sample(trips, NUM_TRIP)
for trip_num in sorted(trips):
trip = Trip.Trip(self.driver_num, trip_num)
self.trips.append(trip)
self.kpis = self.kpis.append(trip.kpi, ignore_index=True)
self.kpis.sort(['driver_num', 'trip_num'], inplace=True)
def YES_TRIP_DR(call):
Trip.change_trip_pas(chat_id_passenger, 2)
time_arrival_drive(call.message) # Запрос на время прибытия
def __init__(self):
self.neighbourClass = trip.Trip()
def add_trips(self, trip=None):
if trip == None:
self.trips.append(Trip(shopper_id=self.shopper_id))
else:
self.trips.append(trip)
def NO_TRIP_DR(call):
Trip.START_SEARCH_PAS(call.message)
def trip_assessment(self, top_ten, customers, graph, stores, trip_size=3):
"""
:top_ten: top ten target customers for generating the trips
:customers: list of all customers with their data attributes
:graph: underlying network structure
:stores: list of all stores
:trip_size: 1,2 or 3
return: list of customers with updated data
"""
curr_store = self.get_current_location()
stores = np.array(stores)
# ** Check whether current location is a Store, if not, send the shopper to a nearby store.
if np.sum(np.isin(stores, curr_store)) > 0:
self.go_to_store(stores, graph, distance='randomize')
visited_customers = Customer.find_visited_customers(customers)
if visited_customers.size == len(customers):
print("All Customers have been visited")
return customers
if visited_customers.size > len(customers) - trip_size:
trip_size = len(customers) - visited_customers.size
all_trp = list(combinations(top_ten, trip_size))
all_trp2 = [list(c) for c in all_trp]
all_trp2_2 = [list(set(permutations(c))) for c in all_trp2]
all_trp2_2_1 = [y for x in all_trp2_2 for y in x]
all_trp22 = [list(t) for t in all_trp2_2_1]
all_trp3 = [np.array([curr_store] + c) for c in all_trp22]
if trip_size == 3:
all_trp4 = list(
map(
lambda x: np.array([[x[0], x[1]], [x[1], x[2]],
[x[2], x[3]]]), all_trp3))
elif trip_size == 2:
all_trp4 = list(
map(lambda x: np.array([[x[0], x[1]], [x[1], x[2]]]),
all_trp3))
elif trip_size == 1:
all_trp4 = list(map(lambda x: np.array([[x[0], x[1]]]), all_trp3))
else:
print("Trip size must be either 1,2 or 3!")
return
del (all_trp, all_trp2, all_trp22, all_trp3) # clear up memory
travel_time = [graph.find_trip_time(c) for c in all_trp4]
customer_table = defaultdict(int)
for c in customers:
customer_table[c.get_id()] = c
cust_list = [list(c[:, 0]) for c in travel_time]
items = [[customer_table[c].get_item_count() for c in t]
for t in cust_list]
node_due_time = [[customer_table[c].get_due_time() for c in t]
for t in cust_list]
store_time = [sum(c) + 5 for c in items]
trv_time = [list(c[:, 1]) for c in travel_time
] # travel time to each individual node from the store
assert (len(store_time) == len(trv_time))
node_arr_time = [accumulate(s) for s in trv_time]
node_arrival_time = []
for i in range(len(store_time)):
node_arrival_time.append([
store_time[i] + self.current_time + s for s in node_arr_time[i]
])
arrv_vec = np.array(node_arrival_time)
due_vec = np.array(node_due_time)
violations = [
list(s) for s in list(abs(np.subtract(arrv_vec, due_vec)))
] #violations of each node in a trip
total_viol = [sum(s)
for s in violations] # total violations of each trip
min_idx = np.argmin(
np.array(total_viol)) # index of the minimum violations
trip = cust_list[min_idx]
trip_nodes = [self.get_current_location()] + trip # store + customers
trip_arr_times = [self.get_current_time()] + node_arrival_time[
min_idx] # current time & arrv times of customers
trip_violations = [0] + violations[min_idx]
curr_trip = Trip(self.get_shopper_id(), trip_nodes, trip_arr_times,
trip_violations)
self.add_trips(curr_trip)
# ** Update the visit customers data:
for i in range(len(trip)):
customer_table[trip[i]].set_visit_time(
node_arrival_time[min_idx][i])
customer_table[trip[i]].set_shopper(self.get_shopper_id())
self.set_current_time(
node_arrival_time[min_idx][-1]) # Set the current time for shopper
self.set_current_location(trip[-1])
return customers
def exchange_route(self, other, customers, graph, stores):
"""
"""
if not isinstance(other, Shopper):
print("Argument must be a Shopper Object!")
return
customer_table = defaultdict(int)
for c in customers:
customer_table[c.get_id()] = c
# ** Get the list of trips for both shoppers:
self_trips = self.get_trips()
other_trips = other.get_trips()
# ** Get the last trip generated for both shoppers:
self_trip = self_trips[-1]
other_trip = other_trips[-1]
self_t = self_trip.get_customers()
other_t = other_trip.get_customers()
# *** Get the total violations of each trip before swap:
curr_total_viol = self_trip.get_total_violations(
) + other_trip.get_total_violations()
switch_nodes_idx = self_trip.nodes_to_switch(
other_trip) # indices of the nodes that can be switched!
if len(switch_nodes_idx) == 0:
return
elif len(switch_nodes_idx) == 1:
n = switch_nodes_idx[
0] # pick the first node (for both trips) to be exchanged
elif len(switch_nodes_idx) > 1:
n = switch_nodes_idx[1]
# *** new trips with exchanged routes:
new_self_t = self_t[0:n] + other_t[n:len(other_t)]
new_other_t = other_t[0:n] + self_t[n:len(self_t)]
new_self_trip = copy.deepcopy(new_self_t)
new_other_trip = copy.deepcopy(new_other_t)
new_trip_list = []
new_trip_list.extend((new_self_trip, new_other_trip))
# ** Start-Time at stores:
self_start = self_trip.get_visit_time()[0]
other_start = other_trip.get_visit_time()[0]
start_time_list = []
start_time_list.extend((self_start, other_start))
new_total_viol,new_trip_nodes,new_trip_arrv_times,new_total_viol = \
Shopper.evaluate_trips(new_trip_list,start_time_list,customers,graph,stores)
# *** If violations didn't improve stop
if sum(new_total_viol) >= curr_total_viol:
return customers
print(" $$$$$----- USEFUL SWAP -----$$$$$")
# *** If violations improved Update customers and shoppers data:
self_trip_new = Trip(self.get_shopper_id(), new_trip_nodes[0],
new_trip_arrv_times[0], list(new_total_viol[0]))
other_trip_new = Trip(other.get_shopper_id(), new_trip_nodes[1],
new_trip_arrv_times[1], list(new_total_viol[1]))
# ** Drop the last trips of both shoppers to be able to swap some customers
self.drop_last_trip()
other.drop_last_trip()
# *** Add new trips:
self.add_trips(self_trip_new)
other.add_trips(other_trip_new)
# #** Update the visit customers data:
# ** self shopper:
for i in range(len(new_self_trip)):
customer_table[new_self_trip[i]].set_visit_time(
new_trip_arrv_times[0][i])
customer_table[new_self_trip[i]].set_shopper(self.get_shopper_id())
# ** other shopper:
for i in range(len(new_other_trip)):
customer_table[new_other_trip[i]].set_visit_time(
new_trip_arrv_times[1][i])
customer_table[new_other_trip[i]].set_shopper(
other.get_shopper_id())
#
self.set_current_time(
new_trip_arrv_times[0][-1]) # Set the current time for shopper
self.set_current_location(new_self_trip[-1])
other.set_current_time(
new_trip_arrv_times[1][-1]) # Set the current time for shopper
other.set_current_location(new_other_trip[-1])
return customers
def generateFeatures(driversDataPath, driverLimit = 10000):
import os
import glob
driverIndex = 0;
tripIndex = 0;
''' read drivers directory '''
for dId in sorted(os.listdir(driversDataPath)):
print " driver: index %s name %s " % (driverIndex, dId)
driver = Driver(driverIndex, dId)
tripIndex = 0
''' for each driver read the trip files, one file at a time and
compute the features and stores them in the Trip object
'''
folder = '%s/%s/*.csv'%(driversDataPath, dId)
for f in sorted( glob.glob(folder) ):
#print " f: ", f
fileName = os.path.basename(f)
[name, ext] = os.path.splitext(fileName)
tripMatrix = []
features = []
''' data sample rate is 1 sec '''
tripMatrix = np.loadtxt(f, delimiter=',', skiprows=1)
''' distances '''
distances = getDistances(tripMatrix)
medianDist = np.median(distances)
meanDist = np.mean(distances)
stdDist = np.std(distances)
maxDist = distances.max()
tripTime = len(tripMatrix)
tripDist = distances.sum()#np.sum(distances)
''' distance features '''
features.append(tripDist)
features.append(tripTime)
features.append(maxDist)
features.append(stdDist)
features.append(meanDist)
features.append(medianDist)
variances = getPCAVariance(tripMatrix)
xVariance = variances[0]
yVariance = variances[1]
''' xy variance features '''
features.append(xVariance)
features.append(yVariance)
''' stops '''
stopCount = getStops(tripMatrix)
dataJumpCount = getDataJumps(distances)
''' stops and jumps features '''
features.append(stopCount)
features.append(dataJumpCount)
'''speeds '''
speeds = distances
medianSpeed = np.median(speeds)
meanSpeed = np.mean(speeds)
maxSpeed = speeds.max()
mimSpeed = speeds.min()
stdSpeed = np.std(speeds)
'''speeds features '''
features.append(maxSpeed)
features.append(mimSpeed)
features.append(stdSpeed)
features.append(meanSpeed)
features.append(medianSpeed)
''' accelerations - derivative of speed'''
accels = np.diff(speeds)
[minAccel, maxAccel, totalAccel] = getMinMaxPos(accels)
[minDecel, maxDecel, totalDecel] = getMinMaxNeg(accels)
''' accelerations features '''
features.append(maxAccel)
features.append(minAccel)
features.append(totalAccel)
features.append(maxDecel)
features.append(minDecel)
features.append(totalDecel)
''' jerks - derivative of acceleration'''
jerks = np.diff(accels)
[minAccelJerk, maxAccelJerk, totalAccelJerck] = getMinMaxPos(jerks)
[minDecelJerk, maxDecelJerk, totalDecelJerck] = getMinMaxNeg(jerks)
''' jerk features '''
features.append(maxAccelJerk)
features.append(minAccelJerk)
features.append(totalAccelJerck)
features.append(maxDecelJerk)
features.append(minDecelJerk)
features.append(totalDecelJerck)
''' angles '''
angles, originAngles = getAngles(tripMatrix)
maxAngle = angles.max()
minAngle = angles.min()
totalAngle = angles.sum()
meanAngle = np.mean(angles)
medianAngle = np.median(angles)
''' angles features '''
features.append(maxAngle)
features.append(minAngle)
features.append(meanAngle)
features.append(medianAngle)
features.append(totalAngle)
''' angularVelocity '''
angularSpeeds = angles * speeds
maxAngularSpeed = angularSpeeds.max()
minAngularSpeed = angularSpeeds.min()
medianAngularSpeed = np.median(angularSpeeds)
meanAngularSpeed = np.mean(angularSpeeds)
features.append(maxAngularSpeed)
features.append(minAngularSpeed)
features.append(meanAngularSpeed)
features.append(medianAngularSpeed)
''' instantiate Trip object '''
trip = Trip(tripIndex, name, tripTime, tripDist)
''' add the feature list to the current trip'''
trip.setFeatureList(features)
''' add the trip to the driver '''
driver.addTrip(trip)
del trip #the local trip should be dealocated every loop
tripIndex += 1
''' add driver to the manager. At this point the driver has
all the trips with the corresponding features
'''
driverMgr.addDriver(driver);
del driver #the local driver should be dealocated every loop
driverIndex += 1
''' to get out of the drivers loop - for testing only '''
if driverIndex > driverLimit:
break
def continue_search(message):
count, num = Trip.continue_search(message)
location_drive(message, num, count)
def time10(call):
global time_arrival
time_arrival = 10
Trip.message_for_passenger(call.message, time_arrival, chat_id_passenger,
chat_id_drive)
accepted_teip_drive(call.message, time_arrival)
def MITSpeedAlgorithm(read_from, start_time, kill_time, fileName):
#####################################
# #
# PART 1: #
# CONDENSE DUPLICATES #
# #
#####################################
# We will be using a NxN Grid, where each region has a set of nodes
# to make it easier to seek out nodes
max_speed = 5 # meters per second
n = 20
# Gets all of the nodes
grid_of_nodes = get_correct_nodes(n, None, None)
node_info = get_node_range()
trip_file = csv.reader(open(read_from, 'rb'))
t_agg = []
# Each keeps track of distinct trips, so we can filter out duplicates and
# replace them with a great average trip
dictionary_cab = dict()
dictionary_time_agg = dict()
dictionary_counter = dict()
dictionary_distance = dict()
header = True
for row in trip_file:
if not header:
if row[5] > str(kill_time):
print row[5]
break
if row[5] >= str(start_time):
try:
beginnode = find_nodes(float(row[10]), float(row[11]),
grid_of_nodes, node_info, n)
end_node = find_nodes(float(row[12]), float(row[13]),
grid_of_nodes, node_info, n)
except (ValueError):
continue
if beginnode is None or end_node is None:
continue
newEntry = (beginnode.node_id, end_node.node_id)
dictionary_cab[newEntry] = row
if newEntry in dictionary_time_agg:
dictionary_time_agg[newEntry] += float(
(create_datetime(row[6]) -
create_datetime(row[5])).seconds)
dictionary_distance[newEntry] += float(row[9])
dictionary_counter[newEntry] += 1
else:
dictionary_time_agg[newEntry] = float(
(create_datetime(row[6]) -
create_datetime(row[5])).seconds)
dictionary_distance[newEntry] = float(row[9])
dictionary_counter[newEntry] = 1
header = False
# Replaces the single trip with a trip object and adds it to our set of
# all trips
for key in dictionary_time_agg:
# The current trip row
t = dictionary_cab[key]
new_time = dictionary_time_agg[key] / dictionary_counter[key]
new_dist = dictionary_distance[key] / dictionary_counter[key]
# The new trip array that initializes a trip object
new_tripList = [
t[0], new_time, new_dist, t[10], t[11], t[12], t[13], key[0],
key[1], dictionary_counter[key]
]
new_trip = Trip(new_tripList)
t_agg.append(new_trip)
print len(t_agg)
#####################################
# #
# PART 2: #
# REMOVE SHORT/longitude #
# #
#####################################
# This removes any trip that starts and ends at the same node, as long as
# extremely short or extremely long trips
t_agg = remove_loop_trips(t_agg)
t_agg = remove_extreme_trips(t_agg)
#####################################
# #
# PART 3: #
# COMPUTE tripS #
# #
#####################################
for trip in t_agg:
path = AStar(trip.start_long, trip.start_lat, trip.end_long,
trip.end_lat, grid_of_nodes, node_info, n, max_speed)
trip.nodeList = path
#####################################
# #
# PART 4: #
# REMOVE FAST/SLOW #
# #
#####################################
t_agg = remove_speed_trips(t_agg)
print len(t_agg)
#############################################
#############################################
# #
# PART 5: #
# ITERATIVE PART #
# #
#############################################
#############################################
# MIRROR OF PSUEDO CODE: PART 5.1, SET AGAIN = TRUE
again = True
# This is a dictionary of sets - give it a streetID (start_node.node_id,
# end_node.node_id) and it will return the set of trips that include that
# street and O_s
dict_of_streets = dict()
time_outer_loop = 0
time_inner_loop = 0
iter_outer_loop = 0
iter_inner_loop = 0
##########################################
# #
# PART 5.3: #
# OUTTER LOOP #
# #
##########################################
while again:
# Now the we are out of the Inner Loop, we must reset the times
# associated with each trip
print "Outer Loop!"
start = timeit.default_timer()
for _id in dict_of_streets:
tripsWithStreet = dict_of_streets[_id][0]
# All the streets have the street, so we can pick any one
random_trip = next(iter(tripsWithStreet))
# node_tuple[0] = start_node, node_tuple[1] = end_node
node_tuple = random_trip.node_dict[_id]
new_time = node_tuple[0].distance_connections[node_tuple[1]] / (
node_tuple[0].speed_connections[node_tuple[1]])
node_tuple[0].time_connections[node_tuple[1]] = new_time
print "End of resetting times"
# We now have an entirely new set of streets used
# so we must reset the old dictionary
dict_of_streets = dict()
again = False
rel_error = 0
# We find new paths based off of the new times we got
for trip in t_agg:
path = AStar(trip.start_long, trip.start_lat, trip.end_long,
trip.end_lat, grid_of_nodes, node_info, n, max_speed)
trip.nodeList = path
trip.node_dict = build_dictionary(path)
for _id in trip.node_dict:
if _id in dict_of_streets:
dict_of_streets[_id][0].add(trip)
else:
dict_of_streets[_id] = (set(), 0)
dict_of_streets[_id][0].add(trip)
trip.est_time = find_time(path)
rel_error += abs(trip.est_time - trip.trip_time) / trip.trip_time
print "End of getting rel_error, finding paths, " + (
"filling dictionaryand getting streetIDs")
# Offset Computation
for _id in dict_of_streets:
offSet = 0
for trip in dict_of_streets[_id][0]:
offSet += (trip.est_time - trip.trip_time) * trip.numtrips
dict_of_streets[_id] = (dict_of_streets[_id][0], offSet)
print "End of calculating offset coefficients"
k = 1.2
stop = timeit.default_timer()
time_outer_loop += (stop - start)
iter_outer_loop += 1
print stop - start
##########################################
# #
# PART 5.3: #
# INNER LOOP #
# #
##########################################
print "Inner Loop!"
# MIRROR OF PSUEDO CODE: PART 5.3, INNER LOOP
# (KEEP TRACK OF FASTEST SPEED HERE)
while True:
start = timeit.default_timer()
# Recalculates the time with a different ratio
for _id in dict_of_streets:
tripsWithStreet = dict_of_streets[_id][0]
# It doesn't matter what trip we take from this set, as they
# all include this street
random_trip = next(iter(tripsWithStreet))
node_tuple = random_trip.node_dict[_id]
if dict_of_streets[_id][1] < 0:
node_tuple[0].time_connections[node_tuple[1]] = (
node_tuple[0].time_connections[node_tuple[1]] * k)
else:
node_tuple[0].time_connections[node_tuple[1]] = (
node_tuple[0].time_connections[node_tuple[1]] / k)
# Figures out what the error would be under these new time
# constraints
new_rel_error = 0
for trip in t_agg:
etPrime = find_time(trip.nodeList)
new_rel_error += abs(etPrime -
trip.trip_time) / (trip.trip_time)
# Our new times are more accurate - time to redo everything
if new_rel_error < rel_error:
# We are going to have a new fastest speed
max_speed = -1
rel_error = new_rel_error
# Since our new times are better, we ReUpdate the speed based
# off these new times
for _id in dict_of_streets:
tripsWithStreet = dict_of_streets[_id][0]
# It doesn't matter what trip we take from this set
# as they all include this street
random_trip = next(iter(tripsWithStreet))
node_tuple = random_trip.node_dict[_id]
new_speed = (
node_tuple[0].distance_connections[node_tuple[1]] /
node_tuple[0].time_connections[node_tuple[1]])
if new_speed > max_speed:
max_speed = new_speed
node_tuple[0].speed_connections[node_tuple[1]] = new_speed
again = True
else:
# Continue reducing k
iter_inner_loop += 1
k = 1 + (k - 1) * .75
if k < 1.0001:
stop = timeit.default_timer()
time_inner_loop += (stop - start)
print stop - start
break
# TODO: TEST TO MAKE SURE TIMES ARE UP-TO-DATE
for column in grid_of_nodes:
for region in column:
for node in region.nodes:
for connection in node.time_connections:
node.time_connections[connection] = (
node.distance_connections[connection] /
(node.speed_connections[connection]))
##########################################
# #
# PART 6: #
# UNUSED STREETS #
# #
##########################################
print "Outer loop time:"
print time_outer_loop
print "Inner loop time:"
print time_inner_loop
print "Iterations outer:"
print iter_outer_loop
print "Iterations inner:"
print iter_inner_loop
# A set of pairs of nodes (start_node, end_node)
all_streets = get_all_streets(grid_of_nodes)
unused_streets = get_sorted_unused_streets(all_streets, dict_of_streets)
prev_len = -1
# We now set every street in order, averaging the velocity along each
# street and the times, then assigning it to the usedStreet set
while True:
if prev_len == len(unused_streets):
print prev_len
for street in unused_streets:
curr_pair = street[1]
curr_pair[0].speed_connections[curr_pair[1]] = -1
curr_pair[0].time_connections[curr_pair[1]] = -1
break
prev_len = len(unused_streets)
for street in unused_streets:
if street[0] == 0:
unused_streets = get_sorted_unused_streets(
all_streets, dict_of_streets)
break
curr_pair = street[1]
all_adjacent = find_adjacent(curr_pair, dict_of_streets)
all_velocities = 0
for node_tuple in all_adjacent:
all_velocities += node_tuple[0].speed_connections[
node_tuple[1]]
if len(all_adjacent) != 0:
all_velocities /= len(all_adjacent)
else:
all_velocities = -1
curr_pair[0].speed_connections[curr_pair[1]] = all_velocities
if all_velocities != 0:
curr_pair[0].time_connections[curr_pair[1]] = (
curr_pair[0].distance_connections[curr_pair[1]] /
(all_velocities))
else:
curr_pair[0].time_connections[curr_pair[1]] = -1
dict_of_streets[(curr_pair[0].node_id,
curr_pair[1].node_id)] = (curr_pair[0],
curr_pair[1])
##########################################
# #
# PART 7: #
# WRITE LINK FILE #
# #
##########################################
# Writes all of the pertinent information to a file, so that we can compare
# it to the link file later and add the time/speed
link_file = csv.writer(open(fileName, 'wb'))
headers = ["begin_node_id", "end_node_id", "length", "speed", "time"]
link_file.writerow(headers)
for node_tuple in all_streets:
new_arr = [
node_tuple[0].node_id, node_tuple[1].node_id,
node_tuple[0].distance_connections[node_tuple[1]],
node_tuple[0].speed_connections[node_tuple[1]],
node_tuple[0].time_connections[node_tuple[1]]
]
link_file.writerow(new_arr)
def arrived(call):
Trip.car_in_place(call.message, chat_id_passenger, chat_id_drive)
accepted_teip_drive(call.message, time_arrival)
def fulfilled(call):
Trip.review_drive(call.message, chat_id_passenger)
Trip.START_SEARCH_PAS(call.message)
def star_1(call):
star = 1
Trip.review_rating_drive(call.message, star, chat_id_drive)
bot.edit_message_text('Оценка оставлена', call.message.chat.id,
call.message.message_id)
Trip.START_TRIP(call.message)
def create_update_trip(self):
global db_timer
if not self.user:
self.redirect('/')
ukey = self.user.key
tname = self.request.get('tname')
tdescription = self.request.get('tdescription')
tdetails = self.request.get('tdetails')
tlinks = self.request.get('tlinks')
linkList = striplist(tlinks.split(','))
ttags = self.request.get('ttags')
taglist = striplist(ttags.split(','))
tdestinations = self.request.get('tdestinations').strip()
d = []
destinationList = striplist(tdestinations.split(','))
if len(destinationList)>0:
for dest in destinationList:
#TODO add exception handling - trim spaces
dest = Destination1.getDestinationByName(dest.strip())
logging.error(dest.count())
if dest and dest.count() > 0:
d.append(dest.fetch()[0].key)
#logging.error('NewTrip.post tname:'+tname)
turl = 'trip/'+tname.replace(' ','-')
path = self.request.path
isEdit = True if path[:6] == '/_edit' else False
path = path[6:] if isEdit else path
logging.error('NewTrip.post turl:'+turl)
if tname:
tq = Trip.getTripByPath(path)
if tq and tq.count()>0:
t = tq.fetch()[0]
t.last_updated_by = ukey
else:
t = Trip()
t.added_by = ukey
t.name = tname
t.turl = '/'+turl
t.description=tdescription
t.details=tdetails
t.destinations = d
t.tags = taglist
t.links=linkList
t = t.put()
search.Index(name=_T_INDEX_NAME).add(CreateDocument(str(t.id()), tname))
self.redirect('/%s' % turl)
else:
error = "trip, please!"
self.render("trip-edit.html", t=trip, error=error)
def generateFeatures(driversDataPath, driverLimit=10000):
import os
import glob
driverIndex = 0
tripIndex = 0
''' read drivers directory '''
for dId in sorted(os.listdir(driversDataPath)):
print " driver: index %s name %s " % (driverIndex, dId)
driver = Driver(driverIndex, dId)
tripIndex = 0
''' for each driver read the trip files, one file at a time and
compute the features and stores them in the Trip object
'''
folder = '%s/%s/*.csv' % (driversDataPath, dId)
for f in sorted(glob.glob(folder)):
#print " f: ", f
fileName = os.path.basename(f)
[name, ext] = os.path.splitext(fileName)
tripMatrix = []
features = []
''' data sample rate is 1 sec '''
tripMatrix = np.loadtxt(f, delimiter=',', skiprows=1)
''' distances '''
distances = getDistances(tripMatrix)
medianDist = np.median(distances)
meanDist = np.mean(distances)
stdDist = np.std(distances)
maxDist = distances.max()
tripTime = len(tripMatrix)
tripDist = distances.sum() #np.sum(distances)
''' distance features '''
features.append(tripDist)
features.append(tripTime)
features.append(maxDist)
features.append(stdDist)
features.append(meanDist)
features.append(medianDist)
variances = getPCAVariance(tripMatrix)
xVariance = variances[0]
yVariance = variances[1]
''' xy variance features '''
features.append(xVariance)
features.append(yVariance)
''' stops '''
stopCount = getStops(tripMatrix)
dataJumpCount = getDataJumps(distances)
''' stops and jumps features '''
features.append(stopCount)
features.append(dataJumpCount)
'''speeds '''
speeds = distances
medianSpeed = np.median(speeds)
meanSpeed = np.mean(speeds)
maxSpeed = speeds.max()
mimSpeed = speeds.min()
stdSpeed = np.std(speeds)
'''speeds features '''
features.append(maxSpeed)
features.append(mimSpeed)
features.append(stdSpeed)
features.append(meanSpeed)
features.append(medianSpeed)
''' accelerations - derivative of speed'''
accels = np.diff(speeds)
[minAccel, maxAccel, totalAccel] = getMinMaxPos(accels)
[minDecel, maxDecel, totalDecel] = getMinMaxNeg(accels)
''' accelerations features '''
features.append(maxAccel)
features.append(minAccel)
features.append(totalAccel)
features.append(maxDecel)
features.append(minDecel)
features.append(totalDecel)
''' jerks - derivative of acceleration'''
jerks = np.diff(accels)
[minAccelJerk, maxAccelJerk, totalAccelJerck] = getMinMaxPos(jerks)
[minDecelJerk, maxDecelJerk, totalDecelJerck] = getMinMaxNeg(jerks)
''' jerk features '''
features.append(maxAccelJerk)
features.append(minAccelJerk)
features.append(totalAccelJerck)
features.append(maxDecelJerk)
features.append(minDecelJerk)
features.append(totalDecelJerck)
''' angles '''
angles, originAngles = getAngles(tripMatrix)
maxAngle = angles.max()
minAngle = angles.min()
totalAngle = angles.sum()
meanAngle = np.mean(angles)
medianAngle = np.median(angles)
''' angles features '''
features.append(maxAngle)
features.append(minAngle)
features.append(meanAngle)
features.append(medianAngle)
features.append(totalAngle)
''' angularVelocity '''
angularSpeeds = angles * speeds
maxAngularSpeed = angularSpeeds.max()
minAngularSpeed = angularSpeeds.min()
medianAngularSpeed = np.median(angularSpeeds)
meanAngularSpeed = np.mean(angularSpeeds)
features.append(maxAngularSpeed)
features.append(minAngularSpeed)
features.append(meanAngularSpeed)
features.append(medianAngularSpeed)
''' instantiate Trip object '''
trip = Trip(tripIndex, name, tripTime, tripDist)
''' add the feature list to the current trip'''
trip.setFeatureList(features)
''' add the trip to the driver '''
driver.addTrip(trip)
del trip #the local trip should be dealocated every loop
tripIndex += 1
''' add driver to the manager. At this point the driver has
all the trips with the corresponding features
'''
driverMgr.addDriver(driver)
del driver #the local driver should be dealocated every loop
driverIndex += 1
''' to get out of the drivers loop - for testing only '''
if driverIndex > driverLimit:
break
def onRelease(self, event):
self.end = event
trip = Trip((self.start.x, self.start.y), (self.end.x, self.end.y))
trips.append(trip)
trip.display()
def passenger_Not_change(call):
bot.send_message(call.message.chat.id, 'Изменений нет')
Trip.START_TRIP(call.message)
