请用python语言实现

以下是一个简单的基于Python语言实现的双向RRT路径规划算法：

import random
import math

class Node:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class RRT:
    def __init__(self, start, goal, obstacles):
        self.start = start
        self.goal = goal
        self.obstacles = obstacles
        self.nodes_start = []
        self.nodes_goal = []
        self.max_iter = 1000
        self.step_size = 10
        self.goal_sample_rate = 0.1
        self.connect_distance = 20

    def generate_random_node(self):
        if random.random() > self.goal_sample_rate:
            x = random.randint(0, 800)
            y = random.randint(0, 800)
            return Node(x, y)
        else:
            return self.goal

    def get_nearest_node(self, nodes, node):
        min_distance = float('inf')
        nearest_node = None
        for n in nodes:
            distance = math.sqrt((n.x - node.x) ** 2 + (n.y - node.y) ** 2)
            if distance < min_distance:
                min_distance = distance
                nearest_node = n
        return nearest_node

    def is_collision_free(self, n1, n2):
        for o in self.obstacles:
            if math.sqrt((n1.x - n2.x) ** 2 + (n1.y - n2.y) ** 2) <= o.radius:
                return False
        return True

    def connect(self, nodes, node):
        nearest_node = self.get_nearest_node(nodes, node)
        dx = node.x - nearest_node.x
        dy = node.y - nearest_node.y
        distance = math.sqrt(dx ** 2 + dy ** 2)
        if distance > self.step_size:
            new_x = nearest_node.x + (dx / distance) * self.step_size
            new_y = nearest_node.y + (dy / distance) * self.step_size
            new_node = Node(new_x, new_y)
        else:
            new_node = node
        if self.is_collision_free(nearest_node, new_node):
            nodes.append(new_node)
            return True
        else:
            return False

    def plan(self):
        self.nodes_start.append(self.start)
        self.nodes_goal.append(self.goal)
        for i in range(self.max_iter):
            q_rand = self.generate_random_node()
            if i % 2 == 0:
                if self.connect(self.nodes_start, q_rand):
                    for j in range(len(self.nodes_goal)):
                        if math.sqrt((self.nodes_start[-1].x - self.nodes_goal[j].x) ** 2 + (self.nodes_start[-1].y - self.nodes_goal[j].y) ** 2) < self.connect_distance:
                            return self.nodes_start + self.nodes_goal[j::-1]
            else:
                if self.connect(self.nodes_goal, q_rand):
                    for j in range(len(self.nodes_start)):
                        if math.sqrt((self.nodes_goal[-1].x - self.nodes_start[j].x) ** 2 + (self.nodes_goal[-1].y - self.nodes_start[j].y) ** 2) < self.connect_distance:
                            return self.nodes_start[j::-1] + self.nodes_goal

        return None

在这个实现中，我们定义了一个`Node`类来表示RRT树的节点，然后定义了一个`RRT`类来表示双向RRT路径规划算法。在`RRT`类中，我们定义了一些参数，如起点、终点、障碍物等，并且实现了一些方法，如节点的扩展、最近节点的查找、路径的检查等。

在`plan`方法中，我们对起点和终点分别构建RRT树，然后不断地扩展节点并连接路径，直到找到一条连接起点和终点的路径或达到最大迭代次数。如果找到了可行路径，就返回该路径上的所有节点；否则返回None。

虽然这个实现比较简单，但是可以作为基础代码来进一步扩展和优化。