问如何连接点和吸收动量？

EN

# Initial points 
points = [(1,1),(2,3),(5,3),(-4.1),(12,3)]
#List of point in the order find by the solution of the TSP
spl = tsp_solve(points) # generic function to solve the TSP

# Append the first two point of the list so that I can iterate over the list
# and parse every triplet of points in the same way.
spl = spl + spl[:2]

# The list where will be added every path that connect the points
paths = []

# For each tirplets of sequential points
for A,B,C in zip(spl[:-2],spl[1:-1],spl[2:]):
    # Calculate the angular coefficent of the two line that pass on A,B and B,C
    coeff_ab = (B[1] - A[1]) / (B[0] - A[0])
    coeff_bc = (C[1] - B[1]) / (C[0] - B[0])
    # If the two line have the same coeff then all the 3 point are on the same line
    # and therfore the best path is that line.
    if(coeff_ab == coeff_bc):
        offset_y = A[1] - coeff_ab * A[0]   
        delta_x = C[0] - B[0]            
        paths.append({"type":"Line","coeff":coeff_ab,"offset_y":offset_y,"deta_x":delta_x})
        continue
    # Calculate the x of the center of the circle
    center_x  = coeff_ab *coeff_bc *(C[0]-A[0])
    center_x += coeff_ab *(B[0]+C[0]) 
    center_x -= coeff_bc *(A[0]+B[0])
    center_x /= 2*(coeff_ab - coeff_bc)
    # Calculate the y of the center of the circle
    center_y  = (A[1]+B[1)/2
    center_y -= (center_x - (A[0] + B[0])/2)
    center_y /= coeff_bc

    radius = sqrt(center_x**2 + center_y**2)

    paths.append({"type":"Circle","Radius":radius,"center_x":center_x,"center_y":center_y})

# Function To Calculate the X and Y of the lines and circles.

def calculate_circle_x(circle,time):
    """Function that return the x of a circle at a given time"""
    time = time + circle["time_off"]
    return circle["radius"] * cos(2*pi*time) + circle["center_x"]
def calculate_circle_y(circle,time):
    """Function that return the y of a circle at a given time"""
    time = time + circle["time_off"]
    return circle["radius"] * sin(2*pi*time) + circle["center_y"]

def calculate_line_x(line,time):
    """Function that return the x of a line at a given time"""
    time = (line['delta_x']*time) + line["time_off"]
    return time
def calculate_line_y(line,time):
    """Function that return the y of a line at a given time"""
    time = (line['delta_x']*time) + line["time_off"]
    return time * line["coeff"] + line['offset_y']

def calculate_x(obj,time):
    """Function that return the x of whatever it's passed"""
    if(obj['type'] == 'Circle'):
        return calculate_circle_x(obj,time)
    else:
        return calculate_line_x(obj,time)

def calculate_y(obj,time):
    """Function that return the y of whatever it's passed"""
    if(obj['type'] == 'Circle'):
        return calculate_circle_y(obj,time)
    else:
        return calculate_line_y(obj,time)

# Calculate some sample of the global path to plot it or do whatever with it.
number_of_sample = 100000
path_points = []
number_of_paths = len(paths)

# Calculate some time equidistant point's sample
for i in range(number_of_sample):
    # Calculate the global time
    global_time = i*number_of_paths/number_of_sample
    # Calculate in which path the point it is
    path_number = int(global_time)
    # Calculate which time of the path it is
    local_time  = global_time - path_number
    path = paths[path_number]
    # Calculate the sampled point
    new_point = (calculate_x(path,local_time),calculate_y(path,local_time))
    # Add the sampled point to the path_points list
    path_points.append(new_point)

# Print the result of the path point sampled.
print(path_points)