robotics-geometry 0.1.0__py3-none-any.whl

robotics_geometry/.mypy_cache/.gitignore

@@ -0,0 +1,2 @@
+# Automatically created by mypy
+*

robotics_geometry/.mypy_cache/CACHEDIR.TAG

@@ -0,0 +1,3 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag automatically created by mypy.
+# For information about cache directory tags see https://bford.info/cachedir/

robotics_geometry/__init__.py

@@ -0,0 +1 @@
+"""Geometry library for mobile robotics applications."""

robotics_geometry/functions.py

@@ -0,0 +1,44 @@
+"""Common utility functions."""
+
+# standard imports
+import math
+
+from .ros import Quaternion
+
+
+def normalize_angle(angle: float) -> float:
+    """Normalize an angle to the range (-pi, pi]."""
+    return math.pi - ((math.pi - angle) % (2 * math.pi))
+
+
+def yaw_from_quaternion(quaternion: Quaternion) -> float:
+    """Compute the yaw angle from a quaternion.
+
+    Warning: other rotation components are ignored.
+
+    Arguments:
+        quaternion: a `geometry_msgs.msg.Quaternion`.
+
+    Returns:
+        The yaw angle in radians in the range (-pi, pi].
+    """
+    x = quaternion.x
+    y = quaternion.y
+    z = quaternion.z
+    w = quaternion.w
+    return normalize_angle(math.atan2(2 * (w * z + x * y),
+                           w * w + x * x - y * y - z * z))
+
+
+def quaternion_from_yaw(yaw: float) -> Quaternion:
+    """Compute the quaternion from a yaw angle.
+
+    Arguments:
+        yaw: The yaw angle in radians.
+
+    Returns:
+        A `geometry_msgs.msg.Quaternion`.
+    """
+    w = math.cos(yaw / 2)
+    z = math.sin(yaw / 2)
+    return Quaternion(x=0., y=0., z=z, w=w)

robotics_geometry/rigid_body2.py

@@ -0,0 +1,328 @@
+"""Definition of pose and transformation in a 2D workspace."""
+
+from __future__ import annotations
+
+# standard imports
+import dataclasses
+import math
+from types import NotImplementedType
+from typing import Iterator, Self, overload
+
+# local imports
+from .functions import normalize_angle, quaternion_from_yaw, yaw_from_quaternion
+from .ros import Point, Pose, Transform, Vector3
+from .workspace2 import Point2, Vector2
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Transform2:
+    """2D transformation.
+
+    Rotation is done before translation.
+    """
+    tx: float = 0.0
+    """`x` coordinate of the translation."""
+    ty: float = 0.0
+    """`y` coordinate of the translation."""
+    angle: float = 0.0
+    """Rotation angle in radians."""
+    translation: Vector2 = dataclasses.field(
+        init=False, repr=False, compare=False)
+    """Translation vector (``Vector2(tx, ty)``)."""
+
+    def __post_init__(self) -> None:
+        """Create translation."""
+        # `self.translation = ...` would not work since the class is frozen
+        # `super().__setattr__(...)` does not work due to slots (https://github.com/python-attrs/attrs/issues/1038#issuecomment-1269542786)
+        super(Transform2, self).__setattr__(
+            'translation', Vector2(self.tx, self.ty))
+
+    def __iter__(self) -> Iterator[float]:
+        """Iterate over `tx`, `ty`, and `angle`.
+
+        Allows unpacking.
+        """
+        yield self.tx
+        yield self.ty
+        yield self.angle
+
+    def keys(self) -> Iterator[str]:
+        """Return the coordinate keys.
+
+        In conjunction to :meth:`__getitem__`, allows dictionary unpacking.
+        """
+        yield 'tx'
+        yield 'ty'
+        yield 'angle'
+
+    def __getitem__(self, key: str) -> float:
+        """Return the coordinate value for the given key.
+
+        In conjunction with :meth:`keys`, allows dictionary unpacking.
+
+        Raises:
+            KeyError: if the key is not a valid coordinate name.
+        """
+        return getattr(self, key)
+
+    @overload
+    def __matmul__(self, other: Transform2) -> Transform2: ...
+    @overload
+    def __matmul__(self, other: object) -> Transform2 | NotImplementedType: ...
+    def __matmul__(
+        self, other: Transform2 | object
+    ) -> Transform2 | NotImplementedType:
+        """Compose two transformations."""
+        match other:
+            case Transform2():
+                return Transform2(
+                    *(self.translation + other.translation.rotate(self.angle)),
+                    angle=normalize_angle(self.angle + other.angle))
+            case _:
+                return NotImplemented
+
+    @overload
+    def __mul__(self, other: Vector2) -> Vector2: ...
+    @overload
+    def __mul__(self, other: Point2) -> Point2: ...
+    @overload
+    def __mul__(self, other: Pose2) -> Pose2: ...
+    def __mul__(
+        self, other: Vector2 | Point2 | Pose2 | object
+    ) -> Vector2 | Point2 | Pose2 | NotImplementedType:
+        """Apply transformation.
+
+        Transform a vector or point by this transformation.
+
+        Arguments:
+            other: the object to transform.
+
+        Returns:
+            The transformed vector or point, or ``NotImplemented`` if the type
+            is not supported.
+        """
+        match other:
+            case Vector2():
+                return self.translation + other.rotate(self.angle)
+            case Point2():
+                return Point2(
+                    **(self.translation + Vector2(*other).rotate(self.angle))
+                )
+            case Pose2():
+                return Pose2(**(self * other.position),
+                             theta=normalize_angle(self.angle + other.theta)
+                )
+            case _:
+                return NotImplemented
+
+    def isclose_to(
+        self, other: Self, *, rel_tol: float = 1e-09,
+        abs_tol_m: float = 0.0, abs_tol_rad: float = 0.0
+    ) -> bool:
+        """Approximate transformation equality.
+
+        Warning: there are two absolute tolerances (one for the translation and
+        the other for the rotation).
+
+        Arguments:
+            other: the other transformation to compare with.
+            rel_tol: the relative tolerance for comparison.
+            abs_tol_m: the absolute tolerance for the translation component.
+            abs_tol_rad: the absolute tolerance for the rotation component.
+
+        Returns:
+            ``True`` if the transformations are close, ``False`` otherwise.
+        """
+        return (
+            math.isclose(self.tx, other.tx, rel_tol=rel_tol, abs_tol=abs_tol_m)
+            and math.isclose(
+                self.ty, other.ty, rel_tol=rel_tol, abs_tol=abs_tol_m)
+            and (abs(normalize_angle(self.angle - other.angle))
+                 <= max(rel_tol * max(abs(normalize_angle(self.angle)),
+                                      abs(normalize_angle(other.angle))),
+                        abs_tol_rad))
+        )
+
+    def __invert__(self) -> Self:
+        """Inverse transformation."""
+        sa, ca = math.sin(self.angle), math.cos(self.angle)
+        return type(self)(
+            -self.tx * ca - self.ty * sa,
+            self.tx * sa - self.ty * ca,
+            normalize_angle(-self.angle)
+        )
+
+    @classmethod
+    def from_pose2(cls, pose2: Pose2) -> Self:
+        """Create transform from pose.
+
+        Warning: assuming that the pose is of rigid body A expressed with
+        respect to frame B, the transform will map coordinates expressed in
+        frame A into frame B.
+        """
+        return cls(*pose2)
+
+    @classmethod
+    def from_transform_msg(cls, transform: Transform) -> Self:
+        """Create a transform from a ROS 2 ``Transform`` message.
+
+        The ``z`` coordinate of the translation is ignored.
+        """
+        return cls(
+            transform.translation.x,
+            transform.translation.y,
+            yaw_from_quaternion(transform.rotation),
+        )
+
+    def to_transform_msg(self) -> Transform:
+        """Convert this transform to a ROS 2 ``Transform`` message.
+
+        The translation ``z`` component is set to ``0.0``.
+        """
+        return Transform(
+            translation=Vector3(x=self.tx, y=self.ty, z=0.0),  # ty:ignore[invalid-argument-type]
+            rotation=quaternion_from_yaw(self.angle)  # ty:ignore[invalid-argument-type]
+        )
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Pose2:
+    """2D pose."""
+    x: float = 0.
+    """`x` coordinate."""
+    y: float = 0.
+    """`y` coordinate."""
+    theta: float = 0.
+    """Orientation."""
+    position: Point2 = dataclasses.field(
+        init=False, repr=False, compare=False)
+    """Position (``Point2(x, y)``)."""
+    # ? add orientation field as alias for theta?
+
+    def __post_init__(self) -> None:
+        """Create position."""
+        super(Pose2, self).__setattr__(
+            'position', Point2(self.x, self.y)
+        )
+
+    def __iter__(self) -> Iterator[float]:
+        """Iterate over ``x``, ``y``, and ``theta``.
+
+        Allows unpacking.
+        """
+        yield self.x
+        yield self.y
+        yield self.theta
+
+    def keys(self) -> Iterator[str]:
+        """Return the coordinate keys.
+
+        In conjunction to :meth:`__getitem__`, allows dictionary unpacking.
+        """
+        yield 'x'
+        yield 'y'
+        yield 'theta'
+
+    def __getitem__(self, key: str) -> float:
+        """Return the coordinate value for the given key.
+
+        In conjunction with :meth:`keys`, allows dictionary unpacking.
+
+        Raises:
+            KeyError: if the key is not a valid coordinate name.
+        """
+        return getattr(self, key)
+
+    def isclose_to(
+        self, other: Self, *, rel_tol: float = 1e-09,
+        abs_tol_m: float = 0.0, abs_tol_rad: float = 0.0
+    ) -> bool:
+        """Approximate pose equality.
+
+        Warning: there are two absolute tolerances (one for the position and
+        the other for the orientation).
+
+        Arguments:
+            other: the other pose to compare with.
+            rel_tol: the relative tolerance for comparison.
+            abs_tol_m: the absolute tolerance for the position component.
+            abs_tol_rad: the absolute tolerance for the orientation component.
+
+        Returns:
+            ``True`` if the poses are close, ``False`` otherwise.
+        """
+        return (
+            math.isclose(self.x, other.x, rel_tol=rel_tol, abs_tol=abs_tol_m)
+            and math.isclose(
+                self.y, other.y, rel_tol=rel_tol, abs_tol=abs_tol_m)
+            and (abs(normalize_angle(self.theta - other.theta))
+                 <= max(rel_tol * max(abs(normalize_angle(self.theta)),
+                                      abs(normalize_angle(other.theta))),
+                        abs_tol_rad))
+        )
+
+    def distance_to(self, other: Self, weight: float = 1.0) -> float:
+        """Compute the distance between two poses.
+
+        Arguments:
+            other: the other pose.
+            weight: the weight to apply to the orientation component.
+
+        Returns:
+            the weighted distance between the two poses.
+        """
+        return math.sqrt(
+            (self.x - other.x)**2
+            + (self.y - other.y)**2
+            + weight**2 * normalize_angle(self.theta - other.theta)**2
+        )
+
+    @classmethod
+    def from_transform2(cls, transform2: Transform2) -> Self:
+        """Create pose from transform.
+
+        Warning: assuming that the transform object maps coordinates from
+        frame A to frame B, the pose corresponds to the rigid body A expressed
+        with respect to frame B.
+        """
+        return cls(*transform2)
+
+    @classmethod
+    def from_pose_msg(cls, pose: Pose) -> Self:
+        """Create pose from a ROS 2 ``Pose`` message.
+
+        The 3D pose is projected down to 2D.
+        """
+        return cls(
+            pose.position.x,
+            pose.position.y,
+            yaw_from_quaternion(pose.orientation)
+        )
+
+    def to_pose_msg(self) -> Pose:
+        """Convert this pose to a ROS 2 ``Pose`` message."""
+        return Pose(
+            position=Point(x=self.x, y=self.y),  # ty:ignore[invalid-argument-type]
+            orientation=quaternion_from_yaw(self.theta),  # ty:ignore[invalid-argument-type]
+        )
+
+    def move_by(self, other: Transform2 | Pose2) -> Pose2:
+        """Move pose by another transform or pose.
+
+        It corresponds to adding a small displacement (``other``) on top of the
+        current pose.
+        """
+        self_transform = Transform2.from_pose2(self)
+        match other:
+            case Transform2():
+                return type(self).from_transform2(self_transform @ other)
+            case Pose2():
+                return self_transform * other
+
+    def pose_relative_to(self, reference: Pose2) -> Pose2:
+        """Compute current pose relative to the reference.
+
+        It corresponds to the current pose expressed with respect to the frame
+        attached to the reference pose.
+        """
+        return ~Transform2.from_pose2(reference) * self

robotics_geometry/ros/__init__.py

@@ -0,0 +1,20 @@
+"""ROS-related helpers and message definitions."""
+
+try:
+    from geometry_msgs.msg import (
+        Point,
+        Pose,
+        Quaternion,
+        Transform,
+        Vector3,
+    )
+except ImportError:
+    from .msgs_mockup import (
+        Point,
+        Pose,
+        Quaternion,
+        Transform,
+        Vector3,
+    )
+
+__all__ = ["Point", "Pose", "Quaternion", "Transform", "Vector3"]

robotics_geometry/ros/msgs_mockup.py

@@ -0,0 +1,79 @@
+"""Mockups for ROS message types."""
+
+from __future__ import annotations
+
+# standard import
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True)
+class Point:
+    """Mockup for the `geometry_msgs.msg.Point` ROS message."""
+
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+
+    def __repr__(self) -> str:
+        """Pretend to be a ``geometry_msgs.msg.Point``."""
+        return (f"geometry_msgs.msg.Point(x={self.x}, y={self.y}, "
+                f"z={self.z})")
+
+
+@dataclass(slots=True)
+class Quaternion:
+    """Mockup for the `geometry_msgs.msg.Quaternion` ROS message."""
+
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+    w: float = 1.0
+
+    def __repr__(self) -> str:
+        """Pretend to be a ``geometry_msgs.msg.Quaternion``."""
+        return (f"geometry_msgs.msg.Quaternion(x={self.x}, y={self.y}, "
+                f"z={self.z}, w={self.w})")
+
+
+@dataclass(slots=True)
+class Pose:
+    """Mockup for the `geometry_msgs.msg.Pose` ROS message."""
+
+    position: Point = field(default_factory=Point)
+    orientation: Quaternion = field(default_factory=Quaternion)
+
+    def __repr__(self) -> str:
+        """Pretend to be a ``geometry_msgs.msg.Pose``."""
+        return (
+            "geometry_msgs.msg.Pose(position="
+            f"{self.position}, orientation={self.orientation})"
+        )
+
+
+@dataclass(slots=True)
+class Vector3:
+    """Mockup for the `geometry_msgs.msg.Vector3` ROS message."""
+
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+
+    def __repr__(self) -> str:
+        """Pretend to be a ``geometry_msgs.msg.Vector3``."""
+        return (f"geometry_msgs.msg.Vector3(x={self.x}, y={self.y}, "
+                f"z={self.z})")
+
+
+@dataclass(slots=True)
+class Transform:
+    """Mockup for the `geometry_msgs.msg.Transform` ROS message."""
+
+    translation: Vector3 = field(default_factory=Vector3)
+    rotation: Quaternion = field(default_factory=Quaternion)
+
+    def __repr__(self) -> str:
+        """Pretend to be a ``geometry_msgs.msg.Transform``."""
+        return (
+            "geometry_msgs.msg.Transform(translation="
+            f"{self.translation}, rotation={self.rotation})"
+        )

robotics_geometry/workspace2.py

@@ -0,0 +1,295 @@
+"""Definition of vectors and points of a 2D workspace."""
+
+from __future__ import annotations
+
+# standard imports
+import dataclasses
+import math
+from types import NotImplementedType
+from typing import Iterator, Self, overload
+
+# local imports
+from .ros import Point, Vector3
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Coord2:
+    """2D coordinates.
+
+    This base class holds the coordinates and provides utility methods that
+    are common to both points and vectors such as distance computation and
+    approximate equality.
+    """
+
+    x: float = 0.0
+    """`x` coordinate."""
+    y: float = 0.0
+    """`y` coordinate."""
+
+    def __iter__(self) -> Iterator[float]:
+        """Iterate over the coordinates.
+
+        Allows unpacking.
+        """
+        yield self.x
+        yield self.y
+
+    def keys(self) -> Iterator[str]:
+        """Return the coordinate keys.
+
+        In conjunction to :meth:`__getitem__`, allows dictionary unpacking.
+        """
+        yield from self.__slots__
+
+    def __getitem__(self, key: str) -> float:
+        """Return the coordinate value for the given key.
+
+        In conjunction with :meth:`keys`, allows dictionary unpacking.
+
+        Raises:
+            KeyError: if the key is not a valid coordinate name.
+        """
+        return getattr(self, key)
+
+    def dist(self, other: Self, *, order: int | float = 2) -> float:
+        """Minkowski distance between two coordinates.
+
+        This method computes the `Minkowski distance <https://en.wikipedia.org/wiki/Minkowski_distance>`__
+        between two coordinates.
+
+        Arguments:
+            other: the other element.
+            order: a positive number, ``math.inf`` or ``-math.inf``
+                (default: 2).
+
+        Returns:
+            The Minkowski distance between the two coordinates.
+
+        Raises:
+            ValueError: if ``order`` is not a supported value.
+        """
+        dx = self.x - other.x
+        dy = self.y - other.y
+        match order:
+            case 2:
+                return math.hypot(dx, dy)
+            case math.inf:
+                return max(abs(dx), abs(dy))
+            case float(f) if f == -math.inf:
+                return min(abs(dx), abs(dy))
+            case float(f) | int(f) if f > 0.0:
+                return (abs(dx) ** order + abs(dy) ** order) ** (1.0 / order)
+            case _:
+                raise ValueError(f"unsupported {order=}")
+
+    def isclose_to(
+        self, other: Self, *, rel_tol: float = 1e-09, abs_tol: float = 0.0
+    ) -> bool:
+        """Approximate equality of two elements.
+
+        It uses :func:`math.isclose` to compare each coordinate; the elements
+        are considered equal if all coordinates are close.
+
+        Arguments:
+            other: the other element to compare with.
+            rel_tol: the relative tolerance for comparison.
+            abs_tol: the absolute tolerance for comparison.
+
+        Returns:
+            ``True`` if the elements are close, ``False`` otherwise.
+        """
+        return all(
+            math.isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol)
+            for a, b in zip(self, other)
+        )
+
+
+class Vector2(Coord2):
+    """2D vector with standard operations and utility methods."""
+
+    @classmethod
+    def from_vector3(cls, vector3: Vector3) -> Self:
+        """Create a 2D vector from a ROS 2 ``Vector3`` message.
+
+        The ``z`` component is ignored.
+        """
+        return cls(vector3.x, vector3.y)
+
+    def to_vector3(self) -> Vector3:
+        """Convert this 2D vector to a ROS 2 ``Vector3`` message.
+
+        The ``z`` component is set to ``0.0``.
+        """
+        return Vector3(**self, z=0.)
+
+    def __neg__(self) -> Self:
+        """Negate the vector."""
+        return type(self)(-self.x, -self.y)
+
+    @overload
+    def __add__(self, other: Vector2 | Iterator[float]) -> Self: ...
+    @overload
+    def __add__(self, other: int | float) -> Self: ...
+    @overload
+    def __add__(self, other: Point2) -> Point2: ...
+    @overload
+    def __add__(self, other: object) -> Self | Point2 | NotImplementedType: ...
+    def __add__(self, other: object) -> Self | Point2 | NotImplementedType:
+        """Add two vectors or point translation."""
+        match other:
+            case Vector2(x=ox, y=oy) | (float(ox), float(oy)):
+                return type(self)(self.x + ox, self.y + oy)
+            case Point2(x=ox, y=oy):
+                return type(other)(self.x + ox, self.y + oy)
+            case int() | float():
+                return type(self)(self.x + other, self.y + other)
+            case _:
+                return NotImplemented
+
+    __radd__ = __add__
+
+    @overload
+    def __sub__(self, other: Vector2 | Iterator[float]) -> Self: ...
+    @overload
+    def __sub__(self, other: int | float) -> Self: ...
+    @overload
+    def __sub__(self, other: object) -> Self | NotImplementedType: ...
+    def __sub__(self, other: object) -> Self | NotImplementedType:
+        """Subtract two vectors or shift."""
+        match other:
+            case Vector2(x=ox, y=oy) | (float(ox), float(oy)):
+                return type(self)(self.x - ox, self.y - oy)
+            case int() | float():
+                return type(self)(self.x - other, self.y - other)
+            case _:
+                return NotImplemented
+
+    @overload
+    def __mul__(self, other: int | float) -> Self: ...
+    @overload
+    def __mul__(self, other: object) -> Self | NotImplementedType: ...
+    def __mul__(self, other: object) -> Self | NotImplementedType:
+        """Multiply by a scalar."""
+        match other:
+            case int() | float():
+                return type(self)(self.x * other, self.y * other)
+            case _:
+                return NotImplemented
+
+    __rmul__ = __mul__
+
+    @overload
+    def __truediv__(self, other: int | float) -> Self: ...
+    @overload
+    def __truediv__(self, other: object) -> Self | NotImplementedType: ...
+    def __truediv__(self, other: object) -> Self | NotImplementedType:
+        """Divide by a scalar."""
+        match other:
+            case int() | float():
+                return type(self)(self.x / other, self.y / other)
+            case _:
+                return NotImplemented
+
+    def dot(self, other: Vector2) -> float:
+        """Compute dot product with another vector."""
+        return self.x * other.x + self.y * other.y
+
+    def cross(self, other: Vector2) -> float:
+        """Compute magnitude of the cross product with another vector."""
+        return self.x * other.y - self.y * other.x
+
+    def norm(self, *, order: int | float = 2) -> float:
+        """Compute vector norm.
+
+        It computes the `p-norm <https://en.wikipedia.org/wiki/Norm_(mathematics)#p-norm>`__
+        of the vector.
+
+        Arguments:
+            order: a positive number, ``math.inf`` or ``-math.inf`` (default: 2)
+
+        Returns:
+            The norm of the vector.
+
+        Raises:
+            ValueError: if ``order`` is not a supported value.
+        """
+        match order:
+            case 2:
+                return math.hypot(*self)
+            case math.inf:
+                return max(abs(self.x), abs(self.y))
+            case float(f) if f == -math.inf:
+                return min(abs(self.x), abs(self.y))
+            case float(f) | int(f) if f > 0.0:
+                x, y = self
+                return (abs(x) ** order + abs(y) ** order) ** (1.0 / order)
+            case _:
+                raise ValueError(f"unsupported {order=}")
+
+    @property
+    def orientation(self) -> float:
+        """Orientation of the vector.
+
+        Returns:
+            The orientation with respect to the `x` axis in radians.
+        """
+        return math.atan2(self.y, self.x)
+
+    def rotate(self, angle: float) -> Vector2:
+        """Compute the rotated vector.
+
+        Arguments:
+            angle: the rotation angle in radians.
+
+        Returns:
+            The rotated vector.
+        """
+        sa, ca = math.sin(angle), math.cos(angle)
+        x, y = self
+        return Vector2(x * ca - y * sa, x * sa + y * ca)
+
+
+class Point2(Coord2):
+    """2D point with standard operations and utility methods."""
+
+    @classmethod
+    def from_point_msg(cls, point: Point) -> Self:
+        """Create a 2D point from a ROS 2 ``Point`` message.
+
+        The ``z`` component is ignored.
+        """
+        return cls(point.x, point.y)
+
+    def to_point_msg(self) -> Point:
+        """Convert this 2D point to a ROS 2 ``Point`` message.
+
+        The ``z`` component is set to ``0.0``.
+        """
+        return Point(x=self.x, y=self.y, z=0.)
+
+    def __add__(self, other: Vector2 | object) -> Point2 | NotImplementedType:
+        """Translate by a vector."""
+        match other:
+            case Vector2(x=ox, y=oy):
+                return Point2(self.x + ox, self.y + oy)
+            case _:
+                return NotImplemented
+
+    @overload
+    def __sub__(self, other: Point2) -> Vector2: ...
+    @overload
+    def __sub__(self, other: Vector2) -> Point2: ...
+    @overload
+    def __sub__(self, other: object) -> Point2 | Vector2 | NotImplementedType:
+        ...
+    def __sub__(
+        self, other: Point2 | Vector2 | object
+    ) -> Point2 | Vector2 | NotImplementedType:
+        """Compute vector between two points."""
+        match other:
+            case Point2(x=ox, y=oy):
+                return Vector2(self.x - ox, self.y - oy)
+            case Vector2(x=ox, y=oy):
+                return Point2(self.x - ox, self.y - oy)
+            case _:
+                return NotImplemented

robotics_geometry-0.1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.3
+Name: robotics-geometry
+Version: 0.1.0
+Summary: Geometry library for robotics applications
+Author: Francis Colas
+Author-email: Francis Colas <francis.colas@inria.fr>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+Geometry library for mobile robotics applications.
+
+See the [documentation](https://colas.gitlabpages.inria.fr/robotics-geometry/index.html) for more information.

robotics_geometry-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+robotics_geometry/.mypy_cache/.gitignore,sha256=amnaZw0RUw038PDP3HvtMLeOpkNOJPenMgi5guKdMiw,34
+robotics_geometry/.mypy_cache/3.11/cache.0.db,sha256=uUMUfCwsj46mQNfiGAKTTlLh4vBCCWfjZRCIJccYU3c,106496
+robotics_geometry/.mypy_cache/3.11/cache.1.db,sha256=WEYmbMUFLeK0CiVDxyftRtvSjpKBKDbtO0WjdtgFm_w,167936
+robotics_geometry/.mypy_cache/3.11/cache.10.db,sha256=IwbyKIwop0668-7ApQk45tittDBMmE5VwQ-6mPzEwuU,155648
+robotics_geometry/.mypy_cache/3.11/cache.11.db,sha256=iWJ-j1Eijhu7SBof5VrXmbf8BiieeC1ThnkNh0wsHUI,81920
+robotics_geometry/.mypy_cache/3.11/cache.12.db,sha256=3RkljoNaelvlN-NhRTYjHJVDn_8tdE4TT-BYH20crB0,40960
+robotics_geometry/.mypy_cache/3.11/cache.13.db,sha256=8QO19GEf_JFyAavIUNgAdLT7OCEKSwmkQPajlbiQQ0I,208896
+robotics_geometry/.mypy_cache/3.11/cache.14.db,sha256=0bjb3Ya5iQvC-ua95Yczi03fxcf8_abFuoPj6kooQuM,65536
+robotics_geometry/.mypy_cache/3.11/cache.15.db,sha256=cEd5rglLeXpCzsXocyypTYbHGOxxnWho-HjfafHiqQc,200704
+robotics_geometry/.mypy_cache/3.11/cache.2.db,sha256=_2Clv1SmsL6AkCv8ZEbqMO56vfWs-9Q-qadZs_PXYgQ,73728
+robotics_geometry/.mypy_cache/3.11/cache.3.db,sha256=qqoSPNMkq78CXg9TJd4FCDWz02H7Hd_ZGrduAnEN7pY,36864
+robotics_geometry/.mypy_cache/3.11/cache.4.db,sha256=0q596s1HpwX43JhSXhR24R-CjwnCRNgWkijOufNlBXU,204800
+robotics_geometry/.mypy_cache/3.11/cache.5.db,sha256=nBHXTFaqIDOIwaf8iU02d5L9rZwmnxL0fCanerefb38,94208
+robotics_geometry/.mypy_cache/3.11/cache.6.db,sha256=0VcFquFaxkJfATQzfxUyjuE82nWt6QNrNqIvRIj-69A,73728
+robotics_geometry/.mypy_cache/3.11/cache.7.db,sha256=M0yYuHIbSKRO8EfOUzcnRS7J3WIUyp0903EMWMz78mY,24576
+robotics_geometry/.mypy_cache/3.11/cache.8.db,sha256=1ZkMUczd965OpYZKjc8Z7wziWi_UsKUMshjVrGDQ4Vg,118784
+robotics_geometry/.mypy_cache/3.11/cache.9.db,sha256=LmO_2Qx4MzJ_XBDNt2foPxArFjHRdwi9t2JdeQx7-8g,786432
+robotics_geometry/.mypy_cache/CACHEDIR.TAG,sha256=8cE6_FVTWMkDOw8fMKqhd_6IvaQPS4okWYQA1UeHatw,190
+robotics_geometry/__init__.py,sha256=9yzxoDSltMZkEjrmmWpFlg7mAp-jWxecPLXeHkG_D0M,57
+robotics_geometry/functions.py,sha256=QrYPHBUidYBrxE-ZETGN9A9jlYXhMskyS_O3nvZ9w2s,1077
+robotics_geometry/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+robotics_geometry/rigid_body2.py,sha256=V4prdbSwpR5aBBGSmrFr_F0pIIoDR0zJE2jbcNdY8CQ,11022
+robotics_geometry/ros/__init__.py,sha256=1BZAx5fpe5v3eBYVrQHk_OrP2ZhbKwqgUjQVqcBFV1s,393
+robotics_geometry/ros/msgs_mockup.py,sha256=yOCZlwSNS7yYMWeIOKVS6L3JNMYv6Qv8X2ZvjKdxBnM,2157
+robotics_geometry/workspace2.py,sha256=E--FDMh-YUmMVnJlJrFa_DU_2c7a3k2PVoYf0qQ7Y7s,9512
+robotics_geometry-0.1.0.dist-info/WHEEL,sha256=5XVLiN68MV2VpIWvmvgvvELLyDEnIzAqfKmdusfYfHI,80
+robotics_geometry-0.1.0.dist-info/METADATA,sha256=cSBpa48Ob8HYKrei32KJ5wJKkxDVQaIhd7TMr2ir9uY,416
+robotics_geometry-0.1.0.dist-info/RECORD,,

robotics_geometry-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.10.3
+Root-Is-Purelib: true
+Tag: py3-none-any