python-motion-planning 2.0.dev2__py3-none-any.whl → 2.0.1__py3-none-any.whl

{python_motion_planning-2.0.dev2.dist-info → python_motion_planning-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-motion-planning
-Version: 2.0.dev2
+Version: 2.0.1
 Summary: Motion planning algorithms for Python
 Maintainer-email: Wu Maojia <omige@mail.nwpu.edu.cn>, Yang Haodong <913982779@qq.com>
 License: GNU GENERAL PUBLIC LICENSE
@@ -685,6 +685,7 @@ Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
+Requires-Dist: numba
 Requires-Dist: scipy
 Requires-Dist: matplotlib
 Requires-Dist: osqp
@@ -697,6 +698,8 @@ Dynamic: license-file
 
 # Introduction
 
+`Python Motion Planning` repository provides the implementations of common `Motion planning` algorithms, including path planners on N-D grid, controllers for path-tracking, trajectory optimizers, a visualizer based on matplotlib and a toy physical simulator to test controllers.
+
 `Motion planning` plans the state sequence of the robot without conflict between the start and goal. 
 
 `Motion planning` mainly includes `Path planning` and `Trajectory planning`.
@@ -704,8 +707,6 @@ Dynamic: license-file
 * `Path Planning`: It's based on path constraints (such as obstacles), planning the optimal path sequence for the robot to travel without conflict between the start and goal.
 * `Trajectory planning`: It plans the motion state to approach the global path based on kinematics, dynamics constraints and path sequence.
 
-This repository provides the implementations of common `Motion planning` algorithms, including path planners on N-D grid and controllers for path-tracking, a visualizer based on matplotlib and a toy physical simulator to test controllers.
-
 The theory analysis can be found at [motion-planning](https://blog.csdn.net/frigidwinter/category_11410243.html).
 
 We also provide [ROS C++](https://github.com/ai-winter/ros_motion_planning) version and [Matlab](https://github.com/ai-winter/matlab_motion_planning) version.
@@ -732,7 +733,8 @@ python_motion_planning
 |   ├─graph_search
 |   ├─sample_search
 |   └─hybrid_search
-└─curve_generator
+└─traj_optimizer
+    └─curve_generator
 ```
 
 ## Install
@@ -746,7 +748,7 @@ conda activate pmp
 To install the repository, please run the following command in shell.
 
 ```shell
-pip install python-motion-planning==2.0.dev2
+pip install python-motion-planning
 ```
 
 ## Run
@@ -803,7 +805,7 @@ In the following demos, the blue robot 1 is the `CircularRobot`, and the orange
 | **PID**     |![pid_2d.gif](assets/pid_2d.gif)|Not implemented
 | **APF**     |![apf_2d.gif](assets/apf_2d.gif)|Not implemented
 | **DWA**     |![dwa_2d.gif](assets/dwa_2d.gif)|Not implemented
-| **RPP**     |Implemented in [V1.1.1](https://github.com/ai-winter/python_motion_planning/tree/v1.1.1), not migrated|Not implemented
+| **RPP**     |![rpp_2d.gif](assets/rpp_2d.gif)|Not implemented
 | **LQR**     |Implemented in [V1.1.1](https://github.com/ai-winter/python_motion_planning/tree/v1.1.1), not migrated|Not implemented
 | **MPC**     |Implemented in [V1.1.1](https://github.com/ai-winter/python_motion_planning/tree/v1.1.1), not migrated|Not implemented
 | **MPPI**    |Not implemented|Not implemented
@@ -812,19 +814,22 @@ In the following demos, the blue robot 1 is the `CircularRobot`, and the orange
 | **DQN**    |Not implemented|Not implemented
 | **DDPG**    |Implemented in [V1.0](https://github.com/ai-winter/python_motion_planning/tree/v1.0), not migrated|Not implemented
 
-## Curve Generator
+## Trajectory Optimizer
+### Curve Generator
+#### Point-based
 
-The visualization of the curve generators has not been implemented in current version. They can be visualized in [V1.1.1](https://github.com/ai-winter/python_motion_planning/tree/v1.1.1).
+|Generator|2D|3D|
+| ------- | -------------------------------------------------------- | -------------------------------------------------------- 
+| **Cubic Spline** |![cubic_spline_2d.svg](assets/cubic_spline_2d.svg)|Not implemented
+| **BSpline** |![bspline_2d.svg](assets/bspline_2d.svg)|Not implemented
 
+#### Pose-based
 |Generator|2D|3D|
 | ------- | -------------------------------------------------------- | -------------------------------------------------------- 
-| **Polynomia** | ![polynomial_curve_python.gif](assets/polynomial_curve_python.gif)|Not implemented
-| **Bezier** |![bezier_curve_python.png](assets/bezier_curve_python.png)|Not implemented
-| **Cubic Spline** |![cubic_spline_python.png](assets/cubic_spline_python.png)|Not implemented
-| **BSpline** |![bspline_curve_python.png](assets/bspline_curve_python.png)|Not implemented
-| **Dubins** |![dubins_curve_python.png](assets/dubins_curve_python.png)|Not implemented
-| **Reeds-Shepp** |![reeds_shepp_python.png](assets/reeds_shepp_python.gif)|Not implemented
-| **Fem-Pos Smoother** |![fem_pos_smoother_python.png](assets/fem_pos_smoother_python.png)|Not implemented
+| **Polynomia** | ![polynomial_2d.svg](assets/polynomial_2d.svg)|Not implemented
+| **Bezier** |![bezier_2d.svg](assets/bezier_2d.svg)|Not implemented
+| **Dubins** |![dubins_2d.svg](assets/dubins_2d.svg)|Not implemented
+| **Reeds-Shepp** |![reeds_shepp_2d.svg](assets/reeds_shepp_2d.svg)|Not implemented
 
 # Future Works
 
@@ -834,6 +839,8 @@ The visualization of the curve generators has not been implemented in current ve
 
 * Path planning on topological map.
 
+* Sample search with Dubins or Reeds-Shepp curves.
+
 * Application on ROS2.
 
 * Application in mainstream robot simulation environments (e.g. Gazebo, Carla, Airsim, PyBullet, MuJoCo, Issac Sim).

{python_motion_planning-2.0.dev2.dist-info → python_motion_planning-2.0.1.dist-info}/RECORD

@@ -1,11 +1,11 @@
-python_motion_planning/__init__.py,sha256=xE1YRraUctbm14jTr4vEkHepRQMsm_gatKRTjDwTGi8,109
+python_motion_planning/__init__.py,sha256=qsRVlO3n-WSdeyH6NvduCQJ_G0Yqrml7F_juvs2UnJ4,108
 python_motion_planning/common/__init__.py,sha256=9CeruPgGOBOtro9EafPEhK5VKTav2OWeNbMLJCBwuNg,67
 python_motion_planning/common/env/__init__.py,sha256=Q8qIUcn5fvtLrmrc3SXStQoEwwrNMF-IofKotFermBk,129
 python_motion_planning/common/env/node.py,sha256=6I10JpU4tjK4aZEMWN7Dttz41QKskNFoe7gBR4aSyII,2727
 python_motion_planning/common/env/types.py,sha256=h5HtPrffu5qH_F1G4V1g8eXBPTPuDW-nFFfEFECVGYo,380
 python_motion_planning/common/env/map/__init__.py,sha256=5bVsJd2mrghKMj7erXfgc8V4NahXHe6zXngG9fMCjo0,44
 python_motion_planning/common/env/map/base_map.py,sha256=tX-9iO3RwbdvhGUHDtPNQUj8h-HNONjopXCLyUdtfQE,3321
-python_motion_planning/common/env/map/grid.py,sha256=pDQJyH5pGhRzhpk-a0j6N-EiveD35uqxHBIkjA3tdPU,20060
+python_motion_planning/common/env/map/grid.py,sha256=-QDhKpKrjE4Hi-NZPWIgPiiZagJCZH_dw8QgpHgLor4,28441
 python_motion_planning/common/env/robot/__init__.py,sha256=njq1_k2uWikGH2AjtxoFDdmxqsM1YY5B9nVtIheyx6Y,122
 python_motion_planning/common/env/robot/base_robot.py,sha256=KEajU9iFCnrzDOFp3Vm3SMWJWQgGJAYLT4VB6IMX2Is,7913
 python_motion_planning/common/env/robot/circular_robot.py,sha256=6SS3XP91WfQlccxbtyVLjmPQjgesP9cFaxXg6txkxVI,1512
@@ -16,7 +16,7 @@ python_motion_planning/common/env/world/toy_simulator.py,sha256=J2JrZhQD-lCd4TB2
 python_motion_planning/common/utils/__init__.py,sha256=wYzKTiyKgYfl5cTO0pUHF1zkr8Q9VhhEwKcRy1xSSdM,114
 python_motion_planning/common/utils/child_tree.py,sha256=f6ypaZ-d7mJpWOaVH99KriJuzjDc6q353USsO7D5F9g,625
 python_motion_planning/common/utils/frame_transformer.py,sha256=D9xaOUcxCPLvTl9oJHRSuhue84i88nMiuI-3ns0i7Ao,7609
-python_motion_planning/common/utils/geometry.py,sha256=C-y_K2ZVixytqdsCYezH2FD-pyaZzoIVBQPmwIbWZJU,3149
+python_motion_planning/common/utils/geometry.py,sha256=FFYM_eVAgJ3wA7H8MRXNvwXliGd6dKo4WU8fzbwdCXE,2693
 python_motion_planning/common/visualizer/__init__.py,sha256=HWWbLehtqEl0q_hEO28tEMDH-v8lXqduN-EJ7mo9LEI,90
 python_motion_planning/common/visualizer/base_visualizer.py,sha256=sjkH8lbyW8q9BVIEaQBTF10M27d73cpQqdTAPbEBFD0,5518
 python_motion_planning/common/visualizer/visualizer_2d.py,sha256=mqaKFZEtNHOCm82I1nCbCOhDP444JSySq1BzQCnPyEM,15656
@@ -31,15 +31,6 @@ python_motion_planning/controller/path_tracker/path_tracker.py,sha256=5p_MhqRWpM
 python_motion_planning/controller/path_tracker/pid.py,sha256=pqZggmTWaNd7XrlqfaK4wtBk9syg8PnIC7vOEnfN9S8,2403
 python_motion_planning/controller/path_tracker/pure_pursuit.py,sha256=gsfiMXZx3RwHIwmI2CSu4fTZNFKbZP31cXMgKUdDjs8,2405
 python_motion_planning/controller/path_tracker/rpp.py,sha256=e7qRIaUfeiVfVoiY5k797Yk9RK-Q7gnegmaOB7_BVP4,4181
-python_motion_planning/curve_generator/__init__.py,sha256=6eeN0NBlAndBhjk-ol3Yaa-0om2lNG7n43BASRfeV9k,370
-python_motion_planning/curve_generator/bezier_curve.py,sha256=E0J4bBxVaYZCRViKG4kEcZn9Scua0AJlrh-_RiycpSw,3705
-python_motion_planning/curve_generator/bspline_curve.py,sha256=bUDIOcCYgKgfznMwEL_TQQ82sTUlB_sOFZhi3hAw0FQ,9418
-python_motion_planning/curve_generator/cubic_spline.py,sha256=S5p3uNWDTgHR6JqLEMDEnr9A3A0KjyqH0aNBCQVmVFw,3452
-python_motion_planning/curve_generator/curve.py,sha256=xf7G5lDGTCVUBoSK8Oa14fmdf_AANOZVqdSmAKlwu-A,1543
-python_motion_planning/curve_generator/dubins_curve.py,sha256=EPKF7gRZT-Omc88RWmrDfQzGBzFZzxqzmdlemMBfnLM,11041
-python_motion_planning/curve_generator/fem_pos_smooth.py,sha256=8K2OI6YBP40T9zXp6uXdQ8dggLqHdsR9VXoqP_-hawk,3512
-python_motion_planning/curve_generator/polynomial_curve.py,sha256=h247Zk23ae-n3lQqZuWBp-rNs7eDBNJSD_hGtQmr69s,7602
-python_motion_planning/curve_generator/reeds_shepp.py,sha256=_-0_fo85vwmQVfBvsZ3-MzK96gAzzKn-kSwwskW8JIk,21511
 python_motion_planning/path_planner/__init__.py,sha256=Y0Im0cJ3iuUOYJyAOYvA_IavaNTNowb7SE6atrdJqX0,121
 python_motion_planning/path_planner/base_path_planner.py,sha256=YZcLqAIkLJtp5MWoT5zPmzxv05xUlnDpfuzN-CgPQuc,3640
 python_motion_planning/path_planner/graph_search/__init__.py,sha256=ugZpHV12dY-yb8d1jx4NepdRzQKn2qNKS6yWEBlvWy0,146
@@ -52,11 +43,22 @@ python_motion_planning/path_planner/graph_search/theta_star.py,sha256=JxxWukRTI4
 python_motion_planning/path_planner/hybrid_search/__init__.py,sha256=RCvNhSq6nskZPCc7jo9Y5MOzrD4f7TL9RfVUCHgpeq4,30
 python_motion_planning/path_planner/hybrid_search/voronoi_planner.py,sha256=sDTE-IFMf2035mUIRulEIOF0NiZSrwhW_bWrCiPetu4,7897
 python_motion_planning/path_planner/sample_search/__init__.py,sha256=RYz6o_xmdsoErMGdBKvXEK4w-48P_ogi1bJsdJmUupk,71
-python_motion_planning/path_planner/sample_search/rrt.py,sha256=adag-et3pyn-SuGyOimjroXfOyuJiT3Yhrr_HEIhJic,8649
-python_motion_planning/path_planner/sample_search/rrt_connect.py,sha256=KZewgIWiecQMy5EmSkdXb2KBjv8HA9NwF-6K8-Snck4,9666
-python_motion_planning/path_planner/sample_search/rrt_star.py,sha256=0cHLXbz3PuZbHXguAJny7si7id7EfXYAYZcSLg52zcE,10030
-python_motion_planning-2.0.dev2.dist-info/licenses/LICENSE,sha256=a4N8el8H0UrdAJzCeVgj9HklpT3VkZfsy4aL1SAifJE,35793
-python_motion_planning-2.0.dev2.dist-info/METADATA,sha256=P2njUua7bkdTT08yDVrWEIkf87sTUsIJQLpucancBE0,49711
-python_motion_planning-2.0.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-python_motion_planning-2.0.dev2.dist-info/top_level.txt,sha256=VtZTYZios8VncYIkec7tOVdYqj5oMRmoeBb9RcJHluY,23
-python_motion_planning-2.0.dev2.dist-info/RECORD,,
+python_motion_planning/path_planner/sample_search/rrt.py,sha256=hFBN1RaAnBn_ap7V2IPdkkKJIaMEIc7bHGALxoMkV-I,8682
+python_motion_planning/path_planner/sample_search/rrt_connect.py,sha256=2GYQS5InB-jWr74c_dDGnLLCkIIeLnIrJmgfBfNNtOw,9670
+python_motion_planning/path_planner/sample_search/rrt_star.py,sha256=f32G0h3_ds0cWvukNDRtDUoLZy0_KYpALcqCQcTxP1w,11223
+python_motion_planning/traj_optimizer/__init__.py,sha256=0HeRril2pkNw1uUdro2HuV5z3eouQaC-kh6_uHOTzZg,69
+python_motion_planning/traj_optimizer/base_curve_generator.py,sha256=m7-EZOIH5lOFiMVyvh5LYemjnWsiw0yRAvYUWG5mIFQ,1619
+python_motion_planning/traj_optimizer/curve_generator/__init__.py,sha256=q40AJi09Wgv84NEU7fkdcSdNIGwoKy42Bsnt7YHaOdY,55
+python_motion_planning/traj_optimizer/curve_generator/point_based/__init__.py,sha256=3V3ddQ0RfWs9oS57MUioGqzmMhPEXdVxbHkL9t_KlSM,53
+python_motion_planning/traj_optimizer/curve_generator/point_based/bspline.py,sha256=GRcRHCC56Kdm74LFv96ANzHdaBxihTCfL-sk87rD3h8,9110
+python_motion_planning/traj_optimizer/curve_generator/point_based/cubic_spline.py,sha256=sArmL1kLKHc-NRLFtczwpO6ATmuI3SB_FHTgSk826wI,3962
+python_motion_planning/traj_optimizer/curve_generator/pose_based/__init__.py,sha256=muLe-_uENMf_btwqmVsRP0Ikbryut3Wl0_0BxNRhhbU,101
+python_motion_planning/traj_optimizer/curve_generator/pose_based/bezier.py,sha256=BuLp6MzbyhuElD4qnos_nQQi9HvRVxx2AI5xPuUf2_I,4405
+python_motion_planning/traj_optimizer/curve_generator/pose_based/dubins.py,sha256=76ujAOJHl3o4HkV1e5wuZEyz9wxzaGkDizDUx3M9C0w,13895
+python_motion_planning/traj_optimizer/curve_generator/pose_based/polynomial.py,sha256=kjDkVskkfFHERZdJx6GU_GrRTJmrGHuX383W2s1oECI,7381
+python_motion_planning/traj_optimizer/curve_generator/pose_based/reeds_shepp.py,sha256=I6KjYZvG4lOE2N9_vp1hSzJuan4SOrpuQF2L57owII4,22970
+python_motion_planning-2.0.1.dist-info/licenses/LICENSE,sha256=a4N8el8H0UrdAJzCeVgj9HklpT3VkZfsy4aL1SAifJE,35793
+python_motion_planning-2.0.1.dist-info/METADATA,sha256=61r3x6QoQCBJIHm1yt10khJLLdTw5P7zEXHZGkZwr7Y,49587
+python_motion_planning-2.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_motion_planning-2.0.1.dist-info/top_level.txt,sha256=VtZTYZios8VncYIkec7tOVdYqj5oMRmoeBb9RcJHluY,23
+python_motion_planning-2.0.1.dist-info/RECORD,,

{python_motion_planning-2.0.dev2.dist-info → python_motion_planning-2.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (82.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

python_motion_planning/curve_generator/__init__.py

@@ -1,9 +0,0 @@
-from .polynomial_curve import Polynomial
-from .bezier_curve import Bezier
-from .bspline_curve import BSpline
-from .dubins_curve import Dubins
-from .reeds_shepp import ReedsShepp
-from .cubic_spline import CubicSpline
-from .fem_pos_smooth import FemPosSmoother
-
-__all__ = ["Polynomial", "Dubins", "ReedsShepp", "Bezier", "CubicSpline", "BSpline", "FemPosSmoother"]

python_motion_planning/curve_generator/bezier_curve.py

@@ -1,131 +0,0 @@
-"""
-@file: bezier_curve.py
-@breif: Bezier curve generation
-@author: Winter
-@update: 2023.7.25
-"""
-import numpy as np
-
-from scipy.special import comb
-# from python_motion_planning.utils import Plot
-from .curve import Curve
-
-class Bezier(Curve):
-	"""
-	Class for Bezier curve generation.
-
-	Parameters:
-		step (float): Simulation or interpolation size
-		offset (float): The offset of control points
-
-	Examples:
-		>>> from python_motion_planning.curve_generation import Bezier
-		>>>	points = [(0, 0, 0), (10, 10, -90), (20, 5, 60)]
-		>>> generator = Bezier(step, offset)
-		>>> generator.run(points)
-	"""
-	def __init__(self, step: float, offset: float) -> None:
-		super().__init__(step)
-		self.offset = offset
-
-	def __str__(self) -> str:
-		return "Bezier Curve"
-
-	def generation(self, start_pose: tuple, goal_pose: tuple):
-		"""
-		Generate the Bezier Curve.
-
-		Parameters:
-			start_pose (tuple): Initial pose (x, y, yaw)
-			goal_pose (tuple): Target pose (x, y, yaw)
-
-		Returns:
-			x_list (list): x of the trajectory
-			y_list (list): y of the trajectory
-			yaw_list (list): yaw of the trajectory
-		"""
-		sx, sy, _ = start_pose
-		gx, gy, _ = goal_pose
-		n_points = int(np.hypot(sx - gx, sy - gy) / self.step)
-		control_points = self.getControlPoints(start_pose, goal_pose)
-
-		return [self.bezier(t, control_points) for t in np.linspace(0, 1, n_points)], \
-			   control_points
-
-	def bezier(self, t: float, control_points: list) ->np.ndarray:
-		"""
-		Calculate the Bezier curve point.
-
-		Parameters:
-			t (float): scale factor
-			control_points (list[tuple]): control points
-
-		Returns:
-			point (np.array): point in Bezier curve with t
-		"""
-		n = len(control_points) - 1
-		control_points = np.array(control_points)
-		return np.sum([comb(n, i) * t ** i * (1 - t) ** (n - i) *
-			control_points[i] for i in range(n + 1)], axis=0)
-
-	def getControlPoints(self, start_pose: tuple, goal_pose: tuple):
-		"""
-		Calculate control points heuristically.
-
-		Parameters:
-			start_pose (tuple): Initial pose (x, y, yaw)
-			goal_pose (tuple): Target pose (x, y, yaw)
-
-		Returns:
-			control_points (list[tuple]): Control points
-		"""
-		sx, sy, syaw = start_pose
-		gx, gy, gyaw = goal_pose
-
-		dist = np.hypot(sx - gx, sy - gy) / self.offset
-		return [(sx, sy),
-				(sx + dist * np.cos(syaw), sy + dist * np.sin(syaw)),
-				(gx - dist * np.cos(gyaw), gy - dist * np.sin(gyaw)),
-				(gx, gy)]
-
-	# def run(self, points: list):
-	# 	"""
-    #     Running both generation and animation.
-
-	# 	Parameters:
-	# 		points (list[tuple]): path points
-    #     """
-	# 	assert len(points) >= 2, "Number of points should be at least 2."
-	# 	import matplotlib.pyplot as plt
-
-	# 	# generation
-	# 	path_x, path_y = [], []
-	# 	path_control_x, path_control_y = [], []
-	# 	for i in range(len(points) - 1):
-	# 		path, control_points = self.generation(
-	# 			(points[i][0], points[i][1], np.deg2rad(points[i][2])),
-	# 			(points[i + 1][0], points[i + 1][1], np.deg2rad(points[i + 1][2])))
-
-	# 		for pt in path:
-	# 			path_x.append(pt[0])
-	# 			path_y.append(pt[1])
-
-	# 		path_control_x.append(points[i][0])
-	# 		path_control_y.append(points[i][1])
-
-	# 		for pt in control_points:
-	# 			path_control_x.append(pt[0])
-	# 			path_control_y.append(pt[1])
-
-	# 	# animation
-	# 	plt.figure("curve generation")
-	# 	plt.plot(path_x, path_y, linewidth=2, c="#1f77b4")
-	# 	plt.plot(path_control_x, path_control_y, '--o', c='#dddddd', label="Control Points")
-	# 	for x, y, theta in points:
-	# 		Plot.plotArrow(x, y, np.deg2rad(theta), 2, 'blueviolet')
-
-	# 	plt.axis("equal")
-	# 	plt.legend()
-	# 	plt.title(str(self))
-	# 	plt.show()
-

python_motion_planning/curve_generator/bspline_curve.py

@@ -1,271 +0,0 @@
-"""
-@file: bspline_curve.py
-@breif: B-Spline curve generation
-@author: Winter
-@update: 2023.7.29
-"""
-import math
-import numpy as np
-
-from .curve import Curve
-
-class BSpline(Curve):
-    """
-    Class for B-Spline curve generation.
-
-    Parameters:
-        step (float): Simulation or interpolation size
-        k (int): Degree of curve
-
-    Examples:
-        >>> from python_motion_planning.curve_generation import BSpline
-        >>>	points = [(0, 0, 0), (10, 10, -90), (20, 5, 60)]
-        >>> generator = BSpline(step, k)
-        >>> generator.run(points)
-    """
-    def __init__(self, step: float, k: int, param_mode: str="centripetal", 
-                 spline_mode: str="interpolation") -> None:
-        super().__init__(step)
-        self.k = k
-
-        assert param_mode == "centripetal" or param_mode == "chord_length" \
-               or param_mode == "uniform_spaced", "Parameter selection mode error!"
-        self.param_mode = param_mode
-
-        assert spline_mode == "interpolation" or spline_mode == "approximation", \
-               "Spline mode selection error!"
-        self.spline_mode = spline_mode
-    
-    def __str__(self) -> str:
-        return "B-Spline Curve"
-    
-    def baseFunction(self, i: int, k: int, t: float, knot: list):
-        """
-        Calculate base function using Cox-deBoor function.
-
-        Parameters:
-            i (int): The index of base function
-            k (int): The degree of curve
-            t (float): parameter
-            knot (list[float]): knot vector
-
-        Returns:
-            Nik_t (float): The value of base function Nik(t)
-        """
-        Nik_t = 0
-        if k == 0:
-            Nik_t = 1.0 if t >= knot[i] and t < knot[i + 1] else 0.0
-        else:
-            length1 = knot[i + k] - knot[i]
-            length2 = knot[i + k + 1] - knot[i + 1]
-            if not length1 and not length2:
-                Nik_t = 0
-            elif not length1:
-                Nik_t = (knot[i + k + 1] - t) / length2 * self.baseFunction(i + 1, k - 1, t, knot)
-            elif not length2:
-                Nik_t = (t - knot[i]) / length1 * self.baseFunction(i, k - 1, t, knot)
-            else:
-                Nik_t = (t - knot[i]) / length1 * self.baseFunction(i, k - 1, t, knot) + \
-                        (knot[i + k + 1] - t) / length2 * self.baseFunction(i + 1, k - 1, t, knot)
-        return Nik_t
-
-    def paramSelection(self, points: list):
-        """
-        Calculate parameters using the `uniform spaced` or `chrod length`
-        or `centripetal` method.
-
-        Parameters:
-            points (list[tuple]): path points
-
-		Returns:
-		    Parameters (list[float]): The parameters of given points
-        """
-        n = len(points)
-        x_list = [pt[0] for pt in points]
-        y_list = [pt[1] for pt in points]
-        dx, dy = np.diff(x_list), np.diff(y_list)
-
-        if self.param_mode == "uniform_spaced":
-            return np.linspace(0, 1, n).tolist()
-
-        elif self.param_mode == "chord_length":
-            parameters = np.zeros(n)
-            s = np.cumsum([math.hypot(idx, idy) for (idx, idy) in zip(dx, dy)])
-            for i in range(1, n):
-                parameters[i] = s[i - 1] / s[-1]
-            return parameters.tolist()
-        
-        elif self.param_mode == "centripetal":
-            alpha = 0.5
-            s = np.cumsum([math.pow(math.hypot(idx, idy), alpha) for (idx, idy) in zip(dx, dy)])
-            parameters = np.zeros(n)
-            for i in range(1, n):
-                parameters[i] = s[i - 1] / s[-1]
-            return parameters.tolist()
-
-    def knotGeneration(self, param: list, n: int):
-        """
-        Generate knot vector.
-
-        Parameters:
-            param (list[float]): The parameters of given points
-            n (int): The number of data points
-		
-		Returns:
-		    knot (list[float]): The knot vector
-        """
-        m = n + self.k + 1
-        knot = np.zeros(m)
-        for i in range(self.k + 1):
-            knot[i] = 0
-        for i in range(n, m):
-            knot[i] = 1
-        for i in range(self.k + 1, n):
-            for j in range(i - self.k, i):
-                knot[i] = knot[i] + param[j]
-            knot[i] = knot[i] / self.k
-        return knot.tolist()
-    
-    def interpolation(self, points: list, param: list, knot: list):
-        """
-        Given a set of N data points, D0, D1, ..., Dn and a degree k,
-        find a B-spline curve of degree k defined by N control points
-        that passes all data points in the given order.
-
-        Parameters:
-            points (list[tuple]): path points
-            param (list[float]): The parameters of given points
-            knot (list[float]): The knot vector
-        
-        Returns:
-            control_points (np.ndarray): The control points
-        """
-        n = len(points)
-        N = np.zeros((n, n))
-
-        for i in range(n):
-            for j in range(n):
-                N[i][j] = self.baseFunction(j, self.k, param[i], knot)
-        N[n-1][n-1] = 1
-        N_inv = np.linalg.inv(N)
-
-        D = np.array(points)
-
-        return N_inv @ D
-
-    def approximation(self, points: list, param: list, knot: list):
-        """
-        Given a set of N data points, D0, D1, ..., Dn, a degree k,
-        and a number H, where N > H > k >= 1, find a B-spline curve
-        of degree k defined by H control points that satisfies the
-        following conditions:
-            1. this curve contains the first and last data points;
-            2. this curve approximates the data polygon in the sense
-            of least square
-        
-        Parameters:
-            points (list[tuple]): path points
-            param (list[float]): The parameters of given points
-            knot (list[float]): The knot vector
-        
-		Returns:
-		    control_points (np.ndarray): The control points
-        """
-        n = len(points)
-        D = np.array(points)
-
-        # heuristically setting the number of control points
-        h = n - 1
-
-        N = np.zeros((n, h))
-        for i in range(n):
-            for j in range(h):
-                N[i][j] = self.baseFunction(j, self.k, param[i], knot)
-        N_ = N[1 : n - 1, 1 : h - 1]
-
-        qk = np.zeros((n - 2, 2))
-        for i in range(1, n - 1):
-            qk[i - 1] = D[i, :] - N[i][0] * D[0, :] - N[i][h - 1] * D[-1, :]
-        Q = N_.T @ qk
-
-        P = np.linalg.inv(N_.T @ N_) @ Q
-        P = np.insert(P, 0, D[0, :], axis=0)
-        P = np.insert(P, len(P), D[-1, :], axis=0)
-
-        return P
-
-    def generation(self, t, k, knot, control_pts):
-        """
-        Generate the B-spline curve.
-
-        Parameters:
-            t (np.ndarray): The parameter values
-            k (int): The degree of the B-spline curve
-            knot (list[float]): The knot vector
-            control_pts (np.ndarray): The control points
-
-        Returns:
-            curve (np.ndarray): The B-spline curve
-        """
-        N = np.zeros((len(t), len(control_pts)))
-
-        for i in range(len(t)):
-            for j in range(len(control_pts)):
-                N[i][j] = self.baseFunction(j, k, t[i], knot)
-        N[len(t) - 1][len(control_pts) - 1] = 1
-
-        return N @ control_pts
-
-    # def run(self, points: list, display: bool = True):
-    #     """
-    #     Running both generation and animation.
-
-    #     Parameters:
-    #         points (list[tuple]): path points
-    #     """
-    #     assert len(points) >= 2, "Number of points should be at least 2."
-    #     import matplotlib.pyplot as plt
-
-    #     if len(points[0]) > 2:
-    #         points = [(points[i][0], points[i][1]) for i in range(len(points))]
-
-    #     t = np.linspace(0, 1, int(1 / self.step))
-    #     params = self.paramSelection(points)
-    #     knot = self.knotGeneration(params, len(points))
-
-    #     if self.spline_mode == "interpolation":
-    #         control_pts = self.interpolation(points, params, knot)
-    #     elif self.spline_mode == "approximation":
-    #         control_pts = self.approximation(points, params, knot)
-    #         h = len(control_pts)
-    #         new_points = [(control_pts[i][0], control_pts[i][1])
-    #             for i in range(h)]
-    #         params = self.paramSelection(new_points)
-    #         knot = self.knotGeneration(params, h)
-    #     else:
-    #         raise NotImplementedError
-        
-    #     control_x = control_pts[:, 0].tolist()
-    #     control_y = control_pts[:, 1].tolist()
-
-    #     path = self.generation(t, self.k, knot, control_pts)
-    #     path_x = path[:, 0].tolist()
-    #     path_y = path[:, 1].tolist()
-
-    #     if display:
-    #         # animation
-    #         plt.figure("curve generation")
-
-    #         # static
-    #         plt.figure("curve generation")
-    #         plt.plot(path_x, path_y, linewidth=2, c="#1f77b4")
-    #         plt.plot(control_x, control_y, '--o', c='#dddddd', label="Control Points")
-    #         for x, y in points:
-    #             plt.plot(x, y, "xr", linewidth=2)
-    #         plt.axis("equal")
-    #         plt.legend()
-    #         plt.title(str(self))
-
-    #         plt.show()
-        
-    #     return [(ix, iy) for (ix, iy) in zip(path_x, path_y)]