class TargetSelection(object):
# Constructor
def __init__(self, selection_method):
self.goals_position = []
self.goals_value = []
self.omega = 0.0
self.radius = 0
self.method = selection_method
if self.method_is_cost_based():
from robot_perception import RobotPerception
self.robot_perception = RobotPerception()
self.cost_based_properties = rospy.get_param("cost_based_properties")
numpy.set_printoptions(precision=3, threshold=numpy.nan, suppress=True)
self.brush = Brushfires()
self.path_planning = PathPlanning()
def method_is_cost_based(self):
return self.method in ['cost_based', 'cost_based_fallback']
def selectTarget(self, ogm, coverage, robot_pose, origin, resolution, force_random=False):
######################### NOTE: QUESTION ##############################
# Implement a smart way to select the next target. You have the following tools: ogm_limits, Brushfire field,
# OGM skeleton, topological nodes.
# Find only the useful boundaries of OGM. Only there calculations have meaning.
ogm_limits = OgmOperations.findUsefulBoundaries(ogm, origin, resolution)
# Blur the OGM to erase discontinuities due to laser rays
ogm = OgmOperations.blurUnoccupiedOgm(ogm, ogm_limits)
# Calculate Brushfire field
tinit = time.time()
brush = self.brush.obstaclesBrushfireCffi(ogm, ogm_limits)
Print.art_print("Brush time: " + str(time.time() - tinit), Print.ORANGE)
# Calculate skeletonization
tinit = time.time()
skeleton = topology.skeletonizationCffi(ogm, origin, resolution, ogm_limits)
Print.art_print("Skeletonization time: " + str(time.time() - tinit), Print.ORANGE)
# Find topological graph
tinit = time.time()
nodes = topology.topologicalNodes(ogm, skeleton, coverage, brush)
Print.art_print("Topo nodes time: " + str(time.time() - tinit), Print.ORANGE)
# Visualization of topological nodes
vis_nodes = [[n[0] * resolution + origin['x'], n[1] * resolution + origin['y']] for n in nodes]
RvizHandler.printMarker(
vis_nodes,
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_topological_nodes", # Namespace
[0.3, 0.4, 0.7, 0.5], # Color RGBA
0.1 # Scale
)
try:
tinit = time.time()
except:
tinit = None
if self.method == 'random' or force_random:
target = self.selectRandomTarget(ogm, coverage, brush)
elif self.method_is_cost_based():
g_robot_pose = self.robot_perception.getGlobalCoordinates([robot_pose['x_px'], robot_pose['y_px']])
self.path_planning.setMap(self.robot_perception.getRosMap())
class MapContainer:
def __init__(self):
self.skeleton = skeleton
self.coverage = coverage
self.ogm = ogm
self.brush = brush
self.nodes = [node for node in nodes if TargetSelection.is_good(brush, ogm, coverage, node)]
self.robot_px = [robot_pose['x_px'] - origin['x'] / resolution,
robot_pose['y_px'] - origin['y'] / resolution]
self.theta = robot_pose['th']
@staticmethod
def create_path(path_target):
return self.path_planning.createPath(g_robot_pose, path_target, resolution)
target = self.select_by_cost(MapContainer())
else:
assert False, "Invalid target_selector method."
if tinit is not None:
Print.art_print("Target method {} time: {}".format(self.method, time.time() - tinit), Print.ORANGE)
return target
@staticmethod
def selectRandomTarget(ogm, coverage, brushogm):
# The next target in pixels
while True:
x_rand = random.randint(0, ogm.shape[0] - 1)
y_rand = random.randint(0, ogm.shape[1] - 1)
if ogm[x_rand][y_rand] < 50 and coverage[x_rand][y_rand] < 50 and brushogm[x_rand][y_rand] > 5:
return x_rand, y_rand
@staticmethod
def is_good(brush, ogm, coverage, target=None):
"""
:rtype: numpy.ndarray
"""
if target is not None:
x, y = target
return ogm[x][y] < 50 and coverage[x][y] < 50 and brush[x][y] > 5
else:
return numpy.logical_and(numpy.logical_and(ogm < 50, coverage < 50), brush > 5)
def select_by_cost(self, map_info):
nodes, paths, topo_costs = zip(*self.choose_best_nodes(map_info))
if nodes[0] is None: # choose_best_node's yield when no path is found will make nodes = (None,)
return -1, -1
elif len(nodes) == 1:
return nodes[0]
best_path_idx = self.weight_costs(
topo_costs,
[self.distance_cost(path, map_info.robot_px) for path in paths], # Distance
[self.coverage_cost(path, map_info.coverage) for path in paths], # Coverage
[self.rotation_cost(path, map_info.robot_px, map_info.theta) for path in paths] # Rotational
).argmax()
assert paths[best_path_idx]
target = nodes[best_path_idx]
Print.art_print("Best: {}".format(best_path_idx), Print.BLUE)
return target
def choose_best_nodes(self, map_info):
# Since path planning takes a lot of time for many nodes we should reduce the possible result to the nodes
# with the best distance and topological costs.
if self.method == 'cost_based_fallback':
yield self.closer_node(map_info), None, None
return
nodes = list(self.cluster_nodes(map_info.nodes, map_info.robot_px, self.cost_based_properties['node_clusters']))
topo_costs = [self._topological_cost(node, map_info.ogm) for node in nodes]
best_nodes_idx = self.weight_costs(
topo_costs,
[euclidean(node, map_info.robot_px) for node in nodes]
).argsort()[::-1] # We need descending order since we now want to maximize.
count = 0
for idx in best_nodes_idx:
node = nodes[idx]
path = map_info.create_path(node)
if path:
count += 1
yield node, path, topo_costs[idx]
if count == self.cost_based_properties['max_paths']:
break
if count == 0:
Print.art_print("Failed to create any path. Falling back to closer unoccupied.", Print.RED)
self.method = 'cost_based_fallback'
yield self.closer_node(map_info), None, None
@staticmethod
def cluster_nodes(nodes_original, robot_px, n_clusters):
Print.art_print("Trying to cluster:" + str(nodes_original), Print.BLUE)
whitened = whiten(nodes_original)
_, cluster_idx = kmeans2(whitened, n_clusters)
Print.art_print("Ended with clusters:" + str(cluster_idx), Print.BLUE)
keyfun = lambda x: cluster_idx[x[0]]
nodes = sorted(enumerate(nodes_original), key=keyfun)
for _, group in itertools.groupby(nodes, key=keyfun):
# For each cluster pick the farthest one.
max_idx = max(group, key=lambda x: euclidean(robot_px, x[1]))[0]
yield nodes_original[max_idx]
def weight_costs(self, *cost_vectors, **kwargs):
costs = self.normalize_costs(numpy.array(tuple(vector for vector in cost_vectors)))
if 'weights' in kwargs:
weights = kwargs['weights']
else:
weights = 2 ** numpy.arange(costs.shape[0] - 1, -1, -1)
return numpy.average(costs, axis=0, weights=weights)
@staticmethod
def closer_node(map_info):
robot_px = numpy.array(map_info.robot_px)
nodes = numpy.array(numpy.where(TargetSelection.is_good(
numpy.array(map_info.brush),
numpy.array(map_info.ogm),
numpy.array(map_info.coverage),
target=None
))).transpose()
closer_idx = numpy.linalg.norm(nodes - robot_px, axis=1).argmin()
return nodes[closer_idx]
def _topological_cost(self, node, ogm):
threshold = self.cost_based_properties['topo_threshold']
return self.topological_cost(node, ogm, threshold)
@staticmethod
def topological_cost(node, ogm, threshold):
result = 0
for dir_x, dir_y in [(0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0), (-1, 1)]:
cost = 0
idx = 0
x, y = node
while cost < threshold:
idx += 1
x_c = x + idx * dir_x
y_c = y + idx * dir_y
cost = (x - x_c) ** 2 + (y - y_c) ** 2
if ogm[x_c][y_c] > 50:
break
elif ogm[x_c][y_c] in [50, -1]:
Print.art_print("{},{} is unknown!".format(x_c, y_c), Print.RED)
cost = threshold
break
result += min(threshold, cost)
return result
@staticmethod
def distance_cost(path, robot_px):
weighted_distances = (TargetSelection.distance(node1, node2) * TargetSelection.distance_coeff(node1, robot_px)
for node1, node2 in zip(path[:-1], path[1:]))
return sum(weighted_distances)
@staticmethod
def distance_coeff(node, robot_px, s=30, epsilon=0.0001):
x_n, y_n = node
x_g, y_g = robot_px
coeff = 1 - math.exp(-((x_n - x_g) ** 2 / (2 * s ** 2) + (y_n - y_g) ** 2 / (2 * s ** 2))) + epsilon
return 1 / coeff
@staticmethod
def distance(node_a, node_b):
x_1, y_1 = node_a
x_2, y_2 = node_b
return math.sqrt((x_1 - x_2) ** 2 + (y_1 - y_2) ** 2)
@staticmethod
def rotation_cost(path, robot_px, theta):
rotation = 0
rx, ry = robot_px
theta_old = theta
for node in path:
st_x, st_y = node
theta_new = math.atan2(st_y - ry, st_x - rx)
rotation += abs(theta_new - theta_old)
theta_old = theta_new
return rotation
@staticmethod
def coverage_cost(path, coverage):
coverage_sum = sum(coverage[x][y] for x, y in path)
return coverage_sum
@staticmethod
def normalize_costs(costs):
"""
:rtype: numpy.ndarray
"""
Print.art_print("Costs before normalization:\n" + str(costs), Print.BLUE)
assert (costs >= 0).all()
return 1 - (costs.transpose() / numpy.abs(costs).max(axis=1)).transpose()
class TargetSelection:
# Constructor
def __init__(self, selection_method):
self.goals_position = []
self.goals_value = []
self.omega = 0.0
self.radius = 0
self.method = selection_method
self.brush = Brushfires()
self.topo = Topology()
self.path_planning = PathPlanning()
# Initialize previous target
self.previous_target = [-1, -1]
def selectTarget(self, init_ogm, ros_ogm, coverage, robot_pose, origin, \
resolution, force_random = False):
target = [-1, -1]
######################### NOTE: QUESTION ##############################
# Implement a smart way to select the next target. You have the
# following tools: ogm_limits, Brushfire field, OGM skeleton,
# topological nodes.
# Find only the useful boundaries of OGM. Only there calculations
# have meaning
ogm_limits = OgmOperations.findUsefulBoundaries(
init_ogm, origin, resolution)
# Blur the OGM to erase discontinuities due to laser rays
ogm = OgmOperations.blurUnoccupiedOgm(init_ogm, ogm_limits)
# Calculate Brushfire field
tinit = time.time()
brush = self.brush.obstaclesBrushfireCffi(ogm, ogm_limits)
Print.art_print("Brush time: " + str(time.time() - tinit),
Print.ORANGE)
# Calculate skeletonization
tinit = time.time()
skeleton = self.topo.skeletonizationCffi(ogm, \
origin, resolution, ogm_limits)
Print.art_print("Skeletonization time: " + str(time.time() - tinit),
Print.ORANGE)
# Find topological graph
tinit = time.time()
nodes = self.topo.topologicalNodes(ogm, skeleton, coverage, origin, \
resolution, brush, ogm_limits)
Print.art_print("Topo nodes time: " + str(time.time() - tinit),
Print.ORANGE)
# Visualization of topological nodes
vis_nodes = []
for n in nodes:
vis_nodes.append([
n[0] * resolution + origin['x'],
n[1] * resolution + origin['y']
])
RvizHandler.printMarker(\
vis_nodes,\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_topological_nodes", # Namespace
[0.3, 0.4, 0.7, 0.5], # Color RGBA
0.1 # Scale
)
# Random point
if self.method == 'random' or force_random == True:
target = self.selectRandomTarget(ogm, coverage, brush, ogm_limits)
# Custom point
elif self.method == 'cost_based':
self.path_planning.setMap(ros_ogm)
g_robot_pose = [robot_pose['x_px'] - int(origin['x'] / resolution),\
robot_pose['y_px'] - int(origin['y'] / resolution)]
# Remove all covered nodes from the candidate list
nodes = np.array(nodes)
uncovered_idxs = np.array(
[coverage[n[0], n[1]] == 0 for n in nodes])
goals = nodes[uncovered_idxs]
# Initialize costs
w_dist = np.full(len(goals), np.inf)
w_turn = np.full(len(goals), np.inf)
w_topo = np.full(len(goals), np.inf)
w_cove = np.full(len(goals), np.inf)
for idx, node in zip(range(len(goals)), goals):
subgoals = np.array(
self.path_planning.createPath(g_robot_pose, node,
resolution))
# If path is empty then skip to the next iteration
if subgoals.size == 0:
continue
# subgoals should contain the robot pose, so we don't need to diff it explicitly
subgoal_vectors = np.diff(subgoals, axis=0)
# Distance cost
dists = [math.hypot(v[0], v[1]) for v in subgoal_vectors]
w_dist[idx] = np.sum(dists)
# Turning cost
w_turn[idx] = 0
theta = robot_pose['th']
for v in subgoal_vectors[:-1]:
st_x, st_y = v
theta2 = math.atan2(st_y - g_robot_pose[1],
st_x - g_robot_pose[0])
w_turn[idx] += abs(theta2 - theta)
theta = theta2
# Coverage cost
w_cove[idx] = sum(coverage[x][y] for x, y in subgoal_vectors)
# Topology cost
w_topo[idx] = brush[node[0], node[1]]
# Normalize weights
w_dist = (w_dist - min(w_dist)) / (max(w_dist) - min(w_dist))
w_turn = (w_turn - min(w_turn)) / (max(w_turn) - min(w_turn))
w_cove = (w_cove - min(w_cove)) / (max(w_cove) - min(w_cove))
w_topo = (w_topo - min(w_topo)) / (max(w_topo) - min(w_topo))
# Cost weights
c_topo = 4
c_dist = 3
c_cove = 2
c_turn = 1
# Calculate combination cost (final)
cost = c_dist * w_dist + c_turn * w_turn + c_cove * w_cove + c_topo * w_topo
min_dist, min_idx = min(zip(cost, range(len(cost))))
target = nodes[min_idx]
# Check if next target exists and if it exists, check if is close to previous
if target is None:
target = self.selectRandomTarget(ogm, coverage, brush,
ogm_limits)
else:
target_dist = math.hypot(target[0] - self.previous_target[0],
target[1] - self.previous_target[1])
if target_dist <= 5:
target = self.selectRandomTarget(ogm, coverage, brush,
ogm_limits)
########################################################################
self.previous_target = target
return target
def selectRandomTarget(self, ogm, coverage, brushogm, ogm_limits):
# The next target in pixels
tinit = time.time()
next_target = [0, 0]
found = False
while not found:
x_rand = random.randint(0, ogm.shape[0] - 1)
y_rand = random.randint(0, ogm.shape[1] - 1)
if ogm[x_rand][y_rand] < 50 and coverage[x_rand][y_rand] < 50 and \
brushogm[x_rand][y_rand] > 5:
next_target = [x_rand, y_rand]
found = True
Print.art_print("Select random target time: " + str(time.time() - tinit), \
Print.ORANGE)
return next_target
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.time_limit = 20 # seconds
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'), \
Path, queue_size = 10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),\
MarkerArray, queue_size = 10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),\
Marker, queue_size = 10)
# Timer Thread (initialization)
self.timerThread = TimerThread(self.time_limit)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or\
self.next_subtarget == len(self.subtargets):
return
# Check if timer has expired
if self.timerThread.expired == True:
Print.art_print('\n~~~~ Time reset ~~~~',Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in pixels
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta_robot = self.robot_perception.robot_pose['th']
# Clear achieved targets
self.subtargets = self.subtargets[self.next_subtarget:]
self.next_subtarget = 0
# Find the distance between the robot pose and all remaining subtargets
dx = [rx - st[0] for st in self.subtargets]
dy = [ry - st[1] for st in self.subtargets]
dist = [math.hypot(v[0], v[1]) for v in zip(dx, dy)]
# Try to optimize path only when there is more than one target available
if len(self.subtargets) > 1:
ogm = self.robot_perception.getMap()
theta_goals = np.arctan2(-np.array(dy),-np.array(dx))
dtheta = theta_goals - theta_robot
dtheta[dtheta > np.pi] -= 2*np.pi
dtheta[dtheta < -np.pi] += 2*np.pi
# Check if there are obstacles between robot and subtarget
obstacles_subtarget = []
for st,i in zip(self.subtargets, range(len(self.subtargets))):
# Find line in pixels between robot and goal
line_pxls = list(bresenham(int(round(st[0])), int(round(st[1])),\
int(round(rx)), int(round(ry))))
# Find if there are any obstacles in line
ogm_line = list(map(lambda pxl: ogm[pxl[0], pxl[1]], line_pxls))
N_occupied = len(list(filter(lambda x: x > 80, ogm_line)))
obstacles_subtarget.append(N_occupied)
# Check if one of next goals is aligned with the current robot theta
# In this case plan immediately for this goal in order to improve motion behaviour
for st, i in zip(self.subtargets, range(len(self.subtargets))):
if np.fabs(dtheta[i]) < np.pi/10 and obstacles_subtarget[i] == 0:
self.next_subtarget = i
# Keep resetting timer, while moving towards target (without any obstacles inbetween)
self.timerThread.reset()
# Check if any target is in distance
min_dist, min_idx = min(zip(dist, range(len(dist))))
if min_dist < 5:
self.next_subtarget = min_idx + 1
# Reset timer if a goal has been reached
self.timerThread.reset()
# Check if the final subtarget has been approached
if self.next_subtarget >= len(self.subtargets):
self.target_exists = False
# Publish the current target
if self.next_subtarget >= len(self.subtargets):
return
subtarget = [\
self.subtargets[self.next_subtarget][0]\
* self.robot_perception.resolution + \
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1]\
* self.robot_perception.resolution + \
self.robot_perception.origin['y']\
]
RvizHandler.printMarker(\
[subtarget],\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# Cancel previous goal timer
self.timerThread.stop()
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while self.robot_perception.have_map == False:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(\
[[0, 0]],\
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0,0,0,0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates(\
[self.robot_perception.robot_pose['x_px'],\
self.robot_perception.robot_pose['y_px']])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
# Potential Target
path_altered = False
previous_target = None
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(\
local_ogm,\
local_coverage,\
self.robot_perception.robot_pose,
self.robot_perception.origin,
self.robot_perception.resolution,
force_random)
# ipdb.set_trace()
# Check if there was any path alteration
if target[0] == True:
previous_target = target[2]
target = target[1]
path_altered = True
else:
target = target[1]
self.path = self.path_planning.createPath(\
g_robot_pose,\
target,
self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) +\
" points"
if len(self.path) == 0:
Print.art_print(\
"Path planning failed. Fallback to random target selection", \
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int) (len(self.path)/step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
# Start timer thread
self.timerThread.start()
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
ps.pose.position.x = 0
ps.pose.position.y = 0
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
# ipdb.set_trace()
ps.pose.position.x = p[0] * self.robot_perception.resolution \
+ self.robot_perception.origin['x']
ps.pose.position.y = p[1] * self.robot_perception.resolution \
+ self.robot_perception.origin['y']
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(\
subtargets_mark,\
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
# Print Old and Current Final Target
if path_altered == True:
subt = [
previous_target[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
previous_target[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
# ipdb.set_trace()
RvizHandler.printMarker(\
[subt],\
3, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[1.0, 0.0, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
# ipdb.set_trace()
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
l_max = 0.3
a_max = 0.3
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
theta_rg = np.arctan2(st_y - ry, st_x - rx)
dtheta = (theta_rg - theta)
if dtheta > np.pi:
omega = (dtheta - 2*np.pi)/np.pi
elif dtheta < -np.pi:
omega = (dtheta + 2*np.pi)/np.pi
else:
omega = (theta_rg - theta)/np.pi
# Nonlinear relations derived from experimentation
linear = l_max * ((1 - np.abs(omega)) ** 5)
angular = a_max * np.sign(omega) * (abs(omega) ** (1/5))
######################### NOTE: QUESTION ##############################
return [linear, angular]
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 200 # 20 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'), \
Path, queue_size = 10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),\
MarkerArray, queue_size = 10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),\
Marker, queue_size = 10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or\
self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~', Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in pixels
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
# Find the distance between the robot pose and the next subtarget
dist = math.hypot(\
rx - self.subtargets[self.next_subtarget][0], \
ry - self.subtargets[self.next_subtarget][1])
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# If the robot is in the starting point it immediately sets the next subtarget
if self.next_subtarget == 0:
self.next_subtarget += 1
self.counter_to_next_sub = self.count_limit
else:
# Check if there is a later subtarget, closer than the next one
# If one is found, make it the next subtarget and update the time
for i in range(self.next_subtarget + 1, len(self.subtargets) - 1):
# Find the distance between the robot pose and the later subtarget
dist_from_later = math.hypot(\
rx - self.subtargets[i][0], \
ry - self.subtargets[i][1])
if dist_from_later < 15:
self.next_subtarget = i
self.counter_to_next_sub = self.count_limit + 100
dist = dist_from_later
break
# If distance from subtarget is less than 5, go to the next one
if dist < 5:
self.next_subtarget += 1
self.counter_to_next_sub = self.count_limit
# Check if the final subtarget has been approached
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
########################################################################
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [\
self.subtargets[self.next_subtarget][0]\
* self.robot_perception.resolution + \
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1]\
* self.robot_perception.resolution + \
self.robot_perception.origin['y']\
]
RvizHandler.printMarker(\
[subtarget],\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while self.robot_perception.have_map == False:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(\
[[0, 0]],\
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0,0,0,0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates(\
[self.robot_perception.robot_pose['x_px'],\
self.robot_perception.robot_pose['y_px']])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(\
local_ogm,\
local_coverage,\
self.robot_perception.robot_pose,
self.robot_perception.origin,
self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(\
g_robot_pose,\
target,
self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) +\
" points"
if len(self.path) == 0:
Print.art_print(\
"Path planning failed. Fallback to random target selection", \
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
weight_data = 0.5 # How much weight to update the data (a)
weight_smooth = 0.1 # How much weight to smooth the coordinates (b)
min_change = 0.0001 # Minimum change per iteration to keep iterating
new_path = np.copy(np.array(self.path))
path_length = len(self.path[0])
change = min_change
while change >= min_change:
change = 0.0
for i in range(1, len(new_path) - 1):
for j in range(path_length):
# Initialize x, y
x_i = self.path[i][j]
y_i = new_path[i][j]
y_prev = new_path[i - 1][j]
y_next = new_path[i + 1][j]
y_i_saved = y_i
# Minimize the distance between coordinates of the original
# path (y) and the smoothed path (x). Also minimize the
# difference between the coordinates of the smoothed path
# at time step i, and neighboring time steps. In order to do
# all the minimizations, we use Gradient Ascent.
y_i += weight_data * (x_i - y_i) + weight_smooth * (
y_next + y_prev - (2 * y_i))
new_path[i][j] = y_i
change += abs(y_i - y_i_saved)
self.path = new_path
########################################################################
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int)(len(self.path) / step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
ps.pose.position.x = 0
ps.pose.position.y = 0
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
# Multiply subgoal's coordinates with resolution and
# add robot.origin in order to translate between the (0,0) of the robot
# pose and (0,0) of the map
ps.pose.position.x = p[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x']
ps.pose.position.y = p[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(\
subtargets_mark,\
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
######################### NOTE: QUESTION ##############################
# angular and linear velocities are calculated upon the
# math types presented at 9.exploration_target_selection.pdf
dtheta = math.degrees(math.atan2(st_y - ry,
st_x - rx)) - math.degrees(theta)
if dtheta >= 0 and dtheta < 180:
angular = dtheta / 180
elif dtheta > 0 and dtheta >= 180:
angular = (dtheta - 2 * 180) / 180
elif dtheta <= 0 and dtheta > -180:
angular = dtheta / 180
elif dtheta < 0 and dtheta < -180:
angular = (dtheta + 2 * 180) / 180
#should be angular*0.3 but then the robot moves very slow
#and cannot reach the targets within the time set from the timer
if angular > 0.3:
angular = 0.3
elif angular < -0.3:
angular = -0.3
# **20 is used to avoid overshoot problem
linear = ((1 - abs(angular))**20) * 0.3
return [linear, angular]
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 200 # 20 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'), \
Path, queue_size = 10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),\
MarkerArray, queue_size = 10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),\
Marker, queue_size = 10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or\
self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~',Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in pixels
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
# Find the distance between the robot pose and the next subtarget
dist = math.hypot(\
rx - self.subtargets[self.next_subtarget][0], \
ry - self.subtargets[self.next_subtarget][1])
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# Check if distance is less than 7 px (14 cm)
if dist < 5:
self.next_subtarget += 1
self.counter_to_next_sub = self.count_limit
# Check if the final subtarget has been approached
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
else:
# Find the next subtarget with the minimum distance
min = dist # minimum distance from a next subtarget
jump_to_next_subtarget = self.next_subtarget # the number of the next subtarget to jump to
next_check = self.next_subtarget + 1 # next subtarget to be checked
for i in range(self.next_subtarget+1, len(self.subtargets)):
temp_dist = math.hypot(\
rx - self.subtargets[next_check][0], \
ry - self.subtargets[next_check][1])
if temp_dist < min:
min = temp_dist
jump_to_next_subtarget = i
next_check += 1
self.next_subtarget = jump_to_next_subtarget
self.counter_to_next_sub = self.count_limit
########################################################################
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [\
self.subtargets[self.next_subtarget][0]\
* self.robot_perception.resolution + \
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1]\
* self.robot_perception.resolution + \
self.robot_perception.origin['y']\
]
RvizHandler.printMarker(\
[subtarget],\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while self.robot_perception.have_map == False:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(\
[[0, 0]],\
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0,0,0,0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates(\
[self.robot_perception.robot_pose['x_px'],\
self.robot_perception.robot_pose['y_px']])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(\
local_ogm,\
local_coverage,\
self.robot_perception.robot_pose,
self.robot_perception.origin,
self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(\
g_robot_pose,\
target,
self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) +\
" points"
if len(self.path) == 0:
Print.art_print(\
"Path planning failed. Fallback to random target selection", \
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
#########################################
# Extra challenge #1
# A. Smooth path planner
if len(self.path) > 3:
x = np.array(self.path)
y = np.copy(x)
a = 0.5
b = 0.1
# FORMULA : y_i = y_i + a * (x_i - y_i) + b * (y_i+1 - 2 * y_i + y_i+1)
epsilon = np.sum(np.abs(a * (x[1:-1, :] - y[1:-1, :]) + b * (y[2:, :] - 2*y[1:-1, :] + y[:-2, :])))
while epsilon > 1e-3:
y[1:-1, :] += a * (x[1:-1, :] - y[1:-1, :]) + b * (y[2:, :] - 2*y[1:-1, :] + y[:-2, :])
epsilon = np.sum(np.abs(a * (x[1:-1, :] - y[1:-1, :]) + b * (y[2:, :] - 2*y[1:-1, :] + y[:-2, :])))
# Copy the smoother path
self.path = y.tolist()
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int) (len(self.path)/step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
ps.pose.position.x = 0
ps.pose.position.y = 0
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
ps.pose.position.x = p[0] * self.robot_perception.resolution + self.robot_perception.origin['x']
ps.pose.position.y = p[1] * self.robot_perception.resolution + self.robot_perception.origin['y']
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(\
subtargets_mark,\
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta = self.robot_perception.robot_pose['th'] # robot orientation
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
PI = 3.14
MAX_SPEED = 0.3
st_x_rel = st_x - rx
st_y_rel = st_y - ry
st_th = math.atan2(st_y_rel, st_x_rel)
delta = st_th - theta
if delta >= 0 and delta < PI:
angular = delta / PI
elif delta > 0 and delta >= PI:
angular = (delta - 2 * PI) / PI
elif delta <= 0 and delta > -PI:
angular = delta / PI
elif delta < 0 and delta < -PI:
angular = (delta + 2 * PI) / PI
angular *= 5 #add more twisting sensitivity
angular *= MAX_SPEED
if angular > 0.3:
angular = 0.3
elif angular < -0.3:
angular = -0.3
linear = ((1 - abs(angular)) ** 10 ) * MAX_SPEED
######################### NOTE: QUESTION ##############################
return [linear, angular]
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 400 # 20 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'), \
Path, queue_size = 10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),\
MarkerArray, queue_size = 10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),\
Marker, queue_size = 10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or\
self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~', Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in pixels
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
for i in range(self.next_subtarget, len(self.subtargets)):
# Find the distance between the robot pose and the next subtarget
dist = math.hypot(\
rx - self.subtargets[i][0], \
ry - self.subtargets[i][1])
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# Check if distance is less than 7 px (14 cm)
if dist < 7:
self.next_subtarget = 1 + i
self.counter_to_next_sub = self.count_limit
# Check if the final subtarget has been approached
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
########################################################################
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [\
self.subtargets[self.next_subtarget][0]\
* self.robot_perception.resolution + \
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1]\
* self.robot_perception.resolution + \
self.robot_perception.origin['y']\
]
RvizHandler.printMarker(\
[subtarget],\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while self.robot_perception.have_map == False:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(\
[[0, 0]],\
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0,0,0,0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates(\
[self.robot_perception.robot_pose['x_px'],\
self.robot_perception.robot_pose['y_px']])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(\
local_ogm,\
local_coverage,\
self.robot_perception.robot_pose,
self.robot_perception.origin,
self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(\
g_robot_pose,\
target,
self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) +\
" points"
if len(self.path) == 0:
Print.art_print(\
"Path planning failed. Fallback to random target selection", \
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int)(len(self.path) / step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
ps.pose.position.x = 0
ps.pose.position.y = 0
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin arE
ps.pose.position.x = self.robot_perception.origin['x'] /\
self.robot_perception.resolution
ps.pose.position.y = self.robot_perception.origin['y'] /\
self.robot_perception.resolution
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(\
subtargets_mark,\
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
wmega = math.atan2((st_y - ry), (st_x - rx)) - theta
print(wmega)
print(math.atan2((st_y - ry), (st_x - rx)))
print(theta)
if abs(wmega) >= 0.1:
angular = np.sign(wmega) * 0.3 #(wmega/(3.14))*0.3
linear = 0 #(1-(wmega/(3.14)))*0.3
else:
angular = (wmega / (3.14)) * 0.3
linear = math.tanh(
math.sqrt(pow((st_y - ry), 2) + pow((st_x - rx), 2))) * 0.3
######################### NOTE: QUESTION ##############################
print(angular)
return [linear, angular]
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 500 # 20 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = rospy.Publisher(
rospy.get_param('path_pub_topic'), Path, queue_size=10)
# ROS Publisher for the subtargets
self.subtargets_publisher = rospy.Publisher(
rospy.get_param('subgoals_pub_topic'), MarkerArray, queue_size=10)
# ROS Publisher for the current target
self.current_target_publisher = rospy.Publisher(
rospy.get_param('curr_target_pub_topic'), Marker, queue_size=10)
self.previous_next_subtarget = None
def checkTarget(self, event):
"""
Check if target/sub-target reached.
:param event:
:return:
"""
if self.previous_next_subtarget is None or self.previous_next_subtarget < self.next_subtarget:
Print.art_print("next_subtarget = %d" % self.next_subtarget,
Print.ORANGE)
self.previous_next_subtarget = self.next_subtarget
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False \
or self.move_with_target == False \
or self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~', Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in: pixel units & global (map's) coordinate system
rp_l_px = [
self.robot_perception.robot_pose['x_px'],
self.robot_perception.robot_pose['y_px']
]
# rp_g_px = self.robot_perception.toGlobalCoordinates(rp_l_px)
[rx, ry] = [
self.robot_perception.robot_pose['x_px'] -
self.robot_perception.origin['x'] /
self.robot_perception.resolution,
self.robot_perception.robot_pose['y_px'] -
self.robot_perception.origin['y'] /
self.robot_perception.resolution
]
rp_g_px = [rx, ry]
# Find the distance between the robot pose and the next subtarget
v_g_px = map(operator.sub, rp_g_px,
self.subtargets[self.next_subtarget])
dist = math.hypot(v_g_px[0], v_g_px[1])
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# Check if distance is less than 7 px (14 cm)
# if dist < 5:
# self.next_subtarget += 1
# self.counter_to_next_sub = self.count_limit
# # Check if the final subtarget has been approached
# if self.next_subtarget == len(self.subtargets):
# self.target_exists = False
# Instead of checking only next sub-target check all remaining sub-targets (starting from end up to next
# sub-target) and decide if robot is closer to another sub-target at later point in path
for st_i in range(
len(self.subtargets) - 1, self.next_subtarget - 1, -1):
# @v_st_g_px: Difference of Global coordinates in Pixels between robot's position
# and i-th" sub-target's position
v_st_g_px = map(operator.sub, rp_g_px, self.subtargets[st_i])
if math.hypot(v_st_g_px[0], v_st_g_px[1]) < 5:
# reached @st_i, set next sub-target in path as robot's next sub-target
self.next_subtarget = st_i + 1
self.counter_to_next_sub = self.count_limit
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
########################################################################
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [
self.subtargets[self.next_subtarget][0] *
self.robot_perception.resolution +
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1] *
self.robot_perception.resolution +
self.robot_perception.origin['y']
]
RvizHandler.printMarker(
[subtarget],
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while not self.robot_perception.have_map:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(
[[0, 0]],
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0, 0, 0, 0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
# Get robot pose in global (map's) coordinates
rp_l_px = [
self.robot_perception.robot_pose['x_px'],
self.robot_perception.robot_pose['y_px']
]
rp_g_px = self.robot_perception.toGlobalCoordinates(
rp_l_px, with_resolution=True)
g_robot_pose = rp_g_px
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(
local_ogm, local_coverage, self.robot_perception.robot_pose,
self.robot_perception.origin, self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(
g_robot_pose, target, self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) + \
" points"
if len(self.path) == 0:
Print.art_print(
"Path planning failed. Fallback to random target selection",
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
# Break the path to sub-goals every 2 pixels (1m = 20px)
step = 1
n_subgoals = int(len(self.path) / step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
# Convert p from pixel-units to meter
p_m = self.robot_perception.toMeterUnits(p, False)
# Convert p_m from global (map's) coordinates to relative (image's) coordinates (using resolution = 1)
p_m_r = self.robot_perception.toRelativeCoordinates(p_m, False)
# Fill in $ps object
ps.pose.position.x = p_m_r[0]
ps.pose.position.y = p_m_r[1]
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
st_m = self.robot_perception.toMeterUnits(s, False)
st_m_r = self.robot_perception.toRelativeCoordinates(st_m, False)
subtargets_mark.append(st_m_r)
RvizHandler.printMarker(
subtargets_mark,
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
# Get global robot coordinates
rp_l_px = [
self.robot_perception.robot_pose['x_px'],
self.robot_perception.robot_pose['y_px']
]
rp_g_px = self.robot_perception.toGlobalCoordinates(rp_l_px)
theta_r = self.robot_perception.robot_pose['th']
theta_r_deg = math.degrees(theta_r)
if theta_r_deg < 0:
theta_r_deg += 360
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
# st: in pixel units & on global (map's) coordinate system
st_g_px = self.subtargets[self.next_subtarget]
# Both, st and rp are in the same coordinate system (global - map's) and in the same units (pixels)
# So, the vector difference of these two vectors (st - rp) yields the vector that joins these two points
v_g_px = map(operator.sub, st_g_px, rp_g_px)
# Robot's current orientations forms $theta_r angle from global coordinate system's x-axis, whereas the
# vector calculated above forms $theta_rg angle. The latter is defined next:
theta_rg = math.atan2(v_g_px[1], v_g_px[0])
# FIX: use degrees to correctly address negative angles
theta_rg_deg = math.degrees(theta_rg)
if theta_rg_deg < 0:
theta_rg_deg += 360
# Find angle difference, $delta_theta
delta_theta_deg = theta_rg_deg - theta_r_deg
# Calculate new angular velocity based on delta_theta
# (slide #93 - 9th presentation, IRS Course ECE AUTH, [email protected])
if 0 <= delta_theta_deg < 180:
angular = delta_theta_deg / 180
elif delta_theta_deg > 0 and delta_theta_deg >= 180:
angular = (delta_theta_deg - 360) / 180
elif -180 < delta_theta_deg <= 0:
angular = delta_theta_deg / 180
elif delta_theta_deg < 0 and delta_theta_deg < -180:
angular = (delta_theta_deg + 360) / 180
# Calculate new linear velocity based on new angular velocity and relation in slide #97 (for n = 6)
linear = math.pow(1 - abs(angular), 6)
######################### NOTE: QUESTION ##############################
return [linear, angular]
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 200 # 20 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print("The selected target function is " + self.target_selector)
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'),
Path, queue_size=10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),
MarkerArray, queue_size=10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),
Marker, queue_size=10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or \
self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~', Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in pixels
[rx, ry] = [
self.robot_perception.robot_pose['x_px'] -
self.robot_perception.origin['x'] /
self.robot_perception.resolution,
self.robot_perception.robot_pose['y_px'] -
self.robot_perception.origin['y'] /
self.robot_perception.resolution
]
# # Find the distance between the robot pose and the next subtarget
# dist = math.hypot(
# rx - self.subtargets[self.next_subtarget][0],
# ry - self.subtargets[self.next_subtarget][1])
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# Check if distance is less than 7 px (14 cm)
# if dist < 5:
# self.next_subtarget += 1
# self.counter_to_next_sub = self.count_limit
# # Check if the final subtarget has been approached
# if self.next_subtarget == len(self.subtargets):
# self.target_exists = False
# find the distance between robot and ALL subtargets
dists = (math.hypot(rx - self.subtargets[subtarget][0],
ry - self.subtargets[subtarget][1])
for subtarget, _ in enumerate(self.subtargets))
# check the distance of each subtarget from the robot
# go towards the nearest and change index of next_subtarget
# accordingly
for idx, dist in enumerate(dists):
if dist < 5:
self.next_subtarget = idx + 1
self.counter_to_next_sub = self.count_limit
# Check if the final subtarget has been approached
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
########################################################################
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [
self.subtargets[self.next_subtarget][0] *
self.robot_perception.resolution +
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1] *
self.robot_perception.resolution +
self.robot_perception.origin['y']
]
RvizHandler.printMarker(
[subtarget],
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while not self.robot_perception.have_map:
Print.art_print("Navigation: No map yet", Print.RED)
return
print("\nClearing all markers")
RvizHandler.printMarker( \
[[0, 0]], \
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0, 0, 0, 0], # Color RGBA
0.1 # Scale
)
print('\n\n----------------------------------------------------------')
print("Navigation: Producing new target")
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print("Got the map and Coverage")
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates([
self.robot_perception.robot_pose['x_px'],
self.robot_perception.robot_pose['y_px']
])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
print(self.robot_perception.resolution)
target = self.target_selection.selectTarget(
local_ogm, local_coverage, self.robot_perception.robot_pose,
self.robot_perception.origin, self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(
g_robot_pose, target, self.robot_perception.resolution)
print("Navigation: Path for target found with " + str(len(self.path)) + \
" points")
if len(self.path) == 0:
Print.art_print(
"Path planning failed. Fallback to random target selection",
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int)(len(self.path) / step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print("The path produced " + str(len(self.subtargets)) + " subgoals")
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
ps.pose.position.x = 0
ps.pose.position.y = 0
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
ps.pose.position.x = p[
0] * self.robot_perception.resolution + self.robot_perception.origin[
'x']
ps.pose.position.y = p[
1] * self.robot_perception.resolution + self.robot_perception.origin[
'y']
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(
subtargets_mark,
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [
self.robot_perception.robot_pose['x_px'] -
self.robot_perception.origin['x'] /
self.robot_perception.resolution,
self.robot_perception.robot_pose['y_px'] -
self.robot_perception.origin['y'] /
self.robot_perception.resolution
]
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
# Find the distance between the robot and the next subtarget
# dist = math.hypot(rx - st_x, ry - st_y)
# phi is the angle between the robot and the next subtarget
# we calculate that angle using atan2, which returns the angle
# between a point [x,y] and the x'x axis, with origin on 0,0
# So, we move the origin to the robots position by subtracting
# its coordinates from a given point
phi = math.atan2(st_y - ry, st_x - rx)
if 3.2 >= (
phi - theta
) >= 0.1 and phi > theta: # if phi is bigger than theta and their difference is
# lower than pi (they are anti-parallel), turn left
linear = 0
angular = 1
elif 3.2 >= (
theta - phi
) >= 0.1 and phi < theta: # if phi is smaller than theta and their difference is
# lower than pi (they are anti-parallel), turn right
linear = 0
angular = -1
else: # otherwise, move ahead
linear = 1
angular = 0
######################### NOTE: QUESTION #############-#################
return [linear, angular]
class Navigation(object):
MAX_LINEAR_VELOCITY = rospy.get_param('max_linear_velocity')
MAX_ANGULAR_VELOCITY = rospy.get_param('max_angular_velocity')
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
self.force_random = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 200 # 20 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = rospy.Publisher(
rospy.get_param('path_pub_topic'), Path, queue_size=10)
# ROS Publisher for the subtargets
self.subtargets_publisher = rospy.Publisher(
rospy.get_param('subgoals_pub_topic'), MarkerArray, queue_size=10)
# ROS Publisher for the current target
self.current_target_publisher = rospy.Publisher(
rospy.get_param('curr_target_pub_topic'), Marker, queue_size=10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if not self.inner_target_exists or not self.move_with_target or self.next_subtarget == len(
self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~', Print.RED)
self.inner_target_exists = False
self.target_exists = False
self.force_random = True
return
# Get the robot pose in pixels
[rx, ry] = [
self.robot_perception.robot_pose['x_px'] -
self.robot_perception.origin['x'] /
self.robot_perception.resolution,
self.robot_perception.robot_pose['y_px'] -
self.robot_perception.origin['y'] /
self.robot_perception.resolution
]
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the next subtarget? Alter the code
# accordingly. Check if distance is less than 7 px (14 cm). Slice the list of subtargets and then reverse it.
for idx, st in enumerate(self.subtargets[self.next_subtarget::][::-1]):
# Right now, idx refers to the sliced & reversed array, fix it.
idx = len(self.subtargets) - 1 - idx
assert idx >= self.next_subtarget
dist = math.hypot(rx - st[0], ry - st[1])
if dist < 7:
self.next_subtarget = idx + 1
self.counter_to_next_sub = self.count_limit
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
break
########################################################################
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [
self.subtargets[self.next_subtarget][0] *
self.robot_perception.resolution +
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1] *
self.robot_perception.resolution +
self.robot_perception.origin['y']
]
RvizHandler.printMarker(
[subtarget],
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while not self.robot_perception.have_map:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(
[[0, 0]],
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0, 0, 0, 0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates([
self.robot_perception.robot_pose['x_px'],
self.robot_perception.robot_pose['y_px']
])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(
local_ogm, local_coverage, self.robot_perception.robot_pose,
self.robot_perception.origin, self.robot_perception.resolution,
self.force_random)
self.force_random = False
self.path = self.path_planning.createPath(
g_robot_pose, target, self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(
len(self.path)) + " points"
if len(self.path) == 0:
Print.art_print(
"Path planning failed. Fallback to random target selection",
Print.RED)
self.force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = int(len(self.path) / step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
ps.pose.position.x = p[
0] * self.robot_perception.resolution + self.robot_perception.origin[
'x']
ps.pose.position.y = p[
1] * self.robot_perception.resolution + self.robot_perception.origin[
'y']
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution +
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution +
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(
subtargets_mark,
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
rx = self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution
ry = self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
theta_g = math.atan2(st_y - ry, st_x - rx)
delta_theta = theta_g - theta # All thetas in radians.
angular_coeff = delta_theta / math.pi + 2 * (
delta_theta < -math.pi) - 2 * (delta_theta >= math.pi)
linear_coeff = (1 - abs(angular_coeff))**6
# Experimental: Recalculate angular speed according to linear.
angular_coeff = (1 - linear_coeff) * np.sign(angular_coeff)
linear = self.MAX_LINEAR_VELOCITY * linear_coeff
angular = self.MAX_ANGULAR_VELOCITY * angular_coeff
assert abs(angular_coeff
) <= 1, "Angular coefficient outside of range [-1, 1]."
assert 0 <= linear_coeff <= 1, "Linear coefficient outside of range [0, 1]."
return linear, angular
else:
return 0, 0
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 200 # 20 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'), \
Path, queue_size = 10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),\
MarkerArray, queue_size = 10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),\
Marker, queue_size = 10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or\
self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~',Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in pixels
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# Challenge 5
# Instead of checking the distance of the next target,
# check the distance of the remaining targets, therefore you may reach to a next subject
# bypassing current.
for i in range(self.next_subtarget, len(self.subtargets)):
# Find the distance between the robot pose and the next subtarget
dist = math.hypot( rx - self.subtargets[i][0], ry - self.subtargets[i][1])
# check distance with the i_th target
if i != (len(self.subtargets)-1):
if dist < 10: #if distance found to be small from a terget set as next the target i + 1
self.next_subtarget = i + 1
self.counter_to_next_sub = self.count_limit
else:
if dist < 5: #if distance found to be small from a terget set as next the target i + 1
self.next_subtarget = i + 1
self.counter_to_next_sub = self.count_limit
# Check if the final subtarget has been approached
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
########################################################################
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [\
self.subtargets[self.next_subtarget][0]\
* self.robot_perception.resolution + \
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1]\
* self.robot_perception.resolution + \
self.robot_perception.origin['y']\
]
RvizHandler.printMarker(\
[subtarget],\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while self.robot_perception.have_map == False:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(\
[[0, 0]],\
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0,0,0,0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates(\
[self.robot_perception.robot_pose['x_px'],\
self.robot_perception.robot_pose['y_px']])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(\
local_ogm,\
local_coverage,\
self.robot_perception.robot_pose,
self.robot_perception.origin,
self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(\
g_robot_pose,\
target,
self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) +\
" points"
if len(self.path) == 0:
Print.art_print(\
"Path planning failed. Fallback to random target selection", \
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
###################################################
# Extra Challenge 1
# Smooth path
if len(self.path) > 3:
x = np.array(self.path)
y = np.copy(x)
a = 0.5
b = 0.1
epsilon = np.sum(np.abs(a * (x[1:-1, :] - y[1:-1, :]) + b * (y[2:, :] - 2*y[1:-1, :] + y[:-2, :])))
while epsilon > 1e-3:
y[1:-1, :] += a * (x[1:-1, :] - y[1:-1, :]) + b * (y[2:, :] - 2*y[1:-1, :] + y[:-2, :])
epsilon = np.sum(np.abs(a * (x[1:-1, :] - y[1:-1, :]) + b * (y[2:, :] - 2*y[1:-1, :] + y[:-2, :])))
# Copy the smoother path
self.path = y.tolist()
####################################################
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int) (len(self.path)/step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
ps.pose.position.x = 0
ps.pose.position.y = 0
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
# Challenge 2:
ps.pose.position.x = p[0] * self.robot_perception.resolution + self.robot_perception.origin['x']
ps.pose.position.y = p[1] * self.robot_perception.resolution + self.robot_perception.origin['y']
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(\
subtargets_mark,\
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
# Challenge 3
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
# We know goals position (x', y') and robot's position (x,y)
# It is tan(Theta_RG) = (y'-y)/(x'-x) = lamda
# Theta_RG = atan(lamda)
# Theta_RG is the angle between vector RobotGoal and Ox axis
Theta_RG = math.atan2(st_y - ry, st_x - rx) # atan2 return the result in rads
# We can calculate the angle between the direction of robot's movement
# and the RG vector. The angle will be the difference of RGangle - theta(direction angle of robot's movement)
D_Theta = Theta_RG - theta
# Based on presentation 9, D_Theta
# has to be readjusted in [-pi, pi]
if (D_Theta < math.pi) and (D_Theta > -math.pi):
omega = D_Theta / math.pi
elif D_Theta >= math.pi:
omega = (D_Theta - 2 * math.pi) / math.pi
elif D_Theta <= -math.pi:
omega = (D_Theta + 2 * math.pi) / math.pi
# Linear Speed Calculation
# presentation 9: u = umax(1- |omega|)^n
# larger n -> lower speed
# max speed = 0.3
u = ((1 - abs(omega))**(6.00))
linear = 0.3 * u
# Robot is steering slowly
# therefore we had to make steer faster
# max speed = 0.3
omega = (math.copysign(abs(omega)**(1.0/6), omega))
angular = 0.3 * omega
######################### NOTE: QUESTION ##############################
return [linear, angular]
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
self.TimeOut = False
self.Reset = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 230 # 23 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.1), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'), \
Path, queue_size = 10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),\
MarkerArray, queue_size = 10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),\
Marker, queue_size = 10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or\
self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~',Print.RED)
self.inner_target_exists = False
self.target_exists = False
if self.Reset == False:
self.TimeOut = True
else:
self.Reset = False
return
# Get the robot pose in pixels
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
# remove visited sub targets
self.subtargets = self.subtargets[self.next_subtarget:]
# set the next sub target as the first one that should be visited
self.next_subtarget = 0
dis_x = [rx - target[0] for target in self.subtargets]
dis_y = [ry - target[1] for target in self.subtargets]
#for i in range(0,len(dis_x)):
# print " x dis " + str(dis_x[i])
# print " y dis " + str(dis_y[i])
# target distances
dist_t = [math.hypot(dis[0],dis[1]) for dis in zip(dis_x,dis_y) ]
# find the closest target
min_target = 0
min_dis = dist_t[0]
for i in range(0,len(dist_t)):
if min_dis > dist_t[i]:
min_dis = dist_t[i]
min_target = i
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# print " min target " + str(min_target) + " min dis " + str(min_dis)
# Check if distance is less than 7 px (14 cm)
if min_dis < 5:
self.next_subtarget = min_target + 1
self.counter_to_next_sub = self.count_limit
# print "REACHED"
# print " next target " + str(self.next_subtarget) + " len " +str(len(self.subtargets))
# Check if the final subtarget has been approached
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
########################################################################
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [\
self.subtargets[self.next_subtarget][0]\
* self.robot_perception.resolution + \
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1]\
* self.robot_perception.resolution + \
self.robot_perception.origin['y']\
]
RvizHandler.printMarker(\
[subtarget],\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while self.robot_perception.have_map == False:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(\
[[0, 0]],\
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0,0,0,0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates(\
[self.robot_perception.robot_pose['x_px'],\
self.robot_perception.robot_pose['y_px']])
# Call the target selection function to select the next best goal
# Choose target function
print "TimeOut Flag " +str(self.TimeOut)
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(\
local_ogm,\
local_coverage,\
self.robot_perception.robot_pose,
self.robot_perception.origin,
self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(\
g_robot_pose,\
target,
self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) +\
" points"
if len(self.path) == 0:
Print.art_print(\
"Path planning failed. Fallback to random target selection", \
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
tolerance = 0.000001
weight_data = 0.5
weight_smooth = 0.1
new = deepcopy(self.path)
dims = 2
change = tolerance
# Path smoothing using gradient descent
if len(self.path) > 3:
print "PATH SMOOTHING"
while change >= tolerance:
change = 0.0
for i in range(1, len(new) - 1):
for j in range(dims):
x_i = self.path[i][j]
y_i, y_prev, y_next = new[i][j], new[i - 1][j], new[i + 1][j]
y_i_saved = y_i
y_i += weight_data * (x_i - y_i) + weight_smooth * (y_next + y_prev - (2 * y_i))
new[i][j] = y_i
change += abs(y_i - y_i_saved)
self.path = new
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int) (len(self.path)/step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
#p[0] * resolution => gives the path's point x-coordinate expressed in the map's coordinate system (meters)
# As the path's(p) first point-set is the pixels that are occupied by the robot, multyplying it by resolution (meter/pixel)
# gives the values of that point expressed in meters.
# Adding the robot's initial position we have a path starting from the robot's position expressed in the robot's frame.
ps.pose.position.x = p[0]*0.05 + self.robot_perception.origin['x']
ps.pose.position.y = p[1]*0.05 + self.robot_perception.origin['y']
# print " x val " + str(ps.pose.position.x)
# print " y val " + str(ps.pose.position.y )
# print " origin x " + str(self.robot_perception.origin['x'])
# print " origin y " + str(self.robot_perception.origin['y'])
# print " p0 " +str(p[0])
# print " p1 " +str(p[1])
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(\
subtargets_mark,\
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
# if there is another subtarget , acquire its position
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
# align robot with the target
theta_target = np.arctan2(st_y - ry, st_x - rx)
delta_theta = (theta_target - theta)
# find omega
if delta_theta > np.pi:
omega = (delta_theta - 2*np.pi)/np.pi
elif delta_theta < -np.pi:
omega = (delta_theta + 2*np.pi)/np.pi
else:
omega = delta_theta/np.pi
# maximum magnitude for both velocities is 0.3
linear = 0.3 * ((1 - np.abs(omega)) ** 5)
angular = 0.3 * np.sign(omega)
######################### NOTE: QUESTION ##############################
return [linear, angular]
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 200 # 20 sec
self.counter_to_next_sub = self.count_limit
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is " + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'), \
Path, queue_size = 10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),\
MarkerArray, queue_size = 10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),\
Marker, queue_size = 10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or\
self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~', Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in pixels
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
# Clear visited subtargets
self.subtargets = self.subtargets[self.next_subtarget:]
self.next_subtarget = 0
# Calculate distance between the robot pose and all remaining subtargets
dx = [rx - st[0] for st in self.subtargets]
dy = [ry - st[1] for st in self.subtargets]
dist = [math.hypot(v[0], v[1]) for v in zip(dx, dy)]
# Check if any target is in distance
min_dist, min_idx = min(zip(dist, range(len(dist))))
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# Check if distance is less than 7 px (14 cm)
if min_dist < 5:
self.next_subtarget = min_idx + 1
self.counter_to_next_sub = self.count_limit
# Check if the final subtarget has been approached
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
########################################################################
# Publish the current target
if self.next_subtarget >= len(self.subtargets):
return
subtarget = [\
self.subtargets[self.next_subtarget][0]\
* self.robot_perception.resolution + \
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1]\
* self.robot_perception.resolution + \
self.robot_perception.origin['y']\
]
RvizHandler.printMarker(\
[subtarget],\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while self.robot_perception.have_map == False:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(\
[[0, 0]],\
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0,0,0,0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates(\
[self.robot_perception.robot_pose['x_px'],\
self.robot_perception.robot_pose['y_px']])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(\
local_ogm,\
local_ros_ogm,\
local_coverage,\
self.robot_perception.robot_pose,
self.robot_perception.origin,
self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(\
g_robot_pose,\
target,
self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) +\
" points"
if len(self.path) == 0:
Print.art_print(\
"Path planning failed. Fallback to random target selection", \
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
# Smooth path
if len(self.path) > 3:
x = np.array(self.path)
y = np.copy(x)
a = 0.5
b = 0.2
e = np.sum(
np.abs(a * (x[1:-1, :] - y[1:-1, :]) + b *
(y[2:, :] - 2 * y[1:-1, :] + y[:-2, :])))
while e > 1e-3:
y[1:-1, :] += a * (x[1:-1, :] - y[1:-1, :]) + b * (
y[2:, :] - 2 * y[1:-1, :] + y[:-2, :])
e = np.sum(
np.abs(a * (x[1:-1, :] - y[1:-1, :]) + b *
(y[2:, :] - 2 * y[1:-1, :] + y[:-2, :])))
self.path = y.tolist()
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int)(len(self.path) / step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth (answer is just above)
# and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
ps.pose.position.x = p[
0] * self.robot_perception.resolution + self.robot_perception.origin[
'x']
ps.pose.position.y = p[
1] * self.robot_perception.resolution + self.robot_perception.origin[
'y']
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(\
subtargets_mark,\
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
l_max = 0.3
a_max = 0.3
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
# Fix robot turning problem
theta_r = np.arctan2(st_y - ry, st_x - rx)
dtheta = (theta_r - theta)
if dtheta > np.pi:
omega = (dtheta - 2 * np.pi) / np.pi
elif dtheta < -np.pi:
omega = (dtheta + 2 * np.pi) / np.pi
else:
omega = (theta_r - theta) / np.pi
# Velocities in [-0.3, 0.3] range
linear = l_max * ((1 - np.abs(omega))**4)
angular = a_max * np.sign(omega) * (abs(omega)**(1 / 3))
# omega = (theta_r - theta)/np.pi
# angular = omega * 0.3 # max angular = 0.3 rad/s
# linear_r = 1 - np.abs(omega) #may need square
# linear = linear_r * 0.3 # max linear = 0.3 m/s
######################### NOTE: QUESTION ##############################
return [linear, angular]
class Navigation:
# Constructor
def __init__(self):
# Initializations
self.robot_perception = RobotPerception()
self.path_planning = PathPlanning()
# Check if the robot moves with target or just wanders
self.move_with_target = rospy.get_param("calculate_target")
# Flag to check if the vehicle has a target or not
self.target_exists = False
self.select_another_target = 0
self.inner_target_exists = False
# Container for the current path
self.path = []
# Container for the subgoals in the path
self.subtargets = []
# Container for the next subtarget. Holds the index of the next subtarget
self.next_subtarget = 0
self.count_limit = 200 # 20 sec
self.counter_to_next_sub = self.count_limit
self.laser_aggregation = LaserDataAggregator()
# Check if subgoal is reached via a timer callback
rospy.Timer(rospy.Duration(0.10), self.checkTarget)
# Read the target function
self.target_selector = rospy.get_param("target_selector")
print "The selected target function is" + self.target_selector
self.target_selection = TargetSelection(self.target_selector)
# ROS Publisher for the path
self.path_publisher = \
rospy.Publisher(rospy.get_param('path_pub_topic'), \
Path, queue_size = 10)
# ROS Publisher for the subtargets
self.subtargets_publisher = \
rospy.Publisher(rospy.get_param('subgoals_pub_topic'),\
MarkerArray, queue_size = 10)
# ROS Publisher for the current target
self.current_target_publisher = \
rospy.Publisher(rospy.get_param('curr_target_pub_topic'),\
Marker, queue_size = 10)
def checkTarget(self, event):
# Check if we have a target or if the robot just wanders
if self.inner_target_exists == False or self.move_with_target == False or\
self.next_subtarget == len(self.subtargets):
return
self.counter_to_next_sub -= 1
if self.counter_to_next_sub == 0:
Print.art_print('\n~~~~ Time reset ~~~~', Print.RED)
self.inner_target_exists = False
self.target_exists = False
return
# Get the robot pose in pixels
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
# Find the distance between the robot pose and the next subtarget
dist = math.hypot(\
rx - self.subtargets[self.next_subtarget][0], \
ry - self.subtargets[self.next_subtarget][1])
######################### NOTE: QUESTION ##############################
# What if a later subtarget or the end has been reached before the
# next subtarget? Alter the code accordingly.
# Check if distance is less than 7 px (14 cm)
count = 1
for i in range(
self.next_subtarget,
len(self.subtargets) - 2
): # compare the slope of the points till the end in order to check if there are more than one points at the same line
try: # use try except to avoid zerodivisior error
slope1 = (self.subtargets[i + 1][1] -
self.subtargets[i][1]) / (self.subtargets[i + 1][0] -
self.subtargets[i][0])
except ZeroDivisionError:
slope1 = float('Inf')
try:
slope2 = (self.subtargets[i + 2][1] - self.subtargets[i + 1][1]
) / (self.subtargets[i + 2][0] -
self.subtargets[i + 1][0])
except ZeroDivisionError:
slope2 = float('Inf')
if abs(slope1 - slope2) < 0.3 or (
slope1 == float('inf') and slope2 == float('inf')
): # if difference in slopes is less than 0.3 then we assume that the points are in the same line
count += 1
else:
break
scan = self.laser_aggregation.laser_scan # take scan measurements
count_scan = 0
for i in range(
250, 450
): # count scanlines with measure more than 2. The range has calculated after experiments.
if scan[i] > 2:
count_scan += 1
if dist < 5:
if count != 1:
self.next_subtarget += count # if there are more than one subtargets that belongs to the same line then the robot goes to the last target of the line
self.counter_to_next_sub = self.count_limit + count * 100 # increase time limit proportionally to the count in order to avoid time reset
elif count_scan > 10: # check if obstacle closer than 4 cm exists, if obstacle does not exist then
self.next_subtarget += 2 # increase subtarget by 2. This case happens when count = 1 in order to accelerate the process in case of not having subtargets in the same line
self.counter_to_next_sub = self.count_limit + 300 # increase time limit in order to avoid time reset
if self.next_subtarget >= len(
self.subtargets
): # check if the final subtarget has been approached
self.next_subtarget = len(self.subtargets)
else:
self.next_subtarget += 1 # else if obstacle exists then increase subtarget by 1
self.counter_to_next_sub = self.count_limit + 300 # increase time limit in order to avoid time reset
if self.next_subtarget >= len(
self.subtargets
): # check if the final subtarget has been approached
self.next_subtarget = len(self.subtargets)
if self.next_subtarget == len(self.subtargets):
self.target_exists = False
# Publish the current target
if self.next_subtarget == len(self.subtargets):
return
subtarget = [\
self.subtargets[self.next_subtarget][0]\
* self.robot_perception.resolution + \
self.robot_perception.origin['x'],
self.subtargets[self.next_subtarget][1]\
* self.robot_perception.resolution + \
self.robot_perception.origin['y']\
]
RvizHandler.printMarker(\
[subtarget],\
1, # Type: Arrow
0, # Action: Add
"map", # Frame
"art_next_subtarget", # Namespace
[0, 0, 0.8, 0.8], # Color RGBA
0.2 # Scale
)
# Function that selects the next target, produces the path and updates
# the coverage field. This is called from the speeds assignment code, since
# it contains timer callbacks
def selectTarget(self):
# IMPORTANT: The robot must be stopped if you call this function until
# it is over
# Check if we have a map
while self.robot_perception.have_map == False:
Print.art_print("Navigation: No map yet", Print.RED)
return
print "\nClearing all markers"
RvizHandler.printMarker(\
[[0, 0]],\
1, # Type: Arrow
3, # Action: delete all
"map", # Frame
"null", # Namespace
[0,0,0,0], # Color RGBA
0.1 # Scale
)
print '\n\n----------------------------------------------------------'
print "Navigation: Producing new target"
# We are good to continue the exploration
# Make this true in order not to call it again from the speeds assignment
self.target_exists = True
# Gets copies of the map and coverage
local_ogm = self.robot_perception.getMap()
local_ros_ogm = self.robot_perception.getRosMap()
local_coverage = self.robot_perception.getCoverage()
print "Got the map and Coverage"
self.path_planning.setMap(local_ros_ogm)
# Once the target has been found, find the path to it
# Get the global robot pose
g_robot_pose = self.robot_perception.getGlobalCoordinates(\
[self.robot_perception.robot_pose['x_px'],\
self.robot_perception.robot_pose['y_px']])
# Call the target selection function to select the next best goal
# Choose target function
self.path = []
force_random = False
while len(self.path) == 0:
start = time.time()
target = self.target_selection.selectTarget(\
local_ogm,\
local_coverage,\
self.robot_perception.robot_pose,
self.robot_perception.origin,
self.robot_perception.resolution,
force_random)
self.path = self.path_planning.createPath(\
g_robot_pose,\
target,
self.robot_perception.resolution)
print "Navigation: Path for target found with " + str(len(self.path)) +\
" points"
if len(self.path) == 0:
Print.art_print(\
"Path planning failed. Fallback to random target selection", \
Print.RED)
force_random = True
# Reverse the path to start from the robot
self.path = self.path[::-1]
# Break the path to subgoals every 2 pixels (1m = 20px)
step = 1
n_subgoals = (int)(len(self.path) / step)
self.subtargets = []
for i in range(0, n_subgoals):
self.subtargets.append(self.path[i * step])
self.subtargets.append(self.path[-1])
self.next_subtarget = 0
print "The path produced " + str(len(self.subtargets)) + " subgoals"
######################### NOTE: QUESTION ##############################
# The path is produced by an A* algorithm. This means that it is
# optimal in length but 1) not smooth and 2) length optimality
# may not be desired for coverage-based exploration
########################################################################
self.counter_to_next_sub = self.count_limit
# Publish the path for visualization purposes
ros_path = Path()
ros_path.header.frame_id = "map"
for p in self.path:
ps = PoseStamped()
ps.header.frame_id = "map"
ps.pose.position.x = 0
ps.pose.position.y = 0
######################### NOTE: QUESTION ##############################
# Fill the ps.pose.position values to show the path in RViz
# You must understand what self.robot_perception.resolution
# and self.robot_perception.origin are.
# p[0] and p[1] are the global coordinates so we multiply these values with resolution and add the origin
ps.pose.position.x = p[
0] * self.robot_perception.resolution + self.robot_perception.origin[
'x']
ps.pose.position.y = p[
1] * self.robot_perception.resolution + self.robot_perception.origin[
'y']
########################################################################
ros_path.poses.append(ps)
self.path_publisher.publish(ros_path)
# Publish the subtargets for visualization purposes
subtargets_mark = []
for s in self.subtargets:
subt = [
s[0] * self.robot_perception.resolution + \
self.robot_perception.origin['x'],
s[1] * self.robot_perception.resolution + \
self.robot_perception.origin['y']
]
subtargets_mark.append(subt)
RvizHandler.printMarker(\
subtargets_mark,\
2, # Type: Sphere
0, # Action: Add
"map", # Frame
"art_subtargets", # Namespace
[0, 0.8, 0.0, 0.8], # Color RGBA
0.2 # Scale
)
self.inner_target_exists = True
def velocitiesToNextSubtarget(self):
[linear, angular] = [0, 0]
[rx, ry] = [\
self.robot_perception.robot_pose['x_px'] - \
self.robot_perception.origin['x'] / self.robot_perception.resolution,\
self.robot_perception.robot_pose['y_px'] - \
self.robot_perception.origin['y'] / self.robot_perception.resolution\
]
theta = self.robot_perception.robot_pose['th']
######################### NOTE: QUESTION ##############################
# The velocities of the robot regarding the next subtarget should be
# computed. The known parameters are the robot pose [x,y,th] from
# robot_perception and the next_subtarget [x,y]. From these, you can
# compute the robot velocities for the vehicle to approach the target.
# Hint: Trigonometry is required
if self.subtargets and self.next_subtarget <= len(self.subtargets) - 1:
st_x = self.subtargets[self.next_subtarget][0]
st_y = self.subtargets[self.next_subtarget][1]
######################### NOTE: QUESTION ##############################
# theta contains yaw angle, hence we convert it to x,y coordinates in order to find the angle in degrees
x = math.cos(theta)
y = math.sin(theta)
deg = math.degrees(math.atan2(y, x))
delta_theta = math.degrees(math.atan2(st_y - ry, st_x - rx)) - deg
if delta_theta >= 0 and delta_theta < 180:
angular = delta_theta / 180
elif delta_theta > 0 and delta_theta >= 180:
angular = (delta_theta - 2 * 180) / 180
elif delta_theta <= 0 and delta_theta > -180:
angular = delta_theta / 180
elif delta_theta < 0 and delta_theta < -180:
angular = (delta_theta + 2 * 180) / 180
linear = (
(1 - abs(angular))**25
) # power calculated after experiments and we use it in order to avoid overshoot problem
linear = linear * 0.3 # use tanh to limit the range
if angular > 0.3: # angular = angular * 0.3. angular velocity should be multiplied by max angular velocity according to notes
angular = 0.3
elif angular < -0.3:
angular = -0.3
# but the result was much slower so we didn't multiply it by 0.3
######################### NOTE: QUESTION ##############################
return [linear, angular]
