pybounds 0.0.14__py3-none-any.whl

pybounds/util.py

@@ -0,0 +1,279 @@
+import numpy as np
+import scipy
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import matplotlib.collections as mcoll
+import matplotlib.patheffects as path_effects
+
+
+class FixedKeysDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(FixedKeysDict, self).__init__(*args, **kwargs)
+        self._frozen_keys = set(self.keys())  # Capture initial keys
+
+    def __setitem__(self, key, value):
+        if key not in self._frozen_keys:
+            raise KeyError(f"Key '{key}' cannot be added.")
+        super(FixedKeysDict, self).__setitem__(key, value)
+
+    def __delitem__(self, key):
+        raise KeyError(f"Key '{key}' cannot be deleted.")
+
+    def pop(self, key, default=None):
+        raise KeyError(f"Key '{key}' cannot be popped.")
+
+    def popitem(self):
+        raise KeyError("Cannot pop item from FixedKeysDict.")
+
+    def clear(self):
+        raise KeyError("Cannot clear FixedKeysDict.")
+
+    def update(self, *args, **kwargs):
+        for key in dict(*args, **kwargs):
+            if key not in self._frozen_keys:
+                raise KeyError(f"Key '{key}' cannot be added.")
+        super(FixedKeysDict, self).update(*args, **kwargs)
+
+
+class SetDict(object):
+    # set_dict(self, dTarget, dSource, bPreserve)
+    # Takes a target dictionary, and enters values from the source dictionary, overwriting or not, as asked.
+    # For example,
+    #    dT={'a':1, 'b':2}
+    #    dS={'a':0, 'c':0}
+    #    Set(dT, dS, True)
+    #    dT is {'a':1, 'b':2, 'c':0}
+    #
+    #    dT={'a':1, 'b':2}
+    #    dS={'a':0, 'c':0}
+    #    Set(dT, dS, False)
+    #    dT is {'a':0, 'b':2, 'c':0}
+    #
+    def set_dict(self, dTarget, dSource, bPreserve):
+        for k, v in dSource.items():
+            bKeyExists = (k in dTarget)
+            if (not bKeyExists) and type(v) == type({}):
+                dTarget[k] = {}
+            if ((not bKeyExists) or not bPreserve) and (type(v) != type({})):
+                dTarget[k] = v
+
+            if type(v) == type({}):
+                self.set_dict(dTarget[k], v, bPreserve)
+
+    def set_dict_with_preserve(self, dTarget, dSource):
+        self.set_dict(dTarget, dSource, True)
+
+    def set_dict_with_overwrite(self, dTarget, dSource):
+        self.set_dict(dTarget, dSource, False)
+
+
+class LatexStates:
+    """ Holds LaTex format corresponding to set symbolic variables.
+    """
+
+    def __init__(self, dict=None):
+        self.dict = {'v_para': r'$v_{\parallel}$',
+                     'v_perp': r'$v_{\perp}$',
+                     'phi': r'$\phi$',
+                     'phidot': r'$\dot{\phi}$',
+                     'phi_dot': r'$\dot{\phi}$',
+                     'phiddot': r'$\ddot{\phi}$',
+                     'w': r'$w$',
+                     'zeta': r'$\zeta$',
+                     'I': r'$I$',
+                     'm': r'$m$',
+                     'C_para': r'$C_{\parallel}$',
+                     'C_perp': r'$C_{\perp}$',
+                     'C_phi': r'$C_{\phi}$',
+                     'km1': r'$k_{m_1}$',
+                     'km2': r'$k_{m_2}$',
+                     'km3': r'$k_{m_3}$',
+                     'km4': r'$k_{m_4}$',
+                     'd': r'$d$',
+                     'psi': r'$\psi$',
+                     'gamma': r'$\gamma$',
+                     'alpha': r'$\alpha$',
+                     'of': r'$\frac{g}{d}$',
+                     'gdot': r'$\dot{g}$',
+                     'v_para_dot': r'$\dot{v_{\parallel}}$',
+                     'v_perp_dot': r'$\dot{v_{\perp}}$',
+                     'v_para_dot_ratio': r'$\frac{\Delta v_{\parallel}}{v_{\parallel}}$',
+                     'x':  r'$x$',
+                     'y':  r'$y$',
+                     'v_x': r'$v_{x}$',
+                     'v_y': r'$v_{y}$',
+                     'v_z': r'$v_{z}$',
+                     'w_x': r'$w_{x}$',
+                     'w_y': r'$w_{y}$',
+                     'w_z': r'$w_{z}$',
+                     'a_x': r'$a_{x}$',
+                     'a_y': r'$a_{y}$',
+                     'vx': r'$v_x$',
+                     'vy': r'$v_y$',
+                     'vz': r'$v_z$',
+                     'wx': r'$w_x$',
+                     'wy': r'$w_y$',
+                     'wz': r'$w_z$',
+                     'ax': r'$ax$',
+                     'ay': r'$ay$',
+                     'beta': r'$\beta',
+                     'thetadot': r'$\dot{\theta}$',
+                     'theta_dot': r'$\dot{\theta}$',
+                     'psidot': r'$\dot{\psi}$',
+                     'psi_dot': r'$\dot{\psi}$',
+                     'theta': r'$\theta$',
+                     'Yaw': r'$\psi$',
+                     'R': r'$\phi$',
+                     'P': r'$\theta$',
+                     'dYaw': r'$\dot{\psi}$',
+                     'dP': r'$\dot{\theta}$',
+                     'dR': r'$\dot{\phi}$',
+                     'acc_x': r'$\dot{v}x$',
+                     'acc_y': r'$\dot{v}y$',
+                     'acc_z': r'$\dot{v}z$',
+                     'Psi': r'$\Psi$',
+                     'Ix': r'$I_x$',
+                     'Iy': r'$I_y$',
+                     'Iz': r'$I_z$',
+                     'Jr': r'$J_r$',
+                     'Dl': r'$D_l$',
+                     'Dr': r'$D_r$',
+                     }
+
+        if dict is not None:
+            SetDict().set_dict_with_overwrite(self.dict, dict)
+
+    def convert_to_latex(self, list_of_strings, remove_dollar_signs=False):
+        """ Loop through list of strings and if any match the dict, then swap in LaTex symbol.
+        """
+
+        if isinstance(list_of_strings, str):  # if single string is given instead of list
+            list_of_strings = [list_of_strings]
+            string_flag = True
+        else:
+            string_flag = False
+
+        list_of_strings = list_of_strings.copy()
+        for n, s in enumerate(list_of_strings):  # each string in list
+            for k in self.dict.keys():  # check each key in Latex dict
+                if s == k:  # string contains key
+                    # print(s, ',', self.dict[k])
+                    list_of_strings[n] = self.dict[k]  # replace string with LaTex
+                    if remove_dollar_signs:
+                        list_of_strings[n] = list_of_strings[n].replace('$', '')
+
+        if string_flag:
+            list_of_strings = list_of_strings[0]
+
+        return list_of_strings
+
+
+def make_segments(x, y):
+    points = np.array([x, y]).T.reshape(-1, 1, 2)
+    segments = np.concatenate([points[:-1], points[1:]], axis=1)
+    return segments
+
+
+def colorline(x, y, z, ax=None, cmap=plt.get_cmap('copper'), norm=None, linewidth=1.5, alpha=1.0):
+    # Special case if a single number:
+    if not hasattr(z, "__iter__"):  # to check for numerical input -- this is a hack
+        z = np.array([z])
+
+    z = np.asarray(z)
+
+    # Set normalization
+    if norm is None:
+        norm = plt.Normalize(np.min(z), np.max(z))
+
+    print(norm)
+
+    # Make segments
+    segments = make_segments(x, y)
+    lc = mcoll.LineCollection(segments, array=z, cmap=cmap, norm=norm,
+                              linewidth=linewidth, alpha=alpha,
+                              path_effects=[path_effects.Stroke(capstyle="round")])
+
+    # Plot
+    if ax is None:
+        ax = plt.gca()
+
+    ax.add_collection(lc)
+
+    return lc
+
+def plot_heatmap_log_timeseries(data, ax=None, log_ticks=None, data_labels=None,
+                                cmap='inferno_r', y_label=None,
+                                aspect=0.25, interpolation=False):
+    """ Plot log-scale time-series as heatmap.
+    """
+
+    n_label = data.shape[1]
+
+    # Set ticks
+    if log_ticks is None:
+        log_tick_low = int(np.floor(np.log10(np.min(data))))
+        log_tick_high = int(np.ceil(np.log10(np.max(data))))
+    else:
+        log_tick_low = log_ticks[0]
+        log_tick_high = log_ticks[1]
+
+    log_ticks = np.logspace(log_tick_low, log_tick_high, log_tick_high - log_tick_low + 1)
+
+    # Set color normalization
+    cnorm = mpl.colors.LogNorm(10 ** log_tick_low, 10 ** log_tick_high)
+
+    # Set labels
+    if data_labels is None:
+        data_labels = np.arange(0, n_label).tolist()
+        data_labels = [str(x) for x in data_labels]
+
+    # Make figure/axis
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, figsize=(5 * 1, 4 * 1), dpi=150)
+    else:
+        # ax = plt.gca()
+        fig = plt.gcf()
+
+    # Plot heatmap
+    if interpolation:
+        data = 10**scipy.ndimage.zoom(np.log10(data), (interpolation, 1), order=1)
+        aspect = aspect / interpolation
+
+    ax.imshow(data, norm=cnorm, aspect=aspect, cmap=cmap, interpolation='none')
+
+    # Set axis properties
+    ax.grid(True, axis='x')
+    ax.tick_params(axis='both', which='both', labelsize=6, top=False, labeltop=True, bottom=False, labelbottom=False,
+                   color='gray')
+
+    # Set x-ticks
+    LatexConverter = LatexStates()
+    data_labels_latex = LatexConverter.convert_to_latex(data_labels)
+    ax.set_xticks(np.arange(0, len(data_labels)) - 0.5)
+    ax.set_xticklabels(data_labels_latex)
+
+    # Set labels
+    ax.set_ylabel('time steps', fontsize=7, fontweight='bold')
+    ax.set_xlabel('states', fontsize=7, fontweight='bold')
+    ax.xaxis.set_label_position('top')
+
+    # Set x-ticks
+    xticks = ax.get_xticklabels()
+    for tick in xticks:
+        tick.set_ha('left')
+        tick.set_va('center')
+    #     tick.set_rotation(0)
+    #     tick.set_transform(tick.get_transform() + transforms.ScaledTranslation(6 / 72, 0, ax.figure.dpi_scale_trans))
+
+    # Colorbar
+    if y_label is None:
+        y_label = 'values'
+
+    cax = ax.inset_axes((1.03, 0.0, 0.04, 1.0))
+    cbar = fig.colorbar(mpl.cm.ScalarMappable(norm=cnorm, cmap=cmap), cax=cax, ticks=log_ticks)
+    cbar.set_label(y_label, rotation=270, fontsize=7, labelpad=8)
+    cbar.ax.tick_params(labelsize=6)
+
+    ax.spines[['bottom', 'top', 'left', 'right']].set_color('gray')
+
+    return cnorm, cmap, log_ticks

pybounds-0.0.14.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: pybounds
+Version: 0.0.14
+Summary: Bounding Observability for Uncertain Nonlinear Dynamics Systems (BOUNDS)
+Home-page: https://pypi.org/project/pybounds/
+Author: Ben Cellini, Burak Boyacioglu, Floris van Breugel
+Author-email: bcellini00@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# pybounds
+
+Python implementation of BOUNDS: Bounding Observability for Uncertain Nonlinear Dynamic Systems.
+
+<p align="center">
+    <a href="https://pypi.org/project/pybounds/">
+        <img src="https://badge.fury.io/py/pybounds.svg" alt="PyPI version" height="18"></a>
+</p>
+
+## Introduction
+
+This repository provides a minimal working example demonstrating how to empirically calculate the observability level of individual states for a nonlinear (partially observable) system, and accounts for sensor noise.
+
+## Installing
+
+The package can be installed by cloning the repo and running python setup.py install from inside the home pybounds directory.
+
+Alternatively using pip
+```bash
+pip install pybounds
+```
+
+## Notebook examples
+For a simple system
+*  Monocular camera with optic fow measurements: [mono_camera_example.ipynb](examples%2Fmono_camera_example.ipynb)
+
+For a more complex system
+*  Fly-wind: [fly_wind_example.ipynb](examples%2Ffly_wind_example.ipynb)
+
+## Citation
+
+If you use the code or methods from this package, please cite the following paper:
+
+Cellini, B., Boyacioglu, B., Lopez, A., & van Breugel, F. (2025). Discovering and exploiting active sensing motifs for estimation (arXiv:2511.08766). arXiv. https://arxiv.org/abs/2511.08766
+
+## Related packages
+This repository is the evolution of the EISO repo (https://github.com/BenCellini/EISO), and is intended as a companion to the repository directly associated with the paper above.
+
+## License
+
+This project utilizes the [MIT LICENSE](LICENSE.txt).
+100% open-source, feel free to utilize the code however you like. 

pybounds-0.0.14.dist-info/RECORD

@@ -0,0 +1,10 @@
+pybounds/__init__.py,sha256=ehF8bSQK7jeH-Tg6DY2CR6DzxGtaoRGpCY0DW-V3JfY,449
+pybounds/jacobian.py,sha256=HfQwwYv4lEYldWM97dfp9Q4y56ALcmOugN4mtjM-IjQ,2011
+pybounds/observability.py,sha256=GUNBWdNft5vamschXPZNzp-Hoh6Yz-Y0Wxsl7Wm_RSE,33158
+pybounds/simulator.py,sha256=NFztAB3IbrB4UCDEmcxUxJRBgl3q-Q8geqd7jymD9dI,17615
+pybounds/util.py,sha256=lBeqU21qo-EngTyMZ4K_P9q_OD_PpWKVVVsFNu1Fvec,9858
+pybounds-0.0.14.dist-info/licenses/LICENSE,sha256=AadU7OxPR9xChQ2FQ4aYpLKCe_7xh7Ox0L5LTGOtaC8,1072
+pybounds-0.0.14.dist-info/METADATA,sha256=-3m34Wu5nYo1dyhQR7oIBbjtP20-cr76htVgpRNSNCU,2293
+pybounds-0.0.14.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pybounds-0.0.14.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
+pybounds-0.0.14.dist-info/RECORD,,

pybounds-0.0.14.dist-info/WHEEL

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

pybounds-0.0.14.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 van Breugel lab
+
+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.

pybounds-0.0.14.dist-info/top_level.txt

@@ -0,0 +1 @@
+pybounds