Ejemplo n.º 1
0
 def get_radius(self):
     # faster BBs can move with greater radius
     # return self._spd * 1.0 / MAX_ATTRIBUTE * MAX_RADIUS - self._image_surf_rect.width
     # TODO: need to fix this!
     return calc_distance(self._image_surf_rect.centerx,
                          self._image_surf_rect.centery, int(WIDTH / 2.0),
                          int(HEIGHT / 2.0))
Ejemplo n.º 2
0
 def check_obstacles(self, vehicles):
     minimumDistance = 1000
     for vehicle in vehicles:
         if self.vehicle_type == "Pedrestian":  # and vehicle.vehicle_type == "Pedrestian":
             continue
         elif vehicle.RightOfPassage == 0 and self.RightOfPassage == 1 and self.vehicle_type != "Pedrestian":
             # The vehicle doesn't have right of passage (not in roundabout)
             continue
         elif self.position == vehicle.position:
             # It's our vehicle
             continue
         else:
             distance = utils.calc_distance(self.position, vehicle.position)
             angle = abs(utils.calc_angle(self.position, vehicle.position) - self.direction)
             current_vision = self.vision_angle
             if (
                 self.RightOfPassage == 0
                 and self.velocity < 0.75 * self.max_velocity
                 and vehicle.RightOfPassage == 1
             ):
                 current_vision = self.vision_angle_entrance
             if distance <= self.range_of_sight and angle < current_vision:
                 stopDistance = (
                     utils.calc_stopDistance(distance, angle) - self.length * 2 - vehicle.length
                 )  # 3 times radius
                 if stopDistance < minimumDistance:
                     minimumDistance = stopDistance
     return minimumDistance
Ejemplo n.º 3
0
def recommendation():
    json_data = request.get_json(silent=True)
    df_hotels_return = df_hotels
    df_tour_return = df_tours
    if "city_id" in json_data:
        df_hotels_return = df_hotels_return[df_hotels_return["city_id"]
                                            == int(json_data["city_id"])]

        df_tour_return = df_tour_return[df_tour_return["city_id"]
                                        == int(json_data["city_id"])]
    if "type_price_hotel" in json_data and json_data["type_price_hotel"] != "-1":
        df_hotels_return = filter_by_price_hotel(
            df_hotels_return, type_price=json_data["type_price_hotel"])
    if "type_price_tour" in json_data and json_data["type_price_tour"] != "-1":
        df_tour_return = filter_by_price_tour(
            df_tour_return, type_price=json_data["type_price_tour"])
    center_location = LIST_CENTER_CITY[json_data["city_id"]]

    if len(df_hotels_return) > 0:
        df_hotels_return["distance_calc"] = df_hotels_return["distance"].apply(
            lambda x: calc_distance(x, center_location))

        prob_hotels, hotel_idxes = ranking_topsis(
            df_hotels_return, type_topsis="hotel")
        df_hotels_return = df_hotels_return.iloc[hotel_idxes]

    if len(df_tour_return) > 0:

        prob_tours, tour_idxes = ranking_topsis(
            df_tour_return, type_topsis="tour")

        df_tour_return = df_tour_return.iloc[tour_idxes]
    return jsonify({"hotels": eval(df_hotels_return.to_json(orient="records")), "tours": eval(df_tour_return.to_json(orient="records"))})
Ejemplo n.º 4
0
def getNearestMainNode(pos, node_list):
    min_dist = 1000
    for node in node_list:
        dist = utils.calc_distance(pos, node)
        if  dist < min_dist:
            min_dist = dist
            end_pos = node
    return (pos,end_pos)
Ejemplo n.º 5
0
def getNearestNodeInList(pos, any_list):
    min_dist = 1000
    for node in any_list:
        dist = utils.calc_distance(pos, node)
        if dist < min_dist:
            min_dist = dist
            index = any_list.index(node)
    return any_list[index]
Ejemplo n.º 6
0
def getNearestNodeIndex(pos, node_list):
    min_dist = 1000
    for node in node_list:
        dist = utils.calc_distance(pos, node)
        if  dist < min_dist:
            min_dist = dist
            index = node_list.index(node)
    return index
Ejemplo n.º 7
0
    def getObservation(self):
        sensors = Pa10Task.getObservation(self)

        # Calculate the straightline distance from the arm to the target [m]
        self.distance_to_target = utils.calc_distance(self.tooltip_position,
                                                      self.target_position)

        return sensors
Ejemplo n.º 8
0
 def GetDistanceToBusStop(self,position,direction):
     deltaX=self.roads[2][0]-self.roads[1][0]
     deltaY=self.roads[2][1]-self.roads[1][1]
     busStopX=self.roads[1][0]+deltaX*0.5
     busStopY=self.roads[1][1]+deltaY*0.5
     dist=utils.calc_distance((busStopX,busStopY),position)
     if (abs(utils.calc_angle(position, (busStopX,busStopY)) - direction)>math.pi/2):
         dist=-dist
     return dist
Ejemplo n.º 9
0
 def calc_reward(self):
     """
     Calculate the agent score, which is a linear combination of the distance between the agent and the target
     and the time elapsed since the beginning of the simulation
     :return: the reward
     """
     r1 = -utils.calc_distance(self.agent_xyz, self.tgt_xyz)
     r2 = -self.time * self.time_reward_factor
     return r1 + r2
Ejemplo n.º 10
0
    def test_works_as_expected(self):
        '''utils.calc_distance correctly calculates the distance between two points'''
        pairs = [[[0, 0], [1, 1]], [[0, 0], [0, 1]], [[5, 2], [2, 5]],
                 [[-1, 3], [10, 0]]]

        for pair in pairs:
            distance = utils.calc_distance(*pair)
            expected_distance = math.sqrt((pair[1][0] - pair[0][0])**2 +
                                          (pair[1][1] - pair[0][1])**2)
            self.assertEqual(distance, expected_distance)
Ejemplo n.º 11
0
    def getObservation(self):
        sensors = Pa10Task.getObservation(self)

        # Calculate the straightline distance from the arm to the target [m]
        self.distance_to_target = utils.calc_distance(
                self.tooltip_position,
                self.target_position
        )

        return sensors
Ejemplo n.º 12
0
def recalculate_info(currentLat, currentLong, altitude):
    """
    Recalculate target heading
    """
    heading = utils.calc_heading(currentLat, currentLong, this.targetLat.get(),
                                 this.targetLong.get())
    overlay.show_heading(heading)

    if this.planetRadius.get() > 0:
        distance = utils.calc_distance(currentLat, currentLong,
                                       this.targetLat.get(),
                                       this.targetLong.get(),
                                       this.planetRadius.get(), altitude)
        overlay.show_distance(distance)
Ejemplo n.º 13
0
def knn(all_stations,
        sugg_station,
        nearest_stations=[],
        nearest_stations_distances=None,
        nearest_stations_names=None,
        index=0):
    nearest_station = ''
    minimum_distance = float('inf')
    for station in all_stations:
        diff = calc_distance(station[1], sugg_station[1])
        if diff < minimum_distance:
            minimum_distance = diff
            nearest_station = station[0]

    nearest_stations.append((nearest_station, minimum_distance))
    if nearest_stations_distances:
        nearest_stations_distances[index] = minimum_distance
    if nearest_stations_names:
        nearest_stations_names[index] = nearest_station
    return (nearest_station, minimum_distance)
Ejemplo n.º 14
0
    def test_can_see_an_object_if_angle_does_not_pass_through_center_but_passes_through_some_of_object(
            self):
        '''if the angle of the eye and the angle between the snake's head and the object are not equal but close enough (depending on obj size & distance) then the eye can see the object'''
        ''' example: ( ) - object; x - snake;

			( )
			|
			|
			x
		'''
        expected_seen_object = MockObject([0.5, 5], 1, visual_encoding=[1, 1])
        other_objects = [expected_seen_object]

        output = self.snake.look(other_objects)

        snake_head = self.snake.body[0]
        expected_output = expected_seen_object.visual_encoding + [
            utils.calc_distance(snake_head.position,
                                expected_seen_object.position)
        ]
        self.assertListEqual(output, expected_output)
Ejemplo n.º 15
0
    def __init__(self,
                 agent_xyz_init,
                 agent_acc,
                 tgt_xyz_init,
                 tgt_traj,
                 max_time,
                 time_reward_factor=0.01):
        """
        Initialize the trajectory environment
        :param agent_xyz_init: the initial agent position
        :param agent_acc: the acceleration available to the agent
        :param tgt_xyz_init: the target initial position
        :param tgt_traj: function defining the target trajectory parametrically vs. time
        :param max_time: the maximum trajectory time
        """

        # define the initial separation between target/agent and how close they need to be to terminate the env
        self.init_sep = utils.calc_distance(agent_xyz_init, tgt_xyz_init)
        self.done_sep_threshold = 0.001

        # set the time equal to 0, identify max time, and define the time step, which works out to 50 Hz if the time
        # is in seconds
        self.time = 0
        self.time_step = 0.02
        self.max_time = max_time

        # the time factor is a weight that determines how much the agent cares about time progressing
        # Higher scores <-> lower times
        self.time_reward_factor = time_reward_factor

        # the agent characteristics
        self.agent_xyz = agent_xyz_init
        self.agent_vxyz = np.zeros(3)
        self.agent_axyz = np.zeros(3)
        self.agent_acc = agent_acc

        # the target characteristics
        self.tgt_xyz = tgt_xyz_init
        self.tgt_xyz_next = self.tgt_position_calc(self.time_step)
        self.tgt_traj = tgt_traj
Ejemplo n.º 16
0
 def evaluate_possible_movement_targets(self, possible_targets):
     """The value of a story location is highest when its distance from its author is 40, 
        so determine the value of all possible target locations accordingly."""
     result = []
     # find the goal location - near either the author of the story, or its recipient (in case there's no author)
     if self.authors.all().count() > 0:
         author = self.authors.all()[0]
         goal_location = (author.x, author.y)
     elif self.recipients.all().count() > 0:
         recipient = self.recipients.all()[0]
         goal_location = (recipient.x, recipient.y)
     else:
         goal_location = None
     # move toward the goal location
     if goal_location != None:
         goal_location = near_by_location(goal_location, min_distance=20, max_distance=40, limit=LAYER_SIZE)
         for loc in possible_targets:
             value = -calc_distance(goal_location, loc)
             result.append( (value, loc)  )
     else :
         result = [ (0, i) for i in possible_targets]
     return result
Ejemplo n.º 17
0
    def step(self, thrust_vector):
        """
        Move the agent forward one step forward in time
        :param thrust_vector: the direction the agent moves
        :return: the current state (the acceleration, agent position, target position, and next target position),
        the reward the agent receives for its action, and whether or not the simulation is finished
        """
        # get the unit vector representation of the thrust vector
        thrust_vector = utils.norm_vector(thrust_vector)

        # increment time by one step
        self.time += self.time_step

        # update the target position
        self.tgt_xyz = self.tgt_xyz_next
        self.tgt_xyz_next = self.tgt_position_calc()

        # update the agent position
        self.agent_position_update(thrust_vector)

        # calculate the reward
        reward = self.calc_reward()

        # determine if the simulation is finished or not. It finishes if the distance between the two is less
        # than the threshold or if the time is greater than the maximum time
        if utils.calc_distance(self.agent_xyz, self.tgt_xyz) < self.done_sep_threshold * self.init_sep \
                or self.time > self.max_time:
            done = True
            reward = 0
        else:
            done = False

        # concatenate the important information to feed into the DQN for the next prediction
        cur_state = np.concatenate(self.agent_acc, self.agent_xyz,
                                   self.tgt_xyz, self.tgt_xyz_next)

        return cur_state, reward, done
Ejemplo n.º 18
0
def location_analysis():
    reviews_path = config.Project_CONFIG['user_folder_path']
    city_values = []
    state_values = []
    distance_values = []
    std_dist_values = []
    std_dist_city_values = []
    city_distance_values = []
    b_data = read_business_info()
    files = os.listdir(reviews_path)
    for user_file in files:
        if not os.path.isdir(user_file):
            file_json_data = open(reviews_path + user_file,
                                  'r',
                                  encoding="utf8")
            city_stat = {}
            state_stat = {}
            points = []
            city_points = []
            for line in enumerate(file_json_data):
                temp_json_data = json.loads(line[1])
                b_id = temp_json_data['business_id']
                b_info = b_data[b_id]
                city = b_info['city']
                state = b_info['state']
                lat = b_info['lat']
                lon = b_info['lon']
                points.append((lat, lon))
                if city in city_stat:
                    city_stat[city] += 1
                else:
                    city_stat[city] = 1
                if state in state_stat:
                    state_stat[state] += 1
                else:
                    state_stat[state] = 1
            max_num = city_stat[max(city_stat, key=city_stat.get)]
            city_num = sum(city_stat.values())
            city_values.append(max_num * 1.00 / city_num)

            file_json_data = open(reviews_path + user_file,
                                  'r',
                                  encoding="utf8")
            city_name = max(city_stat, key=city_stat.get)
            for line in enumerate(file_json_data):
                temp_json_data = json.loads(line[1])
                b_id = temp_json_data['business_id']
                b_info = b_data[b_id]
                if b_info['city'] == city_name:
                    lat = b_info['lat']
                    lon = b_info['lon']
                    city_points.append((lat, lon))

            max_num_state = state_stat[max(state_stat, key=state_stat.get)]
            state_num = sum(state_stat.values())
            state_values.append(max_num_state * 1.00 / state_num)

            x = [p[0] for p in points]
            y = [p[1] for p in points]
            centroid = (sum(x) / len(points), sum(y) / len(points))
            distance = 0
            dist_list = []
            for p in points:
                distance += calc_distance(centroid[0], centroid[1], p[0], p[1])
                dist_list.append(
                    calc_distance(centroid[0], centroid[1], p[0], p[1]))
            avg_distance = distance / len(points)
            distance_values.append(avg_distance)
            std_dist_values.append(np.std(dist_list, ddof=1))

            c_x = [c_p[0] for c_p in city_points]
            c_y = [c_p[1] for c_p in city_points]
            c_centroid = (sum(c_x) / len(city_points),
                          sum(c_y) / len(city_points))
            c_distance = 0
            c_dist_list = []
            for c_p in city_points:
                c_distance += calc_distance(c_centroid[0], c_centroid[1],
                                            c_p[0], c_p[1])
                c_dist_list.append(
                    calc_distance(c_centroid[0], c_centroid[1], c_p[0],
                                  c_p[1]))
            c_avg_distance = c_distance / len(city_points)
            city_distance_values.append(c_avg_distance)
            std_dist_city_values.append(np.std(c_dist_list, ddof=1))

    print(city_values)  # the proportion that the business is in the same city
    print(
        state_values)  # the proportion that the business is in the same state
    print(distance_values)  # business distance
    print(std_dist_values)  # business distance standard deviation
    print(city_distance_values)  # business distance in the same city
    print(std_dist_city_values
          )  # business distance in the same city standard deviation
Ejemplo n.º 19
0
 def update_next_node(self,delta_t):
     next_pos = self.road.GetNodePosition(self.nextNode)
     if utils.calc_distance(self.position, next_pos) < self.velocity*delta_t: #We arrive at the next node
         self.nextNode=self.road.GetNextNode(self.nextNode)
         if self.nextNode == -1:
             self.active=False
Ejemplo n.º 20
0
 def touches(self, other):
     return utils.calc_distance(self.x, self.y, other.x, other.y) <= 27
Ejemplo n.º 21
0
                else:
                    print "Main bus road needed"
            elif state == 2 and BusRoadStates == 3:
                if len(buses['Main']) != 0:
                    buses['End'].append((event.pos, getNearestNodeIndex(event.pos, buses['Main'])))
                    busExit_list.append(getNearestMainNode(event.pos, buses['Main']))
                else:
                    print "Main bus road needed"
            elif state == 3:

                alter = 0
                dist = 1000

                if len(roads['Main']) != 0:
                    nearestMainNode = getNearestNodeInList(event.pos, roads['Main'])
                    distMainNode = utils.calc_distance(event.pos, nearestMainNode)
                    if distMainNode < dist:
                        dist = distMainNode
                        alter = 1

                if len(roads['Start']) != 0:
                    nearestStartNode = getNearestNodeInList(event.pos, [x[0] for x in roads['Start']])
                    distStartNode = utils.calc_distance(event.pos, nearestStartNode)
                    if distStartNode < dist:
                        dist = distStartNode
                        alter = 2
                if len(roads['End']) != 0:
                    nearestEndNode = getNearestNodeInList(event.pos, [x[0] for x in roads['End']])
                    distEndNode = utils.calc_distance(event.pos, nearestEndNode)
                    if distEndNode < dist:
                        dist = distEndNode