|
|
| import yaml |
| import argparse |
| import numpy as np |
|
|
| def calculate_orientations(points): |
| """Calculate orientations for a list of points.""" |
| |
| |
| unique_points = [points[0]] if points else [] |
| for p in points[1:]: |
| |
| if not np.allclose(p, unique_points[-1]): |
| unique_points.append(p) |
| points = unique_points |
| |
| waypoints = [] |
| thetas = [] |
| for i in range(len(points) - 1): |
| p1 = points[i] |
| p2 = points[i+1] |
| thetas.append(np.arctan2(p2[1] - p1[1], p2[0] - p1[0])) |
| if len(points) > 1: |
| thetas.append(thetas[-1]) |
| elif len(points) == 1: |
| thetas.append(0) |
|
|
| for i in range(len(points)): |
| waypoints.append({'pose': {'position': {'x': float(points[i][0]), 'y': float(points[i][1])}, 'orientation': {'theta': float(thetas[i])}}}) |
| return waypoints |
|
|
| def generate_square_route(size=5, step=1): |
| """Generate a square route.""" |
| points = [] |
| |
| points.extend([(x, 0.0) for x in np.arange(0, size, step)]) |
| |
| points.extend([(size, y) for y in np.arange(0, size, step)]) |
| |
| points.extend([(x, size) for x in np.arange(size, 0, -step)]) |
| |
| points.extend([(0.0, y) for y in np.arange(size, 0, -step)]) |
| |
| |
| points.append(points[0]) |
|
|
| return calculate_orientations(points) |
|
|
| def generate_u_route(width=5, length=10, step=1, num_points=20): |
| """Generate a U-shaped route with a smooth curve, starting in the X direction.""" |
| points = [] |
| |
| for x in np.arange(0, length, step): |
| points.append((x, 0.0)) |
|
|
| |
| radius = width / 2.0 |
| center_x = length |
| center_y = radius |
| for i in range(num_points + 1): |
| angle = -np.pi/2 + np.pi * i / num_points |
| x = center_x + radius * np.cos(angle) |
| y = center_y + radius * np.sin(angle) |
| points.append((x, y)) |
|
|
| |
| for x in np.arange(length, 0, -step): |
| points.append((x, width)) |
|
|
| return calculate_orientations(points) |
|
|
| def generate_eighth_route(radius=5, num_points=50): |
| """Generate a figure-eight route.""" |
| points = [] |
| t = np.linspace(0, 2 * np.pi, num_points) |
| x = radius * np.sin(t) |
| y = radius * np.sin(t) * np.cos(t) |
| for i in range(len(x)): |
| points.append((x[i], y[i])) |
| return calculate_orientations(points) |
|
|
| def generate_sinusoidal_route(length=20, amplitude=5, num_points=50): |
| """Generate a sinusoidal route.""" |
| points = [] |
| x = np.linspace(0, length, num_points) |
| y = amplitude * np.sin(x) |
| for i in range(len(x)): |
| points.append((x[i], y[i])) |
| return calculate_orientations(points) |
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="Generate a route for robot navigation.") |
| parser.add_argument('shape', choices=['square', 'u', 'eighth', 'sinusoidal'], help="The shape of the route to generate.") |
| parser.add_argument('-o', '--output', default='params/new_route.yaml', help="The output file name.") |
| parser.add_argument('--size', type=float, default=5, help="Size parameter for the shape (e.g., side length for square).") |
| parser.add_argument('--step', type=float, default=1, help="Step size for generating points.") |
| parser.add_argument('--width', type=float, default=5, help="Width for U-shape.") |
| parser.add_argument('--length', type=float, default=10, help="Length for U-shape or sinusoidal.") |
| parser.add_argument('--amplitude', type=float, default=5, help="Amplitude for sinusoidal.") |
| parser.add_argument('--radius', type=float, default=5, help="Radius for figure-eight.") |
| parser.add_argument('--num_points', type=int, default=50, help="Number of points for curves.") |
|
|
| args = parser.parse_args() |
|
|
| waypoints = [] |
| if args.shape == 'square': |
| waypoints = generate_square_route(args.size, args.step) |
| elif args.shape == 'u': |
| waypoints = generate_u_route(args.width, args.length, args.step, args.num_points) |
| elif args.shape == 'eighth': |
| waypoints = generate_eighth_route(args.radius, args.num_points) |
| elif args.shape == 'sinusoidal': |
| waypoints = generate_sinusoidal_route(args.length, args.amplitude, args.num_points) |
|
|
| with open(args.output, 'w') as f: |
| yaml.dump({'waypoints': waypoints}, f, default_flow_style=False) |
|
|
| print(f"Generated {args.shape} route with {len(waypoints)} waypoints in {args.output}") |
|
|
| if __name__ == '__main__': |
| main() |
|
|
