rational-linkages 2.0.0__cp311-cp311-macosx_12_0_arm64.whl → 2.2.3__cp311-cp311-macosx_12_0_arm64.whl

rational_linkages/PointHomogeneous.py

@@ -1,6 +1,6 @@
-import numpy as np
-
 from typing import Optional, Sequence
+
+import numpy as np
 from sympy import Rational
 
 from .TransfMatrix import TransfMatrix
@@ -332,7 +332,7 @@ class PointHomogeneous:
         :return: evaluated point with float elements
         :rtype: PointHomogeneous
         """
-        from sympy import Expr, Symbol, Number
+        from sympy import Expr, Number, Symbol
 
         t = Symbol("t")
 
@@ -386,6 +386,9 @@ class PointOrbit:
 
         self.t_interval = t_interval
 
+    def __repr__(self):
+        return f"PointOrbit(center={self.center}, radius_squared={self.radius_squared}, t_interval={self.t_interval})"
+
     @property
     def radius(self):
         if self._radius is None:

rational_linkages/RationalBezier.py

@@ -2,12 +2,11 @@ from copy import deepcopy
 
 import numpy as np
 import sympy as sp
-from sympy.integrals.quadrature import gauss_legendre
 
+from .DualQuaternion import DualQuaternion
 from .MiniBall import MiniBall
 from .PointHomogeneous import PointHomogeneous
 from .RationalCurve import RationalCurve
-from .DualQuaternion import DualQuaternion
 
 
 class RationalBezier(RationalCurve):
@@ -93,7 +92,7 @@ class RationalBezier(RationalCurve):
         """
         Get the numerical coefficients of the Bezier curve
         """
-        from scipy.special import comb  # INNER IMPORT
+        from scipy.special import comb  # lazy import
 
         control_pts = np.array([point.array() for point in control_points])
         degree = len(control_points) - 1
@@ -210,7 +209,7 @@ class BezierSegment:
 
     @metric.setter
     def metric(self, metric: "AffineMetric"):
-        from .AffineMetric import AffineMetric  # inner import
+        from .AffineMetric import AffineMetric  # lazy import
 
         if isinstance(metric, AffineMetric):
             self._metric = metric
@@ -336,6 +335,52 @@ class RationalSoo(RationalCurve):
 
         return [sp.Poly(gl_curve[i], t, greedy=False) for i in range(dim)]
 
+    @classmethod
+    def from_two_points(cls,
+                        p0: PointHomogeneous,
+                        p1: PointHomogeneous,
+                        degree: int = 2) -> "RationalSoo":
+        """
+        Create a RationalSoo curve from two points.
+
+        The other control points will be added based on the given degree.
+
+        :param PointHomogeneous p0: first point
+        :param PointHomogeneous p1: second point
+        :param int degree: degree of the curve (default is 2)
+
+        :return: the resulting Gauss-Legendre curve
+        :rtype: RationalSoo
+        """
+        control_points = RationalSoo.control_points_between_two_points(p0, p1, degree)
+        return cls(control_points)
+
+    @staticmethod
+    def control_points_between_two_points(p0: PointHomogeneous,
+                                          p1: PointHomogeneous,
+                                          degree: int = 2) -> list[PointHomogeneous]:
+        """
+        Generate control points for a Gauss-Legendre curve between two points.
+
+        :param PointHomogeneous p0: first point
+        :param PointHomogeneous p1: second point
+        :param int degree: degree of the curve (default is 2)
+
+        :return: list of control points
+        :rtype: list[PointHomogeneous]
+        """
+        if degree < 2:
+            raise ValueError("Degree must be at least 2 for a Gauss-Legendre curve.")
+
+        control_points = [p0]
+        for i in range(degree - 1):
+            # create intermediate control points
+            control_points.append(p0.linear_interpolation(p1, (i + 1) / degree))
+
+        control_points.append(p1)
+
+        return control_points
+
     @staticmethod
     def lagrange_basis(tau, symbol, weights):
         """
@@ -359,3 +404,18 @@ class RationalSoo(RationalCurve):
             basis.append(basis_j / weights[j])
 
         return basis
+
+    def get_plot_data(self,
+                      interval: tuple = (-1, 1),
+                      steps: int = 50) -> tuple:
+        """
+        Get the data to plot the curve in 3D.
+        """
+        # perform superclass coordinates
+        x, y, z = super().get_plot_data(interval=interval)
+
+        points = [point.normalized_in_3d() for point in self.control_points]
+
+        x_cp, y_cp, z_cp = zip(*points)
+
+        return x, y, z, x_cp, y_cp, z_cp

rational_linkages/RationalCurve.py

@@ -1,13 +1,11 @@
 from copy import deepcopy
 from typing import Union
 
-from scipy.integrate import quad
-
 import numpy as np
 import sympy as sp
 
-from .PointHomogeneous import PointHomogeneous
 from .DualQuaternion import DualQuaternion
+from .PointHomogeneous import PointHomogeneous
 from .Quaternion import Quaternion
 
 MotionFactorization = "MotionFactorization"
@@ -137,7 +135,7 @@ class RationalCurve:
 
     @metric.setter
     def metric(self, metric: "AffineMetric"):
-        from .AffineMetric import AffineMetric  # inner import
+        from .AffineMetric import AffineMetric  # lazy import
 
         if isinstance(metric, AffineMetric):
             self._metric = metric
@@ -574,7 +572,7 @@ class RationalCurve:
         if not self.is_motion:
             raise ValueError("Not a motion curve, cannot split into Bezier curves.")
 
-        from .RationalBezier import BezierSegment  # inner import
+        from .RationalBezier import BezierSegment  # lazy import
 
         curve = self.get_curve_in_pr12()
 
@@ -658,6 +656,11 @@ class RationalCurve:
         :raises ValueError: if the interval values are identical
         :raises ValueError: if the number of segments is less than 1
         """
+        try:
+            from scipy.integrate import quad  # lazy import
+        except ImportError:
+            raise RuntimeError("Scipy import failed. Check the package installation.")
+
         if interval[0] > interval[1]:
             raise ValueError("The interval must be in the form [a, b] where a < b")
         elif interval[0] == interval[1]:
@@ -709,6 +712,11 @@ class RationalCurve:
         :return: t value that splits the curve into given segment length
         :rtype: float
         """
+        try:
+            from scipy.integrate import quad  # lazy import
+        except ImportError:
+            raise RuntimeError("Scipy import failed. Check the package installation.")
+
         # initial lower and upper bounds
         low = section_start
         high = curve_interval[1]  # start with the upper bound

rational_linkages/RationalDualQuaternion.py

@@ -1,5 +1,6 @@
 import numpy as np
-import sympy as sp
+
+from sympy import Rational
 
 from .DualQuaternion import DualQuaternion
 
@@ -12,7 +13,7 @@ class RationalDualQuaternion(DualQuaternion):
     """
     RationalDualQuaternion class representing a 8-dimensional dual quaternion.
     """
-    def __init__(self, study_parameters: list[sp.Rational]):
+    def __init__(self, study_parameters: list[Rational]):
         """
         RationalDualQuaternion class
 
@@ -34,7 +35,7 @@ class RationalDualQuaternion(DualQuaternion):
         """
         return f"{self.rational_numbers}"
 
-    def __getitem__(self, idx) -> sp.Rational:
+    def __getitem__(self, idx) -> Rational:
         """
         Get an element of DualQuaternion
 
@@ -50,6 +51,6 @@ class RationalDualQuaternion(DualQuaternion):
         Get the array of the rational numbers
 
         :return: Rational numbers
-        :rtype: sp.Matrix
+        :rtype: sympy.Matrix
         """
         return np.array(self.rational_numbers)

rational_linkages/RationalMechanism.py

@@ -8,12 +8,12 @@ import numpy as np
 import sympy as sp
 
 from .DualQuaternion import DualQuaternion
+from .Linkage import LineSegment
 from .MotionFactorization import MotionFactorization
 from .NormalizedLine import NormalizedLine
+from .PointHomogeneous import PointHomogeneous
 from .RationalCurve import RationalCurve
 from .TransfMatrix import TransfMatrix
-from .PointHomogeneous import PointHomogeneous
-from .Linkage import LineSegment
 
 
 class RationalMechanism(RationalCurve):
@@ -110,7 +110,7 @@ class RationalMechanism(RationalCurve):
         This metric is used for collision detection.
         """
         if self._metric is None:
-            from .AffineMetric import AffineMetric  # inner import
+            from .AffineMetric import AffineMetric  # lazy import
             mechanism_points = self.points_at_parameter(0,
                                                         inverted_part=True,
                                                         only_links=False)
@@ -310,18 +310,18 @@ class RationalMechanism(RationalCurve):
         if onshape_print:
             for i in range(self.num_joints):
                 print(f"link{i}: "
-                      f"[{dh[i, 1]:.6f}, {dh[i, 2]:.6f}, {dh[i, 3]:.6f}], "
-                      f"{design_params[i, 0]:.6f}, {design_params[i, 1]:.6f}")
+                      f"[{dh[i, 1]:.15f}, {dh[i, 2]:.15f}, {dh[i, 3]:.15f}], "
+                      f"{design_params[i, 0]:.15f}, {design_params[i, 1]:.15f}")
             pretty_print = False
 
         if pretty_print:
             for i in range(self.num_joints):
                 print("---")
-                print(f"Link {i}: d = {dh[i, 1]:.6f}, "
-                      f"a = {dh[i, 2]:.6f}, "
-                      f"alpha = {dh[i, 3]:.6f}")
-                print(f"cp_0 = {design_params[i, 0]:.6f}, "
-                      f"cp_1 = {design_params[i, 1]:.6f}")
+                print(f"Link {i}: d = {dh[i, 1]:.15f}, "
+                      f"a = {dh[i, 2]:.15f}, "
+                      f"alpha = {dh[i, 3]:.15f}")
+                print(f"cp_0 = {design_params[i, 0]:.15f}, "
+                      f"cp_1 = {design_params[i, 1]:.15f}")
 
         return dh, design_params, design_points
 
@@ -400,7 +400,7 @@ class RationalMechanism(RationalCurve):
         :return: list of TransfMatrix objects
         :rtype: list[TransfMatrix]
         """
-        from .TransfMatrix import TransfMatrix  # inner import
+        from .TransfMatrix import TransfMatrix  # lazy import
 
         screws = deepcopy(self.get_screw_axes())
 
@@ -942,7 +942,7 @@ class RationalMechanism(RationalCurve):
         """
         Perform singularity check of the mechanism.
         """
-        from .SingularityAnalysis import SingularityAnalysis  # inner import
+        from .SingularityAnalysis import SingularityAnalysis  # lazy import
 
         sa = SingularityAnalysis()
         return sa.check_singularity(self)
@@ -957,7 +957,7 @@ class RationalMechanism(RationalCurve):
             result of the optimization
         :rtype: list, list, float
         """
-        from .CollisionFreeOptimization import CollisionFreeOptimization  # inner import
+        from .CollisionFreeOptimization import CollisionFreeOptimization  # lazy import
 
         # get smallest polyline
         pts, points_params, res = CollisionFreeOptimization(self).smallest_polyline()
@@ -1087,7 +1087,8 @@ class RationalMechanism(RationalCurve):
         Calculate inverse kinematics for given pose. Returns the joint angle in radians.
 
         :param Union[DualQuaternion, TransfMatrix] pose: pose of the mechanism
-        :param str unit: unit of the joint angle, can be 'rad' or 'deg'
+        :param str unit: unit of the joint angle, can be 'rad', 'deg', or 't' as
+            t is the parameter of the motion curve. Default is 'rad'.
         :param str method: numerically for 'gauss-newton' or 'algebraic'; 'algebraic'
             requires the input pose to be "achievable" by the mechanism, i.e. the pose
             must be on Study quadric and the mechanism must be able to reach it
@@ -1102,7 +1103,7 @@ class RationalMechanism(RationalCurve):
         elif not isinstance(pose, DualQuaternion):
             raise ValueError("pose must be either DualQuaternion or TransfMatrix")
 
-        if unit != 'rad' and unit != 'deg':
+        if unit not in {'rad', 'deg', 't'}:
             raise ValueError("unit must be deg or rad")
 
         if method == 'algebraic':
@@ -1113,12 +1114,13 @@ class RationalMechanism(RationalCurve):
         else:
             raise ValueError("method must be either 'algebraic' or 'gauss-newton")
 
-        joint_angle = self.factorizations[0].t_param_to_joint_angle(t)
-
-        if unit == 'deg':
-            joint_angle = np.rad2deg(joint_angle)
-
-        return joint_angle
+        if unit == 't':
+            return t
+        else:
+            joint_angle = self.factorizations[0].t_param_to_joint_angle(t)
+            if unit == 'deg':
+                joint_angle = np.rad2deg(joint_angle)
+            return joint_angle
 
     def _ik_gauss_newton(self,
                          goal_pose: DualQuaternion,
@@ -1152,6 +1154,7 @@ class RationalMechanism(RationalCurve):
             if robust:
                 t_init_set = np.linspace(-1.0, 1.0, 30)
                 max_iterations = 50
+                tol = 1e-15
 
             for inv, curve in enumerate(curves):
                 if inv == 1:
@@ -1162,23 +1165,35 @@ class RationalMechanism(RationalCurve):
 
                 c_diff = [element.diff(t) for element in norm_curve]
 
+                # numerical preparation of the derivatives
+                c_diff_funcs = [sp.lambdify(t, expr, modules='numpy')
+                                for expr in c_diff]
+                def c_diff_lambdified(x: float):
+                    return np.array([f(x) for f in c_diff_funcs])
+
+                curve_funcs = [sp.lambdify(t, expr, modules='numpy')
+                               for expr in curve.symbolic]
+                def curve_lambdified(x: float):
+                    return np.array([f(x) for f in curve_funcs])
+
                 for t_val in t_init_set:
                     step_size = 1.0
                     previous_error = float('inf')
 
                     for i in range(max_iterations):
 
-                        if not robust:
-                            if t_val == sp.nan or t_val > 1.0 or t_val < -1.0:
-                                break
+                        # check if t_val is valid, i.e. must be in the range [-1, 1]
+                        if (t_val == sp.nan or np.isnan(t_val) or t_val > 10.0
+                                or t_val < -10.0):
+                            break
 
                         target_pose = pose.array()
-                        current_pose = curve.evaluate(t_val)
-                        c_diff_eval = np.array([element.subs(t, t_val).evalf()
-                                                for element in c_diff])
+                        current_pose = curve_lambdified(t_val)
+                        c_diff_eval = c_diff_lambdified(t_val)
 
                         # error to desired pose
-                        if (target_pose[0] == 0. or current_pose[0] == 0.):
+                        if (np.isclose(target_pose[0], 0.0)
+                                or np.isclose(current_pose[0], 0.0)):
                             twist_to_desired = target_pose - current_pose
                         else:
                             twist_to_desired = (target_pose / target_pose[0]
@@ -1211,7 +1226,7 @@ class RationalMechanism(RationalCurve):
                 t_res = t_min[0]
 
             if inversed_part:
-                if t_res == 0.0:
+                if np.isclose(t_res, 0.0):
                     t_res = np.finfo(np.float64).tiny
                 t_res = 1 / t_res
 
@@ -1473,8 +1488,8 @@ class RationalMechanism(RationalCurve):
         self._segments = self._get_line_segments_of_linkage()
 
     def relative_motion(self,
-                        static: LineSegment,
-                        moving: LineSegment) -> DualQuaternion:
+                        static: int,
+                        moving: int) -> DualQuaternion:
         """
         Calculate the relative motion between given pair of links or joints.
 
@@ -1487,8 +1502,8 @@ class RationalMechanism(RationalCurve):
         if static == moving:
             raise ValueError("static and moving cannot be the same")
 
-        motion_cycle = self._shortest_path(static.creation_index,
-                                           moving.creation_index)
+        motion_cycle = self._shortest_path(static, moving)
+
         rel_motion = DualQuaternion()
         for idx in motion_cycle:
             rel_motion *= self.linear_motions_cycle[idx]

rational_linkages/SingularityAnalysis.py

@@ -1,7 +1,7 @@
-from .RationalMechanism import RationalMechanism
-from .Linkage import LineSegment
+from sympy import Matrix
 
-import sympy
+from .Linkage import LineSegment
+from .RationalMechanism import RationalMechanism
 
 
 class SingularityAnalysis:
@@ -49,8 +49,7 @@ class SingularityAnalysis:
         # normalization
 
 
-
-        jacobian = sympy.Matrix.zeros(6, len(algebraic_plucker_coords))
+        jacobian = Matrix.zeros(6, len(algebraic_plucker_coords))
         for i, plucker_line in enumerate(algebraic_plucker_coords):
             jacobian[:, i] = plucker_line.screw
 

rational_linkages/StaticMechanism.py

@@ -1,15 +1,14 @@
-from warnings import warn
 from typing import Union
+from warnings import warn
 
 import numpy as np
 
-from .RationalMechanism import RationalMechanism
-from .MotionFactorization import MotionFactorization
 from .DualQuaternion import DualQuaternion
+from .MotionFactorization import MotionFactorization
 from .NormalizedLine import NormalizedLine
-from .TransfMatrix import TransfMatrix
 from .PointHomogeneous import PointHomogeneous
-
+from .RationalMechanism import RationalMechanism
+from .TransfMatrix import TransfMatrix
 from .utils import dq_algebraic2vector
 
 

rational_linkages/__init__.py

@@ -1,6 +1,7 @@
 # __init__.py
 
-from importlib.metadata import version, PackageNotFoundError
+from importlib.metadata import PackageNotFoundError, version
+
 try:
     __version__ = version("rational_linkages")
 except PackageNotFoundError:
@@ -19,7 +20,7 @@ from .NormalizedPlane import NormalizedPlane
 from .Plotter import Plotter
 from .PointHomogeneous import PointHomogeneous
 from .Quaternion import Quaternion
-from .RationalBezier import RationalBezier, BezierSegment
+from .RationalBezier import BezierSegment, RationalBezier
 from .RationalCurve import RationalCurve
 from .RationalDualQuaternion import RationalDualQuaternion
 from .RationalMechanism import RationalMechanism

rational_linkages/utils.py

@@ -13,7 +13,7 @@ def dq_algebraic2vector(ugly_expression: list) -> list:
     :return: 8-vector representation of the algebraic equation
     :rtype: list
     """
-    from sympy import symbols, expand  # inner import
+    from sympy import expand, symbols  # lazy import
     i, j, k, epsilon = symbols('i j k epsilon')
 
     expr = expand(ugly_expression)
@@ -41,7 +41,7 @@ def extract_coeffs(expr, var, deg: int, expand: bool = True):
     :rtype: list
     """
     if expand:
-        from sympy import expand  # inner import
+        from sympy import expand  # lazy import
         expr = expand(expr)
     return [expr.coeff(var, i) for i in range(deg, -1, -1)]
 
@@ -97,10 +97,67 @@ def is_package_installed(package_name: str) -> bool:
     """
     Check if a package is installed.
     """
-    from importlib.metadata import distribution
+    from importlib.metadata import distribution  # lazy import
 
     try:
         distribution(package_name)
         return True
     except ImportError:
         return False
+
+
+def tr_from_dh_rationally(t_theta, di, ai, t_alpha):
+    """
+    Create transformation matrix from DH parameters using Sympy in rational form.
+
+    The input shall be rational numbers, including the angles which are expected
+    to be parameters of tangent half-angle substitution, i.e., t_theta = tan(theta/2)
+    and t_alpha = tan(alpha/2).
+
+    :param sp.Rational t_theta: DH parameter theta in tangent half-angle form
+    :param sp.Rational di: DH parameter d, the offset along Z axis
+    :param sp.Rational ai: DH parameter a, the length along X axis
+    :param sp.Rational t_alpha: DH parameter alpha in tangent half-angle form
+
+    :return: 4x4 transformation matrix
+    :rtype: sp.Matrix
+    """
+    from sympy import Matrix, eye, Expr  # lazy import
+
+    if not all(isinstance(param, Expr) for param in [t_theta, di, ai, t_alpha]):
+        raise ValueError("All parameters must be of type sympy objects (Expr).")
+
+    s_th = 2*t_theta / (1 + t_theta**2)
+    c_th = (1 - t_theta**2) / (1 + t_theta**2)
+    s_al = 2*t_alpha / (1 + t_alpha**2)
+    c_al = (1 - t_alpha**2) / (1 + t_alpha**2)
+
+    mat = eye(4)
+    mat[1:4, 0] = Matrix([ai * c_th, ai * s_th, di])
+    mat[1, 1:4] = Matrix([[c_th, -s_th * c_al, s_th * s_al]])
+    mat[2, 1:4] = Matrix([[s_th, c_th * c_al, -c_th * s_al]])
+    mat[3, 1:4] = Matrix([[0, s_al, c_al]])
+    return mat
+
+
+def normalized_line_rationally(point, direction):
+    """
+    Create a normalized Plücker line from a point and a direction using Sympy.
+
+    The input shall be rational numbers, i.e. Sympy objects.
+
+    :param sp.Rational point:
+    :param sp.Rational direction:
+
+    :return: 6-vector representing the Plücker line
+    :rtype: sp.Matrix
+    """
+    from sympy import Matrix, Expr  # lazy import
+
+    if not all(isinstance(param, Expr) for param in point + direction):
+        raise ValueError("All parameters must be of type sympy objects (Expr).")
+
+    dir = Matrix(direction)
+    pt = Matrix(point)
+    mom = (-1 * dir).cross(pt)
+    return Matrix.vstack(dir, mom)

{rational_linkages-2.0.0.dist-info → rational_linkages-2.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rational-linkages
-Version: 2.0.0
+Version: 2.2.3
 Summary: Rational Linkages
 Author-email: Daniel Huczala <daniel.huczala@uibk.ac.at>
 License-Expression: GPL-3.0-or-later
@@ -14,15 +14,17 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: biquaternion-py>=1.2.0
-Requires-Dist: scipy>=1.10.0
+Requires-Dist: numpy>=1.10.0
 Requires-Dist: sympy>=1.10.0
 Requires-Dist: PyQt6>=6.2.0
 Requires-Dist: pyqtgraph>=0.12.4
 Requires-Dist: PyOpenGL>=3.0.0
+Requires-Dist: matplotlib>=3.9.0; platform_system == "Windows" and platform_machine == "ARM64"
 Provides-Extra: opt
 Requires-Dist: ipython>=8.0.0; extra == "opt"
-Requires-Dist: gmpy2>=2.2.0; extra == "opt"
+Requires-Dist: scipy>=1.10.0; extra == "opt"
 Requires-Dist: matplotlib>=3.9.0; extra == "opt"
+Requires-Dist: gmpy2>=2.2.0; (platform_system != "Windows" and platform_machine != "ARM64") and extra == "opt"
 Provides-Extra: exu
 Requires-Dist: exudyn>=1.9.0; extra == "exu"
 Requires-Dist: numpy-stl>=3.0.0; extra == "exu"
@@ -38,6 +40,7 @@ Requires-Dist: sphinx-hoverxref; extra == "doc"
 Requires-Dist: gitpython; extra == "doc"
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
+Requires-Dist: cibuildwheel; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
@@ -112,17 +115,28 @@ Using pip:
 
 <code>pip install rational-linkages</code>
 
-or
+or with optional dependencies:
 
-<code>pip install rational-linkages[opt]</code>
+<code>pip install rational-linkages[opt,exu]</code>
 
-Mac users might need to use backslashes to escape the brackets, e.g.:
+Mac/linux users might need to use backslashes to escape the brackets, e.g.:
 
-<code>pip install rational-linkages\\[opt\\]</code>
+<code>pip install rational-linkages\\[opt,exu\\]</code>
 
-for installing also optional dependencies (ipython - inline plotting, gmpy2 - faster
-symbolic computations, exudyn - multibody simulations, numpy-stl -
-work with meshes in exudyn).
+for installing also **opt**ional dependencies (scipy - optimization problems solving, ipython - inline plotting,  
+matplotlib - alternative engine for 3D plotting, gmpy2 - optimized symbolic computations) 
+and **exu**dyn dependencies (exudyn - multibody simulations, 
+numpy-stl + ngsolve - work with meshes in exudyn).
+
+On **Linux systems**, to run GUI interactive plotting, 
+some additional libraries are required for plotting with PyQt6. For example, 
+on Ubuntu, it can be installed as follows:
+
+   <code>sudo apt install libgl1-mesa-glx libxkbcommon-x11-0 libegl1 libdbus-1-3</code>
+
+or on Ubuntu 24.04 and higher:
+
+   <code>sudo apt install libgl1 libxkbcommon-x11-0 libegl1 libdbus-1-3</code>
 
 ### Install from source
 
@@ -142,21 +156,21 @@ work with meshes in exudyn).
     
    <code>pip install -e .[opt,dev,doc]</code> including the development and documentation dependencies. 
 
-   Mac or Linux users might need to use backslashes to escape the brackets, e.g.: 
+   Mac/linux users might need to use backslashes to escape the brackets, e.g.: 
 
    <code>pip install -e .\\[opt\\]</code>
 
-Additionally, on Linux systems, some additional libraries are required for plotting with PyQt6. For example, 
-on Ubuntu, it can be installed as follows:
 
-   <code>sudo apt install libgl1-mesa-glx libxkbcommon-x11-0 libegl1 libdbus-1-3</code>
 
-or on Ubuntu 24.04 and higher:
+To run the Rust functions, you need to install the [Rust toolchain](https://www.rust-lang.org) and 
+build the Rust code yourself. On top of that, on Windows, you need to install a 
+C++ build toolchain. In `Visual Studio Installer`, select: 
 
-   <code>sudo apt install libgl1 libxkbcommon-x11-0 libegl1 libdbus-1-3</code>
+* MSVC v143 - VS 2022 C++ x64/x86 build tools (latest)
+* Windows 11 SDK
+* C++ CMake tools for Windows
 
-To run the Rust functions, you need to install the [Rust toolchain](https://www.rust-lang.org) and 
-build the Rust code yourself, for example:
+Then, navigate to the `rational_linkages/rust` folder and run:
 
 <code>cargo build --release</code>