Os parâmetros principais são o comprimento total da curva L e a taxa de variação da curvatura k. Eles determinam o quanto o caminho se curva. Primeiro, criamos uma clase geradora de clotoides:

import numpy as np

class ClothoidPathPlanner:
    def __init__(self, length=10.0, curvature_rate=0.1):
        self.total_length = length
        self.k_rate = curvature_rate
        self.waypoints = []
        self.step_size = 0.1

    def generate_path(self):
        heading = 0.0
        pos_x, pos_y = 0.0, 0.0

        for s in np.arange(0, self.total_length, self.step_size):
            curv = self.k_rate * s
            heading += curv * self.step_size
            pos_x += np.cos(heading) * self.step_size
            pos_y += np.sin(heading) * self.step_size
            self.waypoints.append((pos_x, pos_y))

        return np.array(self.waypoints)

O ponto crítico está no cálculo da curvatura e na integração do ângulo de direção. A curvatura cresce linearmente a partir de zero, fazendo com que o volante gire uniformemente — passageiros não ennjoam. O parâmetro L define o comprimento total do caminho; um k maior acelera a mudança de curvatura, útil para manobras mais fechadas.

Testamos diferentes configurações:

# Parâmetros suaves para ré
gentle_path = ClothoidPathPlanner(length=8, curvature_rate=0.05).generate_path()

# Parâmetros para vaga estreita
sharp_path = ClothoidPathPlanner(length=6, curvature_rate=0.15).generate_path()

Plotamos com matplotlib para comparação:

import matplotlib.pyplot as plt

plt.plot(gentle_path[:, 0], gentle_path[:, 1], label='Modo suave')
plt.plot(sharp_path[:, 0], sharp_path[:, 1], '--', label='Modo agressivo')
plt.axis('equal')
plt.legend()
plt.show()

Quando k é muito grande, a curvatura no final do caminho pode mudar abruptamente. Para evitar isso, adicionamos uma verificação de segurança:

def safe_curvature_check(k, L):
    max_curv = k * L
    # Raio mínimo de giro típico de 3.5 m
    return max_curv < 1.0 / 3.5

Na prática, é necessário aplicar transformações de coordenadsa para alinhar o caminho com a posição do veículo. Por exemplo, ao detectar uma vaga à direita, espelhamos o caminho:

mirrored_path = np.array([[-x, y] for x, y in path])

Por fim, lembre-se: a clotoide é ótima, mas o estacionamento real precisa considerar obstáculos. Podemos combinar o algoritmo RRT* para gerar caminhos candidatos e depois suavizá‑los com curvas clotoides — assim garantimos segurança e conforto. O código completo está disponível nos comentários.