openpilot v0.7.6 release

common/android.py

@@ -22,10 +22,10 @@ def get_imei(slot):
   if slot not in ("0", "1"):
     raise ValueError("SIM slot must be 0 or 1")
 
-  ret = parse_service_call_string(service_call(["iphonesubinfo", "3" ,"i32", str(slot)]))
+  ret = parse_service_call_string(service_call(["iphonesubinfo", "3" , "i32", str(slot)]))
   if not ret:
     # allow non android to be identified differently
-    ret = "%015d" % random.randint(0, 1<<32)
+    ret = "%015d" % random.randint(0, 1 << 32)
   return ret
 
 def get_serial():
@@ -132,6 +132,7 @@ def get_network_type():
 
 def get_network_strength(network_type):
   network_strength = NetworkStrength.unknown
+
   # from SignalStrength.java
   def get_lte_level(rsrp, rssnr):
     INT_MAX = 2147483647

common/api/__init__.py

@@ -39,4 +39,3 @@ def api_get(endpoint, method='GET', timeout=None, access_token=None, **params):
   headers['User-Agent'] = "openpilot-" + version
 
   return requests.request(method, backend+endpoint, timeout=timeout, headers = headers, params=params)
-

common/apk.py

@@ -13,7 +13,7 @@ def get_installed_apks():
   ret = {}
   for x in dat:
     if x.startswith("package:"):
-      v,k = x.split("package:")[1].split("=")
+      v, k = x.split("package:")[1].split("=")
       ret[k] = v
   return ret
 

common/basedir.py

@@ -8,4 +8,3 @@ if ANDROID:
 else:
   PERSIST = os.path.join(BASEDIR, "persist")
   PARAMS = os.path.join(BASEDIR, "persist", "params")
-

common/file_helpers.py

@@ -44,7 +44,8 @@ class AutoMoveTempdir():
   def close(self):
     os.rename(self._path, self._target_path)
 
-  def __enter__(self): return self
+  def __enter__(self):
+    return self
 
   def __exit__(self, type, value, traceback):
     if type is None:
@@ -63,7 +64,8 @@ class NamedTemporaryDir():
   def close(self):
     shutil.rmtree(self._path)
 
-  def __enter__(self): return self
+  def __enter__(self):
+    return self
 
   def __exit__(self, type, value, traceback):
     self.close()

common/logging_extra.py

@@ -68,8 +68,11 @@ class SwagErrorFilter(logging.Filter):
   def filter(self, record):
     return record.levelno < logging.ERROR
 
-_tmpfunc = lambda: 0
-_srcfile = os.path.normcase(_tmpfunc.__code__.co_filename)
+def _tmpfunc():
+  return 0
+
+def _srcfile():
+  return os.path.normcase(_tmpfunc.__code__.co_filename)
 
 class SwagLogger(logging.Logger):
   def __init__(self):

common/manager_helpers.py

@@ -6,13 +6,13 @@ def print_cpu_usage(first_proc, last_proc):
   r = 0
   procs = [
       ("selfdrive.controls.controlsd", 59.46),
-      ("./_modeld", 48.94),
+      ("./_modeld", 6.75),
       ("./loggerd", 28.49),
       ("selfdrive.controls.plannerd", 19.77),
       ("selfdrive.controls.radard", 9.54),
       ("./_ui", 9.54),
       ("./camerad", 7.07),
-      ("selfdrive.locationd.locationd", 7.13),
+      ("selfdrive.locationd.locationd", 27.46),
       ("./_sensord", 6.17),
       ("selfdrive.controls.dmonitoringd", 5.48),
       ("./boardd", 3.63),

common/numpy_fast.py

@@ -6,6 +6,7 @@ def clip(x, lo, hi):
 
 def interp(x, xp, fp):
   N = len(xp)
+
   def get_interp(xv):
     hi = 0
     while hi < N and xv > xp[hi]:
@@ -14,8 +15,8 @@ def interp(x, xp, fp):
     return fp[-1] if hi == N and xv > xp[low] else (
       fp[0] if hi == 0 else
       (xv - xp[low]) * (fp[hi] - fp[low]) / (xp[hi] - xp[low]) + fp[low])
-  return [get_interp(v) for v in x] if hasattr(
-    x, '__iter__') else get_interp(x)
+
+  return [get_interp(v) for v in x] if hasattr(x, '__iter__') else get_interp(x)
 
 def mean(x):
   return sum(x) / len(x)

common/params.py

@@ -22,10 +22,7 @@ file in place without messing with <params_dir>/d.
 """
 import time
 import os
-import string
-import binascii
 import errno
-import sys
 import shutil
 import fcntl
 import tempfile
@@ -198,7 +195,8 @@ class DBReader(DBAccessor):
     finally:
       lock.release()
 
-  def __exit__(self, type, value, traceback): pass
+  def __exit__(self, type, value, traceback):
+    pass
 
 
 class DBWriter(DBAccessor):
@@ -401,22 +399,3 @@ def put_nonblocking(key, val):
   t = threading.Thread(target=f, args=(key, val))
   t.start()
   return t
-
-
-if __name__ == "__main__":
-  params = Params()
-  if len(sys.argv) > 2:
-    params.put(sys.argv[1], sys.argv[2])
-  else:
-    for k in keys:
-      pp = params.get(k)
-      if pp is None:
-        print("%s is None" % k)
-      elif all(chr(c) in string.printable for c in pp):
-        print("%s = %s" % (k, pp))
-      else:
-        print("%s = %s" % (k, binascii.hexlify(pp)))
-
-  # Test multiprocess:
-  # seq 0 100000 | xargs -P20 -I{} python common/params.py DongleId {} && sleep 0.05
-  # while python common/params.py DongleId; do sleep 0.05; done

common/profiler.py

@@ -43,4 +43,3 @@ class Profiler():
       else:
         print("%30s: %9.2f   percent: %3.0f" % (n, ms*1000.0, ms/self.tot*100))
     print("Iter clock: %2.6f   TOTAL: %2.2f" % (self.tot/self.iter, self.tot))
-

common/spinner.py

@@ -40,7 +40,7 @@ class Spinner():
     self.close()
 
 
-class FakeSpinner():
+class FakeSpinner(Spinner):
   def __init__(self):
     pass
 

common/stat_live.py

@@ -32,7 +32,7 @@ class RunningStat():
       self.S_last = 0.
     else:
       self.M = self.M_last + (new_data - self.M_last) / self.n
-      self.S = self.S_last + (new_data - self.M_last) * (new_data - self.M);
+      self.S = self.S_last + (new_data - self.M_last) * (new_data - self.M)
       self.M_last = self.M
       self.S_last = self.S
 
@@ -64,7 +64,7 @@ class RunningStatFilter():
     _std_last = self.raw_stat.std()
     self.raw_stat.push_data(new_data)
     _delta_std = self.raw_stat.std() - _std_last
-    if _delta_std<=0:
+    if _delta_std <= 0:
       self.filtered_stat.push_data(new_data)
     else:
       pass

common/testing.py

@@ -6,4 +6,3 @@ def phone_only(x):
     return x
   else:
     return nottest(x)
-

common/text_window.py

@@ -43,7 +43,7 @@ class TextWindow():
     self.close()
 
 
-class FakeTextWindow():
+class FakeTextWindow(TextWindow):
   def __init__(self, s):
     pass
 
@@ -59,6 +59,9 @@ class FakeTextWindow():
   def update(self, _):
     pass
 
+  def close(self):
+    pass
+
   def __exit__(self, type, value, traceback):
     pass
 

common/timeout.py

@@ -25,4 +25,3 @@ class Timeout:
 
   def __exit__(self, exc_type, exc_val, exc_tb):
     signal.alarm(0)
-

common/transformations/camera.py

@@ -59,7 +59,7 @@ def vp_from_ke(m):
 
   The vanishing point is defined as lim x->infinity C (x, 0, 0, 1).T
   """
-  return (m[0, 0]/m[2,0], m[1,0]/m[2,0])
+  return (m[0, 0]/m[2, 0], m[1, 0]/m[2, 0])
 
 
 def vp_from_rpy(rpy):
@@ -81,10 +81,10 @@ def normalize(img_pts, intrinsics=eon_intrinsics):
   img_pts = np.array(img_pts)
   input_shape = img_pts.shape
   img_pts = np.atleast_2d(img_pts)
-  img_pts = np.hstack((img_pts, np.ones((img_pts.shape[0],1))))
+  img_pts = np.hstack((img_pts, np.ones((img_pts.shape[0], 1))))
   img_pts_normalized = img_pts.dot(intrinsics_inv.T)
   img_pts_normalized[(img_pts < 0).any(axis=1)] = np.nan
-  return img_pts_normalized[:,:2].reshape(input_shape)
+  return img_pts_normalized[:, :2].reshape(input_shape)
 
 
 def denormalize(img_pts, intrinsics=eon_intrinsics):
@@ -93,13 +93,13 @@ def denormalize(img_pts, intrinsics=eon_intrinsics):
   img_pts = np.array(img_pts)
   input_shape = img_pts.shape
   img_pts = np.atleast_2d(img_pts)
-  img_pts = np.hstack((img_pts, np.ones((img_pts.shape[0],1))))
+  img_pts = np.hstack((img_pts, np.ones((img_pts.shape[0], 1))))
   img_pts_denormalized = img_pts.dot(intrinsics.T)
-  img_pts_denormalized[img_pts_denormalized[:,0] > W] = np.nan
-  img_pts_denormalized[img_pts_denormalized[:,0] < 0] = np.nan
-  img_pts_denormalized[img_pts_denormalized[:,1] > H] = np.nan
-  img_pts_denormalized[img_pts_denormalized[:,1] < 0] = np.nan
-  return img_pts_denormalized[:,:2].reshape(input_shape)
+  img_pts_denormalized[img_pts_denormalized[:, 0] > W] = np.nan
+  img_pts_denormalized[img_pts_denormalized[:, 0] < 0] = np.nan
+  img_pts_denormalized[img_pts_denormalized[:, 1] > H] = np.nan
+  img_pts_denormalized[img_pts_denormalized[:, 1] < 0] = np.nan
+  return img_pts_denormalized[:, :2].reshape(input_shape)
 
 
 def device_from_ecef(pos_ecef, orientation_ecef, pt_ecef):
@@ -124,10 +124,10 @@ def img_from_device(pt_device):
   pt_view = np.einsum('jk,ik->ij', view_frame_from_device_frame, pt_device)
 
   # This function should never return negative depths
-  pt_view[pt_view[:,2] < 0] = np.nan
+  pt_view[pt_view[:, 2] < 0] = np.nan
 
-  pt_img = pt_view/pt_view[:,2:3]
-  return pt_img.reshape(input_shape)[:,:2]
+  pt_img = pt_view/pt_view[:, 2:3]
+  return pt_img.reshape(input_shape)[:, :2]
 
 
 def get_camera_frame_from_calib_frame(camera_frame_from_road_frame):
@@ -145,4 +145,3 @@ def pretransform_from_calib(calib):
   camera_frame_from_road_frame = np.dot(eon_intrinsics, view_frame_from_road_frame)
   camera_frame_from_calib_frame = get_camera_frame_from_calib_frame(camera_frame_from_road_frame)
   return np.linalg.inv(camera_frame_from_calib_frame)
-

common/transformations/coordinates.py

@@ -18,9 +18,9 @@ def geodetic2ecef(geodetic, radians=False):
   geodetic = np.atleast_2d(geodetic)
 
   ratio = 1.0 if radians else (np.pi / 180.0)
-  lat = ratio*geodetic[:,0]
-  lon = ratio*geodetic[:,1]
-  alt = geodetic[:,2]
+  lat = ratio*geodetic[:, 0]
+  lon = ratio*geodetic[:, 1]
+  alt = geodetic[:, 2]
 
   xi = np.sqrt(1 - esq * np.sin(lat)**2)
   x = (a / xi + alt) * np.cos(lat) * np.cos(lon)
@@ -52,7 +52,7 @@ def ecef2geodetic(ecef, radians=False):
   S = np.cbrt(1 + C + np.sqrt(C * C + 2 * C))
   P = F / (3 * pow((S + 1 / S + 1), 2) * G * G)
   Q = np.sqrt(1 + 2 * esq * esq * P)
-  r_0 =  -(P * esq * r) / (1 + Q) + np.sqrt(0.5 * a * a*(1 + 1.0 / Q) - \
+  r_0 = -(P * esq * r) / (1 + Q) + np.sqrt(0.5 * a * a*(1 + 1.0 / Q) - \
         P * (1 - esq) * z * z / (Q * (1 + Q)) - 0.5 * P * r * r)
   U = np.sqrt(pow((r - esq * r_0), 2) + z * z)
   V = np.sqrt(pow((r - esq * r_0), 2) + (1 - esq) * z * z)
@@ -78,6 +78,8 @@ class LocalCoord():
                                      [-np.sin(lat)*np.sin(lon), np.cos(lon), -np.cos(lat)*np.sin(lon)],
                                      [np.cos(lat), 0, -np.sin(lat)]])
     self.ecef2ned_matrix = self.ned2ecef_matrix.T
+    self.ecef_from_ned_matrix = self.ned2ecef_matrix
+    self.ned_from_ecef_matrix = self.ecef2ned_matrix
 
   @classmethod
   def from_geodetic(cls, init_geodetic):

common/transformations/model.py

@@ -130,9 +130,9 @@ def get_camera_frame_from_bigmodel_frame(camera_frame_from_road_frame):
 
 def get_model_frame(snu_full, camera_frame_from_model_frame, size):
   idxs = camera_frame_from_model_frame.dot(np.column_stack([np.tile(np.arange(size[0]), size[1]),
-                                                            np.tile(np.arange(size[1]), (size[0],1)).T.flatten(),
+                                                            np.tile(np.arange(size[1]), (size[0], 1)).T.flatten(),
                                                             np.ones(size[0] * size[1])]).T).T.astype(int)
-  calib_flat = snu_full[idxs[:,1], idxs[:,0]]
+  calib_flat = snu_full[idxs[:, 1], idxs[:, 0]]
   if len(snu_full.shape) == 3:
     calib = calib_flat.reshape((size[1], size[0], 3))
   elif len(snu_full.shape) == 2:

common/transformations/orientation.py

@@ -13,11 +13,11 @@ Supports both x2y and y_from_x format (y_from_x preferred!).
 def euler2quat(eulers):
   eulers = array(eulers)
   if len(eulers.shape) > 1:
-    output_shape = (-1,4)
+    output_shape = (-1, 4)
   else:
     output_shape = (4,)
   eulers = np.atleast_2d(eulers)
-  gamma, theta, psi = eulers[:,0],  eulers[:,1],  eulers[:,2]
+  gamma, theta, psi = eulers[:, 0],  eulers[:, 1],  eulers[:, 2]
 
   q0 = np.cos(gamma / 2) * np.cos(theta / 2) * np.cos(psi / 2) + \
        np.sin(gamma / 2) * np.sin(theta / 2) * np.sin(psi / 2)
@@ -30,7 +30,7 @@ def euler2quat(eulers):
 
   quats = array([q0, q1, q2, q3]).T
   for i in range(len(quats)):
-    if quats[i,0] < 0:
+    if quats[i, 0] < 0:
       quats[i] = -quats[i]
   return quats.reshape(output_shape)
 
@@ -38,11 +38,11 @@ def euler2quat(eulers):
 def quat2euler(quats):
   quats = array(quats)
   if len(quats.shape) > 1:
-    output_shape = (-1,3)
+    output_shape = (-1, 3)
   else:
     output_shape = (3,)
   quats = np.atleast_2d(quats)
-  q0, q1, q2, q3 = quats[:,0], quats[:,1], quats[:,2], quats[:,3]
+  q0, q1, q2, q3 = quats[:, 0], quats[:, 1], quats[:, 2], quats[:, 3]
 
   gamma = np.arctan2(2 * (q0 * q1 + q2 * q3), 1 - 2 * (q1**2 + q2**2))
   theta = np.arcsin(2 * (q0 * q2 - q3 * q1))
@@ -101,7 +101,7 @@ def rot2quat(rots):
   q = np.empty((len(rots), 4))
   for i in range(len(rots)):
     _, eigvecs = linalg.eigh(K3[i].T)
-    eigvecs = eigvecs[:,3:]
+    eigvecs = eigvecs[:, 3:]
     q[i, 0] = eigvecs[-1]
     q[i, 1:] = -eigvecs[:-1].flatten()
     if q[i, 0] < 0:
@@ -124,8 +124,8 @@ def rot2euler(rots):
 quats_from_rotations = rot2quat
 quat_from_rot = rot2quat
 rotations_from_quats = quat2rot
-rot_from_quat= quat2rot
-rot_from_quat= quat2rot
+rot_from_quat = quat2rot
+rot_from_quat = quat2rot
 euler_from_rot = rot2euler
 euler_from_quat = quat2euler
 rot_from_euler = euler2rot
@@ -154,9 +154,9 @@ def rot_matrix(roll, pitch, yaw):
   cr, sr = np.cos(roll), np.sin(roll)
   cp, sp = np.cos(pitch), np.sin(pitch)
   cy, sy = np.cos(yaw), np.sin(yaw)
-  rr = array([[1,0,0],[0, cr,-sr],[0, sr, cr]])
-  rp = array([[cp,0,sp],[0, 1,0],[-sp, 0, cp]])
-  ry = array([[cy,-sy,0],[sy, cy,0],[0, 0, 1]])
+  rr = array([[1, 0, 0], [0, cr, -sr], [0, sr, cr]])
+  rp = array([[cp, 0, sp], [0, 1, 0], [-sp, 0, cp]])
+  ry = array([[cy, -sy, 0], [sy, cy, 0], [0, 0, 1]])
   return ry.dot(rp.dot(rr))