cbfpy 0.0.1__py3-none-any.whl

cbfpy/examples/point_robot_obstacle_demo.py

@@ -0,0 +1,118 @@
+"""
+# Point Robot Obstacle Avoidance Demo
+
+Example of using a CBF + PD controller to control a point robot to reach the origin,
+while avoiding a moving obstacle and staying in a safe set.
+
+This demo is interactive: click and drag the obstacle to move it around.
+
+Here, we have double integrator dynamics: z = [position, velocity], u = [acceleration]
+and we also use the state of the obstacle as an input to the CBF: z_obs = [position, velocity]
+
+This example includes both relative-degree-1 and relative-degree-2 CBFs. Staying inside the safe-set box is 
+RD2, since we have a positional barrier with acceleration inputs. Avoiding the obstacle is relative-degree-1, 
+because this is based on the relative velocity between the two objects.
+"""
+
+import time
+import jax
+from jax import Array
+import jax.numpy as jnp
+from jax.typing import ArrayLike
+
+from cbfpy import CBF, CBFConfig
+from cbfpy.envs.point_robot_envs import PointRobotObstacleEnv
+
+
+class PointRobotObstacleConfig(CBFConfig):
+    """Configuration for the 3D 'point-robot-avoiding-an-obstacle' example."""
+
+    def __init__(self):
+        self.mass = 1.0
+        self.robot_radius = 0.25
+        self.obstacle_radius = 0.25
+        init_z_obs = jnp.array([3.0, 1.0, 1.0, -0.1, -0.1, -0.1])
+        super().__init__(
+            n=6,  # State = [position, velocity]
+            m=3,  # Control = [force]
+            init_args=(init_z_obs,),
+        )
+
+    def f(self, z):
+        A = jnp.block(
+            [[jnp.zeros((3, 3)), jnp.eye(3)], [jnp.zeros((3, 3)), jnp.zeros((3, 3))]]
+        )
+        return A @ z
+
+    def g(self, z):
+        B = jnp.block([[jnp.zeros((3, 3))], [jnp.eye(3) / self.mass]])
+        return B
+
+    def h_1(self, z, z_obs):
+        # Distance between >= obstacle radius + robot radius + deceleration distance
+        pos_robot = z[:3]
+        vel_robot = z[3:]
+        pos_obs = z_obs[:3]
+        vel_obs = z_obs[3:]
+        dist_between_centers = jnp.linalg.norm(pos_obs - pos_robot)
+        dir_obs_to_robot = (pos_robot - pos_obs) / dist_between_centers
+        collision_velocity_component = (vel_obs - vel_robot).T @ dir_obs_to_robot
+        lookahead_time = 2.0
+        padding = 0.1
+        return jnp.array(
+            [
+                dist_between_centers
+                - collision_velocity_component * lookahead_time
+                - self.obstacle_radius
+                - self.robot_radius
+                - padding
+            ]
+        )
+
+    def h_2(self, z, z_obs):
+        # Stay inside the safe set (a box)
+        pos_max = jnp.array([1.0, 1.0, 1.0])
+        pos_min = jnp.array([-1.0, -1.0, -1.0])
+        return jnp.concatenate([pos_max - z[:3], z[:3] - pos_min])
+
+    def alpha(self, h):
+        return 3 * h
+
+
+@jax.jit
+def nominal_controller(z: ArrayLike, z_des: ArrayLike) -> Array:
+    """A simple PD controller for the point robot.
+
+    This is unsafe without the CBF, as there is no guarantee that the robot wil not collide with the obstacle
+
+    Args:
+        z (ArrayLike): The current state of the robot [x, y, z, vx, vy, vz]
+        z_des (ArrayLike): The desired state of the robot [x_des, y_des, z_des, vx_des, vy_des, vz_des]
+    """
+    Kp = 1.0
+    Kd = 1.0
+    u = -Kp * (z[:3] - z_des[:3]) - Kd * (z[3:] - z_des[3:])
+    return u
+
+
+def main():
+    config = PointRobotObstacleConfig()
+    cbf = CBF.from_config(config)
+    env = PointRobotObstacleEnv()
+
+    @jax.jit
+    def safe_controller(z, z_des, z_obs):
+        u = nominal_controller(z, z_des)
+        return cbf.safety_filter(z, u, z_obs)
+
+    while True:
+        z, z_obs = env.get_state()
+        z_des = env.get_desired_state()
+        u = safe_controller(z, z_des, z_obs)
+        env.apply_control(u)
+        env.step()
+        time.sleep(1 / 300)
+
+
+if __name__ == "__main__":
+    main()

cbfpy/temp/test_import.py

@@ -0,0 +1,3 @@
+import cbfpy
+
+cbfpy.CBF()

cbfpy/utils/general_utils.py

@@ -0,0 +1,131 @@
+"""Assorted utility functions"""
+
+import os
+import sys
+import warnings
+from enum import Enum
+from contextlib import contextmanager
+
+
+class ANSITextStyles(Enum):
+    """A non-exhaustive list of ANSI text styles for use in terminal output."""
+
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    ORANGE = "\033[38;5;214m"  # 256-color mode
+    YELLOW = "\033[33m"
+    GREEN = "\033[32m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+    COLOR_DEFAULT = "\033[39m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+    INVISIBLE = "\033[08m"
+    BG_BLACK = "\033[40m"
+    BG_RED = "\033[41m"
+    BG_ORANGE = "\033[48;5;214m"  # 256-color mode
+    BG_YELLOW = "\033[43m"
+    BG_GREEN = "\033[42m"
+    BG_BLUE = "\033[44m"
+    BG_MAGENTA = "\033[45m"
+    BG_CYAN = "\033[46m"
+    BG_WHITE = "\033[47m"
+    BG_DEFAULT = "\033[49m"
+    RESET = "\033[0m"
+
+
+def print_warning(msg: str) -> None:
+    """Print a warning message with ANSI color formatting."""
+    warnings.warn(
+        f"{ANSITextStyles.YELLOW.value}{msg}{ANSITextStyles.RESET.value}", stacklevel=2
+    )
+
+
+# NOTE: This might be overkill if we always assume that this script is in the utils/ folder. But, it seems to work
+def find_toplevel_dir():
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    while current_dir != os.path.dirname(
+        current_dir
+    ):  # Check if we've reached the root
+        if "setup.py" in os.listdir(current_dir) or ".git" in os.listdir(current_dir):
+            # Found the top-level package directory
+            return current_dir
+        current_dir = os.path.dirname(current_dir)
+    # Top-level directory not found, handle appropriately
+    raise RuntimeError("Top-level directory not found")
+
+
+def find_assets_dir():
+    assets_dir = os.path.join(find_toplevel_dir(), "cbfpy/assets/")
+    if not os.path.exists(assets_dir):
+        raise RuntimeError("Assets directory not found")
+    return assets_dir
+
+
+# The motivation for this is Pybullet prints a ton of logging info when it launches, but I don't necessarily want this
+# printed out. See the following stack overflow thread for the source:
+# https://stackoverflow.com/questions/5081657/how-do-i-prevent-a-c-shared-library-to-print-on-stdout-in-python/17954769#17954769
+@contextmanager
+def stdout_redirected(to: str = os.devnull, restore: bool = True):
+    """Temporarily redirects `sys.stdout` to the specified file
+
+    This context manager is useful for silencing output or redirecting it to a
+    file or other writable stream during the execution of a code block.
+
+    Example:
+        ```
+        import os
+        with stdout_redirected(to=filename):
+            print("from Python")
+            os.system("echo non-Python applications are also supported")
+        ```
+
+    Args:
+        to (str): The target file where stdout should be redirected.
+            Defaults to `os.devnull` (silencing output).
+        restore (bool): Whether to restores stdout to its original state after
+            the context manager exits. Defaults to True.
+    """
+    fd = sys.stdout.fileno()
+
+    ##### assert that Python and C stdio write using the same file descriptor
+    ####assert libc.fileno(ctypes.c_void_p.in_dll(libc, "stdout")) == fd == 1
+
+    def _redirect_stdout(to):
+        sys.stdout.close()  # + implicit flush()
+        os.dup2(to.fileno(), fd)  # fd writes to 'to' file
+        sys.stdout = os.fdopen(fd, "w")  # Python writes to fd
+
+    with os.fdopen(os.dup(fd), "w") as old_stdout:
+        with open(to, "w") as file:
+            _redirect_stdout(to=file)
+        try:
+            yield  # allow code to be run with the redirected stdout
+        finally:
+            if restore:
+                _redirect_stdout(to=old_stdout)  # restore stdout.
+            # buffering and flags such as
+            # CLOEXEC may be different
+
+
+## Tests ##
+
+
+def _test_styles():
+    for fmt in ANSITextStyles:
+        print(f"{fmt.name}: {fmt.value}{fmt.name}{ANSITextStyles.RESET.value}")
+
+
+def _test_warning():
+    print_warning("This is a warning message.")
+
+
+def main():
+    _test_styles()
+    _test_warning()
+
+
+if __name__ == "__main__":
+    main()

cbfpy/utils/jax_utils.py

@@ -0,0 +1,26 @@
+"""Jax helper functions and decorators"""
+
+import os
+
+import jax
+
+
+def conditional_jit(condition: bool):
+    """Decorator to jit a function if a condition is met.
+
+    Args:
+        condition (bool): True to jit the function, False otherwise
+    """
+
+    def wrapper(func):
+        if condition:
+            return jax.jit(func)
+        return func
+
+    return wrapper
+
+
+def jit_if_not_debugging(func):
+    """Decorator to jit a function if the DEBUG environment variable is not set."""
+    debug = os.environ.get("DEBUG", "").lower() in ("1", "true")
+    return conditional_jit(not debug)(func)

cbfpy/utils/math_utils.py

@@ -0,0 +1,21 @@
+"""Assorted helper functions related to math operations / linear algebra"""
+
+import jax.numpy as jnp
+from jax import Array
+from jax.typing import ArrayLike
+
+
+def normalize(vec: ArrayLike) -> Array:
+    """Normalizes a vector to have magnitude 1
+
+    If normalizing an array of vectors, each vector will have magnitude 1
+
+    Args:
+        vec (ArrayLike): Input vector or array. Shape (dim,) or (n_vectors, dim)
+
+    Returns:
+        Array: Unit vector(s), shape (dim,) or (n_vectors, dim) (same shape as the input)
+    """
+    vec = jnp.atleast_1d(vec)
+    norms = jnp.linalg.norm(vec, axis=-1)
+    return vec / norms[..., jnp.newaxis]

cbfpy/utils/visualization.py

@@ -0,0 +1,93 @@
+"""Tools for visualizing shapes in Pybullet"""
+
+from typing import Optional
+
+import numpy as np
+import numpy.typing as npt
+import pybullet
+from pybullet_utils.bullet_client import BulletClient
+
+
+def visualize_3D_box(
+    box: npt.ArrayLike,
+    padding: Optional[npt.ArrayLike] = None,
+    rgba: npt.ArrayLike = (1, 0, 0, 0.5),
+    client: Optional[BulletClient] = None,
+) -> int:
+    """Visualize a box in Pybullet
+
+    Args:
+        box (npt.ArrayLike): Box to visualize. If an array, must be of shape (1, 2, box_dim)
+        padding (Optional[npt.ArrayLike]): If expanding (or contracting) the boxes by a certain amount, include the
+            (x, y, z) padding distances here (shape (3,)). Defaults to None.
+        rgba (npt.ArrayLike): Color of the box (RGB + alpha), shape (4,). Defaults to (1, 0, 0, 0.5).
+        client (BulletClient, optional): If connecting to multiple physics servers, include the client
+            (the class instance, not just the ID) here. Defaults to None (use default connected client)
+
+    Returns:
+        int: Pybullet ID of the box
+    """
+    lower, upper = box
+    if padding is not None:
+        lower -= padding
+        upper += padding
+    return create_box(
+        pos=(lower + (upper - lower) / 2),  # Midpoint
+        orn=(0, 0, 0, 1),
+        mass=0,
+        sidelengths=(upper - lower),
+        use_collision=False,
+        rgba=rgba,
+        client=client,
+    )
+
+
+def create_box(
+    pos: npt.ArrayLike,
+    orn: npt.ArrayLike,
+    mass: float,
+    sidelengths: npt.ArrayLike,
+    use_collision: bool,
+    rgba: npt.ArrayLike = (1, 1, 1, 1),
+    client: Optional[BulletClient] = None,
+) -> int:
+    """Creates a rigid box in the Pybullet simulation
+
+    Args:
+        pos (npt.ArrayLike): Position of the box in world frame, shape (3)
+        orn (npt.ArrayLike): Orientation (XYZW quaternion) of the box in world frame, shape (4,)
+        mass (float): Mass of the box. If set to 0, the box is fixed in space
+        sidelengths (npt.ArrayLike): Sidelengths of the box along the local XYZ axes, shape (3,)
+        use_collision (bool): Whether or not collision is enabled for the box
+        rgba (npt.ArrayLike, optional): Color of the box, with each RGBA value being in [0, 1].
+            Defaults to (1, 1, 1, 1) (white)
+        client (BulletClient, optional): If connecting to multiple physics servers, include the client
+            (the class instance, not just the ID) here. Defaults to None (use default connected client)
+
+    Returns:
+        int: ID of the box in Pybullet
+    """
+    client: pybullet = pybullet if client is None else client
+    if len(sidelengths) != 3:
+        raise ValueError("Must provide the dimensions of the three sides of the box")
+    half_extents = np.asarray(sidelengths) / 2
+    visual_id = client.createVisualShape(
+        pybullet.GEOM_BOX,
+        halfExtents=half_extents,
+        rgbaColor=rgba,
+    )
+    if use_collision:
+        collision_id = client.createCollisionShape(
+            pybullet.GEOM_BOX,
+            halfExtents=half_extents,
+        )
+    else:
+        collision_id = -1
+    box_id = client.createMultiBody(
+        baseMass=mass,
+        basePosition=pos,
+        baseOrientation=orn,
+        baseCollisionShapeIndex=collision_id,
+        baseVisualShapeIndex=visual_id,
+    )
+    return box_id

cbfpy-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Daniel Morton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cbfpy-0.0.1.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.1
+Name: cbfpy
+Version: 0.0.1
+Summary: Control Barrier Functions in Python
+Author-email: Daniel Morton <danielpmorton@gmail.com>
+Project-URL: Documentation, https://danielpmorton.github.io/cbfpy/
+Project-URL: Repository, https://github.com/danielpmorton/cbfpy/
+Keywords: control,barrier,function,CBF,Jax
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2
+Requires-Dist: jax
+Requires-Dist: jaxlib
+Requires-Dist: qpax
+Provides-Extra: examples
+Requires-Dist: pybullet; extra == "examples"
+Requires-Dist: pygame; extra == "examples"
+Requires-Dist: wheel; extra == "examples"
+Requires-Dist: matplotlib; extra == "examples"
+Provides-Extra: dev
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: mkdocstrings[python]; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Provides-Extra: all
+Requires-Dist: pylint; extra == "all"
+Requires-Dist: black; extra == "all"
+Requires-Dist: pybullet; extra == "all"
+Requires-Dist: pygame; extra == "all"
+Requires-Dist: mkdocs-material; extra == "all"
+Requires-Dist: mkdocstrings[python]; extra == "all"
+
+# CBFpy: Control Barrier Functions in Python and Jax
+
+CBFpy is an easy-to-use and high-performance framework for constructing and solving Control Barrier Functions (CBFs) and Control Lyapunov Functions (CLFs), using [Jax](https://github.com/google/jax) for:
+
+- Just-in-time compilation
+- Accelerated linear algebra operations with [XLA](https://openxla.org/xla)
+- Automatic differentiation
+
+For API reference, see the following [documentation](https://danielpmorton.github.io/cbfpy)
+
+If you use CBFpy in your research, please use the following citation:
+
+```
+@software{Morton_CBFpy_2024,
+  author = {Morton, Daniel},
+  license = {MIT},
+  title = {{CBFpy: Control Barrier Functions in Python and Jax}},
+  url = {https://github.com/danielpmorton/cbfpy},
+  version = {0.0.1},
+  month = Dec,
+  year = {2024}
+}
+```
+
+## Installation 
+
+### From PyPI
+
+```
+pip install cbfpy
+```
+
+### From source
+
+A virtual environment is optional, but highly recommended. For `pyenv` installation instructions, see [here](https://danielpmorton.github.io/cbfpy/pyenv).
+
+```
+git clone https://github.com/danielpmorton/cbfpy
+cd cbfpy
+pip install -e ".[examples]"
+```
+The `[examples]` tag installs all of the required packages for development and running the examples. The pure `cbfpy` functionality does not require these extra packages though. If you want to contribute to the repo, you can also include the `[dev]` dependencies.
+
+If you are working on Apple silicon and have issues installing Jax, the following threads may be useful: [[1]](https://stackoverflow.com/questions/68327863/importing-jax-fails-on-mac-with-m1-chip), [[2]](https://github.com/jax-ml/jax/issues/5501#issuecomment-955590288)
+
+## Usage:
+
+#### Example: A point-mass robot in 1D with an applied force and a positional barrier
+
+For this problem, the state $z$ is defined as the position and velocity of the robot,
+
+$$z = [x, \dot{x}]$$ 
+
+So, the state derivative $\dot{z}$ is therefore
+
+$$\dot{z} = [\dot{x}, \ddot{x}]$$ 
+
+And the control input is the applied force in the $x$ direction:
+
+$$u = F_{x}$$
+
+The dynamics can be expressed as follows (with $m$ denoting the robot's mass):
+
+$$\dot{z} = \begin{bmatrix}0 & 1 \\
+                           0 & 0
+            \end{bmatrix}z + 
+            \begin{bmatrix}0 \\
+                          1/m
+            \end{bmatrix} u$$
+
+This is a control affine system, since the dynamics can be expressed as 
+
+$$\dot{z} = f(z) + g(z) u$$
+
+If the robot is controlled by some nominal (unsafe) controller, we may want to guarantee that it remains in some safe region. If we define $X_{safe} \in [x_{min}, \infty]$, we can construct a (relative-degree-2, zeroing) barrier $h$ where $h(z) \geq 0$ for any $z$ in the safe set:
+
+$$h(z) = x - x_{min}$$
+
+### In Code
+
+We'll first define our problem (dynamics, barrier, and any additional parameters) in a `CBFConfig`-derived class. 
+
+We use [Jax](https://github.com/google/jax) for fast compilation of the problem. Jax can be tricky to learn at first, but luckily `cbfpy` just requires formulating your functions in `jax.numpy` which has the same familiar interface as `numpy`. These should be pure functions without side effects (for instance, modifying a class variable in `self`).
+
+Additional tuning parameters/functions can be found in the `CBFConfig` documentation. 
+
+```python
+import jax.numpy as jnp
+from cbfpy import CBF, CBFConfig
+
+# Create a config class for your problem inheriting from the CBFConfig class
+class MyCBFConfig(CBFConfig):
+    def __init__(self):
+        super().__init__(
+            # Define the state and control dimensions
+            n = 2, # [x, x_dot]
+            m = 1, # [F_x]
+            # Define control limits (if desired)
+            u_min = None,
+            u_max = None,
+        )
+
+    # Define the control-affine dynamics functions `f` and `g` for your system
+    def f(self, z):
+        A = jnp.array([[0.0, 1.0], [0.0, 0.0]])
+        return A @ z
+
+    def g(self, z):
+        mass = 1.0
+        B = jnp.array([[0.0], [1.0 / mass]])
+        return B
+
+    # Define the barrier function `h`
+    # The *relative degree* of this system is 2, so, we'll use the h_2 method
+    def h_2(self, z):
+        x_min = 1.0
+        x = z[0]
+        return jnp.array([x - x_min])
+```
+We can then construct the CBF from our config and use it in our control loop as follows.
+```python
+config = MyCBFConfig()
+cbf = CBF.from_config(config)
+
+# Pseudocode
+while True:
+    z = get_state()
+    z_des = get_desired_state()
+    u_nom = nominal_controller(z, z_des)
+    u = cbf.safety_filter(z, u_nom)
+    apply_control(u)
+    step() 
+```
+
+## Examples
+
+These can be found in the `examples` folder [here](https://github.com/danielpmorton/cbfpy/tree/main/cbfpy/examples)
+
+### [Adaptive Cruise Control](https://github.com/danielpmorton/cbfpy/blob/main/cbfpy/examples/adaptive_cruise_control_demo.py)
+
+Use a CLF-CBF to maintain a safe follow distance to the vehicle in front, while tracking a desired velocity
+
+- State: z = [Follower velocity, Leader velocity, Follow distance] (n = 3)
+- Control: u = [Follower wheel force] (m = 1)
+- Relative degree: 1
+
+![Image: Adaptive cruise control](https://raw.githubusercontent.com/danielpmorton/cbfpy/refs/heads/main/images/acc_safe.gif)
+
+### [Point Robot Safe-Set Containment](https://github.com/danielpmorton/cbfpy/blob/main/cbfpy/examples/point_robot_demo.py)
+
+Use a CBF to enforce that a point robot stays within a safe box, while a PD controller attempts to reduce the distance to a target position
+
+- State: z = [Position, Velocity] (n = 6)
+- Control: u = [Force] (m = 3)
+- Relative degree: 2
+
+![Image: Point robot in a safe set](https://raw.githubusercontent.com/danielpmorton/cbfpy/refs/heads/main/images/point_robot_safe.gif)
+
+### [Point Robot Obstacle Avoidance](https://github.com/danielpmorton/cbfpy/blob/main/cbfpy/examples/point_robot_obstacle_demo.py)
+
+Use a CBF to keep a point robot inside a safe box, while avoiding a moving obstacle. The nominal PD controller attempts to keep the robot at the origin.
+
+- State: z = [Position, Velocity] (n = 6)
+- Control: u = [Force] (m = 3)
+- Relative degree: 1 + 2 (1 for obstacle avoidance, 2 for safe set containment)
+- Additional data: The state of the obstacle (position and velocity)
+
+![Image: Point robot avoiding an obstacle](https://raw.githubusercontent.com/danielpmorton/cbfpy/refs/heads/main/images/point_robot_obstacle.gif)
+
+### [Manipulator Joint Limit Avoidance](https://github.com/danielpmorton/cbfpy/blob/main/cbfpy/examples/joint_limits_demo.py)
+
+Use a CBF to keep a manipulator operating within its joint limits, even if a nominal joint trajectory is unsafe. 
+
+- State: z = [Joint angles] (n = 3)
+- Control: u = [Joint velocities] (m = 3)
+- Relative degree: 1
+
+![Image: 3-DOF manipulator avoiding joint limits](https://raw.githubusercontent.com/danielpmorton/cbfpy/refs/heads/main/images/joint_limits.png)
+
+### [Drone Obstacle Avoidance](https://github.com/danielpmorton/cbfpy/blob/main/cbfpy/examples/drone_demo.py)
+
+Use a CBF to keep a drone inside a safe box, while avoiding a moving obstacle. This is similar to the "point robot obstacle avoidance" demo, but with slightly different dynamics.
+
+- State: z = [Position, Velocity] (n = 6)
+- Control: u = [Velocity] (m = 3)
+- Relative degree: 1
+- Additional data: The state of the obstacle (position and velocity)
+
+This is the same CBF which was used in the ["Drone Fencing" demo](https://danielpmorton.github.io/drone_fencing/) at the Stanford Robotics center.
+
+![Image: Quadrotor avoiding an obstacle](https://raw.githubusercontent.com/danielpmorton/cbfpy/refs/heads/main/images/drone_demo.gif)

cbfpy-0.0.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+cbfpy/__init__.py,sha256=Fq5snpGxff_id-Qlpl1f52OZWr9WrVaEpZhmWE9fRpI,366
+cbfpy/cbfs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cbfpy/cbfs/cbf.py,sha256=WDNAMFjWJq2gaa8rceg8nsimnb2o3CvAOgf_wCCmr-Q,13923
+cbfpy/cbfs/clf_cbf.py,sha256=o8wyKRhj3h4xqMwxnb3wbOyN5O54TYKTWySUhyQYuY4,17492
+cbfpy/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cbfpy/config/cbf_config.py,sha256=A6HGlf9P3HrG6DeK3qL9pr2zQtaWthbBwm7uN47CQLE,17069
+cbfpy/config/clf_cbf_config.py,sha256=TJVuK5wsESbnVCqm6VNJ5kuaPRpWbQVjyHHALc6KDTs,10703
+cbfpy/envs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cbfpy/envs/arm_envs.py,sha256=mY5A3nId0CbhpwbXrXx34T_Tce0QJzj3fiaJ2YAw4K8,2785
+cbfpy/envs/base_env.py,sha256=JRS9ASNM0NS5pYUG2wiBcvZSUsa5Buf-ggRzd0Xs9js,1818
+cbfpy/envs/car_env.py,sha256=u8-m3Mpp49FJclxARI63IDmZmKSz6zCFnxxwg1Q3CVo,11245
+cbfpy/envs/drone_env.py,sha256=9PpUFXLjz_vj_eGolkbMDpPTXvyQxF6juGcW3zvDua4,5762
+cbfpy/envs/point_robot_envs.py,sha256=p_UK_uwUWLyDdwvsFgVRWEI1Ngw1WqgadkMb8yjuj8Q,7877
+cbfpy/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cbfpy/examples/adaptive_cruise_control_demo.py,sha256=QzdYJnUlt5SphE6Foz7wTMnxkk-ojxQ7I1tHVPNQdBg,4147
+cbfpy/examples/drone_demo.py,sha256=FjV9DLeo6CyhwA77XNKxW7LzWZCYULu-XMhG6nYXIes,3590
+cbfpy/examples/joint_limits_demo.py,sha256=imAK7cQ8Uch5b_kFfsmCHy4E7pmlSfZFoEhs8_-rJBw,4534
+cbfpy/examples/point_robot_demo.py,sha256=rLHI32H76Sk-w4CTvuIo8YjgBLFZi7NLZILaGEciG9Y,2868
+cbfpy/examples/point_robot_obstacle_demo.py,sha256=zItuf3L-s9RZvactqo7chZAv0ylTmCTvOPrsHn4V3mk,3775
+cbfpy/temp/test_import.py,sha256=pPeIB0ZtQ-Fb71or2A8LFnSA7fCcpDAYRwocoxdMRIg,25
+cbfpy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cbfpy/utils/general_utils.py,sha256=TV8pk7Miysu0H3HLe9L0MrEZLMTxOIykW_h4cIrts-o,4157
+cbfpy/utils/jax_utils.py,sha256=87zT1_6OlaSw2HCdTfC-rqP8gchtUleSH6v_QlwzkYA,596
+cbfpy/utils/math_utils.py,sha256=69Wb6kAuAAG38_eW39QrZHNDYYv--5hBS8RJOFsJ0BE,637
+cbfpy/utils/visualization.py,sha256=d4bdZCEl9AUjRz-D_uNpCu4bSUkz_wOBBaTaAH9D7go,3319
+test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/test_speed.py,sha256=hBXNKjO414f3wzHfEIK2ND60dD9AssE9ku_p15YPttE,7336
+test/test_utils.py,sha256=vf9NOPLxY9EnQStzAGhctQ21DBoggbFdMOpzbDg1o8E,829
+cbfpy-0.0.1.dist-info/LICENSE,sha256=VsRPtVDiLQq5oEH67g9hLJNScJhe6URhGIkCcfLjGAA,1070
+cbfpy-0.0.1.dist-info/METADATA,sha256=sA7_vBtcmrNTPKE3WsLXmWoXOSAd2wYuGKkJFzyAT-c,8883
+cbfpy-0.0.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+cbfpy-0.0.1.dist-info/top_level.txt,sha256=zf3vvm0IroFA5aatt-r1KWBtjBg-FeAh_e2ut4fLsjk,11
+cbfpy-0.0.1.dist-info/RECORD,,

cbfpy-0.0.1.dist-info/WHEEL

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