def MakeSuccessor(x, y, gX, gY): if (x < 0 or x >= MAX_X() or y < 0 or y >= MAX_Y()): return None ele = elevations[x][y] ter = Terrain.GetTerrainVal(pix[x, y]) if ter == Terrain.OutOfBounds(): return None s = State.State(ele, ter, x, y, gX, gY) return s
def make_neighbor(x, y): # validates out of bound indices if (x < 0 or x >= MAX_X() or y < 0 or y >= MAX_Y()): return None ter = Terrain.GetTerrainVal(pix[x, y]) # filters out of bound neighbors if ter == Terrain.OutOfBounds(): return None # must be a valid neighbor at this point return (x, y)
def winter_DLT(x, y, d=7): t_val = Terrain.GetTerrainVal(pix[x, y]) if (t_val != Terrain.Water()): return if (d == 0): return pix[x, y] = (113, 237, 255, 255) for tup in pixel_neighbors((x, y)): i, j = tup winter_DLT(i, j, d - 1)
def move(self): lastPos = [self.pos[0], self.pos[1]] self.attackCooldown -= (self.attackCooldown > 0) self.frame += self.frameRate if len(self.hitFrames ) > 0 and self.frame >= self.hitFrames[0] and not self.attacked: self.abilList[0].useCallback(self) del self.hitFrames[0] if len(self.hitFrames) <= 0: self.attacked = True if (self.frame >= len(self.animationFrames) - 1): self.setState(self.animationFrames[len(self.animationFrames) - 1]) self.stunResidue = max(0, self.stunResidue - 0.001) speed = [self.knockback[0], self.knockback[1]] #if math.fabs(self.knockback[0]) == 0 and math.fabs(self.knockback[1]) == 0: if (self.currState is not "stunned"): speed[0] += self.speed[0] speed[1] += self.speed[1] if Terrain.canMoveThrough(PTRS["TERRAIN"].getAtPos( [self.pos[0] + speed[0], self.pos[1]])): self.pos[0] += speed[0] else: if speed[0] > 0: self.pos[0] = int(self.pos[0] / 20 + 1) * 20 - 0.001 else: self.pos[0] = int(self.pos[0] / 20) * 20 + 0.001 if Terrain.canMoveThrough(PTRS["TERRAIN"].getAtPos( [self.pos[0], self.pos[1] + speed[1]])): self.pos[1] += speed[1] else: if speed[1] > 0: self.pos[1] = int(self.pos[1] / 20 + 1) * 20 - 0.001 else: self.pos[1] = int(self.pos[1] / 20) * 20 + 0.001 for i in [0, 1]: self.knockback[i] *= 0.96 if math.fabs(self.knockback[i]) <= 0.1: self.knockback[i] = 0 if math.fabs( self.knockback[i]) <= 1 and self.currState == "attack": self.knockback[i] = 0 if self.currState == "walk" and lastPos[0] == self.pos[0] and lastPos[ 1] == self.pos[1]: self.setState("idle") elif self.currState == "idle" and (lastPos[0] != self.pos[0] or lastPos[1] != self.pos[1]): self.setState("walk")
def __init__(self, start, end): global allControlPoints self.controls = assets.getAsset( 'Road from {} to {}'.format(start, end), generateControls, (start, end), args.args.remake_roads) allControlPoints += self.controls setRoadUniforms() self.center = sum(self.controls) / len(self.controls) self.radius = max( [np.linalg.norm(i - self.center) for i in self.controls]) + 1000 Terrain.registerCallback(self.renderHeightmap)
def plot_terrain(SynthPlot,**kwargs): terrain=kwargs['terrain'] slope=kwargs['slope'] terrain_file=kwargs['terrain_file'] if terrain: Terrain.plot_altitude_map(SynthPlot,terrain_file) if slope: Terrain.plot_slope_map(SynthPlot)
def drawMe(self, camera, atStart): pos = intOf([self.pos[0] - camera.Left(), self.pos[1] - camera.Top()]) size = int(self.size) if self.selected == 1: pygame.draw.circle(camera.getSurface(), [255, 0, 0], pos, size, 3) elif self.selected == 2: pygame.draw.circle(camera.getSurface(), [0, 0, 255], pos, size, 3) drawCharPic(camera.getSurface(), self.picture, pos, int(self.animationFrames[int(self.frame)]), int(self.angleFacing * 180 / math.pi), self.team) if self.itemHeld != None: Terrain.drawItem(camera, [self.pos[0], self.pos[1] - self.size], self.itemHeld)
def spring_DLT(x, y, base, d=15): t_val = Terrain.GetTerrainVal(pix[x, y]) e_val = float(elevations[y][x]) diff = e_val - base if (diff > 1): return if (d == 0): return pix[x, y] = (113, 237, 255, 255) for tup in pixel_neighbors((x, y)): i, j = tup t_val = Terrain.GetTerrainVal(pix[i, j]) if (t_val != Terrain.Water() and t_val != Terrain.Ice()): spring_DLT(i, j, base, d - 1)
def BiomeGeneration(size, variance): terrain_array = Terrain.terrain_generation(size) precip_array = Terrain.terrain_generation(size) simulation_board = [[0 for x in range(size)] for y in range(size)] n = [[0 for x in range(size)] for y in range(size)] for lat in range(size): for lon in range(size): simulation_board[lat][lon] = Square(terrain_array[lat][lon], variance, lat, lon, size, precip_array[lat][lon]) ex = simulation_board[lat][lon] n[lat][lon] = ex.precipitation return simulation_board
def plot_vertical_momentum_flux(self,data,xdata,terrain): met=data[['wdir','wspd','wvert','lats','lons']] # topo=np.asarray(Terrain.get_topo(lats=met['lats'], lons=met['lons'])) topo2=np.asarray(Terrain.get_topo2(lats=met['lats'], lons=met['lons'],terrain=terrain)) u_comp,v_comp = get_wind_components(met.wspd,met.wdir) w_comp=met.wvert u_moflux = pd.rolling_cov(u_comp, w_comp, 60, center=True) v_moflux = pd.rolling_cov(v_comp, w_comp, 60, center=True) fig, ax = plt.subplots(2,1, sharex=True) l1=ax[0].plot(xdata,u_moflux,label='U-moment') l2=ax[0].plot(xdata,v_moflux,label='V-moment') ax[0].set_ylim([-1.0,1.0]) ax[0].set_ylabel('Vertical momentum flux [ m2 s-2]',color='b',fontsize=15) # plt.legend(handles=[l1,l2]) ax[0].legend() spl=UnivariateSpline(xdata[::5],topo2[::5],k=5) xsmooth=np.linspace(0.,xdata[-1],int(len(xdata))) ysmooth=spl(xsmooth) ysmooth[ysmooth<0]=0 ax[1].plot(xsmooth, ysmooth,color='black') ax[1].set_xlabel('Distance from flight start [km]',fontsize=15) plt.draw()
def load(self, level): """Loads in level based on ASCII values""" count_x = 0 count_y = 0 if level == 1: ascii_map = self.level_one_key elif level == 2: ascii_map = self.level_two_key elif level == 3: ascii_map = self.level_three_key for i in ascii_map: if i == '/': self.terrain_objects.append(Terrain(count_x, count_y)) elif i == 'S': pass elif i == 'X': self.enemy_manager.spawn(count_x, count_y) elif i == 'G': # self.objects.append(Gun(count_x, count_y, self.surface) pass count_x += SIZE_BLOCK if count_x == SIZE_SCREEN_X: count_x = 0 count_y += SIZE_BLOCK if count_y == SIZE_SCREEN_Y: break
def read(input_file): input_data = InputData() with open(input_file, "r") as in_file: header = in_file.readline().strip().split() input_data.map_m = int(header[1]) input_data.map_n = int(header[0]) input_data.num_customers = int(header[2]) input_data.num_max_offices = int(header[3]) input_data.customers_list = list() for i in range(0, input_data.num_customers): line = in_file.readline().strip().split() customer = Node(i, int(line[0]), int(line[1]), int(line[2])) input_data.customers_list.append(customer) input_data.map = [[0 for x in range(input_data.map_n)] for y in range(input_data.map_m)] for i in range(input_data.map_m): line = in_file.readline().strip() j = 0 for char in line: input_data.map[i][j] = Terrain.get_cost(char) j += 1 for node in input_data.customers_list: input_data.map[node.y][node.x] = -1 return input_data
def new(self): # initialize all variables and do all the setup for a new game self.all_sprites = pg.sprite.Group() self.walls = pg.sprite.Group() self.terrain = pg.sprite.Group() self.logicMaze = np.zeros((20, 20), int) for row, tiles in enumerate(self.map_data): for col, tile in enumerate(tiles): if tile == '.': self.setTerrain(col, row) if tile == '1': if (col < 20 and row < 20): self.logicMaze[row][col] = 1 Wall(self, col, row) if tile == 'P': Terrain(self, col, row, 1) for i in range(self.genSize): newPlayer = Player(self, col, row, i) self.generation.append(newPlayer) if i == 1: self.best = newPlayer if tile == 'F': print('Finish Line') for i in range(self.genSize): self.generation[i].configure(self.logicMaze)
def generate_grid(self, surf): """ Generates a new grid with randomized terrain covering the map. :param surf: surface images are displayed to :return: stored data """ row_len = 0 for row in range(self.width // self.block_size): col_len = 0 self.grid.append([]) for col in range(self.height // self.block_size): grass_or_clover = random.randint(0, 5) spot = [ [row_len, col_len, self.block_size, self.block_size], Creature.Creature(""), Terrain.Terrain(""), ] spot[1] = Empty.Empty() if grass_or_clover > 1: spot[2] = Grass.Grass() else: spot[2] = Clover.Clover() spot[2].set_color("alive") spot.append( pygame.draw.rect(surf, spot[2].get_color(), spot[0])) self.grid[row].append(spot) col_len += self.block_size row_len += self.block_size return self.grid
def main(): size = (70, 70) food = (3,3) colony = (size[0]-4, 3) initPatrol = 5 step = 1 terrain = Terrain.Terrain(size, colony, food) root = tk.Tk() board = Board.Board(root, terrain) board.pack(side="top", fill="both", expand="true", padx=4, pady=4) terrain.setNewPatrolCount(initPatrol) for i in range(50): terrain.makeObstacle((35, 0+i)) while 1: for i in range(1, step + 1): time.sleep(0.01) if i == step: terrain.iterate() board.update() root.update_idletasks() root.update()
def update(self): while np.linalg.norm(self.destination - self.position) < 4: self.destination = random.choice( [i.position for i in self.destination_town.buildings]) self.position += (self.destination - self.position) / np.linalg.norm(self.destination - self.position) * 0.1 self.position[1] = Terrain.getAt(self.position[0], self.position[2])
def __init__(self): super().__init__(width=960, height=640, fovx=80, downSample=1) self.changeTitle("AXI OpenCL 3D Visualizer") self.α = 3.1 self.β = -0.1 self.pos = numpy.array([600.8, 20.4, 600.3]) self.camSpeed = 0.04 self.mouseSensitivity = 20 self.ambLight = 0.08 self.st = 0 self.tt = 200 self.drawAxes = False self.b = None self.chunksize = 50 self.chunkscale = 0.8 self.renderDist = 2 self.rdextra = 0 self.numWorkers = 4 S = self.chunksize L = self.chunkscale self.cchunk = [ int(self.pos[0] / (S * L) + 0.5), int(self.pos[2] / (S * L) + 0.5) ] terr = Terrain.RandTerrain(1) self.rmax = 50000 self.terr = terr self.tp = [mp.Queue(16) for i in range(self.numWorkers)] self.rp = [mp.Queue(16) for i in range(self.numWorkers)] self.workLen = [0 for i in range(self.numWorkers)] self.vischunks = [None for i in range((self.renderDist * 2)**2)] self.reqChunks = [] self.procChunks = [] for u in range(self.cchunk[0] - self.renderDist, self.cchunk[0] + self.renderDist): for v in range(self.cchunk[1] - self.renderDist, self.cchunk[1] + self.renderDist): self.reqChunks.append((u, v)) for i in range(len(self.reqChunks)): a = self.reqChunks[0] del self.reqChunks[0] self.requestChunk(a, i)
def behavior(self): self.parent.destroy() maze = m.Maze(window, self.width, self.height, t.Terrain(10, 20, p.Player(), [], barriers=True), path="random") maze.terrain.spawnEnemy() maze.display(next="expand") self.startScreen.rebuild()
def do_fall(): print("do fall was called") newColor = (128, 128, 128, 255) oldColor = (255, 255, 255, 255) print(Terrain.GetTerrainVal((255, 255, 255, 255))) s = time.time() for x in range(MAX_X()): for y in range(MAX_Y()): if (pix[x, y] == oldColor): for tup in pixel_neighbors((x, y)): i, j = tup t_val = Terrain.GetTerrainVal(pix[i, j]) if pix[i, j] != pix[x, y] and t_val != Terrain.Water( ) and t_val != Terrain.ImpassibleVeg( ) and t_val != Terrain.RoughMeadow(): pix[i, j] = newColor pix[x, y] = newColor e = time.time() print(e - s)
def drawHUD(self, camera, atStart): if self.controlled or self.selected == 1: for i in range(self.maxHealth): xWiggle = 1 yWiggle = 2 pos = [xWiggle + 2 + 10 * i, yWiggle + 2] icon = 7 if self.health <= i: icon = 8 xWiggle = 0 yWiggle = 0 pos[0] += int( math.cos((PTRS["FRAME"] + i * 11 % 23) * math.pi / 10.0) * xWiggle) pos[1] += int( math.sin((PTRS["FRAME"] + i * 11 % 23) * math.pi / 40.0) * yWiggle) Terrain.drawItem(camera, pos, icon, True)
def main(): global pix global elevations img = Image.open('elevations_pixels.PNG') pix = img.load() with open('elevations.txt') as f: elevations = [line.split() for line in f] img.show() #do_fall() #do_winter() #do_spring() #img.show() #return print("done") print(len(elevations)) points = [] if (len(sys.argv) > 2): print("argument was passed!") with open(sys.argv[1]) as f: points = [tuple([int(i) for i in line.split()]) for line in f] season = int(sys.argv[2]) change_season(season) paths = [] stime = time.time() for i in range(len(points) - 1): start = points[i] end = points[i + 1] init = State.State(elevations[start[0]][start[1]], Terrain.GetTerrainVal(pix[start[0], start[1]]), start[0], start[1], end[0], end[1]) paths.append(A_star(init)) etime = time.time() counter = 1 for path in paths: path.reverse() hr_output(path, counter) counter += 1 for s in path: pix[s.x, s.y] = (255, 0, 0, 255) print(etime - stime) img.show() img.close() #print(points) # no file parameter passed, defaults to using points for brown path else: print("Usage: python3 orienteering.py file [season mode bit]") print("\tSEASON MODE BITS") print("\t0 -> summmer") print("\t1 -> fall") print("\t2 -> winter") print("\t3 -> spring") points = [(230, 327), (276, 279), (303, 240), (306, 286), (290, 310), (304, 331), (306, 341), (253, 372), (246, 355), (288, 338), (282, 321), (243, 327), (230, 327)]
def update(self, camera_position, camera_direction): lo = 0 hi = 1e2 for _ in xrange(8): mi = (lo + hi) / 2. test = camera_position + camera_direction * mi if Terrain.getAt(test[0], test[2]) > test[1]: hi = mi else: lo = mi self.position = camera_position + camera_direction * lo
def main(): global pix global elevations print('hello') img = Image.open('elevations_pixels.PNG') pix = img.load() print(pix) print(pix[0, 0]) print(pix[228, 308]) print(pix[230, 327]) #pix[168,236] = (255,0,0,255) #pix[178,222] = (255,0,0,255) #pix[0,0] = (0,0,0,255) #img.show() x = img.size[0] y = img.size[1] print(x) print(y) with open('elevations.txt') as f: elevations = [line.split() for line in f] print("done") print(len(elevations)) if (len(sys.argv) > 1): print("argument was passed!") return points = [(230, 327), (276, 279), (303, 240), (306, 286), (290, 310), (304, 331), (306, 341), (253, 372), (246, 355), (288, 338), (282, 321), (243, 327), (230, 327)] paths = [] """ #init = State.State(elevations[168][236], Terrain.GetTerrainVal(pix[168,236]), 168, 236, 178, 222) init = State.State(elevations[230][327], Terrain.GetTerrainVal(pix[230,327]), 230, 327, 276, 279) start = time.time() paths.append(A_star(init)) end = time.time() print(end-start) """ stime = time.time() for i in range(len(points) - 1): start = points[i] end = points[i + 1] init = State.State(elevations[start[0]][start[1]], Terrain.GetTerrainVal(pix[start[0], start[1]]), start[0], start[1], end[0], end[1]) paths.append(A_star(init)) etime = time.time() for path in paths: for s in path: pix[s.x, s.y] = (255, 0, 0, 255) print(etime - stime) img.show() img.close()
def getTerrain(rp, tp): doQuit = False terr = Terrain.RandTerrain(1) while not doQuit: try: a = rp.get(True, 0.2) except: continue if a is None: doQuit = True break else: ga = terr.getArea(*a[3:]) tp.put((*a[:3], ga))
def update(t): character.update(t) character.last_unanimated_position[1] = Terrain.getAt( character.position[0], character.position[2]) character.update(t) for i in xrange(numberNPCs): npcs[i].update() for i in xrange(numberNPCs): npcs_object.instances['model'][i] = np.eye(4) npcs_object.instances['model'][i][:3][:3] *= npcs_object.scale transforms.translate(npcs_object.instances["model"][i], *npcs[i].position) npcs_object.refreeze()
def __init__(self, main, size, gravity=Vector2.Vector2()): size = (main.screen.get_width(), main.screen.get_height()) self.terrain = Terrain.Terrain(main.resources, size, self) self.phyEng = PhysEng.PhysEng() self.objects = [] self.toRemove = [] self.gravity = gravity self.main = main self.reset = False self.load = False self.objs = [] self.map_file = [] self.name = "world" self.music = [] self.size = size
def plot_vertical_heat_flux(self,data,xdata): met=data[['theta','wvert','lats','lons']] topo=np.asarray(Terrain.get_topo(lats=met['lats'], lons=met['lons'])) v_heatflux = pd.rolling_cov(met.wvert, met.theta, 60, center=True) plt.figure() plt.plot(xdata,v_heatflux) ax=plt.gca() ax.set_ylim([-0.5,0.5]) ax.set_ylabel('Vertical heat flux [K m s-1]',color='b',fontsize=15) ax.set_xlabel('Distance from flight start [km]',fontsize=15) add_second_y_in(ax,topo,xaxis=xdata, color='r',label='Topography [m]') plt.draw()
def canSeeUnit(self, unit): if dist(unit.getPos(), self.getPos()) <= self.getListenRange() or \ (dist(unit.getPos(), self.getPos()) <= self.getSightRange() and self.unitInSightArc(unit)): for square in raytrace([ int(self.getPos()[0] / TILESIZE[0]), int(self.getPos()[1] / TILESIZE[1]) ], [ int(unit.getPos()[0] / TILESIZE[0]), int(unit.getPos()[1] / TILESIZE[1]) ]): if not Terrain.canSeeThrough(PTRS["TERRAIN"].getAtCoord( intOf(square))): return False return True return False
def plot_tke(self,data,xaxis): met=data[['wdir','wspd','wvert','lats','lons']] topo=np.asarray(Terrain.get_topo(lats=met['lats'], lons=met['lons'])) u_comp,v_comp = get_wind_components(met.wspd,met.wdir) w_comp=met.wvert u_var = pd.rolling_var(u_comp,60,center=True) v_var = pd.rolling_var(v_comp,60,center=True) w_var = pd.rolling_var(w_comp,60,center=True) tke = 0.5*(u_var+v_var+w_var) plt.figure() plt.plot(xaxis,tke) ax=plt.gca() ax.set_ylim([0,10]) plt.xlabel('distance') plt.ylabel('TKE [m2 s-2]') add_second_y_in(ax,topo,xaxis=xaxis,color='g',label='Topography [m]') plt.draw()
def GetSuccessors(state): succ = [] # successors above succ.append( State.State(elevations[state.x + 1][state.y - 1], Terrain.GetTerrainVal(pix[state.x + 1, state.y - 1]), state.x + 1, state.y - 1, state.goalX, state.goalY)) succ.append( State.State(elevations[state.x + 1][state.y], Terrain.GetTerrainVal(pix[state.x + 1, state.y]), state.x + 1, state.y, state.goalX, state.goalY)) succ.append( State.State(elevations[state.x + 1][state.y + 1], Terrain.GetTerrainVal(pix[state.x + 1, state.y + 1]), state.x + 1, state.y + 1, state.goalX, state.goalY)) succ.append( State.State(elevations[state.x][state.y - 1], Terrain.GetTerrainVal(pix[state.x, state.y - 1]), state.x, state.y - 1, state.goalX, state.goalY)) succ.append( State.State(elevations[state.x][state.y + 1], Terrain.GetTerrainVal(pix[state.x, state.y + 1]), state.x, state.y + 1, state.goalX, state.goalY)) succ.append( State.State(elevations[state.x - 1][state.y - 1], Terrain.GetTerrainVal(pix[state.x - 1, state.y - 1]), state.x - 1, state.y - 1, state.goalX, state.goalY)) succ.append( State.State(elevations[state.x - 1][state.y], Terrain.GetTerrainVal(pix[state.x + 1, state.y]), state.x + 1, state.y, state.goalX, state.goalY)) succ.append( State.State(elevations[state.x - 1][state.y + 1], Terrain.GetTerrainVal(pix[state.x - 1, state.y + 1]), state.x - 1, state.y + 1, state.goalX, state.goalY)) return succ
def setTerrain(self, col, row): rand = random.randint(0, 100) if (self.difficulty == 1): if (rand <= 80): Terrain(self, col, row, 1) elif (rand > 80 and rand <= 90): Terrain(self, col, row, 2) else: Terrain(self, col, row, 3) if (self.difficulty == 2): if (rand <= 60): Terrain(self, col, row, 1) elif (rand > 60 and rand <= 80): Terrain(self, col, row, 2) else: Terrain(self, col, row, 3)
def loadBackground(self): self.terrain = Terrain(self)
from Terrain import * T = Terrain(128) T.simplex(5) T.mesh()
import pygame import config import Player import Terrain import Inventory import showcoords pygame.init() window = pygame.display.set_mode((config.screen_width, config.screen_height)) pygame.display.set_caption("Minecraft2D") terrain = Terrain.Terrain() player = Player.Player(terrain) equipment = Inventory.Inventory() def update(ev): player.update(ev, terrain, equipment) equipment.update(ev) def draw(): window.fill((0, 0, 0)) terrain.draw(window, player) player.draw(window) equipment.draw(window) showcoords.draw(window, player) terrain.create_terrain()
def cross_section(self,**kwargs): field_array=kwargs['field'] ''' calculate wind components''' u_array=self.u_array v_array=self.v_array ''' along cross section assuming self.azimuth within [0, 90] ''' wind_dir_section = self.azimuth -180. wx = u_array*np.sin(wind_dir_section*np.pi/180.) wy = v_array*np.cos(wind_dir_section*np.pi/180.) wind_array = -(wx+wy) ''' perpendicular to cross section ''' orthogonal_dir_section =wind_dir_section + 90. qx = u_array*np.sin(orthogonal_dir_section*np.pi/180.) qy = v_array*np.cos(orthogonal_dir_section*np.pi/180.) orth_array = (qx+qy) self.slice_type='cross_section' self.set_panel(option=self.slice_type,wind=False) figsize=self.figure_size['vertical'] ''' get indices of starting and ending coordinates ''' latix_0=cm.find_index_recursively(array=self.lats,value=self.slice[0][0],decimals=2) lonix_0=cm.find_index_recursively(array=self.lons,value=self.slice[0][1],decimals=2) latix_1=cm.find_index_recursively(array=self.lats,value=self.slice[1][0],decimals=2) lonix_1=cm.find_index_recursively(array=self.lons,value=self.slice[1][1],decimals=2) ''' create grid for the entire domain ''' xx = np.arange(0,self.axesval['x'].size) yy = np.arange(0,self.axesval['y'].size) zz = np.arange(0,self.axesval['z'].size) xm,ym,zm = np.meshgrid(xx,yy,zz) ''' convert grid and plotting field to vector columns''' xd=np.reshape(xm,[1,xm.size]).tolist() yd=np.reshape(ym,[1,ym.size]).tolist() zd=np.reshape(zm,[1,zm.size]).tolist() xd=xd[0] yd=yd[0] zd=zd[0] ''' specify grid for interpolated cross section ''' hres = 100 vres = 44 xi = np.linspace(lonix_0, lonix_1, hres) yi = np.linspace(latix_0, latix_1, hres) zi = np.linspace(0, 43, vres) zi=np.array([zi,]*hres) ki=np.ma.empty([vres,hres]) wi=np.ma.empty([vres,hres]) qi=np.ma.empty([vres,hres]) # fillv = field_array.fill_value ''' convert to standard numpy array (not masked) and replace fill values for nans ''' kd=np.ma.filled(field_array, fill_value=np.nan) wd=np.ma.filled(wind_array, fill_value=np.nan) qd=np.ma.filled(orth_array, fill_value=np.nan) ''' convert to 1 column array ''' kd=np.reshape(kd,[kd.size,1]) wd=np.reshape(wd,[wd.size,1]) qd=np.reshape(qd,[qd.size,1]) ''' create kdTree with entire domain''' coords=zip(xd,yd,zd) tree = cKDTree(coords) ''' interpolate using kdTree (nearest neighbor) and averaging the neighborhood ''' neigh = 8 for k in range(vres): coords = zip(yi, xi, zi[:,k]) dist, idx = tree.query( coords, k=neigh, eps=0, p=1, distance_upper_bound=10) kd_mean = np.nanmean(kd[idx],axis=1) wd_mean = np.nanmean(wd[idx],axis=1) qd_mean = np.nanmean(qd[idx],axis=1) ki[k,:]=kd_mean.T wi[k,:]=wd_mean.T qi[k,:]=qd_mean.T component = [wi, qi] comptitle = ['Along-section wind speed [m s-1] (contours)\n', 'Cross-section wind speed [m s-1] (contours)\n'] for n in range(2): """make plot with wind speed along cross section """ with sns.axes_style("white"): fig,ax = plt.subplots(figsize=(8,11*0.5)) ''' add field as image ''' zsynth = self.axesval['z'] gate_hgt=0.25 #[km] extent = [0, self.distance, zsynth[0]-gate_hgt/2., zsynth[-1]+gate_hgt/2.] # im, cmap, norm = self.add_field(ax,array=ki,field=self.var, extent=extent) im, cmap, norm = self.add_field2(ax,array=ki,field=self.var, extent=extent) ''' add terrain profiel ''' prof = Terrain.get_altitude_profile(self) prof = np.asarray(prof) self.add_terrain_profile(ax, prof ,None) self.terrain.array['profile']=prof ''' add contour of wind section ''' X,Y = np.meshgrid(np.linspace(0, self.distance, hres), zsynth) sigma=0.5 section = gaussian_filter(component[n], sigma,mode='nearest') cs = ax.contour(X,Y,section,colors='k', linewidths=1.5, levels=range(-4,26,2)) # cs = ax.contour(X,Y,component[n],colors='k',linewidths=0.5, levels=range(-4,26,2)) ax.clabel(cs, fontsize=12, fmt='%1.0f',) ax.set_yticks(zsynth[1::2]) ytlabels = ["{:3.1f}".format(z) for z in zsynth[1::2]] ax.set_yticklabels(ytlabels) ax.set_ylim(0. , 7.5) ax.set_xlim(0. , self.distance) legname = os.path.basename(self.file) ta=ax.transAxes ax.text(0.05,0.9, legname[:3].upper() + " " + legname[3:5], transform = ta,weight='bold') y,x = zip(*self.slice) stlat='{:3.2f}'.format(y[0]) stlon='{:3.2f}'.format(x[0]) ax.text(0.05,0.85, 'start: ('+stlat+','+stlon+')', transform = ta) enlat='{:3.2f}'.format(y[-1]) enlon='{:3.2f}'.format(x[-1]) ax.text(0.05,0.8, 'end: ('+enlat+','+enlon+')', transform = ta) staz='{:3.1f}'.format(self.azimuth) ax.text(0.05, 0.75, 'az: '+staz, transform=ta) ax.set_xlabel('Distance along cross section [km]') ax.set_ylabel('Altitude [km]') if self.verticalGridMajorOn: ax.grid(True, which = 'major',linewidth=1) if self.verticalGridMinorOn: ax.grid(True, which = 'minor',alpha=0.5) ax.minorticks_on() ''' add color bar ''' fig.colorbar(im,cmap=cmap, norm=norm) ''' add title ''' titext='Dual-Doppler Synthesis: '+ self.get_var_title(self.var)+' (color coded)\n' titext=titext+comptitle[n] line_start='Start time: '+self.synth_start.strftime('%Y-%m-%d %H:%M')+' UTC\n' line_end='End time: '+self.synth_end.strftime('%Y-%m-%d %H:%M')+' UTC' fig.suptitle(titext+line_start+line_end) plt.subplots_adjust(top=0.85,right=1.0) plt.draw() return ki,component
def main(genomes, config): nets = [] ge = [] birds = [] for _, g in genomes: net = neat.nn.FeedForwardNetwork.create(g, config) nets.append(net) birds.append(Bird.Bird(230, 350)) g.fitness = 0 ge.append(g) base = Terrain.Base(730) pipes = [Pipe.Pipe(700)] win = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT)) clock = pygame.time.Clock() score = 0 run = True while run: clock.tick(30) for event in pygame.event.get(): if event.type == pygame.QUIT: run = False pygame.quit() quit() # bird move pipe_ind = 0 if len(birds) > 0: if len(pipes) > 1 and birds[ 0].x > pipes[0].x + pipes[0].PIPE_TOP.get_width(): pipe_ind = 1 else: run = False break for x, bird in enumerate(birds): bird.move() ge[x].fitness += 0.3 output = nets[x].activate( (bird.y, abs(bird.y - pipes[pipe_ind].height), abs(bird.y - pipes[pipe_ind].bottom))) if output[0] > 0.5: bird.jump() add_pipe = False rem = [] for pipe in pipes: for x, bird in enumerate(birds): if pipe.collide(bird): ge[x].fitness -= 0.5 birds.pop(x) nets.pop(x) ge.pop(x) if not pipe.passed and pipe.x < bird.x: pipe.passed = True add_pipe = True if pipe.x + pipe.PIPE_TOP.get_width() < 0: rem.append(pipe) pipe.move() if add_pipe: score += 1 for g in ge: g.fitness += 5 pipes.append(Pipe.Pipe(600)) for r in rem: pipes.remove(r) for x, bird in enumerate(birds): if bird.y + bird.img.get_height() >= 730 or bird.y < 0: birds.pop(x) nets.pop(x) ge.pop(x) base.move() draw_window(win, birds, pipes, base, score)
def vertical_plane(self,**kwargs): field_array=None for key,value in kwargs.iteritems(): if key == 'field': isWind=False field_array=value if key == 'spd': isWind=True windname=value elif key == 'sliceo': self.sliceo=value u_array=self.u_array v_array=self.v_array w_array=self.w_array self.slice_type='vertical' self.set_panel(option=self.slice_type,wind=isWind) figsize=self.figure_size['vertical'] fig = plt.figure(figsize=figsize) plot_grids=ImageGrid( fig,111, nrows_ncols = self.rows_cols, axes_pad = 0.0, add_all = True, share_all=False, label_mode = "L", cbar_location = "top", cbar_mode="single", aspect=True) """ get list with slices """ uComp = self.get_slices(u_array) vComp = self.get_slices(v_array) wComp = self.get_slices(w_array) profiles = Terrain.get_altitude_profile(self) if isWind: if windname == 'u': field_group = uComp colorName='U' varName=colorName elif windname == 'v': field_group = vComp colorName='V' varName=colorName elif windname == 'w': field_group = wComp colorName='WVA' varName=colorName else: field_group = self.get_slices(field_array) varName=self.var ''' field extent ''' extent1=self.get_extent() ''' if zoomOpt is false then extent1=extent2 ''' if self.zoomOpt: opt=self.zoomOpt[0] extent2=cm.zoom_in(self,extent1,self.zoomCenter[opt]) else: extent2=extent1 ''' scale for horizontal axis''' self.scale=20 ''' adjust vertical extent ''' if self.sliceo=='meridional': extent3=cm.adjust_extent(self,extent1,'meridional','data') extent4=cm.adjust_extent(self,extent2,'meridional','detail') horizontalComp=vComp geo_axis='Lon: ' elif self.sliceo=='zonal': extent3=cm.adjust_extent(self,extent1,'zonal','data') extent4=cm.adjust_extent(self,extent2,'zonal','detail') horizontalComp=uComp geo_axis='Lat: ' """creates iterator group """ group=zip(plot_grids, field_group, horizontalComp, wComp, profiles['altitude'],profiles['axis']) """make gridded plot """ p=0 for g,field,h_comp,w_comp,prof,profax in group: if isWind: im, cmap, norm = self.add_field(g, array=field.T, field=varName, name=colorName, ext=extent3) else: im, cmap, norm = self.add_field(g, array=field.T, field=varName, name=self.var, ext=extent3) self.add_terrain_profile(g,prof,profax) if self.wind and not isWind: self.add_windvector(g,h_comp.T,w_comp.T) self.add_slice_line(g) g.set_xlim(extent4[0], extent4[1]) g.set_ylim(extent4[2], extent4[3]) if p == 0: self.match_horizontal_grid(g) self.adjust_ticklabels(g) if self.verticalGridMajorOn: g.grid(True, which = 'major',linewidth=1) if self.verticalGridMinorOn: g.grid(True, which = 'minor',alpha=0.5) g.minorticks_on() if self.sliceo=='meridional': geotext=geo_axis+str(self.slicem[p]) elif self.sliceo=='zonal': geotext=geo_axis+str(self.slicez[p]) g.text( 0.03, 0.9, geotext, fontsize=self.zlevel_textsize, horizontalalignment='left', verticalalignment='center', transform=g.transAxes) p+=1 # add color bar plot_grids.cbar_axes[0].colorbar(im,cmap=cmap, norm=norm) # add title titext='Dual-Doppler Synthesis: '+ self.get_var_title(varName)+'\n' line_start='\nStart time: '+self.synth_start.strftime('%Y-%m-%d %H:%M')+' UTC' line_end='\nEnd time: '+self.synth_end.strftime('%Y-%m-%d %H:%M')+' UTC' fig.suptitle(titext+self.file+line_start+line_end) # show figure plt.draw()
def horizontal_plane(self , **kwargs): field_array=kwargs['field'] u_array=self.u_array v_array=self.v_array w_array=self.w_array if self.mask: field_array.mask=w_array.mask u_array.mask=w_array.mask v_array.mask=w_array.mask if self.panel: self.set_panel(option='single') figsize=self.figure_size['single'] else: self.set_panel(option='multi') figsize=self.figure_size['multi'] self.slice_type='horizontal' with sns.axes_style("white"): fig = plt.figure(figsize=figsize) plot_grids=ImageGrid( fig,111, nrows_ncols = self.rows_cols, axes_pad = 0.0, add_all = True, share_all=False, label_mode = "L", cbar_location = "top", cbar_mode="single") ''' field extent ''' extent1=self.get_extent() ''' if zoomOpt is false then extent1=extent2 ''' if self.zoomOpt: opt=self.zoomOpt[0] extent2=cm.zoom_in(self,extent1,self.zoomCenter[opt]) else: extent2=extent1 ''' make slices ''' field_group = self.get_slices(field_array) ucomp = self.get_slices(u_array) vcomp = self.get_slices(v_array) ''' creates iterator group ''' group=zip(plot_grids,self.zlevels,field_group,ucomp,vcomp) gn=0 ''' make gridded plot ''' for g,k,field,u,v in group: self.add_coastline(g) self.add_flight_path2(g) im, cmap, norm = self.add_field2(g, array=field.T, field=self.var) if self.terrain.file: Terrain.add_contour(g,k,self) if self.wind: self.add_windvector(g,u.T,v.T,gn) if self.slice: self.add_slice_line(g,gn) if self.markersLocations: self.add_location_markers(g, gn) g.set_xlim(extent2[0], extent2[1]) g.set_ylim(extent2[2], extent2[3]) if gn == 0: legname = os.path.basename(self.file) g.text(0.02,0.15, legname[:3].upper() + " " + legname[3:5], horizontalalignment='left', transform = g.transAxes,weight='bold') if self.horizontalGridMajorOn: g.grid(True, which = 'major',linewidth=1) if self.horizontalGridMinorOn: g.grid(True, which = 'minor',alpha=0.5) g.minorticks_on() ztext=str(k)+'km MSL' g.text( 0.02, 0.03, ztext, fontsize=self.zlevel_textsize, horizontalalignment='left', verticalalignment='center', transform=g.transAxes) self.horizontal['ymajor'] = g.get_yticks(minor=False) self.horizontal['yminor'] = g.get_yticks(minor=True) self.horizontal['xmajor'] = g.get_xticks(minor=False) self.horizontal['xminor'] = g.get_xticks(minor=True) gn+=1 ''' add color bar ''' plot_grids.cbar_axes[0].colorbar(im,cmap=cmap, norm=norm) ''' add title ''' st=self.synth_start en=self.synth_end t1='Dual-Doppler Synthesis: '+ self.get_var_title(self.var) +'\n' t2='Date: '+st.strftime('%Y-%m-%d') + '\n' t3= 'Time: '+st.strftime('%H:%M')+'-'+en.strftime('%H:%M UTC') + '\n' # fig.suptitle(t1+t2+t3+self.file) fig.suptitle(t1+t2+t3) plt.draw() self.haxis=g
def plot_meteo(self,xaxis,dots): topo=Terrain.get_topo(lats=self.met['lats'], lons=self.met['lons']) varname={ 0:{'var':'atemp','name': 'air temperature', 'loc':3,'ylim':None,'fmt':False}, 1:{'var':'dewp','name': 'dew point temp', 'loc':3,'ylim':None,'fmt':False}, 2:{'var':'wdir','name':'wind direction', 'loc':(0.05,0.9),'ylim':None,'fmt':True}, 3:{'var':'apres','name': 'air pressure', 'loc':(0.05,0.9),'ylim':None,'fmt':False}, 4:{'var':'relh','name':'relative humidity', 'loc':(0.05,0.05),'ylim':[80,101],'fmt':True}, 5:{'var':'wspd','name': 'wind speed', 'loc':(0.05,0.9),'ylim':None,'fmt':True}, 6:{'var':'galt','name': 'geopotential alt', 'loc':(0.05,0.9),'ylim':None,'fmt':True}, 7:{'var':'jwlwc','name':'liquid water content', 'loc':(0.05,0.9),'ylim':None,'fmt':False}, 8:{'var':'wvert','name':'vertical velocity', 'loc':(0.05,0.9),'ylim':[-2,4],'fmt':True}, 9:{'var':'palt','name': 'pressure alt', 'loc':(0.05,0.9),'ylim':None,'fmt':True}} fig, ax = plt.subplots(3,3, sharex=True,figsize=(15,10)) axs=ax.ravel() for i in varname.items(): item = i[0] var = i[1]['var'] name = i[1]['name'] loc = i[1]['loc'] ylim = i[1]['ylim'] ax = axs[item-1] if item < 2: # air temp and dew point in the same plot axs[0].plot(xaxis,self.met[var],label=name) if ylim: axs[0].set_ylim(ylim) if item == 1: axs[0].grid(True) axs[0].legend(loc=loc,frameon=False) else: ax.plot(xaxis,self.met[var],label=name) if item == 6: ax2 = ax.twinx() ax2.plot(xaxis,topo,'r') ax2.set_ylabel('topography [m]', color='r') for tl in ax2.get_yticklabels(): tl.set_color('r') ax2.grid(False) if ylim: ax.set_ylim(ylim) ax.grid(True) ax.annotate(name, fontsize=16, xy=loc, xycoords='axes fraction') if item == 8: ax.set_xlabel('Distance from beginning of flight [km]') new_xticks=[xaxis[i] for i in dots] adjust_xaxis(axs,new_xticks) adjust_yaxis(axs) # --> it's affecting formatter l1='Flight level meteorology for '+self.name l2='\nStart time: '+self.time[0].strftime('%Y-%m-%d %H:%M')+' UTC' l3='\nEnd time: '+self.time[1].strftime('%Y-%m-%d %H:%M')+' UTC' fig.suptitle(l1+l2+l3,y=0.98) fig.subplots_adjust(bottom=0.08,top=0.9, hspace=0,wspace=0.2) plt.draw