def test_waypoint_visualization_with_ngon_generator_predicted_human(self): # initialize the drone state waypoint_generator = NGonWaypointGenerator(n=6, radius=4) gamma = 0.9 cinematic_controller = CinematicController( waypoint_generator=waypoint_generator, bb_filter_gamma=gamma) cinematic_controller.update_latest_drone_state(DroneState(x=2, y=-3)) cinematic_controller.person_predictor = PolynomialPredictor( poly_degree=2, weight_decay_factor=1) cinematic_controller.update_latest_bbs([BoundingBox((10, 10), (0, 0))]) time.sleep(.001) cinematic_controller.update_latest_bbs([BoundingBox((5, 5), (50, 0))]) time.sleep(.001) cinematic_controller.update_latest_bbs([BoundingBox((2, 2), (50, 0))]) time.sleep(.001) cinematic_controller.update_latest_bbs([BoundingBox((1, 1), (50, 0))]) # initialize the drone waypoints waypoints = cinematic_controller.generate_waypoints() # initialize the person state person_states = cinematic_controller.person_predictor.predict_next_person_state( [2, 4, 6, 8, 10, 15, 20, 25, 30]) # initialize the environment environment = Environment() environment.add_obstacles([[(6, 0), (4, 2), (6, 2)], [(8, -4), (9, -3), (10, -3), (10, -5), (9, -3.5)], [(-6, -2), (-1, -5), (-1, -2)]]) # initialize visualization object and plot viz = WaypointVisualization(waypoints, person_states, environment) viz.plot('plots/moving_target.png')
def test_waypoint_visualization_with_ngon_generator(self): # initialize the drone state waypoint_generator = NGonWaypointGenerator(n=6, radius=4) gamma = 0.9 cinematic_controller = CinematicController( waypoint_generator=waypoint_generator, bb_filter_gamma=gamma) cinematic_controller.update_latest_drone_state(origin_drone_state) cinematic_controller.update_latest_bbs([bb_10_10_0_0]) # initialize the drone waypoints waypoints = cinematic_controller.generate_waypoints() # initialize the person state person_state = PersonState(4, 0) # initialize the environment environment = Environment() environment.add_obstacles([[(6, 0), (4, 2), (6, 2)], [(7, -4), (8, -3), (9, -3), (9, -5), (8, -3.5)], [(-5, -2), (0, -5), (0, -2)]]) # initialize visualization object and plot viz = WaypointVisualization(waypoints, [person_state], environment) viz.plot('plots/test_waypoint_visualization_with_ngon_generator.png') # check that file was saved properly assert os.path.isfile( 'plots/test_waypoint_visualization_with_ngon_generator.png')
def create_environment(self): # Create the maze self.env = Environment(n=self.ground_dimension, mine_density=self.mine_density, visual=self.visual, end_game_on_mine_hit=self.end_game_on_mine_hit) self.env.generate_environment()
def create_environment(self, new_maze = None): # Create the maze self.env = Environment(algorithm = self.algorithm, n = self.maze_dimension, p = self.probability_of_obstacles, fire = self.fire) self.env.generate_maze(new_maze = new_maze) # Generate graph from the maze self.env.create_graph_from_maze()
def generate_traj_set(feat_list): # Before calling this function, you need to decide what features you care # about, from a choice of table, coffee, human, origin, and laptop. pick = [104.2, 151.6, 183.8, 101.8, 224.2, 216.9, 310.8] place = [210.8, 101.6, 192.0, 114.7, 222.2, 246.1, 322.0] start = np.array(pick) * (math.pi / 180.0) goal = np.array(place) * (math.pi / 180.0) goal_pose = None T = 20.0 timestep = 0.5 WEIGHTS_DICT = { "table": [0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 7.0, 8.0], "coffee": [0.0, 0.2, 0.4, 0.6, 0.8, 1.0], "laptop": [0.0, 20.0, 21.0, 22.0, 24.0, 26.0, 30.0, 40.0], "human": [0.0, 20.0, 21.0, 22.0, 24.0, 26.0, 30.0, 40.0], "efficiency": [1.0] } # Openrave parameters for the environment. model_filename = "jaco_dynamics" object_centers = { 'HUMAN_CENTER': [-0.6, -0.55, 0.0], 'LAPTOP_CENTER': [-0.7929, -0.1, 0.0] } environment = Environment(model_filename, object_centers) # Planner Setup max_iter = 50 num_waypts = 5 feat_list = [x.strip() for x in feat_list.split(',')] num_features = len(feat_list) planner = TrajoptPlanner(feat_list, max_iter, num_waypts, environment) # Construct set of weights of interest. weights_span = [None] * num_features for feat in range(0, num_features): weights_span[feat] = WEIGHTS_DICT[feat_list[feat]] weight_pairs = list(itertools.product(*weights_span)) weight_pairs = [list(i) for i in weight_pairs] traj_rand = {} for (w_i, weights) in enumerate(weight_pairs): traj = planner.replan(start, goal, goal_pose, weights, T, timestep) Phi = environment.featurize(traj.waypts, feat_list) # Getting rid of bad, out-of-bounds trajectories if any(phi < 0.0 for phi in Phi): continue traj = traj.waypts.tolist() if repr(traj) not in traj_rand: traj_rand[repr(traj)] = weights here = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../')) savefile = "/data/traj_sets/traj_set_table_laptop.p" pickle.dump(traj_rand, open(here + savefile, "wb")) print "Saved in: ", savefile print "Used the following weight-combos: ", weight_pairs
def action(): env = Environment().get_environment_info() allure.environment(app=env.apk) allure.environment(app_activity=env.app_activity) allure.environment(device_name=env.devices[0].device_name) allure.environment(platform_name=env.devices[0].platform_name) allure.environment(platform_version=env.devices[0].platform_version) capabilities = { 'platformName': env.devices[0].platform_name, 'platformVersion': env.devices[0].platform_version, 'deviceName': env.devices[0].device_name, 'app': env.apk, 'clearSystemFiles': True, 'appActivity': env.app_activity, 'appPackage': env.app_package, 'automationName': 'UIAutomator2', 'newCommandTimeout': "2000", 'unicodeKeyboard': True, 'resetKeyboard': True, 'noSign': True, 'autoGrantPermissions': True } host = "http://localhost:4724/wd/hub" driver = webdriver.Remote(host, capabilities) yield ElementActions(driver).reset(driver) driver.quit()
def __init__(self, config_path=""): super(ProjectMain, self).__init__() environment = Environment.get_instance() environment.init_by_file_name("/.", os.path.basename(os.getcwd()), 1) configure = Configure.get_instance(environment) self._project = Project()
def __init__(self, loadfile): with open(loadfile, 'r') as stream: params = yaml.load(stream) # ----- General Setup ----- # self.prefix = params["setup"]["prefix"] self.feat_list = params["setup"]["feat_list"] self.demo_spec = params["setup"]["demo_spec"] # Openrave parameters for the environment. model_filename = params["setup"]["model_filename"] object_centers = params["setup"]["object_centers"] self.environment = Environment(model_filename, object_centers) # Learner setup. constants = {} constants["trajs_path"] = params["learner"]["trajs_path"] constants["betas_list"] = params["learner"]["betas_list"] constants["weight_vals"] = params["learner"]["weight_vals"] constants["FEAT_RANGE"] = params["learner"]["FEAT_RANGE"] self.learner = DemoLearner(self.feat_list, self.environment, constants) if self.demo_spec == "simulate": # Task setup. pick = params["sim"]["task"]["start"] place = params["sim"]["task"]["goal"] self.start = np.array(pick)*(math.pi/180.0) self.goal = np.array(place)*(math.pi/180.0) self.goal_pose = None if params["sim"]["task"]["goal_pose"] == "None" else params["sim"]["task"]["goal_pose"] self.T = params["sim"]["task"]["T"] self.timestep = params["sim"]["task"]["timestep"] self.weights = params["sim"]["task"]["feat_weights"] # Planner Setup. planner_type = params["sim"]["planner"]["type"] if planner_type == "trajopt": max_iter = params["sim"]["planner"]["max_iter"] num_waypts = params["sim"]["planner"]["num_waypts"] # Initialize planner and compute trajectory simulation. self.planner = TrajoptPlanner(self.feat_list, max_iter, num_waypts, self.environment) else: raise Exception('Planner {} not implemented.'.format(planner_type)) self.traj = [self.planner.replan(self.start, self.goal, self.goal_pose, self.weights, self.T, self.timestep)] plotTraj(self.environment.env, self.environment.robot, self.environment.bodies, self.traj[0].waypts, size=0.015,color=[0, 0, 1]) plotCupTraj(self.environment.env, self.environment.robot, self.environment.bodies, [self.traj[0].waypts[-1]],color=[0,1,0]) else: data_path = params["setup"]["demo_dir"] data_str = self.demo_spec.split("_") data_dir = os.path.abspath(os.path.join(os.path.dirname( __file__ ), '../')) + data_path if data_str[0] == "all": file_str = data_dir + '/*task{}*.p'.format(data_str[1]) else: file_str = data_dir + "/demo_ID{}_task{}*.p".format(data_str[0], data_str[1]) self.traj = [pickle.load(open(demo_file, "rb")) for demo_file in glob.glob(file_str)] self.learner.learn_weights(self.traj)
def action(): env = Environment().get_environment_info() capabilities = {'platformName': env.devices[0].platform_name, 'platformVersion': env.devices[0].platform_version, 'deviceName': env.devices[0].device_name, 'appPackage': 'in.togetu.video', 'clearSystemFiles': True, 'appActivity': env.app_activity, 'noReset':True, 'noSign': True } host = "http://localhost:4723/wd/hub" driver = webdriver.Remote(host, capabilities) yield ElementActions(driver).reset(driver) driver.quit()
def load_parameters(self): """ Loading parameters and setting up variables from the ROS environment. """ # ----- General Setup ----- # self.prefix = rospy.get_param("setup/prefix") self.start = np.array(rospy.get_param("setup/start"))*(math.pi/180.0) self.T = rospy.get_param("setup/T") self.timestep = rospy.get_param("setup/timestep") self.save_dir = rospy.get_param("setup/save_dir") # Openrave parameters for the environment. model_filename = rospy.get_param("setup/model_filename") object_centers = rospy.get_param("setup/object_centers") self.environment = Environment(model_filename, object_centers) # ----- Controller Setup ----- # # Retrieve controller specific parameters. controller_type = rospy.get_param("controller/type") if controller_type == "pid": # P, I, D gains. P = rospy.get_param("controller/p_gain") * np.eye(7) I = rospy.get_param("controller/i_gain") * np.eye(7) D = rospy.get_param("controller/d_gain") * np.eye(7) # Stores proximity threshold. epsilon = rospy.get_param("controller/epsilon") # Stores maximum COMMANDED joint torques. MAX_CMD = rospy.get_param("controller/max_cmd") * np.eye(7) self.controller = PIDController(P, I, D, epsilon, MAX_CMD) else: raise Exception('Controller {} not implemented.'.format(controller_type)) # Tell controller to move to start. self.controller.set_trajectory(Trajectory([self.start], [0.0])) # Stores current COMMANDED joint torques. self.cmd = np.eye(7) # Utilities for recording data. self.expUtil = experiment_utils.ExperimentUtils(self.save_dir)
def action2(): env = Environment().get_environment_info() capabilities = { 'platformName': env.devices[0].platform_name, 'platformVersion': env.devices[0].platform_version, 'deviceName': env.devices[0].device_name, 'app': env.apk, 'clearSystemFiles': True, 'appActivity': env.app_activity, 'appPackage': env.app_package, #'automationName': 'UIAutomator2', 'noSign': True, 'noReset': True, 'systemPort': random.randint(4700, 4900) } host = "http://localhost:4724/wd/hub" driver = webdriver.Remote(host, capabilities) yield ElementActions(driver).reset(driver) driver.quit()
def get_performance(self): performance_dict_1 = dict() performance_dict_2 = dict() for mine_density in np.arange(0.01, 0.2, 0.01): print(mine_density) performance_dict_1[mine_density] = dict() performance_dict_2[mine_density] = dict() final_scores_1 = list() mines_hit_1 = list() correct_mines_1 = list() incorrect_mines_1 = list() final_scores_2 = list() mines_hit_2 = list() correct_mines_2 = list() incorrect_mines_2 = list() for _ in range(10): env = Environment(n=15, mine_density=mine_density, end_game_on_mine_hit=False, visual=False) env.generate_environment() agent1 = CSPAgent(env=env, end_game_on_mine_hit=False) agent1.play() agent2 = BonusCSPAgent(env=env, end_game_on_mine_hit=False) agent2.play() # agent = ProbCSPAgent(env = env, # end_game_on_mine_hit = False, # use_probability_agent = self.use_probability_agent, # prob = 0.3) # agent.play() metrics_1 = agent1.get_gameplay_metrics() final_scores_1.append(metrics_1["final_score"]) mines_hit_1.append(metrics_1["number_of_mines_hit"]) metrics_2 = agent2.get_gameplay_metrics() final_scores_2.append(metrics_2["final_score"]) mines_hit_2.append(metrics_2["number_of_mines_hit"]) final_score_1 = np.mean(final_scores_1) num_mines_hit_1 = np.mean(mines_hit_1) final_score_2 = np.mean(final_scores_2) num_mines_hit_2 = np.mean(mines_hit_2) performance_dict_1[mine_density]["final_score"] = final_score_1 performance_dict_1[mine_density][ "number_of_mines_hit"] = num_mines_hit_1 performance_dict_2[mine_density]["final_score"] = final_score_2 performance_dict_2[mine_density][ "number_of_mines_hit"] = num_mines_hit_2 mine_densities_1 = performance_dict_1.keys() final_scores_1 = [ performance_dict_1[density]["final_score"] for density in performance_dict_1 ] mines_hit_1 = [ performance_dict_1[density]["number_of_mines_hit"] for density in performance_dict_1 ] mine_densities_2 = performance_dict_2.keys() final_scores_2 = [ performance_dict_2[density]["final_score"] for density in performance_dict_2 ] mines_hit_2 = [ performance_dict_2[density]["number_of_mines_hit"] for density in performance_dict_2 ] plt.plot(mine_densities_1, final_scores_1, marker='o', label="Normal CSP Agent") plt.plot(mine_densities_2, final_scores_2, marker='o', label="Bonus CSP Agent") plt.xlabel("Mine Density") plt.ylabel("Average Final Score") plt.savefig('avg_final_score_bonus.png') plt.legend() plt.close() plt.plot(mine_densities_1, mines_hit_1, marker='o', label="Normal CSP Agent") plt.plot(mine_densities_2, mines_hit_2, marker='o', label="Bonus CSP Agent") plt.xlabel("Mine Density") plt.ylabel("Average Density of Mines Hit") plt.savefig('avg_density_of_mines_hit_bonus.png') plt.legend() plt.close() return performance_dict_1, performance_dict_2
from flask import Flask from flask_restx import Api from flask_bcrypt import Bcrypt from flask_jwt_extended import JWTManager # Configuración Inicial Flask app = Flask(__name__) app.config['JWT_SECRET_KEY'] = "12usuario12" app.config['JWT_ALGORITHM'] = "HS256" bcrypt = Bcrypt(app) jwt = JWTManager(app) api = Api( app, title='Usuarios corporativos', version='2.0', description='Creando servicio a usuarios corporativos', ) from utils.environment import Environment config = Environment().settingsGeneral()
from flask import Flask from flask_restx import Api from flask_bcrypt import Bcrypt #JWT from flask_jwt_extended import JWTManager #JWT app = Flask(__name__) app.config['JWT_SECRET_KEY'] = "HolaMensajedePruebas" #JWT app.config['JWT_ALGORITHM'] = "HS256" #JWT bcrypt = Bcrypt(app) jwt = JWTManager(app) api = Api( app, title='Proyecto API CRUD Users', version='1.0', description='aplicacion CRUD', ) from utils.environment import Environment config = Environment().configGeneral()
def get_vin_box(self): vin = Environment().get_inited_config().vin_success box = Environment().get_inited_config().box_success L.d('车架号:%s 盒子号 %s' % (vin, box)) return [vin, box]
def plot_performance_metrics(self): algo_performance = dict() env = Environment(n = 20, p = self.probability_of_obstacles, fire = self.fire) # env.generate_maze() # env.create_graph_from_maze() for n in np.arange(10, 100, 10): print(n) for algo in ["astar"]: for heuristic in ["euclid", "manhattan"]: print(algo, heuristic) if (algo + "_" + heuristic) not in algo_performance: algo_performance[(algo + "_" + heuristic)] = dict() if algo not in algo_performance: algo_performance[algo] = dict() env.algorithm = algo env.create_graph_from_maze() path_finder = PathFinderAlgorithm(environment = env, algorithm = algo, visual = self.visual, heuristic = self.heuristic) path_finder.run_path_finder_algorithm() performances = path_finder.performance_dict if "path_length" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["path_length"] = [] if "maximum_fringe_size" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["maximum_fringe_size"] = [] if "number_of_nodes_expanded" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["number_of_nodes_expanded"] = [] algo_performance[(algo + "_" + heuristic)]['path_length'].append(performances['path_length']) algo_performance[(algo + "_" + heuristic)]['maximum_fringe_size'].append(performances['maximum_fringe_size']) algo_performance[(algo + "_" + heuristic)]['number_of_nodes_expanded'].append(performances['number_of_nodes_expanded']) for algo in ["astar", "thin_astar"]: for heuristic in ["euclid", "manhattan"]: print(algo, heuristic) if (algo + "_" + heuristic) not in algo_performance: algo_performance[(algo + "_" + heuristic)] = dict() env.algorithm = algo path_finder = PathFinderAlgorithm(environment = env, algorithm = algo, q = q, visual = self.visual, heuristic = heuristic) path_finder.run_path_finder_algorithm() performances = path_finder.performance_dict if "path_length" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["path_length"] = [] if "maximum_fringe_size" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["maximum_fringe_size"] = [] if "number_of_nodes_expanded" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["number_of_nodes_expanded"] = [] algo_performance[(algo + "_" + heuristic)]['path_length'].append(performances['path_length']) algo_performance[(algo + "_" + heuristic)]['maximum_fringe_size'].append(performances['maximum_fringe_size']) algo_performance[(algo + "_" + heuristic)]['number_of_nodes_expanded'].append(performances['number_of_nodes_expanded']) return algo_performance
def load_parameters(self): """ Loading parameters and setting up variables from the ROS environment. """ # ----- General Setup ----- # self.prefix = rospy.get_param("setup/prefix") pick = rospy.get_param("setup/start") place = rospy.get_param("setup/goal") self.start = np.array(pick) * (math.pi / 180.0) self.goal = np.array(place) * (math.pi / 180.0) self.goal_pose = None if rospy.get_param( "setup/goal_pose") == "None" else rospy.get_param( "setup/goal_pose") self.T = rospy.get_param("setup/T") self.timestep = rospy.get_param("setup/timestep") self.save_dir = rospy.get_param("setup/save_dir") self.feat_list = rospy.get_param("setup/feat_list") self.weights = rospy.get_param("setup/feat_weights") self.INTERACTION_TORQUE_THRESHOLD = rospy.get_param( "setup/INTERACTION_TORQUE_THRESHOLD") self.INTERACTION_TORQUE_EPSILON = rospy.get_param( "setup/INTERACTION_TORQUE_EPSILON") # Openrave parameters for the environment. model_filename = rospy.get_param("setup/model_filename") object_centers = rospy.get_param("setup/object_centers") self.environment = Environment(model_filename, object_centers) # ----- Planner Setup ----- # # Retrieve the planner specific parameters. planner_type = rospy.get_param("planner/type") if planner_type == "trajopt": max_iter = rospy.get_param("planner/max_iter") num_waypts = rospy.get_param("planner/num_waypts") # Initialize planner and compute trajectory to track. self.planner = TrajoptPlanner(self.feat_list, max_iter, num_waypts, self.environment) else: raise Exception('Planner {} not implemented.'.format(planner_type)) self.traj = self.planner.replan(self.start, self.goal, self.goal_pose, self.weights, self.T, self.timestep) self.traj_plan = self.traj.downsample(self.planner.num_waypts) # Track if you have reached the start/goal of the path. self.reached_start = False self.reached_goal = False # Save the intermediate target configuration. self.curr_pos = None # ----- Controller Setup ----- # # Retrieve controller specific parameters. controller_type = rospy.get_param("controller/type") if controller_type == "pid": # P, I, D gains. P = rospy.get_param("controller/p_gain") * np.eye(7) I = rospy.get_param("controller/i_gain") * np.eye(7) D = rospy.get_param("controller/d_gain") * np.eye(7) # Stores proximity threshold. epsilon = rospy.get_param("controller/epsilon") # Stores maximum COMMANDED joint torques. MAX_CMD = rospy.get_param("controller/max_cmd") * np.eye(7) self.controller = PIDController(P, I, D, epsilon, MAX_CMD) else: raise Exception( 'Controller {} not implemented.'.format(controller_type)) # Planner tells controller what plan to follow. self.controller.set_trajectory(self.traj) # Stores current COMMANDED joint torques. self.cmd = np.eye(7) # ----- Learner Setup ----- # constants = {} constants["UPDATE_GAINS"] = rospy.get_param("learner/UPDATE_GAINS") constants["MAX_WEIGHTS"] = rospy.get_param("learner/MAX_WEIGHTS") constants["FEAT_RANGE"] = rospy.get_param("learner/FEAT_RANGE") constants["P_beta"] = rospy.get_param("learner/P_beta") constants["alpha"] = rospy.get_param("learner/alpha") constants["n"] = rospy.get_param("learner/n") self.feat_method = rospy.get_param("learner/type") self.learner = PHRILearner(self.feat_method, self.feat_list, self.environment, constants) # ---- Experimental Utils ---- # self.expUtil = experiment_utils.ExperimentUtils(self.save_dir) # Update the list of replanned plans with new trajectory plan. self.expUtil.update_replanned_trajList(0.0, self.traj_plan.waypts) # Update the list of replanned waypoints with new waypoints. self.expUtil.update_replanned_wayptsList(0.0, self.traj.waypts)
class MazeRunner(): def __init__(self, maze_dimension, probability_of_obstacles, algorithm, visual, heuristic, fire): self.algorithm = algorithm self.maze_dimension = maze_dimension self.probability_of_obstacles = probability_of_obstacles self.visual = visual self.heuristic = heuristic self.fire = fire def create_environment(self, new_maze = None): # Create the maze self.env = Environment(algorithm = self.algorithm, n = self.maze_dimension, p = self.probability_of_obstacles, fire = self.fire) self.env.generate_maze(new_maze = new_maze) # Generate graph from the maze self.env.create_graph_from_maze() def run(self): # Run the path finding algorithm on the graph self.path_finder = PathFinderAlgorithm(environment = self.env, algorithm = self.algorithm, visual = self.visual, heuristic = self.heuristic) self.path_finder.run_path_finder_algorithm() def find_solvable_map_size(self): dim_list = range(10, 250, 10) runtimes = dict() for dim in dim_list: print("Dim = " + str(dim)) self.maze_dimension = dim self.create_environment() start = time() self.run() end = time() - start print(end) runtimes[dim] = end del self.path_finder plt.plot(dim_list, runtimes.values(), marker = "o") plt.figure() plt.show() def plot_performance_metrics(self): algo_performance = dict() env = Environment(n = 20, p = self.probability_of_obstacles, fire = self.fire) # env.generate_maze() # env.create_graph_from_maze() for n in np.arange(10, 100, 10): print(n) for algo in ["astar"]: for heuristic in ["euclid", "manhattan"]: print(algo, heuristic) if (algo + "_" + heuristic) not in algo_performance: algo_performance[(algo + "_" + heuristic)] = dict() if algo not in algo_performance: algo_performance[algo] = dict() env.algorithm = algo env.create_graph_from_maze() path_finder = PathFinderAlgorithm(environment = env, algorithm = algo, visual = self.visual, heuristic = self.heuristic) path_finder.run_path_finder_algorithm() performances = path_finder.performance_dict if "path_length" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["path_length"] = [] if "maximum_fringe_size" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["maximum_fringe_size"] = [] if "number_of_nodes_expanded" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["number_of_nodes_expanded"] = [] algo_performance[(algo + "_" + heuristic)]['path_length'].append(performances['path_length']) algo_performance[(algo + "_" + heuristic)]['maximum_fringe_size'].append(performances['maximum_fringe_size']) algo_performance[(algo + "_" + heuristic)]['number_of_nodes_expanded'].append(performances['number_of_nodes_expanded']) for algo in ["astar", "thin_astar"]: for heuristic in ["euclid", "manhattan"]: print(algo, heuristic) if (algo + "_" + heuristic) not in algo_performance: algo_performance[(algo + "_" + heuristic)] = dict() env.algorithm = algo path_finder = PathFinderAlgorithm(environment = env, algorithm = algo, q = q, visual = self.visual, heuristic = heuristic) path_finder.run_path_finder_algorithm() performances = path_finder.performance_dict if "path_length" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["path_length"] = [] if "maximum_fringe_size" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["maximum_fringe_size"] = [] if "number_of_nodes_expanded" not in algo_performance[(algo + "_" + heuristic)]: algo_performance[(algo + "_" + heuristic)]["number_of_nodes_expanded"] = [] algo_performance[(algo + "_" + heuristic)]['path_length'].append(performances['path_length']) algo_performance[(algo + "_" + heuristic)]['maximum_fringe_size'].append(performances['maximum_fringe_size']) algo_performance[(algo + "_" + heuristic)]['number_of_nodes_expanded'].append(performances['number_of_nodes_expanded']) return algo_performance
#!/usr/bin/env python # -*- coding: utf-8 -*- # Librerias importadas from utils.environment import Environment import unittest import json # Modulos propios from application import app from utils.userGenerator import UserGenerator generateUser = UserGenerator().generateUser BASE_URL = "http://localhost:8080" SIGNUP_URL = f"{BASE_URL}/home/signup" LOGIN_URL = f"{BASE_URL}/home/login" CHAT_URL = f"{BASE_URL}/chat" FRIENDS_URL = f"{BASE_URL}/dashboard/friends" PROFILE_URL = f"{BASE_URL}/dashboard" MONGO = Environment().settingsDB()
from utils import L import sys """ run all case: python3 run.py run one module case: python3 run.py test/test_home.py run case with key word: python3 run.py -k <keyword> """ if __name__ == '__main__': env = Environment() xml_report_path = env.get_environment_info().xml_report html_report_path = env.get_environment_info().html_report # 开始测试 args = [ '-s', '-q', '--allure_features=My stdio1', '--alluredir', xml_report_path ] # args = ['-s', '-q'],'--allure_features=My stdio' self_args = sys.argv[1:] pytest.main(args) # 生成html测试报告 cmd = 'allure generate %s -o %s' % (xml_report_path, html_report_path) # try: Shell.invoke(cmd)
def gen_page_py(): GenPages.gen_page_py() class WatchHandler(PatternMatchingEventHandler): patterns = ["*.yaml"] def on_created(self, event): L.i('监听到文件: yaml 发生了变化') try: gen_page_py() except Exception as e: L.e('\n!!!!!!!---pages.yaml---!!!!!!\n解析文件 pages.yaml 错误\n' '请到{}路径下检查修改后重新保存.'.format(self.watch_path)) if __name__ == "__main__": event_handler = WatchHandler() full_path = Environment().get_environment_info().pages_yaml print(full_path) observer = Observer() observer.schedule(event_handler, full_path) observer.start() try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join()
def get_account(): account = Environment().get_inited_config().account_success pwd = Environment().get_inited_config().password_success L.d('账号:%s 密码 %s' % (account, pwd)) return [account, pwd]
class MineSweeper(): BasicAgent = "base_agent" CSPAgent = "csp_agent" def __init__(self, ground_dimension=None, mine_density=None, agent_name=None, visual=False, end_game_on_mine_hit=True, bonus_uncertain_p=0.0): self.ground_dimension = ground_dimension self.mine_density = mine_density self.agent_name = agent_name self.visual = visual self.end_game_on_mine_hit = end_game_on_mine_hit self.bonus_uncertain_p = bonus_uncertain_p self.use_probability_agent = False if self.bonus_uncertain_p > 0: self.use_probability_agent = True def create_environment(self): # Create the maze self.env = Environment(n=self.ground_dimension, mine_density=self.mine_density, visual=self.visual, end_game_on_mine_hit=self.end_game_on_mine_hit) self.env.generate_environment() def run(self): # Use the agent to find mines in our mine-sweeper environment if self.agent_name == self.BasicAgent: self.mine_sweeper_agent = BaseAgent(env=self.env) elif self.agent_name == self.CSPAgent: self.mine_sweeper_agent = CSPAgent( env=self.env, end_game_on_mine_hit=self.end_game_on_mine_hit) else: self.mine_sweeper_agent = ProbCSPAgent( env=self.env, end_game_on_mine_hit=self.end_game_on_mine_hit, use_probability_agent=self.use_probability_agent, prob=self.bonus_uncertain_p) self.mine_sweeper_agent.play() metrics = self.mine_sweeper_agent.get_gameplay_metrics() # print("Game won = ", str(metrics["game_won"])) print("Number of mines hit = ", str(metrics["number_of_mines_hit"])) print("Number of mines flagged correctly = ", str(metrics["number_of_mines_flagged_correctly"])) print("Number of cells flagged incorrectly = ", str(metrics["number_of_cells_flagged_incorrectly"])) self.env.render_env(100) def get_performance(self): performance_dict_1 = dict() performance_dict_2 = dict() for mine_density in np.arange(0.01, 0.2, 0.01): print(mine_density) performance_dict_1[mine_density] = dict() performance_dict_2[mine_density] = dict() final_scores_1 = list() mines_hit_1 = list() correct_mines_1 = list() incorrect_mines_1 = list() final_scores_2 = list() mines_hit_2 = list() correct_mines_2 = list() incorrect_mines_2 = list() for _ in range(10): env = Environment(n=15, mine_density=mine_density, end_game_on_mine_hit=False, visual=False) env.generate_environment() agent1 = CSPAgent(env=env, end_game_on_mine_hit=False) agent1.play() agent2 = BonusCSPAgent(env=env, end_game_on_mine_hit=False) agent2.play() # agent = ProbCSPAgent(env = env, # end_game_on_mine_hit = False, # use_probability_agent = self.use_probability_agent, # prob = 0.3) # agent.play() metrics_1 = agent1.get_gameplay_metrics() final_scores_1.append(metrics_1["final_score"]) mines_hit_1.append(metrics_1["number_of_mines_hit"]) metrics_2 = agent2.get_gameplay_metrics() final_scores_2.append(metrics_2["final_score"]) mines_hit_2.append(metrics_2["number_of_mines_hit"]) final_score_1 = np.mean(final_scores_1) num_mines_hit_1 = np.mean(mines_hit_1) final_score_2 = np.mean(final_scores_2) num_mines_hit_2 = np.mean(mines_hit_2) performance_dict_1[mine_density]["final_score"] = final_score_1 performance_dict_1[mine_density][ "number_of_mines_hit"] = num_mines_hit_1 performance_dict_2[mine_density]["final_score"] = final_score_2 performance_dict_2[mine_density][ "number_of_mines_hit"] = num_mines_hit_2 mine_densities_1 = performance_dict_1.keys() final_scores_1 = [ performance_dict_1[density]["final_score"] for density in performance_dict_1 ] mines_hit_1 = [ performance_dict_1[density]["number_of_mines_hit"] for density in performance_dict_1 ] mine_densities_2 = performance_dict_2.keys() final_scores_2 = [ performance_dict_2[density]["final_score"] for density in performance_dict_2 ] mines_hit_2 = [ performance_dict_2[density]["number_of_mines_hit"] for density in performance_dict_2 ] plt.plot(mine_densities_1, final_scores_1, marker='o', label="Normal CSP Agent") plt.plot(mine_densities_2, final_scores_2, marker='o', label="Bonus CSP Agent") plt.xlabel("Mine Density") plt.ylabel("Average Final Score") plt.savefig('avg_final_score_bonus.png') plt.legend() plt.close() plt.plot(mine_densities_1, mines_hit_1, marker='o', label="Normal CSP Agent") plt.plot(mine_densities_2, mines_hit_2, marker='o', label="Bonus CSP Agent") plt.xlabel("Mine Density") plt.ylabel("Average Density of Mines Hit") plt.savefig('avg_density_of_mines_hit_bonus.png') plt.legend() plt.close() return performance_dict_1, performance_dict_2
import matplotlib.pyplot as plt from utils.environment import Environment print("") print("#==============================#") print("# Define Global Variables") print("#==============================#") MAP_DIR = "./maps/test/" MONSTER_DIR = "./monsters/" WAVE_DIR = "./waves/test/" print("") print("#==============================#") print("# Define the Environment") print("#==============================#") environment = Environment(MAP_DIR, MONSTER_DIR, WAVE_DIR) plt.pause(0.1) print("") print("#==============================#") print("# Walk Monster Path") print("#==============================#") print("#") print("# visualize the walking") plt.figure(1) boxProps = dict(boxstyle='round', facecolor='wheat', alpha=0.5) winText = "You somehow did it ^.^" looseText = "You lost...as suspected..." frameRate = 0.01 # [s]
#!/usr/bin/env python # -*- coding: utf-8 -*- # Librerias importadas from flask import Flask from flask_restx import Api from flask_bcrypt import Bcrypt from flask_jwt_extended import JWTManager from flask_pymongo import PyMongo from utils.environment import Environment # Configuracion inicial de Flask app = Flask(__name__) env = Environment() # Configuracion del JWT settingsJWT = env.settingsJWT() app.config['JWT_SECRET_KEY'] = settingsJWT['JWT_SECRET_KEY'] app.config['JWT_ALGORITHM'] = settingsJWT['JWT_ALGORITHM'] jwt = JWTManager(app) # Configuracion de Pymongo settingsDB = env.settingsDB() app.config['MONGO_URI'] = settingsDB['MONGO_URI'] mongo = PyMongo(app) bcrypt = Bcrypt(app) app.config['PROPAGATE_EXCEPTIONS'] = True api = Api(app, title='Pachaqtec Intranet',
class FeatureElicitator(): """ This class represents a node that moves the Jaco with PID control AND supports receiving human corrections online. Additionally, it implements a protocol for elicitating novel features from human input. Subscribes to: /$prefix$/out/joint_angles - Jaco sensed joint angles /$prefix$/out/joint_torques - Jaco sensed joint torques Publishes to: /$prefix$/in/joint_velocity - Jaco commanded joint velocities """ def __init__(self): # Create ROS node. rospy.init_node("feature_elicitator") # Load parameters and set up subscribers/publishers. self.load_parameters() self.register_callbacks() # Start admittance control mode. ros_utils.start_admittance_mode(self.prefix) # Publish to ROS at 100hz. r = rospy.Rate(100) print "----------------------------------" print "Moving robot, type Q to quit:" while not rospy.is_shutdown(): if sys.stdin in select.select([sys.stdin], [], [], 0)[0]: line = raw_input() if line == "q" or line == "Q" or line == "quit": break self.vel_pub.publish(ros_utils.cmd_to_JointVelocityMsg(self.cmd)) r.sleep() print "----------------------------------" ros_utils.stop_admittance_mode(self.prefix) def load_parameters(self): """ Loading parameters and setting up variables from the ROS environment. """ # ----- General Setup ----- # self.prefix = rospy.get_param("setup/prefix") pick = rospy.get_param("setup/start") place = rospy.get_param("setup/goal") self.start = np.array(pick)*(math.pi/180.0) self.goal = np.array(place)*(math.pi/180.0) self.goal_pose = None if rospy.get_param("setup/goal_pose") == "None" else rospy.get_param("setup/goal_pose") self.T = rospy.get_param("setup/T") self.timestep = rospy.get_param("setup/timestep") self.save_dir = rospy.get_param("setup/save_dir") self.INTERACTION_TORQUE_THRESHOLD = rospy.get_param("setup/INTERACTION_TORQUE_THRESHOLD") self.INTERACTION_TORQUE_EPSILON = rospy.get_param("setup/INTERACTION_TORQUE_EPSILON") self.CONFIDENCE_THRESHOLD = rospy.get_param("setup/CONFIDENCE_THRESHOLD") self.N_QUERIES = rospy.get_param("setup/N_QUERIES") self.nb_layers = rospy.get_param("setup/nb_layers") self.nb_units = rospy.get_param("setup/nb_units") # Openrave parameters for the environment. model_filename = rospy.get_param("setup/model_filename") object_centers = rospy.get_param("setup/object_centers") feat_list = rospy.get_param("setup/feat_list") weights = rospy.get_param("setup/feat_weights") FEAT_RANGE = rospy.get_param("setup/FEAT_RANGE") feat_range = [FEAT_RANGE[feat_list[feat]] for feat in range(len(feat_list))] LF_dict = rospy.get_param("setup/LF_dict") self.environment = Environment(model_filename, object_centers, feat_list, feat_range, np.array(weights), LF_dict) # ----- Planner Setup ----- # # Retrieve the planner specific parameters. planner_type = rospy.get_param("planner/type") if planner_type == "trajopt": max_iter = rospy.get_param("planner/max_iter") num_waypts = rospy.get_param("planner/num_waypts") # Initialize planner and compute trajectory to track. self.planner = TrajoptPlanner(max_iter, num_waypts, self.environment) else: raise Exception('Planner {} not implemented.'.format(planner_type)) self.traj = self.planner.replan(self.start, self.goal, self.goal_pose, self.T, self.timestep) self.traj_plan = self.traj.downsample(self.planner.num_waypts) # Track if you have reached the start/goal of the path. self.reached_start = False self.reached_goal = False self.feature_learning_mode = False self.interaction_mode = False # Save the intermediate target configuration. self.curr_pos = None # Track data and keep stored. self.interaction_data = [] self.interaction_time = [] self.feature_data = [] self.track_data = False # ----- Controller Setup ----- # # Retrieve controller specific parameters. controller_type = rospy.get_param("controller/type") if controller_type == "pid": # P, I, D gains. P = rospy.get_param("controller/p_gain") * np.eye(7) I = rospy.get_param("controller/i_gain") * np.eye(7) D = rospy.get_param("controller/d_gain") * np.eye(7) # Stores proximity threshold. epsilon = rospy.get_param("controller/epsilon") # Stores maximum COMMANDED joint torques. MAX_CMD = rospy.get_param("controller/max_cmd") * np.eye(7) self.controller = PIDController(P, I, D, epsilon, MAX_CMD) else: raise Exception('Controller {} not implemented.'.format(controller_type)) # Planner tells controller what plan to follow. self.controller.set_trajectory(self.traj) # Stores current COMMANDED joint torques. self.cmd = np.eye(7) # ----- Learner Setup ----- # constants = {} constants["step_size"] = rospy.get_param("learner/step_size") constants["P_beta"] = rospy.get_param("learner/P_beta") constants["alpha"] = rospy.get_param("learner/alpha") constants["n"] = rospy.get_param("learner/n") self.feat_method = rospy.get_param("learner/type") self.learner = PHRILearner(self.feat_method, self.environment, constants)
def _run_thinning_astar(self, root, dest): current_maze_copy = self.environment.maze.copy() simpler_maze = self._create_simpler_maze(maze=current_maze_copy) simpler_env = Environment(n=self.environment.n, p=self.environment.p) simpler_env.generate_maze(new_maze=simpler_maze) # Root is at a distance of 0 from itself root.distance_from_source = 0 self.fringe = Q.PriorityQueue() self.fringe.put(root) self.visited.append(root) while self.fringe.queue: # Keep track of maximum fringe length fringe_length = len(self.fringe.queue) if fringe_length >= self.max_fringe_length: self.max_fringe_length = fringe_length temp_path = [] node = self.fringe.get() if node not in self.visited: self.visited.append(node) node_children = node.get_children(node=node, algorithm=self.algorithm) for child in node_children: if child is None or child in self.visited: continue if child not in self.fringe.queue: child.parent = node temp_simpler_maze = simpler_maze.copy() temp_simpler_maze[child.row, child.column] = 4 simpler_env.modify_environment(new_maze=temp_simpler_maze) child.distance_from_dest = self._calculate_thinning_heuristic( simpler_maze_env=simpler_env, node_row=child.row, node_column=child.column) child.distance_from_source = node.distance_from_source + 1 self.fringe.put(child) else: if child.get_heuristic( ) >= node.distance_from_source + child.distance_from_dest: child.parent = node child.distance_from_source = node.distance_from_source + 1 # Get the path through which you reach this node from the root node flag = True temp_node = node while (flag): temp_path.append(temp_node) temp_node = temp_node.parent if temp_node is None: flag = False temp_path_copy = temp_path.copy() # Update the color of the path which we found above by popping the root first and the subsequent nodes. while (len(temp_path) != 0): temp_node = temp_path.pop() # Visualisation Parameter added if self.visual == True: self.environment.update_color_of_cell( temp_node.row, temp_node.column) self.environment.render_maze(title=self.title) # if you reach the destination, then break if (node == dest): break # We reset the entire path again to render a new path in the next iteration. while (len(temp_path_copy) != 0): temp_node = temp_path_copy.pop(0) # Visualisation Parameter added if self.visual == True: self.environment.reset_color_of_cell( temp_node.row, temp_node.column) self.environment.render_maze(title=self.title)
parser.add_argument("--savefig", action="store_true", help="Save figure") parser.add_argument("--figdir", type=str, default='figures', help="Directory to place figures") parser.add_argument("-e", "--epsilon", type=float, default=0.25, help="Epsilon value for RDP algorithm") parser.add_argument("-n", "--solution", type=int, default=0, help="Number of solution") parser.add_argument("--video", action="store_true", help="Epsilon value for RDP algorithm") # parser.add_argument("-s", "--solver", type=str, default='impost', choices=('impost', 'astar', 'apf'), help="Solver") args = parser.parse_args() # print('Read targets data from ', args.targets) # with open(args.targets, 'r') as f: # targets_data = load(f) print('Read solution data from ', args.result) with open(args.result, 'r') as f: data = load(f) env = Environment() for target_path in data[1:]: speed = target_path["items"][0]["length"] / target_path["items"][0]["duration"] * 3600 env.add_ts(targets.LinearTarget((target_path["items"][0]["x"], target_path["items"][0]["y"]), ( speed * cos( radians(target_path["items"][0]["begin_angle"])), speed * sin( radians(target_path["items"][0]["begin_angle"])) ), 2)) path = [] time = 0 first = True for segment in data[0]["items"]:
#!/usr/bin/env python # -*- coding: utf-8 -*- # Created by zhouyuyan on 2017/5/3 14:14 from time import sleep from Common.Element import * from Common.action import ElementActions from utils.environment import Environment env = Environment().get_environment_info() # """"登录页面测试步骤""" # def goto_login(self): global action action = ElementActions(driver=self.driver) sleep(4) my = get_name(self, "我的") check_my = lambda action: action.is_element_displayed(my) if check_my: my.click() sleep(2) try: lgbs = get_name(self, '登录') check_lgbs = lambda action: action.is_element_displayed(lgbs) if check_lgbs: lgbs.click() sleep(2)
def load_parameters(self): """ Loading parameters and setting up variables from the ROS environment. """ # ----- General Setup ----- # self.prefix = rospy.get_param("setup/prefix") pick = rospy.get_param("setup/start") place = rospy.get_param("setup/goal") self.start = np.array(pick) * (math.pi / 180.0) self.goal = np.array(place) * (math.pi / 180.0) self.goal_pose = None if rospy.get_param( "setup/goal_pose") == "None" else rospy.get_param( "setup/goal_pose") self.T = rospy.get_param("setup/T") self.timestep = rospy.get_param("setup/timestep") self.feat_list = rospy.get_param("setup/feat_list") self.weights = rospy.get_param("setup/feat_weights") # Openrave parameters for the environment. model_filename = rospy.get_param("setup/model_filename") object_centers = rospy.get_param("setup/object_centers") self.environment = Environment(model_filename, object_centers) # ----- Planner Setup ----- # # Retrieve the planner specific parameters. planner_type = rospy.get_param("planner/type") if planner_type == "trajopt": max_iter = rospy.get_param("planner/max_iter") num_waypts = rospy.get_param("planner/num_waypts") # Initialize planner and compute trajectory to track. self.planner = TrajoptPlanner(self.feat_list, max_iter, num_waypts, self.environment) else: raise Exception('Planner {} not implemented.'.format(planner_type)) self.traj = self.planner.replan(self.start, self.goal, self.goal_pose, self.weights, self.T, self.timestep) # Save the intermediate target configuration. self.curr_pos = None # ----- Controller Setup ----- # # Retrieve controller specific parameters. controller_type = rospy.get_param("controller/type") if controller_type == "pid": # P, I, D gains. P = rospy.get_param("controller/p_gain") * np.eye(7) I = rospy.get_param("controller/i_gain") * np.eye(7) D = rospy.get_param("controller/d_gain") * np.eye(7) # Stores proximity threshold. epsilon = rospy.get_param("controller/epsilon") # Stores maximum COMMANDED joint torques. MAX_CMD = rospy.get_param("controller/max_cmd") * np.eye(7) self.controller = PIDController(P, I, D, epsilon, MAX_CMD) else: raise Exception( 'Controller {} not implemented.'.format(controller_type)) # Planner tells controller what plan to follow. self.controller.set_trajectory(self.traj) # Stores current COMMANDED joint torques. self.cmd = np.eye(7)