def distance_field(grid, position, obstacles): """ Compute a distance field on a grid in a given position, with the given obstacles. """ boundary = Queue() # bsf uses queue dynamics boundary.enqueue((position[0], position[1])) # put the starting grid in the queue visited = [[EMPTY for _ in xrange(WIDTH)] for _ in xrange(HEIGHT)] visited[position[0]][position[1]] = FULL # set the starting cell to visited field = Grid(HEIGHT, WIDTH, STRMAP) # we'll store the distance field as a grid field.set_all_to(-1) # -1 will symbolize unreachable cells # Set obstacles for obstacle in obstacles: grid.set_obstacle(obstacle[0], obstacle[1]) field.set_obstacle(obstacle[0], obstacle[1]) field.set_empty(position[0], position[1]) # set the root position while boundary: # while the queue is not empty current = boundary.dequeue() # get a grid cell from the queue neighbors = grid.four_neighbors(current[0], current[1]) # get the four neighbor cells: # up, down, left, and right for neighbor in neighbors: # for every neighbor cell # If the cell hasn't been visited and has no obstacles: if not visited[neighbor[0]][neighbor[1]] and grid.is_empty(neighbor[0], neighbor[1]): visited[neighbor[0]][neighbor[1]] = FULL # set it as visited boundary.enqueue(neighbor) # add it to the queue field.set_to(neighbor[0], neighbor[1], # set the distance from the root field.get_cell(current[0], current[1]) + 1) return field
def bfs(grid, row, col): """ Perform a breath-first search in the given grid, starting in the given cell. """ boundary = Queue() # bsf uses queue dynamics boundary.enqueue((row, col)) # put the starting grid in the queue visited = [[EMPTY for _ in xrange(WIDTH)] for _ in xrange(HEIGHT)] visited[row][col] = FULL # set the starting cell to visited while boundary: # while the queue is not empty current = boundary.dequeue() # get a grid cell from the queue grid.set_marked(current[0], current[1]) # (this is for the print) neighbors = grid.four_neighbors(current[0], current[1]) # get the four neighbor cells: print grid # up, down, left, and right for neighbor in neighbors: # for every neighbor cell if not visited[neighbor[0]][neighbor[1]]: # if it hasn't been visited visited[neighbor[0]][neighbor[1]] = FULL # set it as visited boundary.enqueue(neighbor) # add it to the queue grid.set_full(neighbor[0], neighbor[1]) # (this is for the print) print grid
from crawler import Scraper from multiprocessing import Process #This basic server will send data to the leaflet frontend from random import randint import json from flaskext import uploads import pandas as pd import os from werkzeug import secure_filename from glob import glob from tools import Queue from central_server import InvestigationLogger scraper = Scraper() queue = Queue() @app.route("/", methods=["GET", "POST"]) def index(): return render_template("index.html") #Data Visualization Routes #Map routes UPLOAD_FOLDER = os.getcwd() + "/static/uploads" ALLOWED_EXTENSIONS = set(['csv']) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
def linear_split(data, Q_max, max_tour_duration, nr_vehicles): """ # TODO Create docstring Args: child: Returns: """ nonlocal self length_penalty = self.solver_inst.w_penalty_duration load_penalty = self.solver_inst.w_penalty_load def cost_achieved(data, i, x, Q, D, T): if Q[x] - Q[i] <= 2 * Q_max: return cost(data, i, x, D, Q, T) return sys.maxsize def cost(data, i, j, D, Q, T): return data[i + 1][3] + D[j] - D[ i + 1] + data[j][3] + T[j] - T[i] + load_penalty * max( Q[j] - Q[i] - Q_max, 0) + length_penalty * max( +T[j] + D[j] - D[i + 1] - T[i] - max_tour_duration, 0) def dominates(data, i, j, k, p, D, Q, T): if i <= j: return p[k][i] + data[i + 1][3] - D[i + 1] + T[j] - T[i] + load_penalty * (Q[j] - Q[i]) <= p[k][j] + \ data[j + 1][3] - D[ j + 1] else: return p[k][i] + data[i + 1][3] - D[ i + 1] <= p[k][j] + data[j + 1][3] - D[j + 1] nr_customers = len(data) # compute cumulative distance demand = [0] * nr_customers cumulated_load = [0] * nr_customers duration = [0] * nr_customers for index in range(nr_customers): distance = 0 for i in range(0, index): if index > 0: distance += data[i + 1][2] demand[index] = distance # compute cumulative load for index in range(nr_customers): load_temp = 0 duration_temp = 0 for i in range(1, index + 1): load_temp += data[i][4] duration_temp += data[i][5] cumulated_load[index] = load_temp duration[index] = duration_temp # initializing lists p = [[sys.maxsize for _ in range(nr_customers)] for _ in range(nr_vehicles + 1)] qu = Queue() pred = [[0 for _ in range(nr_customers)] for _ in range(nr_vehicles + 1)] p[0][0] = 0 subsolution = list() for k in range(nr_vehicles): qu.queue.clear() qu.push_back(k) for t in range(k + 1, nr_customers): if len(qu.queue) > 0: p[k + 1][t] = p[k][qu.front()] + cost_achieved( data, i=qu.front(), x=t, Q=cumulated_load, D=demand, T=duration) pred[k + 1][t] = qu.front() if t < nr_customers - 1: if not dominates(data=data, i=qu.back(), j=t, k=k, p=p, D=demand, Q=cumulated_load, T=duration): while len(qu.queue) > 0 and dominates( data=data, i=t, j=qu.back(), k=k, Q=cumulated_load, p=p, D=demand, T=duration): qu.pop_back() qu.push_back(t=t) while len(qu.queue) > 1 and p[k][qu.front()] + cost_achieved(data=data, i=qu.front(), x=t + 1, Q=cumulated_load, D=demand, T=duration) >= \ p[k][qu.front2()] + cost_achieved(data=data, i=qu.front2(), x=t + 1, Q=cumulated_load, D=demand, T=duration): qu.pop_front() start = pred[nr_vehicles][nr_customers - 1] subsolution.append( [data[x][0] for x in range(start + 1, nr_customers)]) index = start for i in range(nr_vehicles - 1, 0, -1): start = pred[i][index] subsolution.append( [data[x][0] for x in range(start + 1, index + 1)]) index = start return subsolution