def Start(self):
istyle = vtk.vtkInteractorStyleImage()
istyle.AddObserver("LeftButtonPressEvent", self.Left)
istyle.AddObserver("RightButtonPressEvent", self.Right)
iren = Globals.renWin.GetInteractor()
iren.SetInteractorStyle(istyle)
self.spline = Spline.PlaneSpline()
self.renSpline = Spline.RenderSpline(1)
self.splineExists = 0
def LoadState(sliceCallback, orientationCallback):
""" loads all the concerned variables
and restores the state of an application """
# open file for reading
handle = tkFileDialog.askopenfile(filetypes=[('SAVE files', '*.save')])
if not handle: return
### 1. read the rendered properties
Globals.renderProps = pickle.load(handle)
# 2. load the slice index and the orientation
pipelineSliceIndex = pickle.load(handle)
pipelineOrientation = pickle.load(handle)
# 3. load the region set
Globals.objectSet.dic.clear()
# load the number of regions
numberOfRegions = pickle.load(handle)
# load each region
for i in range(numberOfRegions):
regionIndex = pickle.load(handle)
sliceIndex = pickle.load(handle)
orientation = pickle.load(handle)
ptsZero = pickle.load(handle)
ptsOne = pickle.load(handle)
numberOfProfiles = pickle.load(handle)
profiles = []
for j in range(numberOfProfiles):
p = pickle.load(handle)
s = Spline.PlaneSpline(p)
profiles.append(s)
# commit each region
zero = Spline.PlaneSpline(ptsZero)
one = Spline.PlaneSpline(ptsOne)
region = Region.Region()
region.SetZeroPoints(zero)
region.SetOnePoints(one)
region.sliceIndex = sliceIndex
region.orientation = orientation
region.profiles = profiles
region.rendering.UpdateProfiles(region.profiles)
Globals.objectSet.AddRegion(region, regionIndex)
region.Hide()
handle.close()
orientationCallback(pipelineOrientation)
sliceCallback(pipelineSliceIndex)
Globals.renWin.Render()
def __init__(self, caller):
caller.imageObservers.append(self.UpdateObserver)
self.region = Region()
self.renSpline = Spline.RenderSpline()
self.InitCurves()
self.caller = caller
def test_with_goe144(self):
file = ["data/goe144.dat"]
for f in file:
(ex, ey, ix, iy) = load_foil(f)
extrados = spline.compute_smthing_dos(ex, ey, 100)
intrados = spline.compute_smthing_dos(ix, iy, 100)
plt.plot(extrados[0], extrados[1], color='green')
plt.plot(intrados[0], intrados[1], color='green')
plt.plot([0, 1], [0, 0], color='black')
plt.scatter(ex, ey, color='red')
plt.scatter(ix, iy, color='red')
plt.xlim((0, 1))
plt.ylim((-0.02, 0.09))
plt.title("Interpolated curve and original points of goe144")
plt.show()
def main():
points = get_data_3()
# calculate new x's and y's
x_curve = np.linspace(points.x[0], points.x[-1], 1000)
y_curve = [None] * 1000
y_curve_opt = [None] * 1000
knots = [points.x[0], 1, 2, 3, 4, points.x[len(points) - 1]]
coefficients = [None] * (len(points) + 2)
knots.append(knots[len(knots) - 2] + 1)
knots.sort()
s = splpckg.Spline(coefficients, knots, 3)
c = CurveFitter(s)
c.initiate_grid(s, points)
q = 1e-9
c.approximate(s, points, q)
index = 0
for point in x_curve:
y_curve[index] = s.get_value(point)
index += 1
index = 0
knots = s.get_knots()
knots_y_uni = [0] * len(knots)
for point in knots:
knots_y_uni[index] = s.get_value(point)
index += 1
c.approximate_with_optimal_grid(s, points, q, 1e-3, 1e-3)
index = 0
for point in x_curve:
y_curve_opt[index] = s.get_value(point)
index += 1
index = 0
knots2 = s.get_knots()
knots_y = [0] * len(knots2)
for point in knots2:
knots_y[index] = s.get_value(point)
index += 1
plt.plot(x_curve, y_curve, x_curve, y_curve_opt, points.x, points.y, 'o',
knots, knots_y_uni, 's', knots2, knots_y, 's')
plt.legend([
"Spline on uniform grid", "Spline on optimal grid", "Data",
"Evenly spreaded knots", "Optimally spreaded knots"
])
plt.xlim([points.x[0] - 1, points.x[-1] + 1])
plt.show()
def Create_pressure_map(file):
(ex, ey, ix, iy) = airload.load_foil(file)
hmin = np.min(iy)
hmax = np.max(ey)
func_intra = spline.get_func_splint(ix, iy)
func_extra = spline.get_func_splint(ex, ey)
#We define here pressures on the upper and lower part of the wing
pressure_extra = create_pressures(hmax, func_extra, 0.01, 500)
pressure_intra = create_pressures(hmin, func_intra, 0.03, 500)
orig_extra = spline.compute_smthing_dos(ex, ey, 200)
orig_intra = spline.compute_smthing_dos(ix, iy, 200)
plt.plot(orig_extra[0], orig_extra[1], color='red')
plt.plot(orig_intra[0], orig_intra[1], color='red')
for i in range(1, len(pressure_intra)):
plt.plot(pressure_intra[i][0], pressure_intra[i][1], color='blue')
for i in range(1, len(pressure_extra)):
plt.plot(pressure_extra[i][0], pressure_extra[i][1], color='blue')
plt.title("Pressure map")
plt.show()
length_extra = (compute_pressure_with_speed(pressure_extra))
length_intra = (compute_pressure_with_speed(pressure_intra))
#now we create a pixel map for the colors
result = create_colors(pressure_extra, pressure_intra, length_extra,
length_intra)
plt.imshow(result, cmap="hot")
plt.show()
def CatmullRomChain(occupancy_grid, P):
"""
Calculate Catmull–Rom for a chain of points and return the combined curve.
"""
sz = len(P)
# C contain splines
C = []
i = 0
while i < sz - 3:
spline = Spline.Spline(P[i], P[i + 1], P[i + 2], P[i + 3])
# Collect the point with the shortest distance to an obstacle
points = spline.discretise()
dist = None
for j in range(len(points)):
for d in np.array([[0, 1], [1, 0], [0, -1], [-1, 0]]):
direc = d * occupancy_grid._resolution
if occupancy_grid.is_occupied(points[j] + direc):
center = occupancy_grid.get_position(
*occupancy_grid.get_index(points[j] + direc))
dis = np.linalg.norm(points[j] - center)
if dist is None or dis < dist[0]:
dist = [dis, j]
# If point is too close to an obstacle, add point as support node and rebuild splines
if dist and dist[0] < occupancy_grid._resolution:
if i < 2:
print(
"There is no path which allow for the starting orientation and curvature constraints."
)
return []
else:
orig = normalize(P[i + 2] - P[i + 1])
new = points[dist[1]] - P[i + 1]
point = P[i + 1] + orig * np.dot(new, orig)
P.insert(i + 2, point)
sz += 1
continue
C.append(spline)
i += 1
return C
def graphicTable(x, y, func=False):
#Spline and Interpolating polinomial calculation
#initiates classes
data = spl.Spline(x, y)
data2 = inter.Interpolation(x, y)
spline = data.buildNormalSpline() #calculates the spline for the dataset
data2_x, data2_y = data2.interpolateData(
) #calculates the interpolating pol
xs = np.arange(x[0], x[-1] + 0.0001, 0.0001)
plt.plot(x, y, "o", label="Data")
if func:
#displays the actual function f
plt.plot(xs, f(xs), label='True Value')
plt.plot(xs, spline(xs), label="Spline Trace")
plt.plot(data2_x, data2_y, label="Interpolation")
plt.legend(loc='lower left', ncol=2)
plt.grid()
plt.show()
return data, spline, data2
def simulate(spline, points, dt=0.01):
print("Simulating...")
vState = SkidSteer.getInitialState()
posns = []
xBound = points[-1][0]
yBound = points[-1][1] * 1.1
i = 0
while (vState[0] < xBound and vState[1] < yBound and vState[0] >= 0
and vState[1] >= 0):
(x, y, _, _, _) = vState
lps = Spline.getLearningParameters(spline, points, (x, y))
(l, r) = Controller.getControl(lps, vState)
vState = SkidSteer.step(vState, l, r, dt)
posns.append((vState[0], vState[1]))
i += 1
if True or i % 1000 == 0:
print(vState)
print("Done Simulating")
return posns
def setUp(self):
uk = np.array([0, 1, 2, 3, 4, 5], dtype='float')
d = np.array([[-4, -2, 2, 4], [-4, -2, 2, 4]], dtype='float')
self.testSpline = Spline.Spline(uk, d) #d is not used in this function
def InitCurves(self):
self.renSpline.Hide()
self.spline = Spline.PlaneSpline()
self.renSpline = Spline.RenderSpline(1)
def Del(self):
pts = self.spline.points
del pts[-1]
self.spline = Spline.PlaneSpline(pts)
self.renSpline.SetInput(self.spline)
Globals.renWin.Render()
y_p.append(start_p_1[1])
y_p.append(finish_p_1[1])
y_p.append(finish_p_2[1])
feedrate = [25, 30]
"Степень точности обхода угла"
Lt = 2
n = 0.9
d = Lt/(2*n+1)
c = n*d
e = ((7*n+16))/32*d
print("с = " + str(c))
print("d = " + str(d))
print("e = " + str(e))
"Построение графиков со сплайном и теоретической траекторией"
Axes_spline = Spline.Spline_6(Lt, n, start_p_1, finish_p_1, start_p_2, finish_p_2)
cord_x = []
cord_y = []
#Расчет ошибки обработки напрямую.
cord_05 = []
cord_05.append(Axes_spline[6])
cord_05.append(Axes_spline[7])
cord_05.append(Axes_spline[8])
epsilon = Path_length_calculator.Path_linear(cord_05, finish_p_1)
LEN = len(Axes_spline[0])
print('LEN = ', LEN)
cord_x.append(Axes_spline[6])
cord_x.append(finish_p_1[0])
cord_y.append(Axes_spline[7])
cord_y.append(finish_p_1[1])
print("e = " + str(epsilon))
import math
import Graphs
start_point_1 = [20, 10, 0]
finish_point_1 = [42.361, 30, 0]
start_point_2 = [42.361, 30, 0]
finish_point_2 = [64.721, 10, 0]
Lt = 2
n = 0.3
d = Lt / (2 * n + 1)
c = n * d
cd = c + d
print('c =', c)
print('d =', d)
point_1 = Spline.Point_find(start_point_1, finish_point_1, Lt, 0)
point_6 = Spline.Point_find(start_point_2, finish_point_2, Lt, 1)
point_2 = Spline.Point_find(start_point_1, finish_point_1, cd, 0)
point_3 = Spline.Point_find(start_point_1, finish_point_1, d, 0)
point_4 = Spline.Point_find(start_point_2, finish_point_2, d, 1)
point_5 = Spline.Point_find(start_point_2, finish_point_2, cd, 1)
t = 0.5
x1 = math.pow((1 - t), 5) * point_1[0] + 5 * t * math.pow(
(1 - t), 4) * point_2[0] + 10 * math.pow(t, 2) * math.pow(
(1 - t), 3) * point_3[0] + 10 * math.pow(t, 3) * math.pow(
(1 - t), 2) * point_4[0] + 5 * math.pow(
t, 4) * (1 - t) * point_5[0] + math.pow(t, 5) * point_6[0]
y1 = math.pow((1 - t), 5) * point_1[1] + 5 * t * math.pow(
def generate_from_path(path: WaypointSequence, config: TrajectoryConfig,
generate_trajectory: bool):
if path.num_waypoints < 2:
return None
splines: List[Spline] = []
for i in range(path.num_waypoints - 1):
splines.append(Spline())
spline_lengths = []
for i in range(len(splines)):
spline_lengths.append(0.0)
total_distance = 0.0
for i in range(path.num_waypoints - 1):
splines[i] = Spline()
start = path.waypoints[i]
end = path.waypoints[i + 1]
print(splines[i].arc_length)
splines[i] = Spline.reticulate_spline(start.x, start.y, start.theta,
end.x, end.y, end.theta)
if splines[i] is None:
return None
spline_lengths[i] = splines[i].calculate_length()
total_distance += spline_lengths[i]
if generate_trajectory:
traj = generate(config, 0.0, path.waypoints[0].theta, total_distance,
0.0, path.waypoints[0].theta)
cur_spline = 0
cur_spline_start_pos = 0.0
length_of_splines_finished = 0.0
for i in range(len(traj.segments)):
cur_pos = traj.segments[i].pos
found_spline = False
while not found_spline:
cur_pos_relative = cur_pos - cur_spline_start_pos
if cur_pos_relative <= spline_lengths[cur_spline]:
percentage = splines[
cur_spline].get_percentage_for_distance(
cur_pos_relative)
traj.segments[i].heading = splines[cur_spline].angle_at(
percentage)
coords = splines[cur_spline].get_xy(percentage)
traj.segments[i].x = coords[0]
traj.segments[i].y = coords[1]
found_spline = True
elif cur_spline < len(splines) - 1:
length_of_splines_finished += spline_lengths[cur_spline]
cur_spline_start_pos = length_of_splines_finished
cur_spline += 1
else:
traj.segments[i].heading = splines[len(splines) -
1].angle_at(1.0)
coords = splines[len(splines) - 1].get_xy(1.0)
traj.segments[i].x = coords[0]
traj.segments[i].y = coords[1]
found_spline = True
return traj
else:
return splines
[100, 0, 0]]
"Степень точности обработки углов"
tolerance_angle = [10, 10]
ratio = [0.95, 0.4]
"Определение углов между участками траектории"
print("Анализ углов участков траектории.")
angles = Trajectory_mapping.Trajectory_analisys(st_point, fn_point)
for i in range (len(angles)):
print(Work_with_files.Write_log("Между участками " + str(i+1) + " и " + str (i+2) + " имеется угол в " + str(angles[i]) + " град."))
length_1 = CIRCLE.Length_linear(st_point[0], fn_point[0])
length_2 = CIRCLE.Length_linear(st_point[1], fn_point[1])
start = Spline.Point_find (st_point[0], fn_point[0], length_1, 0)
finish = Spline.Point_find (st_point[1], fn_point[1], length_2, 1)
spline_result = Spline.Spline6_interpolation(tolerance_angle[0], ratio[0], st_point[0], fn_point[0], st_point[1], fn_point[1], T, V)
spline_result_1 = Spline.Spline6_interpolation(tolerance_angle[1], ratio[1], st_point[0], fn_point[0], st_point[1], fn_point[1], T, V)
print('Острый угол')
print('Минимальная величина сегмента: ' + str(min(spline_result[9])))
print('Максимальная величина сегмента: ' + str(max(spline_result[9])))
print('Число сегментов: ' + str(len(spline_result[9])))
print('Минимальная ошибка: ' + str(min(spline_result[10])))
print('Максимальная ошибка: ' + str(max(spline_result[10])))
print('Тупой угол')
print('Минимальная величина сегмента: ' + str(min(spline_result_1[9])))
print('Максимальная величина сегмента: ' + str(max(spline_result_1[9])))
print('Число сегментов: ' + str(len(spline_result_1[9])))
print('Минимальная ошибка: ' + str(min(spline_result_1[10])))
def Trajectory_mapping(start_points, finish_points, tolerance_list, ratio_list,
optimal_ratio_list, optimal_agree):
x_points = []
y_points = []
spline = []
spline_x = []
spline_y = []
spline_x_out = []
spline_y_out = []
spline_z_out = []
for i in range(len(start_points)):
x_points.append(start_points[i][0])
x_points.append(finish_points[i][0])
y_points.append(start_points[i][1])
y_points.append(finish_points[i][1])
spline_x.append(start_points[0][0])
spline_y.append(start_points[0][1])
for i in range(len(start_points) - 1):
if optimal_agree[i] == 1:
spline = Spline.Spline_6(tolerance_list[i], optimal_ratio_list[i],
start_points[i], finish_points[i],
start_points[i + 1], finish_points[i + 1])
elif optimal_agree[i] == 0:
spline = Spline.Spline_6(tolerance_list[i], ratio_list[i],
start_points[i], finish_points[i],
start_points[i + 1], finish_points[i + 1])
spline_x_out.append(spline[0])
spline_y_out.append(spline[1])
spline_z_out.append(spline[2])
epsilon_x = []
epsilon_x.append(spline[6])
epsilon_x.append(start_points[i + 1][0])
epsilon_y = []
epsilon_y.append(spline[7])
epsilon_y.append(start_points[i + 1][1])
epsilon = Path_length_calculator.Path_linear(
[epsilon_x[0], epsilon_y[0]], [epsilon_x[1], epsilon_y[1]])
print("Ошибка обработки: " + str(epsilon))
"""Русский язык"""
#Graphs.Plotting_02(spline[0], spline[1], spline[3], spline[4],
#"Ось x, мм", "Ось y, мм", "Траектория инструмента в угле " + str(i+1), "Истинная траектория", "Запрограммированная траектория")
"""English language"""
Graphs.Plotting_02(spline[0], spline[1], spline[3], spline[4], "X, mm",
"Y, mm", "Tool trajectory at corner " + str(i + 1),
"Final trajectory", "Programmed trajectory",
"6Spline" + str(i + 1))
#Graphs.Plotting_03_help(spline[0], spline[1], spline[3], spline[4], epsilon_x, epsilon_y,
#"Ось x, мм", "Ось y, мм", "Траектория инструмента в угле " + str(i+1), "Истинная траектория", "Запрограммированная траектория")
for j in range(len(spline[0])):
spline_x.append(spline[0][j])
spline_y.append(spline[1][j])
spline_x.append(finish_points[len(start_points) - 1][0])
spline_y.append(finish_points[len(finish_points) - 1][1])
"""Русский язык"""
#Graphs.Plotting_02_colors(spline_x, spline_y, x_points, y_points,
# "Ось x, мм", "Ось y, мм", "Траектория инструмента", "Истинная траектория", "Запрограммированная траектория")
"""English language"""
Graphs.Plotting_02_colors(spline_x, spline_y, x_points, y_points, "X, mm",
"Y, mm", "Tool trajectory", "Final trajectory",
"Programmed trajectory", "6TrajectoryH")
return spline_x_out, spline_y_out, spline_z_out, spline[6], spline[
7], spline[8]
import matplotlib.pyplot as mpl
import Spline
import SkidSteer
import Simulate
points = [(0, 0), (0.3, 4), (0.5, 5), (1, 10)]
splines = Spline.makeSpline(points)
print(splines)
rectified = Spline.rectify(splines, points, 0.01)
posns = Simulate.simulate(splines, points)
(xs, ys) = zip(*posns)
(yPath, _, _, _) = zip(*rectified)
xPath = list(
map(lambda x: x * (points[-1][0] / len(yPath)), range(0, len(yPath))))
print(list(zip(xs, ys)))
mpl.plot(xPath, yPath)
mpl.plot(xs, ys)
mpl.legend(["Path To Follow", "Attempted Following"])
mpl.show()
#---------------------------------------
Xfig.find_coordinates(obj_list, box_margins)
if xy_specified != "None":
obj_list = Objects.load_xy_coordinates(xy_specified, \
obj_list, \
object_hierarchy)
#----------------------------
# Find calls between objects
#----------------------------
obj_list = Finder.get_new_calls(file_paths, obj_list, obj_memb)
#------------------------------------
# Create connections between objects
#------------------------------------ offset stride
spl_list = Spline.connect_objects(obj_list, box_margins, box_margins * 0.5)
#----------------
# Open Xfig file
#----------------
file = open(Const.FIG_FILE_NAME, "w")
#------------------
# Write header out
#------------------
Xfig.write_header(file)
#-------------------------------------------
# Plot all fortran files starting from root
#-------------------------------------------
Xfig.plot_all(file, obj_list, spl_list, box_margins)
print('Максимальная величина сегмента: ' + str(max(curve_r[4])))
'Построение траектории со скруглениями'
'Траектория'
points = [[2, 2, 0], [2, 5, 0], [6, 8, 0], [8, 4, 0], [5, 0, 0], [2, 2, 0]]
x_points = []
y_points = []
x_no_smooth = []
y_no_smooth = []
for i in range(len(points)):
x_no_smooth.append(points[i][0])
y_no_smooth.append(points[i][1])
x_points.append(points[0][0])
y_points.append(points[0][1])
for i in range(len(points) - 2):
corner_smooth = Spline.Spline_6(Lt, n, points[i], points[i + 1],
points[i + 1], points[i + 2])
for j in range(len(corner_smooth[0])):
x_points.append(corner_smooth[0][j])
y_points.append(corner_smooth[1][j])
x_points.append(points[len(points) - 1][0])
y_points.append(points[len(points) - 1][1])
#Graphs.Plotting_01(x_no_smooth, y_no_smooth, 'Ось X', 'Ось Y', 'Исходная траектория', 'Траектория', 'input_trajectory')
#Graphs.Plotting_01(x_points, y_points, 'Ось X', 'Ось Y', 'Скругление', 'Реальная траектория', 'output_trajectory')
#Graphs.Plotting_02(x_points, y_points, x_no_smooth, y_no_smooth,
# 'Ось X', 'Ось Y', 'Построение треаектории со скруглениями', 'Реальная траектория', 'Заданная траектория', 'final_trajectories')
#Graphs.Plotting_01(x_coord, y_coord, 'Ось X', 'Ось Y', 'Угол', 'da', 'circle')
#Graphs.Plotting_01(corner_smooth[0], corner_smooth[1], 'Ось X', 'Ось Y', 'Скругление', 'Реальная траектория', 'circle')
#Graphs.Plotting_02(corner_smooth[0], corner_smooth[1], corner_smooth[3], corner_smooth[4],
def testOverlappingKnotPoints(self):
self.testSpline = Spline.Spline(
np.array([0, 1, 2, 2, 2, 2, 6, 7], dtype='float64'),
np.array([[-6, -4, -2, 2, 4, 6], [-6, -4, -2, 2, 4, 6]],
dtype='float64'))
assert self.testSpline._findHotInterval(3.) == 5
def setUp(self):
self.testSpline = Spline.Spline(
np.array([0, 1, 2, 3, 4, 5, 6, 7], dtype='float64'),
np.array([[-6, -4, -2, 2, 4, 6], [-6, -4, -2, 2, 4, 6]],
dtype='float64'))
"Определение углов между участками траектории"
print(Work_with_files.Write_log("Анализ углов участков траектории."))
angles = Trajectory_mapping.Trajectory_analisys(st_point, fn_point)
for i in range (len(angles)):
print(Work_with_files.Write_log(
"Между участками " + str(i+1) + " и " + str (i+2) + " имеется угол в " + str(angles[i]) + " град."))
optimal_ratio.append(round(1/(2.0769)*math.pow(math.radians(angles[i]), 0.9927), 2))
print(Work_with_files.Write_log("Оптимальное отношение сторон c и d равно " + str(optimal_ratio[i]) + "."))
"Построение траектории запрограммированной и истинной с учетом скругления углов"
spline_coord = Trajectory_mapping.Trajectory_mapping(st_point, fn_point, tolerance_angle, ratio, optimal_ratio, optimal_agree_list)
print("_________________")
print(Work_with_files.Write_log("Анализ допустимой скорости в углах."))
length_angles_list = []
for i in range (len(spline_coord[0])):
length_angles = Spline.Spline_length(spline_coord[0][i], spline_coord[1][i], spline_coord[2][i])
length_angles_list.append(length_angles)
print(Work_with_files.Write_log(
"Длина пути на углу между " + str(i+1) + " и " + str(i+2) + " блоками равна " + str(round(length_angles, 4)) + " мм."))
"Подсчет допустимой скорости в углах."
feedrate_angles_list = []
for i in range (len(length_angles_list)):
feedrate_angles = Spline.Corner_feedrate(feedrate_input[i], feedrate_input[i+1], path_l_list[i], path_l_list[i+1],
st_point[i], fn_point[i], st_point[i+1], fn_point[i+1], [max_acceleration, max_acceleration, max_acceleration])
feedrate_angles_list.append(feedrate_angles)
print(Work_with_files.Write_log(
"Максимальная допустимая скорость на углу между " + str(i+1) + " и " + str(i+2) + " блоками равна " + str(feedrate_angles) + " мм/с."))
print("_________________")
print(Work_with_files.Write_log("Анализ длины участков траектории с учетом сгругления углов."))
for i in range (len(path_l_list)):
if i == 0:
def setUp(self):
self.testSpline = Spline.Spline(
np.linspace(0, 2),
np.vstack((np.linspace(0, 1, 48), np.linspace(0, 1, 48))))
import Spline import Profile_generation import Path_length_calculator import Block_type import Graphs """Тело программы для расчета индивидуального сплайна и профиля скорости в угле""" "Точки траектории" start_p_1 = [20, 10, 0] finish_p_1 = [42.361, 30, 0] start_p_2 = [42.361, 30, 0] finish_p_2 = [64.721, 10, 0] "Степень точности обхода угла" tolerance = 2 "Построение сплайна" Axes_spline_list = Spline.Spline_3(start_p_1, finish_p_1, start_p_2, finish_p_2, tolerance) "Построение графиков со сплайном и теоретической траекторией" x_hole = [] x_hole.append(start_p_1[0]) x_hole.append(finish_p_1[0]) x_hole.append(finish_p_2[0]) y_hole = [] y_hole.append(start_p_1[1]) y_hole.append(finish_p_1[1]) y_hole.append(finish_p_2[1]) z_hole = [] z_hole.append(start_p_1[2]) z_hole.append(finish_p_1[2]) z_hole.append(finish_p_2[2]) """Русский язык"""
# Example code that gets s(u) given knots and boor points and plots the result.
# Note that each knot has a corresponding boor point. It is important that these
# are np.arrays, ordered in rising order, i.e [u1, u2, u3...] and [d1,d2,d3...].
# we define knots and boor points:
u = 0
u_knots = np.array([0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.])
boor_points = np.array([[0, 0], [1, 1], [2, 4], [3, 2], [4, 7], [5, 7], [6, 6],
[7, 5], [8, 7], [8, 2], [7, 2]])
print(type(u), type(u_knots), type(boor_points))
# Either use the spline directly and loop like this
S = np.zeros((101, 2))
for i in range(0, 101):
u = (i * 0.01)
S[i, :] = spl.spline(u, u_knots, boor_points)
print(type(S))
plt.plot(boor_points[:, 0], boor_points[:, 1], 'r--')
plt.plot(boor_points[:, 0], boor_points[:, 1], 'ro')
plt.plot(S[:, 0], S[:, 1])
plt.title(
"Looped spline: Cubic spline with its polynomial segments and it's controll polygon"
)
plt.show()
# Or you can use spline_set and send in an entire grid as a numpy array like this:
u = np.arange(0, 1.01, 0.01)
S = spl.spline_set(u, u_knots, boor_points)
print(type(S))