VRP_addPickup_Delivery

code_VRP__addPickup_Delivery.py

"""Capacitated Vehicle Routing Problem"""
from six.moves import xrange
from ortools.constraint_solver import pywrapcp
from ortools.constraint_solver import routing_enums_pb2
import networkx as nx
import matplotlib.pyplot as plt
import random
import math
import pandas as pd
from csv import reader
import sys




# Problem Data Definition #

class Vehicle():
	def __init__(self):
		self._capacity = 9000
		# self.id = id
		self.routes = []
		self.time_min = []
		self.time_max = []
		self.load = []
		self.cm3 = []
		self._speed = 0.31 #mile/min


	@property
	def capacity(self):
		"""Gets vehicle capacity"""
		return self._capacity

	def routes(self):
		return self.routes

	def speed(self):
		return self._speed



class DataProblem():
	"""Stores the data for the problem"""
	def __init__(self):
		"""Initializes the data for the problem"""
		self._vehicle = Vehicle()
		self._num_vehicles = num_vehicles()
		self._locations = []
		self._demands = []
		self._time_windows = []
		self._cm3 = []
		self._locationID = []
		self._pickups_deliveries = []
		self._depot = 0


		df = pd.read_csv("C:/Users/Jie/Desktop/VRP_SZ/order_info_7.23.csv", encoding="utf-8")
		last_id = df.shape[0] + 1

		# df = df[df['提货日期'] == 1]
		# df = df[df['ID'] != 65]  # 广西异常地址

		global mode
		global start_node
		global end_node
		# 1:实际起点终点相同0; 2:虚拟起点0, 实际终点; 3:虚拟起点0，虚拟终点0，实际终点为pickup->delivery
		mode = 2
		total_length = len(df["装货地址维度"].tolist())
		start_node = 0
		# end_node = total_length + 1
		end_node = start_node
		# print(df)



		# set lat/lon incl. first and last node
		p_lat = df["装货地址维度"].tolist()
		p_lon = df["装货地址经度"].tolist()
		d_lat = df["卸货地址维度"].tolist()
		d_lon = df["卸货地址经度"].tolist()
		lat = p_lat + d_lat
		lon = p_lon + d_lon
		dummy_lat = df["卸货地址维度"].tolist()[0]
		dummy_lon = df["卸货地址经度"].tolist()[0]
		lat.insert(0, dummy_lat)
		lon.insert(0, dummy_lon)
		# lat.append(dummy_lat)
		# lon.append(dummy_lon)
		self._locations = list(zip(lat,lon))
		# print("locations: ", self._locations)
		print("length locations: ", len(self._locations))



		#set first and last node for each vehicle
		self._starts = [0]*num_vehicles()
		self._ends = [len(lat)-1]*num_vehicles()
		# print("start node: ", self._starts)
		# print("end node: ", self._ends)


		# set time window incl. first and last node
		p_earliest = df['最早装货时间'].tolist()
		p_latest = df['最晚装货时间'].tolist()
		d_earliest = [480]*len(p_earliest)
		d_latest = [1320]*len(p_latest)
		earliest = p_earliest+d_earliest
		latest = p_latest+d_latest
		earliest.insert(0,480)
		latest.insert(0,1320)
		# earliest.append(480)
		# latest.append(1320)
		self._time_windows = list(zip(earliest,latest))
		print(self._time_windows)


		#set weight and cm3 incl. first and last node
		self.p_demands = df["毛重(KGS)"].tolist()
		self.p_cm3 = df["体积(CBM)"].tolist()
		self.d_demands = [0 - x for x in self.p_demands]
		self.d_cm3 = [0 - x for x in self.p_cm3]
		self._demands = self.p_demands+self.d_demands
		self._cm3 = self.p_cm3+self.d_cm3
		self._demands.insert(0,start_node)
		self._cm3.insert(0,start_node)
		# self._demands.append(0)
		# self._cm3.append(0)
		print("demand: ", self._demands)
		print("cm3: ", self._cm3)
		print("demand length: ", len(self._demands))
		print("cm3 length: ", len(self._cm3))
		print("pickup demand: ", self._demands[26])
		print("delivery demand: ", self._demands[64])


		# get index of a certain day
		self._locationID = df["ID"].tolist()
		self._locationID.insert(0,0)
		# self._locationID.append(last_id)
		# print("ID list: ", self._locationID)
		merge = self._locationID + self._locationID[1:]
		self._locationID = merge
		print("ID list: ", self._locationID)
		print("ID list length: ", len(self._locationID))
		self.map = pd.DataFrame(merge).reset_index()
		self.map.columns = ['模型地址编号', '订单地址编号']
		self.map["实际地址编号"] = self.map["模型地址编号"]
		self.map["地址类型"] = 0
		last_loadid = self._locationID[-1]
		self._locationID = self.map["实际地址编号"].tolist()
		self.map.loc[self.map['模型地址编号'] <= last_loadid, '地址类型'] = "装货"
		self.map.loc[self.map['模型地址编号']  > last_loadid, '地址类型'] = "卸货"
		self.map.loc[self.map['模型地址编号'] == 0, '地址类型'] = "起点"
		print("\n地址编号对照表\n", self.map.to_string(index=False))


		#set pickup & delivery pairs
		pickups = self.map[self.map['地址类型'] == "装货"]["模型地址编号"].tolist()
		deliveries = self.map[self.map['地址类型'] == "卸货"]["模型地址编号"].tolist()
		for i,n in enumerate(pickups):
			temp = [n,deliveries[i]]
			self._pickups_deliveries.append(temp)
		print("pickups_deliveries: ", self._pickups_deliveries)




	@property
	def getvehicle(self):
		"""Gets a vehicle"""
		return self._vehicle

	@property
	def num_vehicles(self):
		"""Gets number of vehicles"""
		return self._num_vehicles

	@property
	def locations(self):
		"""Gets locations"""
		return self._locations

	@property
	def num_locations(self):
		"""Gets number of locations"""
		return len(self.locations)

	@property
	def depot(self):
		"""Gets depot location index"""
		return self._depot

	@property
	def demands(self):
		"""Gets demands at each location"""
		return self._demands

	@property
	def cm3(self):
		"""Gets cm3 at each location"""
		return self._cm3

	@property
	def time_per_demand_unit(self):
		"""Gets the time (in min) to load a demand"""
		return 120

	@property
	def time_windows(self):
		"""Gets (start time, end time) for each locations"""
		return self._time_windows

	@property
	def starts(self):
		"""Gets start location for each truck"""
		return self._starts

	@property
	def ends(self):
		"""Gets end location for each truck"""
		return self._ends





#######################
# Problem Constraints #
#######################

class CreateDistanceEvaluator(object): # pylint: disable=too-few-public-methods
	"""Creates callback to return distance between points."""
	def __init__(self, data, manager):
		"""Initializes the distance matrix."""
		self._distances = {}
		self.manager = manager
		self.dist_matrix = []

		# precompute distance between location to have distance callback in O(1)
		total_matrix = []
		with open("C:/Users/Jie/Desktop/VRP_SZ/dist_matrix_7.23.csv", 'r') as read_obj:
			csv_reader = reader(read_obj)
			list_of_rows = list(csv_reader)
			for n in list_of_rows:
				n = [int(i) for i in n]
				total_matrix.append(n)
			print("raw total matrix: ", total_matrix[2][40])

		print("location num: ", data.num_locations)
		for from_node in xrange(data.num_locations):
			convert_from = data._locationID[from_node]
			temp = []
			for to_node in xrange(data.num_locations):
				convert_to = data._locationID[to_node]
				if from_node == to_node:
					temp.append(0)
				else:
					if from_node == start_node or to_node == start_node:
						temp.append(0)
					else:
						dist = total_matrix[convert_from-1][convert_to-1] / 1000
						temp.append(dist)
						# temp.append(int(dist))

			self.dist_matrix.append(temp)
		print("dist matrix: ", self.dist_matrix)
		print("dist matrix length: ", len(self.dist_matrix))

	def distance_evaluator(self, from_index, to_index):
		"""Returns the Harversine Distance between the two nodes"""
		from_node = self.manager.IndexToNode(from_index)
		to_node = self.manager.IndexToNode(to_index)
		print("dist: ", dist_evaluator.dist_matrix[from_node][to_node])
		return self.dist_matrix[from_node][to_node]


	def define_total_cost(self, data, routing, manager):
		for vehicle_idx in range(data.num_vehicles):
			def vehicle_cost_callback(from_index, to_index, i=vehicle_idx):
				from_node = manager.IndexToNode(from_index)
				to_node = manager.IndexToNode(to_index)

				# try:
				# 	from_node = manager.IndexToNode(from_index)
				# 	to_node = manager.IndexToNode(to_index)
				# except:
				# 	print("\nerror from index: ", from_index)
				# 	print("error to index: ", to_index)
				# 	print("error from node: ", manager.IndexToNode(from_index))
				# 	print("error to node: ", manager.IndexToNode(to_index))
				# 	from_node = manager.IndexToNode(from_index)
				# 	to_node = manager.IndexToNode(to_index)
				# 	print("from->to node: ", from_node, " -> ", to_node)
				# 	print("############################\n")
				return cost_vector()[i] * self.dist_matrix[from_node][to_node]

			cost_callback_index = routing.RegisterTransitCallback(vehicle_cost_callback)
			routing.SetArcCostEvaluatorOfVehicle(cost_callback_index, vehicle_idx)



class CreateDemandEvaluator(object):
	"""Creates callback to get demands at each location."""
	def __init__(self, data, manager):
		"""Initializes the demand array."""
		self._demands = data.demands
		self._manager = manager

	def demand_evaluator(self, from_index):
		"""Returns the demand of the current node"""
		from_node = self._manager.IndexToNode(from_index)
		return self._demands[from_node]


class CreateCM3Evaluator(object):
	"""Creates callback to get cm3 at each location."""
	def __init__(self, data, manager):
		"""Initializes the demand array."""
		self._cm3 = data.cm3
		self._manager = manager


	def cm3_evaluator(self, from_index):
		"""Returns the cm3 of the current node"""
		from_node = self._manager.IndexToNode(from_index)
		return self._cm3[from_node]


class CreateTimeEvaluator(object):
	"""Creates callback to get total times between locations."""
	def __init__(self, data, manager):
		"""Initializes the total time matrix."""
		self._total_time = {}
		self._manager = manager
		self.time_matrix = []

		total_matrix = []
		with open("C:/Users/Jie/Desktop/VRP_SZ/time_matrix_7.23.csv", 'r') as read_obj:
			csv_reader = reader(read_obj)
			list_of_rows = list(csv_reader)
			for n in list_of_rows:
				n = [int(i) for i in n]
				total_matrix.append(n)
			# print("total matrix: ", len(total_matrix))

		for from_node in xrange(data.num_locations):
			self._total_time[from_node] = {}
			convert_from = data._locationID[from_node]
			temp = []
			for to_node in xrange(data.num_locations):
				self._total_time[from_node][to_node] = 0
				convert_to = data._locationID[to_node]
				if from_node == to_node:
					temp.append(0)
				else:
					if from_node == start_node or to_node == start_node:
						self._total_time[from_node][to_node] = 0
						temp.append(0)
					else:
						travel_time = total_matrix[convert_from-1][convert_to-1] / 60
						service_time = 0
						if from_node > 38:
							service_time = 0
						else:
							service_time = self.service_time(data,from_node)
						total_time = travel_time + service_time
						# total_time = int(travel_time + service_time)
						temp.append(total_time)
						self._total_time[from_node][to_node] = total_time
			self.time_matrix.append(temp)
		print("time matrix: ", self.time_matrix)
		# print("time matrix2: ", self._total_time[1])


	@staticmethod
	def service_time(data, node):
		"""Gets the service time for the specified location."""
		# return data.demands[node] * data.time_per_demand_unit  #function of volume at this node
		return data.time_per_demand_unit   #constant service time for all nodes



	def time_evaluator(self, from_index, to_index):
		"""Returns the total time between the two nodes"""
		from_node = self._manager.IndexToNode(from_index)
		to_node = self._manager.IndexToNode(to_index)
		return self._total_time[from_node][to_node]



def add_distance_dimension(routing, transit_callback_index, data, manager):
	"""Add Global Span constraint"""
	distance = "Distance"
	maximum_distance = 800
	routing.AddDimension(
		transit_callback_index,
		0, # null slack
		maximum_distance, # maximum distance per vehicle
		True, # start cumul to zero
		distance)
	# distance_dimension = routing.GetDimensionOrDie(distance)
	# Try to minimize the max distance among vehicles.
	# /!\ It doesn't mean the standard deviation is minimized
	# distance_dimension.SetGlobalSpanCostCoefficient(100)



def add_capacity_constraints(routing, data, demand_callback_index, manager):
	"""Adds capacity constraint"""
	capacity = "Capacity"
	routing.AddDimensionWithVehicleCapacity(
		demand_callback_index,
		0, # null capacity slack
		capacity_vector(), # vector vehicle_capacity
		True, # start cumul to zero
		capacity)



def allow_dropping(routing,data,manager):
	# Allow to drop nodes.
	global penalty
	penalty = 1000000
	idx = 1
	for node in range(1, len(data.locations)-1):
		routing.AddDisjunction([manager.NodeToIndex(node)], penalty)
		idx+=1
	print("idx: ", idx)



def setup_PDP(routing,data,manager):
	# Define Transportation Requests.
	distance_dimension = routing.GetDimensionOrDie("Distance")
	time_dimension = routing.GetDimensionOrDie("Time")
	for request in data._pickups_deliveries:
		pickup_index = manager.NodeToIndex(request[0])
		delivery_index = manager.NodeToIndex(request[1])
		routing.AddPickupAndDelivery(pickup_index, delivery_index)
		routing.solver().Add(
			routing.VehicleVar(pickup_index) == routing.VehicleVar(
				delivery_index))
		# routing.solver().Add(
		# 	distance_dimension.CumulVar(pickup_index) <=
		# 	distance_dimension.CumulVar(delivery_index))
		routing.solver().Add(
			time_dimension.CumulVar(pickup_index) <=
			time_dimension.CumulVar(delivery_index))





def add_cm3_constraints(routing, data, demand_callback_index):
	"""Adds capacity constraint"""
	cm3 = "cm3"
	routing.AddDimensionWithVehicleCapacity(
		demand_callback_index,
		0, # null capacity slack
		cm3_vector(), # vector vehicle_capacity
		True, # start cumul to zero
		cm3)



def add_time_window_constraints(routing, data, time_callback_index, manager):
	"""Add Global Span constraint"""
	time = "Time"
	# horizon = 2000
	horizon = 1320
	routing.AddDimension(
		time_callback_index,
		480, # allow waiting time
		horizon, # maximum time per vehicle
		False, # don't force start cumul to zero since we are giving TW to start nodes
		time)
	time_dimension = routing.GetDimensionOrDie(time)
	# print("len time_window: ", data.time_windows)

	# set time window for each customer location's visiting time
	for location_idx, time_window in enumerate(data.time_windows):
		# if location_idx == start_node or location_idx == end_node:
		if location_idx == start_node:
			continue
		index = manager.NodeToIndex(location_idx)
		time_dimension.CumulVar(index).SetRange(time_window[0], time_window[1])
		routing.AddToAssignment(time_dimension.SlackVar(index))

	# set time window for each vehicle's start and end location
	for vehicle_id in xrange(data.num_vehicles):
		index = routing.Start(vehicle_id)
		# index_end = routing.End(vehicle_id)
		# set a constraint on the start or the end node for each vehicle, which is not included in above
		time_dimension.CumulVar(index).SetRange(data.time_windows[start_node][0], data.time_windows[start_node][1])
		# time_dimension.CumulVar(index_end).SetRange(data.time_windows[end_node][0], data.time_windows[end_node][1])
		routing.AddToAssignment(time_dimension.SlackVar(index))





###########
# Printer #
###########

vlist=[]
load_list=[]
time_list_min=[]
time_list_max=[]
class ConsolePrinter():

	"""Print solution to console"""
	def __init__(self, data, manager, routing, assignment):
		"""Initializes the printer"""
		self._data = data
		self._routing = routing
		self._assignment = assignment
		self._manager = manager



	@property
	def data(self):
		"""Gets problem data"""
		return self._data

	@property
	def routing(self):
		"""Gets routing model"""
		return self._routing

	@property
	def assignment(self):
		"""Gets routing model"""
		return self._assignment

	@property
	def manager(self):
		"""Gets routing model"""
		return self._manager


	def print(self,data):
		"""Prints assignment on console"""
		dropped_nodes = []
		global drop_count
		drop_count = 0
		for node in range(self.routing.Size()):
			if self.routing.IsStart(node) or self.routing.IsEnd(node):
				continue
			if self.assignment.Value(self.routing.NextVar(node)) == node:
				dropped_nodes.append(mapID(data.map,self.manager.IndexToNode(node)))
				drop_count += 1

		if len(dropped_nodes) > 0:
			print("dropped nodes: ", dropped_nodes)
			print(f'Objective: {self.assignment.ObjectiveValue()}')
			print(f'Objective excl. penalties: {self.assignment.ObjectiveValue() - drop_count*penalty}\n')
		else:
			print(f'Objective: {self.assignment.ObjectiveValue()}\n')

		# Inspect solution.
		capacity_dimension = self.routing.GetDimensionOrDie('Capacity')
		cm3_dimension = self.routing.GetDimensionOrDie('cm3')
		time_dimension = self.routing.GetDimensionOrDie('Time')
		dist_dimension = self.routing.GetDimensionOrDie('Distance')
		total_dist = 0
		total_time = 0
		global vlist
		global new_vlist
		global load_list
		global time_list_min
		global time_list_max
		for vehicle_id in xrange(self.data.num_vehicles):
			index = self.routing.Start(vehicle_id)
			# print(index)
			# plan_output = 'Route for vehicle {0}:\n'.format(vehicle_id)
			plan_output = '车辆ID {0}, 线路规划明细:\n'.format(vehicle_id)
			# route_dist = 0
			this_vehicle = Vehicle()
			while not self.routing.IsEnd(index):
				node_index = self.manager.IndexToNode(index)
				# print(node_index)
				this_vehicle.routes.append(mapID(data.map,self.manager.IndexToNode(index)))
				# print(this_vehicle.routes)
				# print(self.data.vehicle.routes)
				# print(self.data.vehicle.routes.append(temp_id))
				next_node_index = self.manager.IndexToNode(
					self.assignment.Value(self.routing.NextVar(index)))
				# route_dist += distance(
				# 	self.data.locations[node_index][0],
				# 	self.data.locations[node_index][1],
				# 	self.data.locations[next_node_index][0],
				# 	self.data.locations[next_node_index][1])
				load_var = capacity_dimension.CumulVar(index)
				cm3_var = cm3_dimension.CumulVar(index)
				# print("load_var: ", load_var)
				route_load = self.assignment.Value(load_var)
				# route_load += self.data.demands[node_index]
				cm3_load = self.assignment.Value(cm3_var)
				dist_var = dist_dimension.CumulVar(index)
				route_dist = self.assignment.Value(dist_var)
				time_var = time_dimension.CumulVar(index)
				time_min = self.assignment.Min(time_var)
				time_max = self.assignment.Max(time_var)
				this_vehicle.load.append(route_load)
				this_vehicle.cm3.append(cm3_load)
				this_vehicle.time_min.append(time_min)
				this_vehicle.time_max.append(time_max)
				slack_var = time_dimension.SlackVar(index)
				slack_min = self.assignment.Min(slack_var)
				slack_max = self.assignment.Max(slack_var)
				# plan_output += ' {0} Load({1}) Time({2},{3}) Slack({4},{5}) ->'.format(
				plan_output += ' 地址:{0} 装载量({1}) 最早与最晚到达时间({2},{3}) 呆滞停留时间({4},{5}) ->'.format(
					# node_index,
					mapID(data.map,node_index),
					route_load,
					time_min, time_max,
					slack_min, slack_max)
				index = self.assignment.Value(self.routing.NextVar(index))
				# print("start printing", plan_output)

			node_index = self.manager.IndexToNode(index)
			load_var = capacity_dimension.CumulVar(index)
			cm3_var = cm3_dimension.CumulVar(index)
			# print("truck type: ", str(load_var).split("..")[1][:-1])
			route_load = self.assignment.Value(load_var)
			cm3_load = self.assignment.Value(cm3_var)
			dist_var = dist_dimension.CumulVar(index)
			time_var = time_dimension.CumulVar(index)
			route_dist = self.assignment.Value(dist_var)
			route_time = self.assignment.Value(time_var)
			time_min = self.assignment.Min(time_var)
			time_max = self.assignment.Max(time_var)
			# total_dist += route_dist
			# total_time += route_time
			# if route_load != 0:
			if route_dist != 0:
				# plan_output += '汇总:\n'
				# plan_output += ' {0} Load({1}) Time({2},{3})\n'.format(node_index, route_load, time_min, time_max)
				# plan_output += ' 地址:{0} 装载量({1}) 最早与最晚到达时间({2},{3})\n'.format(node_index, route_load, time_min, time_max)
				plan_output += ' 地址:{0} 装载量({1}) 最早与最晚到达时间({2},{3})\n'.format(mapID(data.map,node_index), route_load, time_min, time_max)
				plan_output += '车型: {0} \n'.format(GetTruckType(int(str(load_var).split("..")[1][:-1])))
				plan_output += '总里程: {0} km\n'.format(int(route_dist))
				plan_output += '总装载公斤: {0}\n'.format(route_load)
				plan_output += '总装载立方: {0}\n'.format(cm3_load)
				plan_output += '总耗时: {0} min\n'.format(route_time-480)
				vlist.append(this_vehicle.routes)
				total_dist += route_dist
				total_time += route_time
				print(plan_output)

			this_vehicle.routes.append(mapID(data.map,end_node))
			this_vehicle.load.append(route_load)
			this_vehicle.cm3.append(cm3_load)
			this_vehicle.time_min.append(time_min)
			this_vehicle.time_max.append(time_max)
			# vlist.append(this_vehicle.routes)
			load_list.append(this_vehicle.load)
			time_list_min.append(this_vehicle.time_min)
			time_list_max.append(this_vehicle.time_max)

		# print("vlist: ", vlist)
		print('总里程（所有线路）: {0} km'.format(int(total_dist)))
		print('总时长（所有线路）: {0} min'.format(int(total_time)))
		temp = vlist.copy()
		new_vlist = RemoveStartDepot(temp)
		# print('vlist: ', vlist)
		print('new vlist: ', new_vlist)


def mapID(df,id):
	actual_id = df.loc[df['模型地址编号'] == id, '实际地址编号'].iloc[0]
	# print("model id: ", id, " -> actual id: ",actual_id)
	return actual_id

def mapID_reverse(df,id):
	model_id = df.loc[df['实际地址编号'] == id, '模型地址编号'].iloc[0]
	# print("model id: ", id, " -> actual id: ",actual_id)
	return model_id





def RemoveStartDepot(temp):
	new = []
	for i in temp:
		x = i[1:]
		new.append(x)
	return new



def PickupColor(count):
	default_cl=["red", "blue","yellowgreen","orange","hotpink","orchid",
					"black","purple","slateblue","olive","steelblue","magenta",
				"cadetblue","teal","lightseagreen","deepskyblue",
				"olivedrab","darkkhaki", "sandybrown", "tomato"]
	if count <= len(default_cl) - 1:
		color=default_cl[count]
	else:
	#     temp=random.choice(list(matplotlib.colors.cnames.items()))[0]
	#     while "white" in temp or "gray" in temp and temp in default_cl:
	#         temp = random.choice(list(matplotlib.colors.cnames.items()))[0]
	#         continue
	#     cl=temp
		rand = lambda: random.randint(70, 170)
		color='#%02X%02X%02X' % (rand(), rand(), rand())
	return color


def DrawNetwork(data):
	G = nx.DiGraph()
	locations = DataProblem()._locations
	# print(locations)
	x = 0
	# for vehicle_id in vlist:
	for vehicle_id in new_vlist:
		n = 0
		e = []
		node = []
		cl=PickupColor(x)
		for i in vehicle_id:
			k = mapID_reverse(data.map,i)
			# G.add_node(i, pos=(locations[i][1], locations[i][0]))
			G.add_node(i, pos=(locations[k][1], locations[k][0]))
			node.append(i)
			if n > 0:
				u = (vehicle_id[n - 1], vehicle_id[n])
				# u = (new[n - 1], new[n])
				e.append(u)
				node.append(i)
				G.add_edge(vehicle_id[n - 1], vehicle_id[n])
			n += 1
		nx.draw(G, nx.get_node_attributes(G, 'pos'), nodelist=node, edgelist=e, with_labels=True,
				node_color=cl, width=2, edge_color=cl,
				style='dashed', font_color='w', font_size=12, font_family='sans-serif')
		x += 1
	# let's color the node 0 in black
	# nx.draw_networkx_nodes(G, locations, nodelist=[0], node_color='k')
	plt.axis('on')
	# plt.show()





########
# Main #
########

def test():
	data = DataProblem()



def main():
	"""Entry point of the program"""
	# Instantiate the data problem.
	data = DataProblem()

	# Create Routing Model
	# manager = pywrapcp.RoutingIndexManager(data.num_locations, data.num_vehicles, data.starts, data.ends)
	# manager = pywrapcp.RoutingIndexManager(data.num_locations, data.num_vehicles, data.starts, data.starts)
	manager = pywrapcp.RoutingIndexManager(data.num_locations, data.num_vehicles, data.depot)
	routing = pywrapcp.RoutingModel(manager)


	# Add Distance constraint
	dist_evaluator = CreateDistanceEvaluator(data,manager)
	distance_callback_index = routing.RegisterTransitCallback(dist_evaluator.distance_evaluator)
	dist_evaluator.define_total_cost(data,routing,manager)
	add_distance_dimension(routing, distance_callback_index, data, manager)

	# def distance_evaluator(from_index, to_index):
	# 	"""Returns the Harversine Distance between the two nodes"""
	# 	from_node = manager.IndexToNode(from_index)
	# 	to_node = manager.IndexToNode(to_index)
	# 	# print("dist: ", dist_evaluator.dist_matrix[from_node][to_node])
	# 	return dist_evaluator.dist_matrix[from_node][to_node]
	#
	# distance_callback_index = routing.RegisterTransitCallback(distance_evaluator)
	# # routing.SetArcCostEvaluatorOfAllVehicles(distance_callback_index)
	# # addTruckCost(routing)
	#
	# for vehicle_idx in range(data.num_vehicles):
	# 	def vehicle_cost_callback(from_index, to_index, i=vehicle_idx):
	# 		from_node = manager.IndexToNode(from_index)
	# 		to_node = manager.IndexToNode(to_index)
	# 		return cost_vector()[i] * dist_evaluator.dist_matrix[from_node][to_node]
	#
	# 	cost_callback_index = routing.RegisterTransitCallback(vehicle_cost_callback)
	# 	routing.SetArcCostEvaluatorOfVehicle(cost_callback_index, vehicle_idx)
	# add_distance_dimension(routing, distance_callback_index, data, manager)


	# Add Capacity constraint
	demand_evaluator = CreateDemandEvaluator(data, manager).demand_evaluator
	demand_callback_index = routing.RegisterUnaryTransitCallback(demand_evaluator)
	add_capacity_constraints(routing, data, demand_callback_index, manager)
	# Add Cubic Meters constraint
	cm3_evaluator = CreateCM3Evaluator(data, manager).cm3_evaluator
	cm3_callback_index = routing.RegisterUnaryTransitCallback(cm3_evaluator)
	add_cm3_constraints(routing, data, cm3_callback_index)
	# Add Time Window constraint
	time_evaluator = CreateTimeEvaluator(data, manager).time_evaluator
	time_callback_index = routing.RegisterTransitCallback(time_evaluator)
	add_time_window_constraints(routing, data, time_callback_index, manager)
	# Allow dropping nodes if solution infeasible
	# allow_dropping(routing, data, manager)
	# # Allow setup pickups and deliveries pairs
	setup_PDP(routing, data, manager)

	# # Define Transportation Requests.
	# distance_dimension = routing.GetDimensionOrDie("Distance")
	# time_dimension = routing.GetDimensionOrDie("Time")
	# for request in data._pickups_deliveries:
	# 	pickup_index = manager.NodeToIndex(request[0])
	# 	delivery_index = manager.NodeToIndex(request[1])
	# 	routing.AddPickupAndDelivery(pickup_index, delivery_index)
	# 	routing.solver().Add(
	# 		routing.VehicleVar(pickup_index) == routing.VehicleVar(
	# 			delivery_index))
	# 	routing.solver().Add(
	# 		distance_dimension.CumulVar(pickup_index) <=
	# 		distance_dimension.CumulVar(delivery_index))
	# 	routing.solver().Add(
	# 		time_dimension.CumulVar(pickup_index) <=
	# 		time_dimension.CumulVar(delivery_index))




	# Setting first solution heuristic (cheapest addition).
	search_parameters = pywrapcp.DefaultRoutingSearchParameters()
	# 1).First Solution Heuristic
	search_parameters.first_solution_strategy = (
		routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)
	search_parameters.log_search = True
	# search_parameters.time_limit.seconds = 20
	search_parameters.time_limit.seconds = 1200
	# 2).Guided Local Search Heuristics
	# search_parameters.local_search_metaheuristic = (
	# routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
	# search_parameters.log_search = True
	# search_parameters.time_limit.seconds = 1200
	# 3).Simulated Annealing Heuristics
	# search_parameters.local_search_metaheuristic = (
	#     routing_enums_pb2.LocalSearchMetaheuristic.SIMULATED_ANNEALING)
	# search_parameters.log_search = True
	# search_parameters.time_limit.seconds = 300
	# 4).TABU_SEARCH Heuristics
	# search_parameters.local_search_metaheuristic = (
	# 	routing_enums_pb2.LocalSearchMetaheuristic.TABU_SEARCH)
	# search_parameters.log_search = True
	# search_parameters.time_limit.seconds = 300


	# Solve the problem.
	# assignment = routing.SolveWithParameters(search_parameters)
	solution = routing.SolveWithParameters(search_parameters)
	if solution:
		print("该方案有最优解！\n")
		printer = ConsolePrinter(data, manager, routing, solution)
		print("before print")
		printer.print(data)
		print("after print")
		DrawNetwork(data)
		# Reporting(data)
		plt.show()
	else:
		print("该方案无解！请修改车辆数！\n")




def num_vehicles():
	global t1
	global t2
	global t3
	global t4
	global t5
	global t6
	global t7
	global t8

	which_button_is_selected = "自动"
	if which_button_is_selected == "手动":
		t1=3
		t2=3
		t3=3
		t4=3
		t5=3
		t6=3
		t7=3
		t8=3
	if which_button_is_selected == "自动":
		t1=50
		t2=50
		t3=50
		t4=50
		t5=50
		t6=50
		t7=50
		t8=50
	# print("total trucks: ", t1+t2+t3+t4+t5)
	return t1+t2+t3+t4+t5+t6+t7+t8


def capacity_vector():
	return [1500]*t1+[1800]*t2+[4000]*t3+[6500]*t4+[7000]*t5+[8500]*t6+[9500]*t7+[12000]*t8


def cm3_vector():
	return [10]*t1+[16]*t2+[28]*t3+[34]*t4+[40]*t5+[45]*t6+[50]*t7+[55]*t8


def cost_vector():
	return [7]*t1+[8]*t2+[9.38]*t3+[10.42]*t4+[10.67]*t5+[12]*t6+[13]*t7+[14.55]*t8




def GetTruckType(item):
	if item == 1500:
		return "3T车型"
	if item == 1800:
		return "5T车型"
	if item == 4000:
		return "8T车型"
	if item == 6500:
		return "10T车型"
	if item == 7000:
		return "12T车型"
	if item == 8500:
		return "15T车型"
	if item == 9500:
		return "18T车型"
	if item == 12000:
		return "20T车型"






if __name__ == '__main__':
	main()
	# test()

dist_matrix_7.23.csv

order_info_7.23.csv

time_matrix_7.23.csv