imt-ring 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

{imt_ring-1.3.3.dist-info → imt_ring-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imt-ring
-Version: 1.3.3
+Version: 1.3.5
 Summary: RING: Recurrent Inertial Graph-based Estimator
 Author-email: Simon Bachhuber <simon.bachhuber@fau.de>
 Project-URL: Homepage, https://github.com/SimiPixel/ring

{imt_ring-1.3.3.dist-info → imt_ring-1.3.5.dist-info}/RECORD

@@ -1,21 +1,21 @@
 ring/__init__.py,sha256=iNvbAZi7Qfa69IbL1z4lB7zHL8WusV5fBrKah2la-Gc,1566
 ring/algebra.py,sha256=F0GwbP8LQP5qGVkoMUYJmkp9Hn2nKAVIkCVYDEjNjGU,3128
-ring/base.py,sha256=ZAoe9B1HbAX9NYiKaisssTBn-1VBXoJTsWgFAvlQoZw,33705
+ring/base.py,sha256=hZZaH1kOmeV4vK2EyOQdxSKBFLZ1bluRHcj725OHo2I,33913
 ring/maths.py,sha256=jJr_kr78-XDce8B4tXQ2Li-jBntVQhaS8csxglCsj8A,12193
 ring/spatial.py,sha256=nmZ-UhRanhyM34bez8uCS4wMwaKqLkuEbgKGP5XNH60,2351
 ring/algorithms/__init__.py,sha256=t3YXcgqMJxadUjFiILVD0HlQRPLdrQyc8aKiB36w0vE,1701
-ring/algorithms/_random.py,sha256=6EG0GHYe6tCq0qUt4Jes8W1EaqqaLa0sSZhnwBbEjCE,13340
+ring/algorithms/_random.py,sha256=M9JQSMXSUARWuzlRLP3Wmkuntrk9LZpP30p4_IPgDB4,13805
 ring/algorithms/dynamics.py,sha256=nqq5I0RYSbHNlGiLMlohz08IfL9Njsrid4upDnwkGbI,10629
-ring/algorithms/jcalc.py,sha256=oqSiwz3Be1VfIpmJXEFTNM_9_o3tyuTtyZt2aqttyN4,28213
+ring/algorithms/jcalc.py,sha256=6olMYQtgKZE5KBEAHF0Rqxe__1wcZQVEiLgm1vO7_Gw,28260
 ring/algorithms/kinematics.py,sha256=DOboHI517Vx0pRJUFZtZPmK_qFaiKiQe-37B-M0aC-c,7422
 ring/algorithms/sensors.py,sha256=Y3Wo9qj3BWKoIHB0V04QwyD-Z5m4BrAjfBX8Pn6y9Lg,18005
 ring/algorithms/custom_joints/__init__.py,sha256=fzeE7TdUhmGgbbFAyis1tKcyQ4Fo8LigDwD3hUVnH_w,316
 ring/algorithms/custom_joints/rr_imp_joint.py,sha256=a3JT0w7pB94kZ95eBR8ZO853eSeyjFoiXmhYlaXoHDE,2392
 ring/algorithms/custom_joints/rr_joint.py,sha256=jnRtjtOCALMaq2_0bcu2d7qgfQ6etXpoh43MioRaDmY,1000
-ring/algorithms/custom_joints/suntay.py,sha256=0Oym3KQssj3QDOldnz9PTy5jPg9ZLk85mMK2YX1qvB4,15600
+ring/algorithms/custom_joints/suntay.py,sha256=oJFU0EnT6yzlSkoA2CegPDLyb8jAk-bGZx4iuZO4nxM,16215
 ring/algorithms/generator/__init__.py,sha256=p4ucl0zQtp5NwNoXIRjmTzGGRu2WOAWFfNmYRPwQles,912
 ring/algorithms/generator/base.py,sha256=zmrRK_I6BWoo4WbEcEVK7iFKdPfetc6txs7U8iu1xEk,14771
-ring/algorithms/generator/batch.py,sha256=BGzmwH1AItXjPRyHtsYnAfYnoogw8jxhng9oyVw72lw,9019
+ring/algorithms/generator/batch.py,sha256=EOCX0vOxDwVOweArGsUneeeYysdSY2mFB55W052Wd9o,9161
 ring/algorithms/generator/motion_artifacts.py,sha256=aKdkZU5OF4_aKyL4Yo-ftZRwrDCve1LuuREGAUlTqtI,8551
 ring/algorithms/generator/pd_control.py,sha256=3pOaYig26vmp8gippDfy2KNJRZO3kr0rGd_PBIuEROM,5759
 ring/algorithms/generator/randomize.py,sha256=G_vBIo0OwQkXL2u0djwbaoaeb02C4LQCTNNloOYIU2M,3699
@@ -77,7 +77,7 @@ ring/utils/hdf5.py,sha256=BzXwVypZmEZeHVgeGZ78YYdi10NEQtnPhdrb8dQAXo0,5856
 ring/utils/normalizer.py,sha256=67L2BU1MRsMT4pD41ta3JJMppLN0ozFmnwrmXDtnqrQ,1698
 ring/utils/path.py,sha256=hAfSlqRi-ew536RnjDDM7IKapdMJc-EvhrR0Y-BCFWc,1265
 ring/utils/utils.py,sha256=I2f6-DMBrrgy5tpLzPLlezifQgkO2fERZWyX3cfb4sI,5303
-imt_ring-1.3.3.dist-info/METADATA,sha256=nTihurycKYmLCI61Cojd7VLrnb1gpd-H8nwUupysaC8,3104
-imt_ring-1.3.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-imt_ring-1.3.3.dist-info/top_level.txt,sha256=EiT790-lAyi8iwTzJArH3f2k77rwhDn00q-4PlmvDQo,5
-imt_ring-1.3.3.dist-info/RECORD,,
+imt_ring-1.3.5.dist-info/METADATA,sha256=lfUIi30c7raML41nr1zCkIhhGbXjaQuNFFs7hBgAIZ0,3104
+imt_ring-1.3.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+imt_ring-1.3.5.dist-info/top_level.txt,sha256=EiT790-lAyi8iwTzJArH3f2k77rwhDn00q-4PlmvDQo,5
+imt_ring-1.3.5.dist-info/RECORD,,

ring/algorithms/_random.py

@@ -4,6 +4,7 @@ import warnings
 import jax
 from jax import random
 import jax.numpy as jnp
+
 from ring import maths
 
 Float = jax.Array
@@ -40,20 +41,20 @@ def random_angle_over_time(
     def body_fn_outer(val):
         i, t, phi, key_t, key_ang, ANG = val
 
-        key_t, consume = random.split(key_t)
-        dt = random.uniform(consume, minval=t_min, maxval=_to_float(t_max, t))
-
-        key_ang, consume = random.split(key_ang)
-        phi = _resolve_range_of_motion(
+        key_t, consume_t = random.split(key_t)
+        key_ang, consume_ang = random.split(key_ang)
+        dt, phi = _resolve_range_of_motion(
             range_of_motion,
             range_of_motion_method,
             _to_float(dang_min, t),
             _to_float(dang_max, t),
             _to_float(delta_ang_min, t),
             _to_float(delta_ang_max, t),
-            dt,
+            t_min,
+            _to_float(t_max, t),
             phi,
-            consume,
+            consume_t,
+            consume_ang,
             max_iter,
         )
         t += dt
@@ -246,12 +247,14 @@ def _resolve_range_of_motion(
     dang_max,
     delta_ang_min,
     delta_ang_max,
-    dt,
+    t_min,
+    t_max,
     prev_phi,
-    key,
+    key_t,
+    key_ang,
     max_iter,
 ):
-    def _next_phi(key):
+    def _next_phi(key, dt):
         key, consume = random.split(key)
 
         if range_of_motion:
@@ -294,21 +297,33 @@ def _resolve_range_of_motion(
             return prev_phi + sign * dphi
 
     def body_fn(val):
-        key, _, i = val
-        key, consume = jax.random.split(key)
-        next_phi = _next_phi(consume)
-        return key, next_phi, i + 1
+        key_t, key_ang, _, _, i = val
+
+        key_t, consume_t = jax.random.split(key_t)
+        dt = jax.random.uniform(consume_t, minval=t_min, maxval=t_max)
+
+        key_ang, consume_ang = jax.random.split(key_ang)
+        next_phi = _next_phi(consume_ang, dt)
+
+        return key_t, key_ang, dt, next_phi, i + 1
 
     def cond_fn(val):
-        _, next_phi, i = val
+        *_, dt, next_phi, i = val
         delta_phi = jnp.abs(next_phi - prev_phi)
-        # delta is in bounds
-        break_if_true1 = (delta_phi >= delta_ang_min) & (delta_phi <= delta_ang_max)
+        # delta_ang is in bounds
+        cond_delta_ang = (delta_phi >= delta_ang_min) & (delta_phi <= delta_ang_max)
+        # dang is in bounds
+        dang = delta_phi / dt
+        cond_dang = (dang >= dang_min) & (dang <= dang_max)
+
+        break_if_true1 = jnp.logical_and(cond_delta_ang, cond_dang)
+        # break out of loop
         break_if_true2 = i > max_iter
         return (i == 0) | (jnp.logical_not(break_if_true1 | break_if_true2))
 
-    # the `prev_phi` here is unused
-    return jax.lax.while_loop(cond_fn, body_fn, (key, prev_phi, 0))[1]
+    init_val = (key_t, key_ang, 1.0, prev_phi, 0)
+    *_, dt, next_phi, _ = jax.lax.while_loop(cond_fn, body_fn, init_val)
+    return dt, next_phi
 
 
 def cosInterpolate(x, xp, fp):

ring/algorithms/custom_joints/suntay.py

@@ -295,14 +295,21 @@ def register_suntay(sconfig: SuntayConfig, name: str = "suntay"):
 
 def Polynomial_DrawnFnPair(
     order: int = 2,
-    val: float = 2.0,
     center: bool = False,
-    flexion_center: Optional[float] = None,
+    flexion_center_deg: Optional[float] = None,
+    include_bias: bool = True,
+    enable_scale_delta: bool = True,
 ) -> DrawnFnPairFactory:
-    assert val >= 0.0
+    assert not (order == 0 and not include_bias)
+
+    flexion_center = (
+        jnp.deg2rad(flexion_center_deg) if flexion_center_deg is not None else None
+    )
+    del flexion_center_deg
 
     # because 0-th order is also counted
     order += 1
+    powers = jnp.arange(order) if include_bias else jnp.arange(1, order)
 
     def factory(xs, mn, mx):
         nonlocal flexion_center
@@ -311,17 +318,22 @@ def Polynomial_DrawnFnPair(
         flexion_mx = jnp.max(xs)
 
         def _apply_poly_factors(poly_factors, q):
-            return poly_factors @ jnp.power(q, jnp.arange(order))
+            return poly_factors @ jnp.power(q, powers)
 
         if flexion_center is None:
             flexion_center = (flexion_mn + flexion_mx) / 2
+
+        if (order - 1) == 0:
+            method = "clip"
+            minval, maxval = mn, mx
         else:
-            flexion_center = jnp.array(flexion_center)
+            method = "minmax"
+            minval, maxval = -1.0, 1.0
 
         def init(key):
-            c1, c2 = jax.random.split(key)
+            c1, c2, c3 = jax.random.split(key, 3)
             poly_factors = jax.random.uniform(
-                c1, shape=(order,), minval=-val, maxval=val
+                c1, shape=(len(powers),), minval=minval, maxval=maxval
             )
             q0 = jax.random.uniform(c2, minval=flexion_mn, maxval=flexion_mx)
             values = jax.vmap(_apply_poly_factors, in_axes=(None, 0))(
@@ -329,13 +341,17 @@ def Polynomial_DrawnFnPair(
             )
             eps = 1e-6
             amin, amax = jnp.min(values), jnp.max(values) + eps
+            if enable_scale_delta:
+                delta = amax - amin
+                scale_delta = jnp.clip(jax.random.normal(c3) + 0.5, 1.0)
+                amax = amin + delta * scale_delta
             return amin, amax, poly_factors, q0
 
         def _apply(params, q):
             amin, amax, poly_factors, q0 = params
             q = q - q0
             value = _apply_poly_factors(poly_factors, q)
-            return restrict(value, mn, mx, amin, amax)
+            return restrict(value, mn, mx, amin, amax, method=method)
 
         if center:
 

ring/algorithms/generator/batch.py

@@ -97,8 +97,10 @@ def batch_generators_eager_to_list(
         for _ in range(n_calls):
             key, consume = jax.random.split(key)
             sample = gen_jit(consume)
-            # converts also to numpy
+            # converts also to numpy; but with np.array.flags.writeable = False
             sample = jax.device_get(sample)
+            # this then sets this flag to True
+            sample = jax.tree_map(np.array, sample)
             data.extend([jax.tree_map(lambda a: a[i], sample) for i in range(size)])
 
     return data

ring/algorithms/jcalc.py

@@ -424,14 +424,14 @@ def _draw_rxyz(
     # TODO, delete these args and pass a modifified `config` with `replace` instead
     enable_range_of_motion: bool = True,
     free_spherical: bool = False,
+    # how often it should try to fullfill the dang_min/max and delta_ang_min/max conds
+    max_iter: int = 5,
 ) -> jax.Array:
     key_value, consume = jax.random.split(key_value)
     ANG_0 = jax.random.uniform(consume, minval=config.ang0_min, maxval=config.ang0_max)
     # `random_angle_over_time` always returns wrapped angles, thus it would be
     # inconsistent to allow an initial value that is not wrapped
     ANG_0 = maths.wrap_to_pi(ANG_0)
-    # only used for `delta_ang_min_max` logic
-    max_iter = 5
     return _random.random_angle_over_time(
         key_t,
         key_value,

ring/base.py

@@ -573,6 +573,8 @@ class System(_Base):
         new_zero: Optional[jax.Array] = None,
     ):
         "By default damping, stiffness are set to zero."
+        from ring.algorithms import get_joint_model
+
         q_size, qd_size = Q_WIDTHS[new_joint_type], QD_WIDTHS[new_joint_type]
 
         def logic_unfreeze_to_spherical(link_name, olt, ola, old, ols, olz):
@@ -594,7 +596,13 @@ class System(_Base):
 
             return nlt, nla, nld, nls, nlz
 
-        return _update_sys_if_replace_joint_type(self, logic_unfreeze_to_spherical)
+        sys = _update_sys_if_replace_joint_type(self, logic_unfreeze_to_spherical)
+
+        jm = get_joint_model(new_joint_type)
+        if jm.init_joint_params is not None:
+            sys = sys.from_str(sys.to_str())
+
+        return sys
 
     def findall_imus(self) -> list[str]:
         return [name for name in self.link_names if name[:3] == "imu"]