moro 0.3.0.dev0__tar.gz → 0.4.0__tar.gz

moro-0.4.0/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: moro
+Version: 0.4.0
+Summary: Python library for kinematic and dynamic modeling of robots
+Author-email: Pedro Jorge De Los Santos <delossantosmfq@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/JorgeDeLosSantos/moro
+Project-URL: Repository, https://github.com/JorgeDeLosSantos/moro
+Project-URL: Issues, https://github.com/JorgeDeLosSantos/moro/issues
+Keywords: robotics,kinematics,dynamics
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: sympy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# moro
+
+[![PyPI version](https://img.shields.io/pypi/v/moro.svg)](https://pypi.org/project/moro/)
+[![License](https://img.shields.io/github/license/JorgeDeLosSantos/moro.svg)](https://github.com/JorgeDeLosSantos/moro/blob/master/LICENSE.txt)
+
+`moro` is a Python library for symbolic modeling, analysis, and visualization of serial robot manipulators.
+
+It is designed primarily for robotics education and for workflows where inspecting the underlying kinematic and dynamic expressions is as important as evaluating them numerically.
+
+## Features
+
+* **Robot modeling:** Define serial manipulators with revolute and prismatic joints using Denavit-Hartenberg parameters.
+* **Transformations:** Work with `SO(3)` rotation matrices, `SE(3)` homogeneous transformations, Euler angles, and axis-angle representations.
+* **Forward kinematics:** Compute symbolic end-effector and intermediate-frame transformations.
+* **Differential kinematics:** Compute geometric Jacobians for the end-effector and other points.
+* **Inverse kinematics:** Solve numerical Cartesian position IK using Levenberg-Marquardt, Newton-Raphson, or CCD.
+* **IK trajectories:** Solve ordered sequences of Cartesian position targets using warm-started inverse kinematics.
+* **Dynamics:** Derive symbolic equations of motion and the standard `M(q) qdd + C(q, qd) qd + G(q) = tau` model.
+* **Visualization:** Plot and animate robot configurations using Matplotlib or an interactive Three.js backend.
+
+## Installation
+
+Install the latest stable release from PyPI:
+
+```bash
+pip install moro
+```
+
+To install the current development version from the `develop` branch:
+
+```bash
+pip install git+https://github.com/JorgeDeLosSantos/moro.git@develop
+```
+
+`moro` requires Python 3.9 or newer.
+
+## Quick Start
+
+The following example creates a symbolic planar 2R manipulator and evaluates its forward kinematics and Jacobian at one configuration:
+
+```python
+from moro import Robot
+from moro.abc import q1, q2, l1, l2
+
+robot = Robot(
+    (l1, 0, 0, q1, "r"),
+    (l2, 0, 0, q2, "r"),
+)
+
+T = robot.T
+J = robot.J
+
+values = {
+    l1: 1.0,
+    l2: 1.0,
+    q1: 0.5,
+    q2: 0.8,
+}
+
+T_num = T.subs(values).evalf()
+J_num = J.subs(values).evalf()
+```
+
+The same symbolic model can also be visualized:
+
+```python
+from moro.visualization import RobotVisualizer
+
+viz = RobotVisualizer(robot)
+viz.plot(values)
+```
+
+For interactive visualization in a notebook:
+
+```python
+viz.plot(values, backend="threejs")
+```
+
+## Inverse Kinematics
+
+A Cartesian position target can be solved numerically with:
+
+```python
+from moro.inverse_kinematics import solve_position_ik
+
+solution = solve_position_ik(
+    robot,
+    [1.5, 0.5, 0.0],
+    q0=[0.1, 0.1],
+    parameters={
+        l1: 1.0,
+        l2: 1.0,
+    },
+)
+
+if solution.converged:
+    print(solution.q)
+else:
+    print(solution.message)
+```
+
+Current inverse-kinematics support is focused on Cartesian position. Full-pose IK with orientation constraints is not yet included.
+
+## Dynamics
+
+Dynamic models can be built by assigning masses, centers of mass, inertia tensors, and gravity to an existing `Robot` model.
+
+For example:
+
+```python
+import sympy as sp
+
+from moro.abc import m1, m2, lc1, lc2, g
+
+I1, I2 = sp.symbols("I1 I2", positive=True)
+
+robot.masses = [m1, m2]
+robot.cm_positions = [
+    (-lc1, 0, 0),
+    (-lc2, 0, 0),
+]
+robot.inertia_tensors = [
+    sp.diag(0, 0, I1),
+    sp.diag(0, 0, I2),
+]
+robot.gravity = (0, -g, 0)
+
+M = robot.inertia_matrix()
+C = robot.coriolis_matrix()
+G = robot.gravity_vector()
+
+model = robot.dynamic_model_matrix_form()
+```
+
+The current dynamics API derives symbolic equations of motion and supports inverse-dynamics-style evaluation. Forward dynamics integration is not currently included.
+
+## Documentation
+
+The complete documentation is available at:
+
+https://jorgedelossantos.github.io/moro/
+
+It includes:
+
+* Getting Started guides;
+* a practical User Guide;
+* complete worked examples;
+* API Reference;
+* mathematical Theory notes;
+* contributor documentation and naming conventions.
+
+## Roadmap
+
+Want to know what may come next? See the [Moro Roadmap Wiki](https://github.com/JorgeDeLosSantos/moro/wiki/Roadmap).
+
+## Bug Reports and Contributions
+
+If you encounter a bug, have a question, or want to request a feature, please open an issue in the [GitHub Issue Tracker](https://github.com/JorgeDeLosSantos/moro/issues).
+
+Contributions are welcome. See the contributor documentation included in the project documentation for the recommended development workflow.

moro-0.4.0/README.md

@@ -0,0 +1,160 @@
+# moro
+
+[![PyPI version](https://img.shields.io/pypi/v/moro.svg)](https://pypi.org/project/moro/)
+[![License](https://img.shields.io/github/license/JorgeDeLosSantos/moro.svg)](https://github.com/JorgeDeLosSantos/moro/blob/master/LICENSE.txt)
+
+`moro` is a Python library for symbolic modeling, analysis, and visualization of serial robot manipulators.
+
+It is designed primarily for robotics education and for workflows where inspecting the underlying kinematic and dynamic expressions is as important as evaluating them numerically.
+
+## Features
+
+* **Robot modeling:** Define serial manipulators with revolute and prismatic joints using Denavit-Hartenberg parameters.
+* **Transformations:** Work with `SO(3)` rotation matrices, `SE(3)` homogeneous transformations, Euler angles, and axis-angle representations.
+* **Forward kinematics:** Compute symbolic end-effector and intermediate-frame transformations.
+* **Differential kinematics:** Compute geometric Jacobians for the end-effector and other points.
+* **Inverse kinematics:** Solve numerical Cartesian position IK using Levenberg-Marquardt, Newton-Raphson, or CCD.
+* **IK trajectories:** Solve ordered sequences of Cartesian position targets using warm-started inverse kinematics.
+* **Dynamics:** Derive symbolic equations of motion and the standard `M(q) qdd + C(q, qd) qd + G(q) = tau` model.
+* **Visualization:** Plot and animate robot configurations using Matplotlib or an interactive Three.js backend.
+
+## Installation
+
+Install the latest stable release from PyPI:
+
+```bash
+pip install moro
+```
+
+To install the current development version from the `develop` branch:
+
+```bash
+pip install git+https://github.com/JorgeDeLosSantos/moro.git@develop
+```
+
+`moro` requires Python 3.9 or newer.
+
+## Quick Start
+
+The following example creates a symbolic planar 2R manipulator and evaluates its forward kinematics and Jacobian at one configuration:
+
+```python
+from moro import Robot
+from moro.abc import q1, q2, l1, l2
+
+robot = Robot(
+    (l1, 0, 0, q1, "r"),
+    (l2, 0, 0, q2, "r"),
+)
+
+T = robot.T
+J = robot.J
+
+values = {
+    l1: 1.0,
+    l2: 1.0,
+    q1: 0.5,
+    q2: 0.8,
+}
+
+T_num = T.subs(values).evalf()
+J_num = J.subs(values).evalf()
+```
+
+The same symbolic model can also be visualized:
+
+```python
+from moro.visualization import RobotVisualizer
+
+viz = RobotVisualizer(robot)
+viz.plot(values)
+```
+
+For interactive visualization in a notebook:
+
+```python
+viz.plot(values, backend="threejs")
+```
+
+## Inverse Kinematics
+
+A Cartesian position target can be solved numerically with:
+
+```python
+from moro.inverse_kinematics import solve_position_ik
+
+solution = solve_position_ik(
+    robot,
+    [1.5, 0.5, 0.0],
+    q0=[0.1, 0.1],
+    parameters={
+        l1: 1.0,
+        l2: 1.0,
+    },
+)
+
+if solution.converged:
+    print(solution.q)
+else:
+    print(solution.message)
+```
+
+Current inverse-kinematics support is focused on Cartesian position. Full-pose IK with orientation constraints is not yet included.
+
+## Dynamics
+
+Dynamic models can be built by assigning masses, centers of mass, inertia tensors, and gravity to an existing `Robot` model.
+
+For example:
+
+```python
+import sympy as sp
+
+from moro.abc import m1, m2, lc1, lc2, g
+
+I1, I2 = sp.symbols("I1 I2", positive=True)
+
+robot.masses = [m1, m2]
+robot.cm_positions = [
+    (-lc1, 0, 0),
+    (-lc2, 0, 0),
+]
+robot.inertia_tensors = [
+    sp.diag(0, 0, I1),
+    sp.diag(0, 0, I2),
+]
+robot.gravity = (0, -g, 0)
+
+M = robot.inertia_matrix()
+C = robot.coriolis_matrix()
+G = robot.gravity_vector()
+
+model = robot.dynamic_model_matrix_form()
+```
+
+The current dynamics API derives symbolic equations of motion and supports inverse-dynamics-style evaluation. Forward dynamics integration is not currently included.
+
+## Documentation
+
+The complete documentation is available at:
+
+https://jorgedelossantos.github.io/moro/
+
+It includes:
+
+* Getting Started guides;
+* a practical User Guide;
+* complete worked examples;
+* API Reference;
+* mathematical Theory notes;
+* contributor documentation and naming conventions.
+
+## Roadmap
+
+Want to know what may come next? See the [Moro Roadmap Wiki](https://github.com/JorgeDeLosSantos/moro/wiki/Roadmap).
+
+## Bug Reports and Contributions
+
+If you encounter a bug, have a question, or want to request a feature, please open an issue in the [GitHub Issue Tracker](https://github.com/JorgeDeLosSantos/moro/issues).
+
+Contributions are welcome. See the contributor documentation included in the project documentation for the recommended development workflow.

moro-0.4.0/moro/__init__.py

@@ -0,0 +1,41 @@
+"""
+Numython R&D, (c) 2026
+Moro is a Python library for kinematic and dynamic modeling of serial robots. 
+This library has been designed, mainly, for academic and research purposes, 
+using SymPy as base library. 
+"""
+from .version import __version__
+
+from .core import Robot
+from .util import enable_vprinting
+from .transformations import (
+    rotx, roty, rotz,
+    rot2eul, eul2rot,
+    axa2rot, rot2axa,
+    htmtra, htmrot,
+    rot2htm, rt2htm,
+    htm2rot, htm2tra,
+    invhtm,
+    dh
+)
+
+__all__ = [
+    "__version__",
+    "Robot",
+    "enable_vprinting",
+    "rotx",
+    "roty",
+    "rotz",
+    "rot2eul",
+    "eul2rot",
+    "axa2rot",
+    "rot2axa",
+    "htmtra",
+    "htmrot",
+    "rot2htm",
+    "rt2htm",
+    "htm2rot",
+    "htm2tra",
+    "invhtm",
+    "dh"
+]

{moro-0.3.0.dev0 → moro-0.4.0}/moro/abc.py

@@ -3,17 +3,15 @@ from sympy.physics.mechanics import dynamicsymbols
 
 t = symbols("t") # time 
 q1,q2,q3,q4,q5,q6 = dynamicsymbols('q_1:7') # joint variables
-q1p,q2p,q3p,q4p,q5p,q6p = [q.diff(t) for q in (q1,q2,q3,q4,q5,q6)] # joint velocities
-q1pp,q2pp,q3pp,q4pp,q5pp,q6pp = [qp.diff(t) for qp in (q1p,q2p,q3p,q4p,q5p,q6p)] # joint accelerations
-t1,t2,t3,t4,t5,t6 = symbols('theta_1:7', real=True) # theta parameter
+qd1,qd2,qd3,qd4,qd5,qd6 = [q.diff(t) for q in (q1,q2,q3,q4,q5,q6)] # joint velocities
+qdd1,qdd2,qdd3,qdd4,qdd5,qdd6 = [qd.diff(t) for qd in (qd1,qd2,qd3,qd4,qd5,qd6)] # joint accelerations
+theta1,theta2,theta3,theta4,theta5,theta6 = symbols('theta_1:7', real=True) # theta parameter
 l1,l2,l3,l4,l5,l6 = symbols('l_1:7', real=True) # parameters for constant lengths of the robot
 lc1,lc2,lc3,lc4,lc5,lc6 = symbols('l_c1:7', real=True) # parameters for center of mass location
 d1,d2,d3,d4,d5,d6 = symbols('d_1:7', real=True)  # for constant lengths of the robot
 m1,m2,m3,m4,m5,m6 = symbols('m_1:7', real=True) # for mass symbols
 a1,a2,a3,a4,a5,a6 = symbols('a_1:7', real=True) # for constant lengths of the robot
-x0,x1,x2,x3,x4,x5,x6 = symbols("x_0:7", real=True) 
-y0,y1,y2,y3,y4,y5,y6 = symbols("y_0:7", real=True)
-z0,z1,z2,z3,z4,z5,z6 = symbols("z_0:7", real=True)
+alpha1,alpha2,alpha3,alpha4,alpha5,alpha6 = symbols('alpha_1:7', real=True) # for DH parameters
 g = symbols("g") # gravity
 tau1,tau2,tau3,tau4,tau5,tau6 = symbols("tau_1:7", real=True) # for generalized forces/torques
 
@@ -25,20 +23,18 @@ xi,omicron,rho,sigma = symbols("xi,omicron,rho,sigma", real=True)
 tau,upsilon,phi,chi = symbols("tau,upsilon,phi,chi", real=True)
 psi,omega = symbols("psi,omega", real=True)
 
-# ~ del pi # Delete "pi" symbolic variable -> conflict with pi number
+
 available_symvars = [g,t,
 q1,q2,q3,q4,q5,q6,
-q1p,q2p,q3p,q4p,q5p,q6p,
-q1pp,q2pp,q3pp,q4pp,q5pp,q6pp,
-t1,t2,t3,t4,t5,t6,
+qd1,qd2,qd3,qd4,qd5,qd6,
+qdd1,qdd2,qdd3,qdd4,qdd5,qdd6,
+theta1,theta2,theta3,theta4,theta5,theta6,
+alpha1,alpha2,alpha3,alpha4,alpha5,alpha6,
 l1,l2,l3,l4,l5,l6,
 lc1,lc2,lc3,lc4,lc5,lc6,
 d1,d2,d3,d4,d5,d6,
 m1,m2,m3,m4,m5,m6,
 a1,a2,a3,a4,a5,a6,
-x0,x1,x2,x3,x4,x5,x6,
-y0,y1,y2,y3,y4,y5,y6,
-z0,z1,z2,z3,z4,z5,z6,
 alpha,beta,gamma,delta,
 epsilon,zeta,eta,theta,
 iota,kappa,mu,nu,