Changed robot.frame, tool, remote_allowed_recorded to be persistent FS adjustables

script/elements/array.py

@@ -0,0 +1,147 @@
+def dimensionality_decorator(func):
+    def decorated(self, *args):
+        if hasattr(self[0], "__len__"):
+            return Array([func(s_, *args) for s_ in self])
+        else:
+            return Array(func(self, *args))
+    return decorated
+
+def indexing_decorator(func):
+    def decorated(self, v, *args):
+        nn = len(shape(v))
+        if (nn ==1):
+            if (type(v[0]) is bool):
+                return Array([s_ for s_, v_ in zip(self,v) if v_])
+            else:
+                return Array([self[v_] for v_ in v])
+        elif nn ==2:
+            if type(v[0]) is bool:
+                return Array([[s_ for s_, v_ in zip(self[n],v[n]) if v_ ] for n in range(nn)])
+        else:
+            ret = func(self, v, *args)
+        if hasattr(ret, "__len__"):
+            return Array(ret)
+        else:
+            return ret
+    return decorated
+
+class Array(list):
+    def __init__(self, data):
+        super(Array, self).__init__(data)
+        self.getint = super(Array, self).__getitem__
+    @dimensionality_decorator
+    def __add__(self, v):
+        return add(self, v)
+    @dimensionality_decorator
+    def __sub__(self, v):
+        return sub(self, v)
+    @dimensionality_decorator
+    def __mul__(self, v):
+        return mul(self, v)
+    @dimensionality_decorator
+    def __div__(self, v):
+        return div(self, v)
+    @dimensionality_decorator
+    def interpolate(self, num):
+        return interpolate(self, num)
+    @dimensionality_decorator
+    def __lt__(self, v):
+        return lower_than(self, v)
+    @dimensionality_decorator
+    def __le__(self, v):
+        return lower_equal(self, v)
+    @dimensionality_decorator
+    def __gt__(self, v):
+        return greater_than(self, v)
+    @dimensionality_decorator
+    def __ge__(self, v):
+        return greater_equal(self, v)
+    @indexing_decorator
+    def __getitem__(self, v):
+        return super(Array, self).__getitem__(v)
+    @property
+    def shape(self):
+        return shape(self)
+    @property
+    def abs(self):
+        return arr_abs(self)
+    @property
+    def T(self):
+        return Array(transpose(self))
+### math helper functions
+def shape(self):
+    o = self
+    s = []
+    while hasattr(o, "__len__"):
+        s = s+[len(o)]
+        o = o[0]
+    return s
+
+def transpose(a):
+    mm = len(a[0])
+    a_t = [[v[m] for v in a] for m in range(mm)]
+    return a_t
+
+def arr_abs(a):
+    n = a.shape
+    if len(n)==1:
+        a_abs = [abs(e) for e in a]
+    elif len(n)==2:
+        a_abs = [[abs(e) for e in v] for v in a]
+    return Array(a_abs)
+
+def interpolate(v,points_per_interval, round_to=2):
+    v_i=[[round(v[m]+1.*n/points_per_interval*(v[m+1]-v[m]), round_to) for n in range(points_per_interval)] for m in range(len(v)-1)]
+    ret = []
+    for i in v_i:
+        ret=ret+i
+    ret=ret+[v[-1]]
+    return ret
+
+def add(list1, v):
+    if hasattr(v, "__len__"):
+        return [l+v_ for l, v_ in zip(list1, v)]
+    else:
+        return [l+v for l in list1]
+
+def sub(list1, v):
+    if hasattr(v, "__len__"):
+        return [l-v_ for l, v_ in zip(list1, v)]
+    else:
+        return [l-v for l in list1]
+
+def mul(list1, v):
+    if hasattr(v, "__len__"):
+        return [l*v_ for l, v_ in zip(list1, v)]
+    else:
+        return [l*v for l in list1]
+
+def div(list1, v):
+    if hasattr(v, "__len__"):
+        return [1.*l/v_ for l, v_ in zip(list1, v)]
+    else:
+        return [1.*l/v for l in list1]
+
+def lower_than(self, v):
+    if hasattr(v, "__len__"):
+        return [v_>s_ for v_, s_ in zip(v, self)]
+    else:
+        return [v>s_ for s_ in self]
+
+def lower_equal(self, v):
+    if hasattr(v, "__len__"):
+        return [v_>=s_ for v_, s_ in zip(v, self)]
+    else:
+        return [v>=s_ for s_ in self]
+
+def greater_than(self, v):
+    if hasattr(v, "__len__"):
+        return [s_>v_ for v_, s_ in zip(v, self)]
+    else:
+        return [s_>v for s_ in self]
+
+def greater_equal(self, v):
+    if hasattr(v, "__len__"):
+        return [s_>=v_ for v_, s_ in zip(v, self)]
+    else:
+        return [s_>=v for s_ in self]