reachy-mini 1.0.0rc1__py3-none-any.whl

reachy_mini/utils/__init__.py

@@ -0,0 +1,46 @@
+"""Utility functions for Reachy Mini.
+
+These functions provide various utilities such as creating head poses, performing minimum jerk interpolation,
+checking if the Reachy Mini daemon is running, and performing linear pose interpolation.
+
+"""
+
+import numpy as np
+import numpy.typing as npt
+from scipy.spatial.transform import Rotation as R
+
+
+def create_head_pose(
+    x: float = 0,
+    y: float = 0,
+    z: float = 0,
+    roll: float = 0,
+    pitch: float = 0,
+    yaw: float = 0,
+    mm: bool = False,
+    degrees: bool = True,
+) -> npt.NDArray[np.float64]:
+    """Create a homogeneous transformation matrix representing a pose in 6D space (position and orientation).
+
+    Args:
+        x (float): X coordinate of the position.
+        y (float): Y coordinate of the position.
+        z (float): Z coordinate of the position.
+        roll (float): Roll angle
+        pitch (float): Pitch angle
+        yaw (float): Yaw angle
+        mm (bool): If True, convert position from millimeters to meters.
+        degrees (bool): If True, interpret roll, pitch, and yaw as degrees; otherwise as radians.
+
+    Returns:
+        np.ndarray: A 4x4 homogeneous transformation matrix representing the pose.
+
+    """
+    pose = np.eye(4)
+    rot = R.from_euler("xyz", [roll, pitch, yaw], degrees=degrees).as_matrix()
+    pose[:3, :3] = rot
+    pose[:, 3] = [x, y, z, 1]
+    if mm:
+        pose[:3, 3] /= 1000
+
+    return pose

reachy_mini/utils/constants.py

@@ -0,0 +1,9 @@
+"""Utility constants for the reachy_mini package."""
+
+from importlib.resources import files
+
+import reachy_mini
+
+URDF_ROOT_PATH: str = str(files(reachy_mini).joinpath("descriptions/reachy_mini/urdf"))
+ASSETS_ROOT_PATH: str = str(files(reachy_mini).joinpath("assets/"))
+MODELS_ROOT_PATH: str = str(files(reachy_mini).joinpath("assets/models"))

reachy_mini/utils/interpolation.py

@@ -0,0 +1,227 @@
+"""Interpolation utilities for Reachy Mini."""
+
+from enum import Enum
+from typing import Callable, Optional, Tuple
+
+import numpy as np
+import numpy.typing as npt
+from scipy.spatial.transform import Rotation as R
+
+InterpolationFunc = Callable[[float], npt.NDArray[np.float64]]
+
+
+def minimum_jerk(
+    starting_position: npt.NDArray[np.float64],
+    goal_position: npt.NDArray[np.float64],
+    duration: float,
+    starting_velocity: Optional[npt.NDArray[np.float64]] = None,
+    starting_acceleration: Optional[npt.NDArray[np.float64]] = None,
+    final_velocity: Optional[npt.NDArray[np.float64]] = None,
+    final_acceleration: Optional[npt.NDArray[np.float64]] = None,
+) -> InterpolationFunc:
+    """Compute the mimimum jerk interpolation function from starting position to goal position."""
+    if starting_velocity is None:
+        starting_velocity = np.zeros(starting_position.shape)
+    if starting_acceleration is None:
+        starting_acceleration = np.zeros(starting_position.shape)
+    if final_velocity is None:
+        final_velocity = np.zeros(goal_position.shape)
+    if final_acceleration is None:
+        final_acceleration = np.zeros(goal_position.shape)
+
+    a0 = starting_position
+    a1 = starting_velocity
+    a2 = starting_acceleration / 2
+
+    d1, d2, d3, d4, d5 = [duration**i for i in range(1, 6)]
+
+    A = np.array(((d3, d4, d5), (3 * d2, 4 * d3, 5 * d4), (6 * d1, 12 * d2, 20 * d3)))
+    B = np.array(
+        (
+            goal_position - a0 - (a1 * d1) - (a2 * d2),
+            final_velocity - a1 - (2 * a2 * d1),
+            final_acceleration - (2 * a2),
+        )
+    )
+    X = np.linalg.solve(A, B)
+
+    coeffs = [a0, a1, a2, X[0], X[1], X[2]]
+
+    def f(t: float) -> npt.NDArray[np.float64]:
+        if t > duration:
+            return goal_position
+        return np.sum([c * t**i for i, c in enumerate(coeffs)], axis=0)  # type: ignore[no-any-return]
+
+    return f
+
+
+def linear_pose_interpolation(
+    start_pose: npt.NDArray[np.float64], target_pose: npt.NDArray[np.float64], t: float
+) -> npt.NDArray[np.float64]:
+    """Linearly interpolate between two poses in 6D space."""
+    # Extract rotations
+    rot_start = R.from_matrix(start_pose[:3, :3])
+    rot_end = R.from_matrix(target_pose[:3, :3])
+
+    # Compute relative rotation q_rel such that rot_start * q_rel = rot_end
+    q_rel = rot_start.inv() * rot_end
+    # Convert to rotation vector (axis-angle)
+    rotvec_rel = q_rel.as_rotvec()
+    # Scale the rotation vector by t (allows t<0 or >1 for overshoot)
+    rot_interp = (rot_start * R.from_rotvec(rotvec_rel * t)).as_matrix()
+
+    # Extract translations
+    pos_start = start_pose[:3, 3]
+    pos_end = target_pose[:3, 3]
+    # Linear interpolation/extrapolation on translation
+    pos_interp = pos_start + (pos_end - pos_start) * t
+
+    # Compose homogeneous transformation
+    interp_pose = np.eye(4)
+    interp_pose[:3, :3] = rot_interp
+    interp_pose[:3, 3] = pos_interp
+
+    return interp_pose
+
+
+class InterpolationTechnique(str, Enum):
+    """Enumeration of interpolation techniques."""
+
+    LINEAR = "linear"
+    MIN_JERK = "minjerk"
+    EASE_IN_OUT = "ease_in_out"
+    CARTOON = "cartoon"
+
+
+def time_trajectory(
+    t: float, method: InterpolationTechnique = InterpolationTechnique.MIN_JERK
+) -> float:
+    """Compute the time trajectory value based on the specified interpolation method."""
+    if t < 0 or t > 1:
+        raise ValueError("time value is out of range [0,1]")
+
+    if method == InterpolationTechnique.LINEAR:
+        return t
+
+    elif method == InterpolationTechnique.MIN_JERK:
+        return 10 * t**3 - 15 * t**4 + 6 * t**5
+
+    elif method == InterpolationTechnique.EASE_IN_OUT:
+        if t < 0.5:
+            return 2 * t * t
+        else:
+            return 1 - ((-2 * t + 2) ** 2) / 2
+
+    elif method == InterpolationTechnique.CARTOON:
+        c1 = 1.70158
+        c2 = c1 * 1.525
+
+        if t < 0.5:
+            # phase in
+            return ((2 * t) ** 2 * ((c2 + 1) * 2 * t - c2)) / 2
+        else:
+            # phase out
+            return (((2 * t - 2) ** 2 * ((c2 + 1) * (2 * t - 2) + c2)) + 2) / 2
+
+    else:
+        raise ValueError(
+            "Unknown interpolation method: {} (possible values: {})".format(
+                method,
+                list(InterpolationTechnique),
+            )
+        )
+
+
+def delta_angle_between_mat_rot(
+    P: npt.NDArray[np.float64], Q: npt.NDArray[np.float64]
+) -> float:
+    """Compute the angle (in radians) between two 3x3 rotation matrices `P` and `Q`.
+
+    This is equivalent to the angular distance in axis-angle space.
+    It is computed via the trace of the relative rotation matrix.
+
+    References:
+        - https://math.stackexchange.com/questions/2113634/comparing-two-rotation-matrices
+        - http://www.boris-belousov.net/2016/12/01/quat-dist/
+
+    Args:
+        P: A 3x3 rotation matrix.
+        Q: Another 3x3 rotation matrix.
+
+    Returns:
+        The angle in radians between the two rotations.
+
+    """
+    R = np.dot(P, Q.T)
+    tr = (np.trace(R) - 1) / 2
+    tr = np.clip(tr, -1.0, 1.0)  # Ensure numerical stability
+    return float(np.arccos(tr))
+
+
+def distance_between_poses(
+    pose1: npt.NDArray[np.float64], pose2: npt.NDArray[np.float64]
+) -> Tuple[float, float, float]:
+    """Compute three types of distance between two 4x4 homogeneous transformation matrices.
+
+    The result combines translation (in mm) and rotation (in degrees) using an arbitrary but
+    emotionally satisfying equivalence: 1 degree ≈ 1 mm.
+
+    Args:
+        pose1: A 4x4 homogeneous transformation matrix representing the first pose.
+        pose2: A 4x4 homogeneous transformation matrix representing the second pose.
+
+    Returns:
+        A tuple of:
+        - translation distance in meters,
+        - angular distance in radians,
+        - unhinged distance in magic-mm (translation in mm + rotation in degrees).
+
+    """
+    distance_translation = float(np.linalg.norm(pose1[:3, 3] - pose2[:3, 3]))
+    distance_angle = delta_angle_between_mat_rot(pose1[:3, :3], pose2[:3, :3])
+    unhinged_distance = distance_translation * 1000 + np.rad2deg(distance_angle)
+
+    return distance_translation, distance_angle, unhinged_distance
+
+
+def compose_world_offset(
+    T_abs: npt.NDArray[np.float64],
+    T_off_world: npt.NDArray[np.float64],
+    reorthonormalize: bool = False,
+) -> npt.NDArray[np.float64]:
+    """Compose an absolute world-frame pose with a world-frame offset.
+
+      - translations add in world:       t_final = t_abs + t_off
+      - rotations compose in world:      R_final = R_off @ R_abs
+    This rotates the frame in place (about its own origin) by a rotation
+    defined in world axes, and shifts it by a world translation.
+
+    Parameters
+    ----------
+    T_abs : (4,4) ndarray
+        Absolute pose in world frame.
+    T_off_world : (4,4) ndarray
+        Offset transform specified in world axes (dx,dy,dz in world; dR about world axes).
+    reorthonormalize : bool
+        If True, SVD-orthonormalize the resulting rotation to fight drift.
+
+    Returns
+    -------
+    T_final : (4,4) ndarray
+        Resulting pose in world frame.
+
+    """
+    R_abs, t_abs = T_abs[:3, :3], T_abs[:3, 3]
+    R_off, t_off = T_off_world[:3, :3], T_off_world[:3, 3]
+
+    R_final = R_off @ R_abs
+    if reorthonormalize:
+        U, _, Vt = np.linalg.svd(R_final)
+        R_final = U @ Vt
+
+    t_final = t_abs + t_off
+
+    T_final = np.eye(4)
+    T_final[:3, :3] = R_final
+    T_final[:3, 3] = t_final
+    return T_final

reachy_mini/utils/parse_urdf_for_kinematics.py

@@ -0,0 +1,85 @@
+"""Generate kinematics data from URDF using Placo as preprocessing.
+
+The analytical kinematics need information from the URDF. This files computes the information and writes it in a .json file.
+"""
+
+import json
+from importlib.resources import files
+from typing import Any, Dict
+
+import numpy as np  # noqa: D100
+from placo_utils.tf import tf
+
+import reachy_mini
+from reachy_mini.kinematics.placo_kinematics import PlacoKinematics
+
+
+def get_data() -> Dict[str, Any]:
+    """Generate the urdf_kinematics.json file."""
+    urdf_root_path: str = str(
+        files(reachy_mini).joinpath("descriptions/reachy_mini/urdf")
+    )
+
+    placo_kinematics = PlacoKinematics(urdf_root_path, 0.02)
+    robot = placo_kinematics.robot
+
+    placo_kinematics.fk(np.array([0.0] * 7), no_iterations=20)
+    robot.update_kinematics()
+
+    # Measuring lengths for the arm and branch (constants could be used)
+    T_world_head_home = robot.get_T_world_frame("head").copy()
+    T_world_1 = robot.get_T_world_frame("stewart_1")
+    T_world_arm1 = robot.get_T_world_frame("passive_1_link_x")
+    T_1_arm1 = np.linalg.inv(T_world_1) @ T_world_arm1
+    arm_z = T_1_arm1[2, 3]
+    motor_arm_length = np.linalg.norm(T_1_arm1[:2, 3])
+
+    T_world_branch1 = robot.get_T_world_frame("closing_1_2")
+    T_arm1_branch1 = np.linalg.inv(T_world_arm1) @ T_world_branch1
+    rod_length = np.linalg.norm(T_arm1_branch1[:3, 3])
+
+    motors = [
+        {"name": "stewart_1", "branch_frame": "closing_1_2", "offset": 0, "solution": 0},
+        {"name": "stewart_2", "branch_frame": "closing_2_2", "offset": 0, "solution": 1},
+        {"name": "stewart_3", "branch_frame": "closing_3_2", "offset": 0, "solution": 0},
+        {"name": "stewart_4", "branch_frame": "closing_4_2", "offset": 0, "solution": 1},
+        {"name": "stewart_5", "branch_frame": "closing_5_2", "offset": 0, "solution": 0},
+        {
+            "name": "stewart_6",
+            "branch_frame": "passive_7_link_y",
+            "offset": 0,
+            "solution": 1,
+        },
+    ]
+
+    for motor in motors:
+        T_world_branch = robot.get_T_world_frame(motor["branch_frame"])
+        T_head_branch = np.linalg.inv(T_world_head_home) @ T_world_branch
+        T_world_motor = robot.get_T_world_frame(motor["name"]) @ tf.translation_matrix(
+            (0, 0, arm_z)
+        )
+        motor["T_motor_world"] = np.linalg.inv(T_world_motor).tolist()
+        motor["branch_position"] = T_head_branch[:3, 3].tolist()
+        motor["limits"] = robot.get_joint_limits(motor["name"]).tolist()
+
+    data = {
+        "motor_arm_length": motor_arm_length,
+        "rod_length": rod_length,
+        "head_z_offset": placo_kinematics.head_z_offset,
+        "motors": motors,
+    }
+
+    return data
+
+
+def main() -> None:
+    """Generate the urdf_kinematics.json file."""
+    assets_root_path: str = str(files(reachy_mini).joinpath("assets/"))
+    data = get_data()
+    print(assets_root_path + "/" + "kinematics_data.json")
+    with open(assets_root_path + "/" + "kinematics_data.json", "w") as f:
+        json.dump(data, f, indent=4)
+
+
+if __name__ == "__main__":
+    main()

reachy_mini-1.0.0rc1.dist-info/METADATA

@@ -0,0 +1,261 @@
+Metadata-Version: 2.4
+Name: reachy_mini
+Version: 1.0.0rc1
+Author-email: Pollen Robotics <contact@pollen-robotics.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.3.0,>=2.2.5
+Requires-Dist: scipy==1.15.3
+Requires-Dist: reachy_mini_motor_controller>=1.0.0
+Requires-Dist: eclipse-zenoh>=1.4.0
+Requires-Dist: opencv-python<=5.0
+Requires-Dist: cv2_enumerate_cameras>=1.2.1
+Requires-Dist: psutil
+Requires-Dist: jinja2
+Requires-Dist: uvicorn[standard]
+Requires-Dist: fastapi
+Requires-Dist: pyserial
+Requires-Dist: huggingface-hub==0.34.4
+Requires-Dist: sounddevice==0.5.1
+Requires-Dist: soundfile==0.13.1
+Requires-Dist: reachy-mini-rust-kinematics>=1.0.1
+Requires-Dist: asgiref
+Requires-Dist: aiohttp
+Requires-Dist: log-throttling==0.0.3
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: ruff==0.12.0; extra == "dev"
+Requires-Dist: onshape-to-robot==1.7.6; extra == "dev"
+Requires-Dist: mujoco==3.3.0; extra == "dev"
+Requires-Dist: placo==0.9.14; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: mypy==1.18.2; extra == "dev"
+Requires-Dist: rustypot>=1.3.0; extra == "dev"
+Provides-Extra: examples
+Requires-Dist: pynput; extra == "examples"
+Provides-Extra: mujoco
+Requires-Dist: mujoco==3.3.0; extra == "mujoco"
+Provides-Extra: nn-kinematics
+Requires-Dist: onnxruntime==1.22.1; extra == "nn-kinematics"
+Provides-Extra: placo-kinematics
+Requires-Dist: placo==0.9.14; extra == "placo-kinematics"
+Provides-Extra: gstreamer
+Requires-Dist: PyGObject<=3.46.0,>=3.42.2; extra == "gstreamer"
+Dynamic: license-file
+
+# Reachy Mini
+
+> ⚠️ Reachy Mini is still in beta. Expect bugs, some of them we won't fix right away if they are not a priority.
+
+[Reachy Mini](https://www.pollen-robotics.com/reachy-mini/) is an expressive, open-source robot designed for human-robot interaction, creative coding, and AI experimentation. We made it to be affordable, easy to use, hackable and cute, so that you can focus on building cool AI applications!
+
+[![Reachy Mini Hello](/docs/assets/reachy_mini_hello.gif)](https://www.pollen-robotics.com/reachy-mini/)
+
+### Versions Lite & Wireless
+
+Reachy Mini's hardware comes in two flavors:
+- **Reachy Mini lite**: where the robot is directly connected to your computer via USB. And the code that controls the robot (the daemon) runs on your computer.
+- **Reachy Mini wireless**: where an Raspberry Pi is embedded in the robot, and the code that controls the robot (the daemon) runs on the Raspberry Pi. You can connect to it via Wi-Fi from your computer. (TODO: add link to section on how to set it up)
+
+There is also a simulated version of Reachy Mini in [MuJoCo](https://mujoco.org) that you can use to prototype your applications before deploying them on the real robot. It behaves like the lite version where the daemon runs on your computer.
+
+## Software overview
+
+This repository provides everything you need to control Reachy Mini, both in simulation and on the real robot. It consists of two main parts:
+
+- **The 😈 Daemon 😈**: A background service that manages communication with the robot's motors and sensors, or with the simulation environment. It should be running before you can control the robot. It can run either for the simulation (MuJoCo) or for the real robot. 
+- **🐍 SDK & 🕸️ API** to control the robot's main features (head, antennas, camera, speakers, microphone, etc.) and connect with your AI experimentation. Depending on your preferences and needs, there is a [Python SDK](#using-the-python-sdk) and a [HTTP REST API](#using-the-rest-api).
+
+Using the [Python SDK](#using-the-python-sdk), making your robot move only require a few lines of code, as illustrated in the example below:
+
+```python
+from reachy_mini import ReachyMini
+from reachy_mini.utils import create_head_pose
+
+with ReachyMini() as reachy_mini:
+    # Move the head up (10mm on z-axis) and roll it 15 degrees
+    pose = create_head_pose(z=10, roll=15, degrees=True, mm=True)
+    reachy_mini.goto_target(head=pose, duration=2.0)
+
+    # Reset to default pose
+    pose = create_head_pose() 
+    reachy_mini.goto_target(head=pose, duration=2.0)
+```
+
+and using the [REST API](#using-the-rest-api), reading the current state of the robot:
+
+```bash
+curl 'http://localhost:8000/api/state/full'
+```
+
+Those two examples above assume that the daemon is already running (either in simulation or on the real robot) locally.
+
+## Installation of the daemon and Python SDK
+
+As mentioned above, before being able to use the robot, you need to run the daemon that will handle the communication with the motors.
+
+We support and test on Linux and macOS. It's also working on Windows, but it is less tested at the moment. Do not hesitate to open an issue if you encounter any problem. 
+
+The daemon is built in Python, so you need to have Python installed on your computer (versions from 3.10 to 3.13 are supported). We recommend using a virtual environment to avoid dependency conflicts with your other Python projects.
+
+You can install Reachy Mini from the source code or from PyPI.
+
+From PyPI, you can install the package with:
+
+```bash
+pip install reachy-mini
+```
+
+From the source code, you can install the package with:
+
+```bash
+git clone https://github.com/pollen-robotics/reachy_mini
+pip install -e ./reachy_mini
+```
+
+The same package provides both the daemon and the Python SDK.
+
+## Run the reachy mini daemon
+
+Before being able to use the robot, you need to run the daemon that will handle the communication with the motors. This daemon can run either in simulation (MuJoCo) or on the real robot.
+
+```bash
+reachy-mini-daemon
+```
+
+or run it via the Python module:
+
+```bash
+python -m reachy_mini.daemon.app.main
+```
+
+Additional argument for both simulation and real robot:
+
+```bash
+--localhost-only: (default behavior). The server will only accept connections from localhost.
+```
+
+or
+
+```bash
+--no-localhost-only: If set, the server will accept connections from any connection on the local network.
+```
+
+### In simulation ([MuJoCo](https://mujoco.org))
+
+You first have to install the optional dependency `mujoco`.
+
+```bash
+pip install reachy-mini[mujoco]
+```
+
+Then run the daemon with the `--sim` argument.
+
+```bash
+reachy-mini-daemon --sim
+```
+
+Additional arguments:
+
+```bash
+--scene <empty|minimal> : (Default empty). Choose between a basic empty scene, or a scene with a table and some objects.
+```
+
+<img src="https://www.pollen-robotics.com/wp-content/uploads/2025/06/Reachy_mini_simulation.gif" width="250" alt="Reachy Mini in MuJoCo">
+
+
+*Note: On OSX in order to run mujoco, you need to use mjpython (see [here](https://mujoco.readthedocs.io/en/stable/python.html#passive-viewer)). So, you should run the daemon with:*
+
+```bash
+ mjpython -m reachy_mini.daemon.app.main --sim
+ ```
+
+### For the lite version (connected via USB)
+
+It should automatically detect the serial port of the robot. If it does not, you can specify it manually with the `-p` option:
+
+```bash
+reachy-mini-daemon -p <serial_port>
+```
+
+### Usage
+
+For more information about the daemon and its options, you can run:
+
+```bash
+reachy-mini-daemon --help
+```
+
+## Run the demo
+
+Conversational demo for the Reachy Mini robot combining LLM realtime APIs, vision pipelines, and choreographed motion libraries: [reachy_mini_conversation_demo](https://github.com/pollen-robotics/reachy_mini_conversation_demo).
+
+## Using the Python SDK
+
+The API is designed to be simple and intuitive. You can control the robot's features such as the head, antennas, camera, speakers, and microphone. For instance, to move the head of the robot, you can use the `goto_target` method as shown in the example below:
+
+```python
+from reachy_mini import ReachyMini
+from reachy_mini.utils import create_head_pose
+
+with ReachyMini() as reachy_mini:
+    # Move the head up (10mm on z-axis) and roll it 15 degrees
+    pose = create_head_pose(z=10, roll=15, degrees=True, mm=True)
+    reachy_mini.goto_target(head=pose, duration=2.0)
+
+    # Reset to default pose
+    pose = create_head_pose() 
+    reachy_mini.goto_target(head=pose, duration=2.0)
+```
+
+For a full description of the SDK, please refer to the [Python SDK documentation](./docs/python-sdk.md).
+
+## Using the REST API
+
+The daemon also provides a REST API via [fastapi](https://fastapi.tiangolo.com/) that you can use to control the robot and get its state. The API is accessible via HTTP and WebSocket.
+
+By default, the API server runs on `http://localhost:8000`. The API is documented using OpenAPI, and you can access the documentation at `http://localhost:8000/docs` when the daemon is running.
+
+More information about the API can be found in the [HTTP API documentation](./docs/rest-api.md).
+
+## Open source & contribution
+
+This project is actively developed and maintained by the [Pollen Robotics team](https://www.pollen-robotics.com) and the [Hugging Face team](https://huggingface.co/). 
+
+We welcome contributions from the community! If you want to report a bug or request a feature, please open an issue on GitHub. If you want to contribute code, please fork the repository and submit a pull request.
+
+### 3D models
+
+TODO
+
+### Contributing
+
+Development tools are available in the optional dependencies.
+
+```bash
+pip install -e .[dev]
+pre-commit install
+```
+
+Your files will be checked before any commit. Checks may also be manually run with
+
+```bash
+pre-commit run --all-files
+```
+
+Checks are performed by Ruff. You may want to [configure your IDE to support it](https://docs.astral.sh/ruff/editors/setup/).
+
+## License
+
+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+
+The robot design files are licensed under the [TODO](TODO) license.
+
+### Simulation model used
+
+- https://polyhaven.com/a/food_apple_01
+- https://polyhaven.com/a/croissant
+- https://polyhaven.com/a/wooden_table_02
+- https://polyhaven.com/a/rubber_duck_toy