def from_dict(request_dict): id = request_dict.get('id', generate_uuid()) request = TaskRequest(id=id) request.load_type = request_dict["loadType"] request.load_id = request_dict["loadId"] request.user_id = request_dict["userId"] request.earliest_pickup_time = TimeStamp.from_str( request_dict["earliestPickupTime"]) request.latest_pickup_time = TimeStamp.from_str( request_dict["latestPickupTime"]) pickup_area_dict = request_dict.get('pickup_pose', None) if pickup_area_dict: request.pickup_pose = Area.from_dict(pickup_area_dict) else: # when the provided dict is from json schema request.pickup_pose = Area() request.pickup_pose.name = request_dict.get("pickupLocation", '') request.pickup_pose.floor_number = request_dict.get( "pickupLocationLevel", 0) delivery_area_dict = request_dict.get('delivery_pose', None) if delivery_area_dict: request.delivery_pose = Area.from_dict(delivery_area_dict) else: # when the provided dict is from json schema request.delivery_pose = Area() request.delivery_pose.name = request_dict.get( "deliveryLocation", '') request.delivery_pose.floor_number = request_dict.get( "deliveryLocationLevel", 0) request.priority = request_dict["priority"] return request
def test_area_calculateDistances(self): area = Area(5) area.saveArea() testArea = Area('file') self.assertEqual(testArea.numberOfBlocks, 5) self.assertEqual(testArea.cords.shape, (5, 2)) self.assertEqual(testArea.sizes.shape, (5, )) self.assertEqual(testArea.distances.shape, (5, 5))
def __init__(self, id=''): if not id: self.id = generate_uuid() else: self.id = id self.pickup_pose = Area() self.delivery_pose = Area() self.earliest_pickup_time = TimeStamp() self.latest_pickup_time = TimeStamp() self.user_id = '' self.load_type = '' self.load_id = '' self.priority = -1
def __init__(self): self.area = Area() self.ant_num = 20 self.ant_list = [] self.add_number = 0 for i in range(self.ant_num): self.ant_list.append(Ant(self.area.area))
def __init__(self, handle): activity.Activity.__init__(self, handle) self.screen = None self.toolbarbox = ToolbarBox(self) self.toolbarbox.connect("show-simulation", self._show_simulation_cb) self.toolbarbox.connect("show-info", self._show_info_cb) self.toolbarbox.connect("go-back", self._go_back_cb) self.toolbarbox.connect("go-forward", self._go_forward_cb) self.toolbarbox.connect("show-orbits", self._show_orbits_cb) self.toolbarbox.connect("show-body", self._show_body_cb) self.toolbarbox.connect("speed-changed", self._speed_changed_cb) self.toolbarbox.connect("zoom-changed", self._zoom_changed_cb) self.set_toolbar_box(self.toolbarbox) self.box = Gtk.VBox() self.set_canvas(self.box) self.area = Area() self.area.connect("body-selected", self._body_selected) self.info_view = InfoView() self.info_view.connect("change-cursor", self._change_cursor) self.info_view.connect("can-go-back", self._can_go_back_cb) self.info_view.connect("can-go-forward", self._can_go_forward_cb) self.set_screen(Screen.SOLAR_SYSTEM) self.show_all()
def __init__(self): Gtk.VBox.__init__(self) self.screen = None self.area = Area() self.area.connect("body-selected", self._body_selected) self.info_view = InfoView() self.info_view.connect("change-cursor", self._change_cursor) adj = Gtk.Adjustment(10, 0.2, 100, 0.5, 1) s = Gtk.HScale() s.set_draw_value(False) s.set_adjustment(adj) s.connect("value-changed", self.change_zoom) self.pack_start(s, False, False, 0) adj = Gtk.Adjustment(1, 0.1, 5, 0.1, 1) s = Gtk.HScale() s.set_draw_value(False) s.set_adjustment(adj) s.connect("value-changed", self.change_speed) self.pack_start(s, False, False, 0) self.set_screen(Screen.SOLAR_SYSTEM) self.show_all()
def test_area_size(self): area = Area('draw', 10) self.assertEqual(area.numberOfBlocks, 10) self.assertEqual(area.cords.shape, (10, 2)) self.assertEqual(area.sizes.shape, (10, )) self.assertEqual(area.distances.shape, (10, 10))
def __init__(self): self.area_number = 1 self.area = Area() self.hero = Hero() self.characters = self.create_characters() self.monsters = self.characters[1:] self.kill_count = 0
def __call__(self, area): start = self.getStart(area) end = self.getEnd(area) a = Area(start.x, start.y, end.x, end.y) for (x, y, orientation) in self.algorithm(a): yield Coords(x, y, orientation)
def __call__(self, c): start = self.area.startFrom(c) end = self.area.endFrom(c) a = Area(start.x, start.y, end.x, end.y) for x in self.feature(a): yield x
def canSee(self, other): cursor = self.cell.getCursor() l = list(algorithms.line(Area(self.x, self.y, other.x, other.y))) l = l[1:-1] for (x, y, _) in l: if cursor.move(x, y).isSolid: return False return True
def next_area(self, canvas): self.area_number += 1 self.area = Area() self.hero.restore_health() self.characters = self.create_characters() self.monsters = self.characters[1:] self.area.draw_map(canvas) canvas.delete(self.hero.name) self.hero.direction = 'hero-down' self.spawn_characters(canvas)
def __init__(self, handle): activity.Activity.__init__(self, handle) self.make_toolbar() hbox = Gtk.HBox() self.set_canvas(hbox) self.area = Area() hbox.pack_start(self.area, True, False, 0) self.show_all()
def convert_unit(self, value, input_unit, output_unit): if self.measurement is 'length': return Length(value, input_unit, output_unit).convert() if self.measurement is 'temperature': return Temperature(value, input_unit, output_unit).convert() if self.measurement is 'area': return Area(value, input_unit, output_unit).convert() if self.measurement is 'volume': return Volume(value, input_unit, output_unit).convert() if self.measurement is 'weight': return Weight(value, input_unit, output_unit).convert() return "Not a valid measurement is entered! Select from : length, temperature, volume, area, weight"
def test_getAdjacent(): # Put two areas in a zone a = Area(name="A", desc="area_desc", domain=[8], action=lambda: 5, resource_id="a_id") b = Area(name="B", desc="area_desc", domain=[9], action=lambda: 5, resource_id="b_id") z = Zone([a, b]) for x in z.areas: x.zone = z assert a.zone == z assert b.zone == z # Test adjacency assert a.getAdjacent() == b assert b.getAdjacent() == a
def test_fields(): # sample areas a1 = Area(name="area1", desc="area desc", domain=[8], action=lambda: 1, resource_id="r_id") a2 = Area(name="area2", desc="area desc", domain=[9], action=lambda: 0, resource_id="r_id") # test initialization areas = [a1, a2] z = Zone(areas) # test fields assert z.areas == areas # test dump assert z.dump() == [a1.dump(), a2.dump()]
def get_board(): numbers = [] for i in range(1, NUMBER_X * NUMBER_Y + 1): numbers.append(i) board = [] for i in range(NUMBER_X): areas = [] for j in range(NUMBER_Y): x = random.randint(0, len(numbers) - 1) position = i * ELEMENT_SIZE, j * ELEMENT_SIZE areas.append(Area(position, numbers[x])) numbers.pop(x) board.append(areas) return board
def __init__(self, env): self.env = env self.actor_moved = [i for i in range(3)] self.areas = [Area(i, "area %d" %i, 100, env) for i in range(3)] self.actors = [Actor(i, self.areas[i], env) for i in range(self.ACTOR_COUNT)] self.actor_wait_event_procs = [env.process(self.actors[i].process_event()) for i in range(3)] # self.actor_procs = env.process(self.trigger_actor_events()) self.check_actors_procs = env.process(self.check_actors()) self.area_move_in_procs = [env.process(self.areas[i].move_in()) for i in range(self.AREA_COUNT)] self.area_move_out_procs = [env.process(self.areas[i].move_out()) for i in range(self.AREA_COUNT)]
def test_generateBasePopulation(self): area = Area('draw', numberOfBlocks) ga = GeneticAlgorithm(area, populationSize, mutationPercent, successionRate, diversityRate, time, solution, secondStage, progress) basePopulation = ga.createBasePopulation() self.assertEqual(basePopulation.shape, (ga.populationSize, ga.area.numberOfBlocks + 1)) self.assertEqual(sum(basePopulation[-1, :-1]), sum(basePopulation[0, :-1])) self.assertEqual(sum(basePopulation[0, :-1]), sum(range(0, ga.area.numberOfBlocks))) self.assertEqual( sum(np.sum(basePopulation[:, :-1], axis=1)), sum(range(0, ga.area.numberOfBlocks)) * ga.populationSize)
def frame(area): startX = area.left startY = area.top endX = area.right endY = area.bottom yield (startX, startY, "stationary") yield (startX, endY, "stationary") yield (endX, endY, "stationary") yield (endX, startY, "stationary") for coords in ((startX + 1, startY, endX - 1, startY), (startX, startY + 1, startX, endY - 1), (startX + 1, endY, endX - 1, endY), (endX, startY + 1, endX, endY - 1)): for point in line(Area(*coords)): yield point
def select_area(epsg_code: str, areas_json: [dict], point_json: dict) -> dict: epsg_code = 'epsg:' + epsg_code areas = [ Area(json['name'], Geometry.from_geojson(json['geometry'], epsg_code)) for json in areas_json ] point = Geometry.from_geojson(point_json, epsg_code) selected_area = Model(areas).select_area(point) selected_area.boundary_distance(point) if selected_area is None: return None return { 'selected_area': selected_area.representation(), 'boundary_distance': selected_area.boundary_distance(point) }
def reset(self): # This ensures that the traffic arrays (which size is dynamic) # are all reset as well, so all lat,lon,sdp etc but also objects adsb super(Traffic, self).reset() self.ntraf = 0 # Reset models self.wind.clear() # Build new modules for area and turbulence self.area = Area() self.Turbulence = Turbulence() # Noise (turbulence, ADBS-transmission noise, ADSB-truncated effect) self.setNoise(False) # Default: BlueSky internal performance model. # Insert your BADA files to the folder "BlueSky/data/coefficients/BADA" # for working with EUROCONTROL`s Base of Aircraft Data revision 3.12 self.perf = Perf() self.trails.reset()
def test_fields(): # test initialization a = Area(name="area_name", desc="area_desc", domain=[9], action=lambda: 5, resource_id="r_id") # test fields assert a.name == "area_name" assert a.desc == "area_desc" assert len(a.domain) == 1 and a.domain[0] == 9 assert a.action() == 5 assert a.resource_id == "r_id" # test dump dump = a.dump() assert dump['name'] == "area_name" assert dump['desc'] == "area_desc" assert dump['domain'] == "[9]" assert str(dump) == str(a)
def __init__(self, size): self.perf = 0 self.size = size self.grid = [[Area(x, y) for x in range(self.size)] for y in range(self.size)] self.situate_portal() for i in range(0, self.size): for j in range(0, self.size): self.grid[i][j].left_neighbour = self.get_area_at_position( j - 1, i) self.grid[i][j].right_neighbour = self.get_area_at_position( j + 1, i) self.grid[i][j].up_neighbour = self.get_area_at_position( j, i - 1) self.grid[i][j].down_neighbour = self.get_area_at_position( j, i + 1) self.grid[i][j].onNeighborsSet() if not (i == 0 & j == 0): if not (self.grid[i][j].get_portal()): if not (self.generate_monster(j, i)): self.generate_hole(j, i)
from area import Area from item import Item from player import Player start = Area( "You find yourself stranded in the middle of a road. Looking to either " "side you see nothing but nondescript forest. It appears your only " "path is either forward, farther down to where you were apparently " "going, or backwards, from where you apparently came. ", "A barren stretch of road. How did you end up there? " ) keychain = Item( frozenset(["keys", "keychain", "key"]), "The keychain is made up of three keys and a key fob with the word " "\"TESIN\" inscribed on a tiny, rubber computer mouse. Two of the keys " "are rather plain but the third has a Toyota symbol on it. ", "There is a keychain at your feet. " ) wallet = Item( frozenset(["wallet", "billfold", "pocketbook"]), "Looking inside the wallet, you find a small photo of yourself with your " "arm around someone's sholders. There's a couple fives as well as an old " "library card. ", "There is a wallet laying on the road to your left. " ) forward = Area( "After a few hours of walking you notice it's starting to get dark. You " "decide it would be better to set up camp before night falls, so you "
from area import Area from zodiaco import Zodiaco from euler import Euler while True: print("1. Calcular areas") print("2. Saber signo Zodiacal") print("3. Numero e") opc = input("Elige una opcion: ") if opc == "1": a = Area() while True: print("\n1. Area cuadrado") print("2. Area triangulo") print("3. Area circulo") op = input("Elige una opcion: ") if op == "1": a.areaCuadrado() elif op == "2": a.areaTriangulo() elif op == "3": a.areaCirculo() elif op == "0": break elif opc == "2": print("\n") z = Zodiaco() z.signo()
def index2(receipt_id): # takes in the click coords and receipt id and returns the text value if it exists within one of the box coords # clicked_coords = request.form.get('coords') # clicked_coords = [1500, 1600] #test case # #should output RM15.09 #obtains click coordinates from the user clicked_coords = request.get_data() clicked_coords = clicked_coords.decode('utf-8') clicked_coords = clicked_coords.split(',') clicked_coords_x = int(clicked_coords[0]) clicked_coords_y = int(clicked_coords[1]) receipt = Receipt.get_by_id(receipt_id) if receipt: receipt_details = Receipt_details.select().where( Receipt_details.receipt == receipt) for i in receipt_details: # check each item in receipt_details to see if the CC is in the box tuple_coords = eval(i.coords) TL_x = tuple_coords[0][0] TL_y = tuple_coords[0][1] BR_x = tuple_coords[1][0] BR_y = tuple_coords[1][1] if BR_x - TL_x < 20: TL_x -= 25 BR_x += 25 TL_y -= 10 BR_y += 10 ''' test code, should return True, and i.text = RM15.09 when receipt_id = 17 clicked_coords = [1500, 1600] clicked_coords_x = clicked_coords[0] clicked_coords_y = clicked_coords[1] TL_x = 1448 TL_y = 1578 BR_x = 1699 BR_y = 1637 ''' test2 = Area(TL_x, TL_y, BR_x, BR_y) if test2.inside(clicked_coords_x, clicked_coords_y) == True: # if the clicked coords are inside of a bound box of a certain item, then return the items that exist on the same row, in a list line_list = [] height = BR_y - TL_y var_factor = 0.30 y_low = TL_y - height * var_factor y_high = height * var_factor + BR_y for i in receipt_details: # searching through receipt details to see what items exist in the range of these y coords y_low to y_high tuple_coords = eval(i.coords) TL_y = tuple_coords[0][1] BR_y = tuple_coords[1][1] line_instance = Line(TL_y, BR_y) if line_instance.inside_line(y_low, y_high) == True: line_list.append(i) largest_BR_x = 0 for i in line_list: tuple_coords = eval(i.coords) BR_x = tuple_coords[1][0] if BR_x > largest_BR_x: largest_BR_x = BR_x subtotal = i.text i_subtotal = i # want the largest_BR_x to be set as subtotal in the JSON if RepresentsInt(i.text): quantity = i.text i_quantity = i #remove the subtotal and qty from the list, join the remaining stuff and call it description subtotal_value = float((re.findall(r"(\d+[\,\.]\d{0,2})", subtotal))[0]) # regex to extract price as a float out ex. RM15.09 -> 15.09 quantity_value = float(quantity) line_list.remove(i_subtotal) line_list.remove(i_quantity) description_list = [] for item in line_list: description_list.append(item.text) # description_list = description_list[::-1] description = ' '.join(description_list) unit_price = subtotal_value / quantity_value unit_price = round(unit_price, 2) # find out the unit price by diving subtotal by quantity # if BR_x is the biggest, then it is the subtotal # if i.text == an integer, then it is the quantity # the remaining elements are the description. the unit price might be thrown into the description # calculate the unit price by dividing the subtotal by the qty return jsonify(description=description, quantity=quantity_value, unit_price=unit_price, subtotal=subtotal_value) # returns json with a list of all the items that exist in the row # want to output QTY, description, subtotal # takes clicked coords, runs it through the query with the receipt_id and returns the text value, else return none return 'not found'
def genrate_ds(self, data, all_paths, folder_id, years): # years=[(((int(data['Year']))-3)-x) for x in range(0,10)][::-1] # flag for compeletion of main csv data flag2 = False #create path # get dataation coordinates area = data['Co-ordinate'] # genrate 4*4 grid of the coordinates elements = self.gc.grid(area) # calculate the total area of the gird total_area = Area({'type': 'Polygon', 'coordinates': area}) / 1000000 # create dict for new row in main df new_row_common = { 'AREA': [data['Area'].replace(" ", "_")], 'REGION': [data['Region'].replace(" ", "_")] } new_main_df_row = self.merge_two_dicts(new_row_common, { 'CO-ORDINATES': [data['Co-ordinate']], 'TOTAL_AREA': [total_area] }) new_forest_row,new_crop_row,new_builtup_row, \ new_burn_row,new_lst_row,new_airtemp_row, \ new_ndvi_row,new_runoff_row, \ new_pdsi_row,\ new_vpd_row,new_water_defict_row=self.create_empty_dict_rows(new_row_common) df_dict = { 0: new_forest_row, 1: new_crop_row, 2: new_builtup_row, 3: new_airtemp_row, 4: new_lst_row, 5: new_burn_row, 6: new_ndvi_row, 7: new_runoff_row, 8: new_pdsi_row, 9: new_vpd_row, 10: new_water_defict_row } year_loop = tqdm(years) for year in year_loop: if year < 2013: #landsat 7 isl8 = False # define limits for calculations forest_limit = 0.22 crop_limit1 = 0.09 crop_limit2 = 0.15 builtup_limit_1 = 0 builtup_limit_2 = 0 else: #landsat 8 isl8 = True # define limits for calculations forest_limit = 0.18 crop_limit1 = 0.07 crop_limit2 = 0.17 builtup_limit_1 = 0.2 builtup_limit_2 = 0 flag1 = False print(f"{data['Region']}_{data['Area']}_{year}") sys.stdout.flush() for i in range(0, len(elements)): # calculate the total grid area grid_area = Area({ 'type': 'Polygon', 'coordinates': [elements[i]] }) / 1000000 new_main_df_row[f'G{i}_AREA'] = [] new_main_df_row[f'G{i}_AREA'].append(grid_area) green,red,nir,swir,thermal,\ tmmx,pdsi,vpd,ro,def_=self.readImages(region=data['Region'],area=data['Area'],year=year,grid=i,isl8=isl8,folder_id=folder_id) # if area per pixel is not calculated then calculate it if not flag1: # calculate the area per pixel area_per_pixel = grid_area / (green.shape[0] * green.shape[1]) # set the flag to true flag1 = True # calculate the required features forest, crops, builtup, burn, lst, ndvi = self.calculation_of_domain( island8=isl8, red=red, nir=nir, thermal=thermal, green=green, swir=swir, forest_limit=forest_limit, crop_limit1=crop_limit1, crop_limit2=crop_limit2, builtup_limit_1=builtup_limit_1, builtup_limit_2=builtup_limit_2) feature_data = [ forest, crops, builtup, tmmx, lst, burn, ndvi, ro, pdsi, vpd, def_ ] features = { 0: 'FOREST', 1: 'CROP', 2: 'BUILTUP', 3: 'AIRTEMP', 4: 'LST', 5: 'BURN', 6: "NDVI", 7: "RUNOFF", 8: "PDSI", 9: "VPD", 10: "WATER_DEFICIT" } for (k, df), (_, feature) in zip(df_dict.items(), features.items()): if k in range(3, 11): if f'{year}_{feature}_MEAN_G{i}' not in df: df[f'{year}_{feature}_MEAN_G{i}'] = [] df[f'{year}_{feature}_MEAN_G{i}'].append( np.mean(feature_data[k])) if f'{year}_{feature}_MEDIAN_G{i}' not in df: df[f'{year}_{feature}_MEDIAN_G{i}'] = [] df[f'{year}_{feature}_MEDIAN_G{i}'].append( np.median(feature_data[k])) if f'{year}_{feature}_MIN_G{i}' not in df: df[f'{year}_{feature}_MIN_G{i}'] = [] df[f'{year}_{feature}_MIN_G{i}'].append( np.min(feature_data[k])) if f'{year}_{feature}_MAX_G{i}' not in df: df[f'{year}_{feature}_MAX_G{i}'] = [] df[f'{year}_{feature}_MAX_G{i}'].append( np.max(feature_data[k])) else: if f'{year}_{feature}_G{i}' not in df: df[f'{year}_{feature}_G{i}'] = [] df[f'{year}_{feature}_G{i}'].append( self.calculate_area(feature_data[k], area_per_pixel)) if not flag2: self.add_to_df(new_main_df_row, all_paths[0]) flag2 = True for df, path in zip(df_dict.values(), all_paths[1:]): self.add_to_df(df, path)
from grid import Grid from hero import Hero from enemies import * from area import Area import random image_size = 72 board_size = 10 root = Tk() canvas = Canvas(root, width=image_size * board_size, height=image_size * board_size + 100) grid = Grid(board_size) hero = Hero() area = Area(grid) background = Resource() level = 1 def on_key_press(e): # When the keycode is 111 (up arrow) we move the position of our box higher is_tile_occupied = hero.is_tile_occupied(area.enemy_list) if e.keycode == 65: hero.erase(canvas, background, image_size) if grid.grid[hero.x - 1][ hero. y].cell_type == "floor" and hero.x - 1 >= 0 and not is_tile_occupied: hero.x = hero.x - 1 hero.image = "hero_left" hero.draw(canvas, background, image_size)
def __init__(self, id=None, robot_actions=dict(), team_robot_ids=list(), earliest_start_time=-1, latest_start_time=-1, estimated_duration=-1, pickup_pose=Area(), delivery_pose=Area(), **kwargs): """Constructor for the Task object Args: id (str): A string of the format UUID robot_actions (dict): A dictionary with robot IDs as keys, and the list of actions to execute as values loadType (str): Valid values are "MobiDik", "Sickbed". Defaults to MobiDik loadId (str): A string of the format UUID team_robot_ids (list): A list of strings containing the UUIDs of the robots in the task earliest_start_time (TimeStamp): The earliest a task can start latest_start_time (TimeStamp): The latest a task can start estimated_duration (timedelta): A timedelta object specifying the duration pickup_pose (Area): The location where the robot should collect the load delivery_pose (Area): The location where the robot must drop off its load priority (constant): The task priority as defined by the constants EMERGENCY, HIGH, NORMAL, LOW hard_constraints (bool): False if the task can be scheduled ASAP, True if the task is not flexible. Defaults to True """ if not id: self.id = generate_uuid() else: self.id = id self.robot_actions = robot_actions self.loadType = kwargs.get('loadType', 'MobiDik') self.loadId = kwargs.get('loadId', generate_uuid()) self.team_robot_ids = team_robot_ids self.earliest_start_time = earliest_start_time self.latest_start_time = latest_start_time self.estimated_duration = estimated_duration self.earliest_finish_time = earliest_start_time + estimated_duration self.latest_finish_time = latest_start_time + estimated_duration self.start_time = kwargs.get('start_time', None) self.finish_time = kwargs.get('finish_time', None) self.hard_constraints = kwargs.get('hard_constraints', True) if isinstance(pickup_pose, Area): self.pickup_pose = pickup_pose else: raise Exception('pickup_pose must be an object of type Area') if isinstance(delivery_pose, Area): self.delivery_pose = delivery_pose else: raise Exception('delivery_pose must be an object of type Area') self.status = TaskStatus(self.id) priority = kwargs.get('priority', self.NORMAL) if priority in (self.EMERGENCY, self.NORMAL, self.HIGH, self.LOW): self.priority = priority else: raise Exception("Priority must have one of the following values:\n" "0) Urgent\n" "1) High\n" "2) Normal\n" "3) Low")