def i(): first = input("Enter an equation for the first function: ") second = input("Enter an equation for the second function: ") from Intersection import Intersection f = Intersection(first, second) f.printFunction() return f
def parse_input(self, filename): with open(filename, 'r') as file: solution = None cars = [] streets = {} intersections = {} for i, line in enumerate(file.readlines()): if i == 0: [D, I, S, V, F] = line.strip().split(' ') solution = Solution(int(D), I, S, V, F) elif i <= int(S): # processing streets [start, end, name, length] = line.strip().split(' ') if start not in intersections: intersections[start] = Intersection(start) if end not in intersections: intersections[end] = Intersection(end) street = Street(name, length, intersections[start], intersections[end]) streets[street.name] = street intersections[end].add_incoming(street) intersections[start].add_outgoing(street) else: # processing cars street_names = line.strip().split(' ')[1:] car_streets = [ streets[street_name] for street_name in street_names ] cars.append(Car(car_streets)) return solution, cars, streets, intersections
def local_intersects(self, ray): # Incoming ray is now in object space already # the vector from the sphere's center, to the ray origin # remember: the sphere is centered at the world origin sphere_to_ray = ray.origin - Tuple4.Point(0, 0, 0) a = ray.direction.dot(ray.direction) b = 2 * ray.direction.dot(sphere_to_ray) c = sphere_to_ray.dot(sphere_to_ray) - 1 discriminant = math.pow(b, 2) - 4 * a * c if discriminant < 0: return Intersections() t1 = (-b - math.sqrt(discriminant)) / (2 * a) t2 = (-b + math.sqrt(discriminant)) / (2 * a) # Intersections are a scalar and an object, so we don't need to # transform them back to world space return Intersections(Intersection(t1, self), Intersection(t2, self))
def create_environment(): game = Intersection(length=length, prob = prob, keepalive = keepalive, wait_weight=wait_weight) idle = [1,0,0] waitNS = [0,1,0] waitEW = [0, 0,1] possible_actions = [idle, waitNS, waitEW] return game, possible_actions
def findIntersections(streamNetwork, numReaches): arcpy.AddMessage("Finding intersections...") intersections = [] points = AVLPointsTree() reqReachLength = 50 polylineCursor = arcpy.da.SearchCursor(streamNetwork, ["SHAPE@"]) row = polylineCursor.next() currentStream = row[0] if currentStream.length > reqReachLength: points.addNode(currentStream.lastPoint, currentStream) previousStream = currentStream for i in range(numReaches - 1): """If the current stream has a point that """ row = polylineCursor.next() currentStream = row[0] pointInTree = points.findPoint(currentStream.lastPoint) continuousStreams = pointsAreEqual(previousStream.lastPoint, currentStream.firstPoint, .01) if pointInTree is not None: if currentStream.length < reqReachLength and continuousStreams: # If the stream is really short, we want to use the stream before it if possible, to get a better DA value intersections.append( Intersection(currentStream.lastPoint, currentStream, pointInTree.stream)) else: intersections.append( Intersection(currentStream.lastPoint, currentStream, pointInTree.stream)) else: if currentStream.length < reqReachLength and continuousStreams: points.addNode(currentStream.lastPoint, currentStream) else: points.addNode(currentStream.lastPoint, currentStream) previousStream = currentStream del row, polylineCursor arcpy.AddMessage("Intersections found") return intersections
def local_intersects(self, ray): # Incoming ray is now in object space already # If the ray is parallel to the plane (y = 0), there # is no intersection if maths.equals(ray.direction.y, 0): return Intersections() else: # Otherwise, the ray is intersecting from above # or below t = -ray.origin.y / ray.direction.y return Intersections(Intersection(t, self))
def color_at(self, r): """ tieing up the intersect(), shade_hit(), and prepare_computations() functions for convenience's sake """ # getting all the hits in total total_junctions = self.intersect_world(r) first = True if len(total_junctions) > 0: for hit in total_junctions: if hit['time'] >= 0 and first == True: i = Intersection(hit['time'], hit['object']) first = False if first == True or len(total_junctions) == 0: return color(0, 0, 0) comps = i.prepare_computations(r) # call shade_hit() to return the color at that specific point COL = self.shade_hit(comps) return COL
def getIntersection(self, ray): ocVector = ray.origin - self.center a = Vector.dot(ray.direction, ray.direction) b = Vector.dot(ocVector, ray.direction) * 2 c = Vector.dot(ocVector, ocVector) - (self.radius * self.radius) discriminant = (b * b) - (4 * a * c) if discriminant < 0: return None else: t = (-b - math.sqrt(discriminant)) / (2.0 * a) t2 = (-b + math.sqrt(discriminant)) / (2.0 * a) if t > 0.0001: return Intersection( ray.origin + ray.direction * t, t, self.normal(ray.origin + ray.direction * t), self) elif t2 > 0.0001: return Intersection( ray.origin + ray.direction * t2, t2, self.normal(ray.origin + ray.direction * t2), self) else: return None
def __init__(self): border = BoundaryLane() self.intersectionArray = N.array( ([Intersection(), Intersection()], [Intersection(), Intersection()])) #self.intersectionArray[0][0] = Intersection() #self.intersectionArray[0][1] = Intersection() #self.intersectionArray[1][0] = Intersection() #self.intersectionArray[1][1] = Intersection() #intersection top left self.intersectionArray[0,0].setAdjacents([border,border,self.intersectionArray[1,0].southLanes[1]\ ,self.intersectionArray[1,0].southLanes[0],\ self.intersectionArray[0,1].eastLanes[1],\ self.intersectionArray[0,1].eastLanes[0],border,border]) #intersection top right self.intersectionArray[0,1].setAdjacents([border,border,self.intersectionArray[1,1].southLanes[1],\ self.intersectionArray[1,1].southLanes[0],border,border,\ self.intersectionArray[0,0].westLanes[1],\ self.intersectionArray[0,0].westLanes[1]]) #intersection bottom left self.intersectionArray[1,0].setAdjacents([self.intersectionArray[0,0].northLanes[1]\ ,self.intersectionArray[0,0].northLanes[1],border,\ border,self.intersectionArray[1,1].eastLanes[1],\ self.intersectionArray[1,1].eastLanes[0],border,border]) #intersection bottom right self.intersectionArray[1,1].setAdjacents([self.intersectionArray[0,1].northLanes[1],\ self.intersectionArray[0,1].northLanes[0],border,\ border,border,border,self.intersectionArray[1,0].westLanes[1],\ self.intersectionArray[1,0].westLanes[1]]) """ create four intersection objects and make clear which ones are adjacent to which. have each intersection adjacent to the boundary. """ self.timeWithinBoundary = []
def simulation(gui): # Initialize instance of intersection currIntersection = Intersection(length=40, wid=40, posX=490, posY=490) for i in range(0, len(carList)): carList[i].displayCar() elapsedTime = 0 # initialize time in seconds runSim = True # bool to stop simulation # Begin simulation: while (runSim): # Remove processed cars from the intersection list # cleanList(carList, gui) # Check to see if we should end simulation if (elapsedTime > values.simluationTime): runSim = False # if time condition is true runSim to false elapsedTime += values.timeInterval # increment 100 mili second # Check if cars are in intersection range currIntersection.updateIntersectionQueues(carList, elapsedTime, gui) # Restore speeds currIntersection.restoreVelocities(carList) # Check for possible collisions Calculations.collisionDetection(currIntersection.queueX, currIntersection.queueY, gui) # Update the positions of the cars in the list for i in range(0, len(carList)): # THIRD update position carList[i].updatePosition(values.timeInterval) # Update the GUI positions gui.moveCars(carList, values.timeInterval) # Every seconds generate new cars ''' if(elapsedTime % values.carGenerationModulo is 0): rndCar = randint(1, 2) if(rndCar == 1): # Generate one car newCar = randomCarGenerator(gui, False, 0) carList.append(newCar) elif(rndCar == 2): # Genereate two cars for i in range(1, 3): newCar = randomCarGenerator(gui, True, i) carList.append(newCar) ''' if (elapsedTime % values.carGenerationModulo is 0): # Generate two cars for i in range(1, 3): newCar = randomCarGenerator(gui, True, i) carList.append(newCar) time.sleep(.01) print len(carList)
def __init__(self): AlgorithmProvider.__init__(self) self.alglist = [SumLines(), PointsInPolygon(), PointsInPolygonWeighted(), PointsInPolygonUnique(), BasicStatisticsStrings(), BasicStatisticsNumbers(), NearestNeighbourAnalysis(), MeanCoords(), LinesIntersection(), UniqueValues(), PointDistance(), ReprojectLayer(), ExportGeometryInfo(), Centroids(), Delaunay(), VoronoiPolygons(), SimplifyGeometries(), DensifyGeometries(), DensifyGeometriesInterval(), MultipartToSingleparts(), SinglePartsToMultiparts(), PolygonsToLines(), LinesToPolygons(), ExtractNodes(), Eliminate(), ConvexHull(), FixedDistanceBuffer(), VariableDistanceBuffer(), Dissolve(), Difference(), Intersection(), Union(), Clip(), ExtentFromLayer(), RandomSelection(), RandomSelectionWithinSubsets(), SelectByLocation(), RandomExtract(), RandomExtractWithinSubsets(), ExtractByLocation(), SpatialJoin(), RegularPoints(), SymetricalDifference(), VectorSplit(), VectorGrid(), DeleteColumn(), DeleteDuplicateGeometries(), TextToFloat(), ExtractByAttribute(), SelectByAttribute(), Grid(), Gridify(), HubDistance(), HubLines(), Merge(), GeometryConvert(), AddTableField(), FieldsCalculator(), SaveSelectedFeatures(), JoinAttributes(), AutoincrementalField(), Explode(), FieldsPyculator(), EquivalentNumField(), PointsLayerFromTable(), StatisticsByCategories(), ConcaveHull(), Polygonize(), RasterLayerStatistics(), PointsDisplacement(), ZonalStatistics(), PointsFromPolygons(), PointsFromLines(), RandomPointsExtent(), RandomPointsLayer(), RandomPointsPolygonsFixed(), RandomPointsPolygonsVariable(), RandomPointsAlongLines(), PointsToPaths(), PostGISExecuteSQL(), ImportIntoPostGIS(), SetVectorStyle(), SetRasterStyle(), SelectByExpression(), HypsometricCurves(), # ------ raster ------ # CreateConstantRaster(), # ------ graphics ------ # VectorLayerHistogram(), VectorLayerScatterplot(), # RasterLayerHistogram(), MeanAndStdDevPlot(), # BarPlot(), PolarPlot() ] folder = os.path.join(os.path.dirname(__file__), 'scripts') scripts = ScriptUtils.loadFromFolder(folder) for script in scripts: script.allowEdit = False self.alglist.extend(scripts) for alg in self.alglist: alg._icon = self._icon
def StartGameBoard(self): for i in range(rows): objectRow = [] row = [] row2 = [] for j in range(cols): x = int(i * boxWidth + (boxWidth/2)) y = int(j * boxWidth + (boxWidth/2)) intersection = Intersection(x, y, boxWidth, stoneRadius) objectRow.append(intersection) row.append(0) row2.append(1) self.objectGameBoard.append(objectRow)
def main(): d = CarDespawner() s1 = CarSpawner(0.5, [d]) s2 = CarSpawner(0.5, [d]) inter = Intersection() lane1 = Lane(5, s1, None, inter, Direction.SOUTH) lane2 = Lane(5, s2, None, inter, Direction.WEST) lane3 = Lane(5, inter, Direction.NORTH, d, None) for i in range(100): d.update() lane1.update() lane2.update() lane3.update() inter.update() s1.update() s2.update() print(lane3, end=" ||| ") print(inter, end=" ||| ") print(lane1) print(" " * 51, end="") print(lane2) print("-" * 100)
def getIntersection(self, ray): dot = Vector.dot(self.normal, ray.direction) if abs(dot) < 0.0001: return None else: difference = self.point - ray.origin t = Vector.dot(difference, self.normal) / dot if t > 0.0001: point = ray.origin + ray.direction * t if self.minxyz.x <= point.x <= self.maxxyz.x and self.minxyz.y <= point.y <= self.maxxyz.y and self.minxyz.z <= point.z <= self.maxxyz.z: return Intersection(point, t, self.normal, self) else: return None else: return None
def run(self, net_data, args, exp_replay, neural_network, eps, rl_stats): ###for batch vehicle data, faster than API calls data_constants = [ traci.constants.VAR_SPEED, traci.constants.VAR_POSITION, traci.constants.VAR_LANE_ID, traci.constants.VAR_LANE_INDEX ] self.vehicles = Vehicles(self.conn, data_constants, net_data, self.sim_len, args.demand, args.scale) ###create some intersections intersections = [ Intersection(_id, args.tsc, self.conn, args, net_data['tsc'][_id], exp_replay[_id], neural_network[_id], eps, rl_stats[_id], self.vehicles.get_edge_delay) for _id in self.conn.trafficlight.getIDList() ] print('start running sumo sim on port ' + str(self.port)) while self.t < self.sim_len: ###loop thru tsc intersections ###run and pass v_data lane_vehicles = self.vehicles.run() for i in intersections: i.run(lane_vehicles) self.step() if args.mode == 'train': ###write travel time mean to csv for graphing after training self.write_csv( str(eps) + '.csv', np.mean([ self.vehicles.travel_times[v] for v in self.vehicles.travel_times ])) ''' if eps < 0.1: # #print('--- SIM FINISHED -- '+str(eps)+' average tt '+str(np.mean([self.vehicles.travel_times[v] for v in self.vehicles.travel_times])) +' std tt '+str(np.std([self.vehicles.travel_times[v] for v in self.vehicles.travel_times])) ) self.write_csv('hpresults.csv', np.mean([self.vehicles.travel_times[v] for v in self.vehicles.travel_times]) ) ''' #self.write_csv(str(eps)+'.csv', np.sum([i.tsc.rewards for i in intersections]) ) #print('-------______TT -------------') #print(np.mean([self.vehicles.travel_times[v] for v in self.vehicles.travel_times])) print('finished running sumo sim on port ' + str(self.port)) self.cleanup()
def simulation(gui): # Initialize instance of intersection currIntersection = Intersection(length=40, wid=40, posX=490, posY=490, gui=gui) generate_physical_test_cars(gui) elapsedTime = 0 # initialize time in seconds runSim = True # bool to stop simulation # Begin simulation: while (runSim): # Remove processed cars rom the intersection list # cleanList(carList, gui, currIntersection) # Check to see if we should end simulation if (elapsedTime > values.simluationTime): runSim = False # if time condition is true runSim to false elapsedTime += values.timeInterval # increment 100 mili second # Update the intersection containers and values update_intersection(currIntersection, elapsedTime) # Check if this is a conventional simulation if (values.conventionalSimFlag): run_conventional(currIntersection, gui) # Check if this is an optimized simulation else: run_optimized(currIntersection, gui, values.carList) # Update the positions of the cars update_positions(gui) # Sleep the while loop with custom spinlock. now = time.time() while (time.time() - now <= (0.01)): pass generate_statistics()
def __init__(self): AlgorithmProvider.__init__(self) self._icon = QIcon(os.path.join(pluginPath, 'images', 'qgis.png')) self.alglist = [ SumLines(), PointsInPolygon(), PointsInPolygonWeighted(), PointsInPolygonUnique(), BasicStatisticsStrings(), BasicStatisticsNumbers(), NearestNeighbourAnalysis(), MeanCoords(), LinesIntersection(), UniqueValues(), PointDistance(), ReprojectLayer(), ExportGeometryInfo(), Centroids(), Delaunay(), VoronoiPolygons(), SimplifyGeometries(), DensifyGeometries(), DensifyGeometriesInterval(), MultipartToSingleparts(), SinglePartsToMultiparts(), PolygonsToLines(), LinesToPolygons(), ExtractNodes(), Eliminate(), ConvexHull(), FixedDistanceBuffer(), VariableDistanceBuffer(), Dissolve(), Difference(), Intersection(), Union(), Clip(), ExtentFromLayer(), RandomSelection(), RandomSelectionWithinSubsets(), SelectByLocation(), RandomExtract(), DeleteHoles(), RandomExtractWithinSubsets(), ExtractByLocation(), SpatialJoin(), RegularPoints(), SymmetricalDifference(), VectorSplit(), VectorGrid(), DeleteColumn(), DeleteDuplicateGeometries(), TextToFloat(), ExtractByAttribute(), SelectByAttribute(), Grid(), Gridify(), HubDistance(), HubLines(), Merge(), GeometryConvert(), AddTableField(), FieldsCalculator(), SaveSelectedFeatures(), JoinAttributes(), AutoincrementalField(), Explode(), FieldsPyculator(), EquivalentNumField(), PointsLayerFromTable(), StatisticsByCategories(), ConcaveHull(), RasterLayerStatistics(), PointsDisplacement(), ZonalStatistics(), PointsFromPolygons(), PointsFromLines(), RandomPointsExtent(), RandomPointsLayer(), RandomPointsPolygonsFixed(), RandomPointsPolygonsVariable(), RandomPointsAlongLines(), PointsToPaths(), PostGISExecuteSQL(), ImportIntoPostGIS(), SetVectorStyle(), SetRasterStyle(), SelectByExpression(), HypsometricCurves(), SplitLinesWithLines(), CreateConstantRaster(), FieldsMapper(), SelectByAttributeSum(), Datasources2Vrt(), CheckValidity(), OrientedMinimumBoundingBox(), Smooth(), ReverseLineDirection() ] if hasMatplotlib: from VectorLayerHistogram import VectorLayerHistogram from RasterLayerHistogram import RasterLayerHistogram from VectorLayerScatterplot import VectorLayerScatterplot from MeanAndStdDevPlot import MeanAndStdDevPlot from BarPlot import BarPlot from PolarPlot import PolarPlot self.alglist.extend([ VectorLayerHistogram(), RasterLayerHistogram(), VectorLayerScatterplot(), MeanAndStdDevPlot(), BarPlot(), PolarPlot(), ]) if hasShapely: from Polygonize import Polygonize self.alglist.extend([Polygonize()]) if QGis.QGIS_VERSION_INT >= 21400: from ExecuteSQL import ExecuteSQL self.alglist.extend([ExecuteSQL()]) folder = os.path.join(os.path.dirname(__file__), 'scripts') scripts = ScriptUtils.loadFromFolder(folder) for script in scripts: script.allowEdit = False self.alglist.extend(scripts) for alg in self.alglist: alg._icon = self._icon
def _intersection(self, name1, t, name2): setattr(world, name1, Intersection(float(t), getattr(world, name2)))
# w = world() # w.set_light(point_light(point(0, 0, -10), color(1, 1, 1))) # s1 = sphere() # w.add_object(s1) # s2 = sphere(transform_within=translation(0, 0, 10)) # w.add_object(s2) # r = ray(point(0, 0, 5), vector(0, 0, 1)) # i = Intersection(4, s2) # comps = i.prepare_computations(r) # c = w.shade_hit(comps) # print(c.red, c.green, c.blue) r = ray(point(0, 0, -5), vector(0, 0, 1)) shape = sphere() shape.transform_within = translation(0, 0, 1) i = Intersection(5, shape) comps = i.prepare_computations(r) print(comps['over_point'].val[2] < -EPSILON / 2) print(comps['point'].val[2] > comps['over_point'].val[2]) # w = default_world() # p = point(10, -10, 10) # result = w.is_shadowed(p) # print(result) # w.set_light(point_light(point(0, 0.25, 0), color(1, 1, 1))) # r = ray(point(0, 0, 0), vector(0, 0, 1)) # i = Intersection(0.5, w.items[1]) # comps = i.prepare_computations(r) # c = w.shade_hit(comps) # print(c)
def main(): pygame.init() # setup with open("colors.json") as f: text = f.read() colors = json.loads(text) wWidth = 800 wHeight = 800 w = pygame.display.set_mode((wWidth, wHeight)) width = 30 streetH = Street((0, wHeight // 2), (wWidth, wHeight // 2), 4, 2, 1, wWidth // 2) streetV = Street((wWidth // 2, 0), (wWidth // 2, wHeight), 3, 3, 1, wHeight // 2) intersection = Intersection(streetH, streetV) cars = [] carsWaiting = [] # cars that aren't past the intersection yet waitTime = 10 time = 0 timeAbsolute = 0 carDensity = 1.2 running = True simulating = True #whether we're in th options menu or not typing = False #whether we're typing or not intersection.changeToCycle(intersection.hgreenCycle) vProb = 0.5 densityLightAlgorithm = True options = Options(streetH.numPos, streetH.numNeg, streetH.numLeftOnly, streetV.numPos, streetV.numNeg, streetV.numLeftOnly, carDensity, 10 / waitTime, vProb, densityLightAlgorithm) carsPassed = 0 carsPassedQueue = deque([0] * 500) flowRate = 0 avgFlowRate = 0 carRects = [] while running: for e in pygame.event.get(): if e.type == pygame.QUIT: return if e.type == pygame.KEYDOWN: if typing: if e.key == pygame.K_RETURN: typing = False options.typing = False elif e.key == pygame.K_BACKSPACE: options.index[options.currentIndex] = options.index[ options.currentIndex][:-1] else: if options.currentIndex < 6: if options.index[options.currentIndex] == '': options.index[ options.currentIndex] += e.unicode else: options.index[options.currentIndex] += e.unicode else: if e.key == pygame.K_ESCAPE: if not simulating: waitTime = int(round(10 / float(options.index[7]))) carDensity = np.math.log( float(options.index[6]) + 1) + 1 simulating = not simulating if e.key == pygame.K_r: streetH = Street((0, wHeight // 2), (wWidth, wHeight // 2), int(options.index[0]), int(options.index[1]), int(options.index[2]), wWidth // 2) streetV = Street((wWidth // 2, 0), (wWidth // 2, wHeight), int(options.index[3]), int(options.index[4]), int(options.index[5]), wHeight // 2) intersection = Intersection(streetH, streetV) waitTime = int(round(10 / float(options.index[7]))) carDensity = float(options.index[6]) cars = [] time = 0 timeAbsolute = 0 carsPassed = 0 carsPassedQueue = deque([0] * 500) simulating = True if not simulating: if e.type == pygame.MOUSEBUTTONDOWN: for box in options.inputBoxes: if box.collidepoint(e.pos): if options.inputBoxes.index(box) == 9: densityLightAlgorithm = not densityLightAlgorithm options.index[9] = densityLightAlgorithm else: typing = True options.typing = True options.currentBox = box options.currentIndex = options.inputBoxes.index( box) options.flashTimer = 0 if time > intersection.totalCycleLength: time = 0 intersection.changeCycle(time) time += 1 if timeAbsolute != 0: timeAbsolute += 1 if simulating: if time > intersection.totalCycleLength: time = 0 intersection.changeCycle(time) time += 1 if np.random.rand() > 1 / carDensity: vProb = float(options.index[8]) street = np.random.choice((streetV, streetH), p=(vProb, 1 - vProb)) carLane = street.lanes[np.random.randint(0, len(street.lanes))] carColor = np.random.choice(Car.COLORS) car = Car(carLane, intersection, carColor, desiredSpeed=np.random.normal(1.35, 0.1)) if not car.hitBox.collidelistall( carRects ): # Making sure the cars don't overlap when spawned cars.append(car) carLane.cars.append(car) carsWaiting.append(car) w.fill(colors["green"]) for l in streetH.lanes: l.draw(w) for l in streetV.lanes: l.draw(w) streetH.drawLines(w) streetV.drawLines(w) intersection.draw(w) carRects = [] for car in cars: carRects.append(car.rect) for i, car in enumerate(cars): if not car.isTurningLeft: collisionIdxs = car.hitBox.collidelistall(carRects) if collisionIdxs != [i]: collisionIdxs.remove(i) if len(collisionIdxs) > 1: # TODO: better way to handle this? #print("multiple collisions detected") cheese = 0 else: if car.speed != 0: car.speed = cars[collisionIdxs[0]].speed * 0.7 for c in cars: c.move(carRects) c.draw(w, showHitbox=False) if c.distance >= c.lane.length + 10 * c.LENGTH: if c in c.lane.cars: c.lane.cars.remove(c) cars.remove(c) carsPassed += 1 if timeAbsolute == 0: timeAbsolute += 1 if c.rect.colliderect(intersection.rect): if c in c.lane.cars: c.lane.cars.remove(c) if c in carsWaiting: carsWaiting.remove(c) numCarsInGreen = 0 numGreenLanes = 0 for light in intersection.lights: light[0].draw(w) if light[0].color == "green": numGreenLanes += 1 numCarsInGreen += len(light[0].lane.cars) # if the density algorithm is on, and the density of cars with green ahead is less than 20% the density of cars # waiting overall, and there are at least 6 cars, and it's been green for at least 2 seconds, then switch if densityLightAlgorithm and numCarsInGreen * ( streetH.numLanes + streetV.numLanes ) < 0.2 * numGreenLanes * len(carsWaiting) and len( cars ) >= 6 and time - intersection.trafficFlow[ intersection.cycleNumber - 1][1] * constants.SECOND > 200: time = intersection.abruptChangeCycle() carsPassedQueue.appendleft(carsPassed) flowRate = carsPassed - carsPassedQueue.pop() avgFlowRate = 500 * carsPassed / (timeAbsolute + 1) if timeAbsolute < 100: Options.text(w, "Flow Rate: n/a", 20, 20, 20) Options.text(w, "Average Flow Rate: n/a", 20, 70, 20) else: Options.text(w, "Current Flow Rate: " + str(flowRate), 20, 20, 20) Options.text( w, "Average Flow Rate: " + str(round(avgFlowRate, 1)), 20, 70, 20) Options.text(w, "ESC for options", 550, 20, 20) Options.text(w, "R to reset", 550, 70, 20) pygame.display.flip() pygame.time.wait(waitTime) else: options.draw(w) pygame.display.flip() pygame.time.wait(waitTime)
def intersect(blank, tool): from Intersection import Intersection return Intersection(blank, tool)
ln, ls, le, lw = Lane("north"), Lane("south"), Lane("east"), Lane("west") lanes = [le, lw, ln, ls] lanes = { "east": le, "west": lw, "north": ln, "south": ls, } #initiate variables lane_data = { "east": 0, "west": 0, "north": 0, "south": 0, } inter = Intersection("Intersection 1") inter.attach(lanes) lights = { (0, 30): "rrrrggggrrrrgggg", (30, 60): "ggggrrrrggggrrrr", } def run(): global lanes, vec_sum, lane_data, intersection, lights traci.init(PORT) step = 0 data_count = inter.cycle while step < MAX_STEP: traci.simulationStep() data = dict(
show(p) ######################################################## table = PrettyTable(["Step", "from_east", "from_west", "from_north", "from_south"]) lane_table = PrettyTable(["Lane", "Q length", "Awt"]) lanevar_table = PrettyTable(["Lane", "Tin", "Tout"]) data = {"east": 0, "west": 0, "north": 0, "south": 0} # initiate lanes' objects ln, ls, le, lw = Lane("north"), Lane("south"), Lane("east"), Lane("west") lanes = [le, lw, ln, ls] lanes = {"east": le, "west": lw, "north": ln, "south": ls} # initiate variables lane_data = {"east": 0, "west": 0, "north": 0, "south": 0} inter = Intersection("Intersection 1") inter.attach(lanes) lights = {(0, 30): "rrrrggggrrrrgggg", (30, 60): "ggggrrrrggggrrrr"} def run(): global lanes, vec_sum, lane_data, intersection, lights traci.init(PORT) step = 0 data_count = inter.cycle while step < MAX_STEP: traci.simulationStep() data = dict( zip( [key for key in ["east", "west", "north", "south"]], [value for value in [numberv(i) for i in lanes_id()]],
import math #keep track of time ts = time.time() #make the toward lanes and the away lanes toward = [] for i in range(7): toward.append(Lane(10,1)) away = [] for i in range(4): away.append(Lane(10,-1)) #make the intersection I = Intersection(toward, away) #store the networks' througputs and wait times #gets cleared every epoch throughs = [] waits = [] #stores average throughs and waits for all the generations avg_throughs = [] avg_waits = [] #stores the best throughput and the best wait time for all the generations best_throughs = [] best_waits = [] #store the best neural networks
def main(): #CHANGE THESE FLAGS TO CONTROL THE EXPERIMENT VIZ = False # Set to True for visualization USE_ROUNDABOUT = True # Set to True to use roundabout PAUSE = 0.1 # time (in sec) between each update, if VIZ is True MAX_TIME = 1000000 SEED = 0 SPAWN_PROB = 0.1 row, col = 2, 2 stat = Stats() # grid of intersection/roundabout if USE_ROUNDABOUT: matrix = [[Roundabout(1) for j in range(col)] for i in range(row)] else: matrix = [[Intersection() for j in range(col)] for i in range(row)] despawns = [CarDespawner(stat) for i in range(row * 4)] spawns = [CarSpawner(stat, SPAWN_PROB, despawns) for i in range(col * 4)] # connect lanes baseLaneLen = 10 lanes = [] # spawn/despawn lanes first lanes.append( Lane(baseLaneLen, spawns[0], None, matrix[0][0], Direction.NORTH)) lanes.append( Lane(baseLaneLen, spawns[1], None, matrix[0][1], Direction.NORTH)) lanes.append( Lane(baseLaneLen, spawns[2], None, matrix[0][1], Direction.EAST)) lanes.append( Lane(baseLaneLen, spawns[3], None, matrix[1][1], Direction.EAST)) lanes.append( Lane(baseLaneLen, spawns[4], None, matrix[1][1], Direction.SOUTH)) lanes.append( Lane(baseLaneLen, spawns[5], None, matrix[1][0], Direction.SOUTH)) lanes.append( Lane(baseLaneLen, spawns[6], None, matrix[1][0], Direction.WEST)) lanes.append( Lane(baseLaneLen, spawns[7], None, matrix[0][0], Direction.WEST)) lanes.append( Lane(baseLaneLen, matrix[0][0], Direction.NORTH, despawns[0], None)) lanes.append( Lane(baseLaneLen, matrix[0][1], Direction.NORTH, despawns[1], None)) lanes.append( Lane(baseLaneLen, matrix[0][1], Direction.EAST, despawns[2], None)) lanes.append( Lane(baseLaneLen, matrix[1][1], Direction.EAST, despawns[3], None)) lanes.append( Lane(baseLaneLen, matrix[1][1], Direction.SOUTH, despawns[4], None)) lanes.append( Lane(baseLaneLen, matrix[1][0], Direction.SOUTH, despawns[5], None)) lanes.append( Lane(baseLaneLen, matrix[1][0], Direction.WEST, despawns[6], None)) lanes.append( Lane(baseLaneLen, matrix[0][0], Direction.WEST, despawns[7], None)) # always order endpoints as northern node, southern node OR # western node, eastern node connect(lanes, matrix, baseLaneLen, 0, 0, 0, 1) connect(lanes, matrix, baseLaneLen, 0, 0, 1, 0) connect(lanes, matrix, baseLaneLen, 0, 1, 1, 1) connect(lanes, matrix, baseLaneLen, 1, 0, 1, 1) if VIZ: root = Tk() viz = Viz(matrix, lanes, baseLaneLen, root) random.seed(SEED) for x in range(MAX_TIME): for i in range(len(matrix)): for j in range(len(matrix[0])): if matrix[i][j]: matrix[i][j].update() for lane in lanes: lane.update() for spawn in spawns: spawn.update() stat.cur_time += 1 # Then update viz if VIZ: viz.update() time.sleep(PAUSE) print(len(stat.car_times)) print(sum(stat.car_times) / len(stat.car_times)) print(stat.n_rejected) # Close window to terminate if VIZ: root.mainloop()
from Intersection import Intersection from GUI import GUI length = 5 prob = 0.5 keepalive = -1 wait_weight = 0.5 state_size = 2 * (length + 2) action_size = 3 if __name__ == '__main__': game = Intersection(length=length, prob=prob, keepalive=keepalive, wait_weight=wait_weight) window = GUI(50) window.update(game.getState()) while not game.gameEnd(): text = raw_input("Input (0 is for nothing, 1 is for NS, 2 is for EW: ") stepReward = 0 if (int(text) == 0): stepReward = game.step(0, 0) elif (int(text) == 1): stepReward = game.step(1, 0) else: stepReward = game.step(0, 1) print("Step Reward: ", stepReward)
def simulation(gui): # Initialize instance of intersection currIntersection_1 = Intersection(length=40, wid=40, posX=490, posY=200, gui=gui) currIntersection_2 = Intersection(length=40, wid=40, posX=1020, posY=500, gui=gui) currIntersection_3 = Intersection(length=40, wid=40, posX=1020, posY=200, gui=gui) currIntersection_4 = Intersection(length=40, wid=40, posX=490, posY=500, gui=gui) IntersectionList.append(currIntersection_1) IntersectionList.append(currIntersection_2) IntersectionList.append(currIntersection_3) IntersectionList.append(currIntersection_4) for i in range(len(IntersectionList)): gui.drawIndicationLines(IntersectionList[i]) elapsedTime = 0 # initialize time in seconds runSim = True # bool to stop simulation # Begin simulation: while (runSim): gui.update() # Determine what kind of simulation we're running if (gui.CheckVar.get() == 1): values.conventionalSimFlag = True else: values.conventionalSimFlag = False # Remove processed cars from the intersection list for i in range(len(IntersectionList)): cleanList(carList, gui, IntersectionList[i]) # Check to see if we should end simulation """ if(elapsedTime > values.simluationTime): runSim = False """ # if time condition is true runSim to false elapsedTime += values.timeInterval # increment 100 mili second # Update the intersection containers and values for i in range(len(IntersectionList)): update_intersection(IntersectionList[i], elapsedTime) # Check if this is a conventional simulation if (values.conventionalSimFlag): for i in range(len(IntersectionList)): # thread.start_new_thread(run_conventional, (IntersectionList[i], gui)) run_conventional(IntersectionList[i], gui) # interThread = IntersectionThread.interThread(IntersectionList[i],) # Check if this is an optimized simulation else: interThreads = [] for i in range(len(IntersectionList)): # run_opt = thread.__init__(run_optimized, (IntersectionList[i], gui, carList)) # run_opt.start() # interThreads.append(run_opt) # interThread = IntersectionThread.InterThread(IntersectionList[i], gui, carList) # interThread.start() # interThreads.append(interThread) run_optimized(IntersectionList[i], gui, carList) ''' for i in range(len(interThreads)): interThreads[i].join() ''' # interThreads.clear() # Update the positions of the cars update_positions(gui) # Generate new cars generate_cars(gui, elapsedTime) # Call server communications # server_send_packet() # Sleep the while loop time.sleep(.01) generate_statistics()