Dev/image server

teleop/carpet_tactile/sensors/app/AppContext.py

@@ -0,0 +1,51 @@
+import numpy as np
+import sys, os, re, time, shutil, math, argparse, datetime
+import scipy.io as sio
+import multiprocessing as mp
+import multiprocessing.managers as mpm
+
+from ..common import myglobals, dataset_tools, input_tools
+from ..app.AppLog import *
+from ..app.PerformanceMonitor import *
+
+class AppContext(object):
+    '''Manages log.'''
+
+    def __init__(self, manager):
+        super(AppContext, self).__init__()
+
+        self.appLog = AppLog()
+        #self.performanceMonitor = manager.setupPerformanceMonitor()
+        self.runDate = datetime.datetime.now()
+
+
+    def release(self):
+        if myglobals.PERFORMANCE_LOG_ENABLED:
+            self.performanceMonitor.dumpToFile(os.path.join(myglobals.DATA_PATH, 'live', 'performance.mat'))
+        self.appLog.release()
+
+
+    # Proxies
+    def log(self, message, timeoutMs = myglobals.DEFAULT_CONSOLE_TIMEOUT_MS):
+        return self.appLog.log(message, timeoutMs)
+
+    def print(self, message, timeoutMs = myglobals.DEFAULT_CONSOLE_TIMEOUT_MS):
+        return self.appLog.log(message, timeoutMs)
+
+    def tick(self, key, desc = ''):
+        return None
+        return self.performanceMonitor.tick(key, desc)
+
+    @staticmethod
+    def create():
+        manager = LgManager()
+        #manager.start()
+        ctx = AppContext(manager)
+        return ctx
+
+
+
+class LgManager(mpm.SyncManager): pass
+    #'''Manages resources.'''
+
+#LgManager.register('setupPerformanceMonitor', setup_PerformanceMonitor, proxytype=PerformanceMonitorProxy, exposed = ('reset', 'tick', 'report', 'dumpToFile', '__str__'))

teleop/carpet_tactile/sensors/app/AppLog.py

@@ -0,0 +1,68 @@
+import sys; sys.path.insert(0, '.')
+
+import numpy as np
+import sys, os, re, time, shutil, math
+from joblib import Parallel, delayed
+from collections import OrderedDict
+import cv2
+import scipy.io as sio
+try:
+    import torch.multiprocessing as mp
+except:
+    import multiprocessing as mp
+import ctypes
+
+
+from ..common import myglobals, dataset_tools, image_tools
+
+class LogEntry(object):
+
+    COUNTER = 0
+
+    def __init__(self, message, timeoutMs):
+        super(LogEntry, self).__init__()
+        self.guid = LogEntry.COUNTER
+        LogEntry.COUNTER += 1
+
+        self.created = dataset_tools.getUnixTimestamp()
+        self.message = message
+        self.timeoutMs = timeoutMs
+
+    def isValid(self):
+        if self.timeoutMs <= 0:
+            return True
+        ageMs = 1000*(dataset_tools.getUnixTimestamp() - self.created)
+        return ageMs < self.timeoutMs
+
+
+class AppLog(object):
+    '''Manages log.'''
+
+    def __init__(self):
+        super(AppLog, self).__init__()
+        #self.logQueue = DataQueueOrdered(limit = 0)
+        #self.entries = []
+
+
+    def log(self, message, timeoutMs = myglobals.DEFAULT_CONSOLE_TIMEOUT_MS):
+        print(message)
+        #entry = LogEntry(message, timeoutMs)
+        #self.logQueue.push(entry)
+
+    def consume(self):
+        return
+        while True:
+            entry = self.logQueue.pop()
+            if entry is None:
+                break
+            self.entries.append(entry)
+
+    def clear(self):
+        #self.entries.clear()
+        pass
+
+    def release(self):
+        print('[AppLog] Releasing...')
+        #self.logQueue.release()            
+        print('[AppLog] Released.')
+

teleop/carpet_tactile/sensors/app/AppOptions.py

@@ -0,0 +1,26 @@
+import numpy as np
+import sys, os, re, time, shutil, math, argparse, datetime
+
+class AppOptions(object):
+
+    def __init__(self, parser):
+        self.parser = parser
+
+    def getCmd(self, mods = None):
+        args = self.parser.parse_args()
+        if not mods is None:
+            args = self.applyMods(args, mods)
+        return args
+
+    def getDefault(self, mods = None):
+        args = self.parser.parse_args()
+        for key in vars(args):
+            setattr(args, key, self.parser.get_default(key))
+        if not mods is None:
+            args = self.applyMods(args, mods)
+        return args
+
+    def applyMods(self, args, mods):
+        for k,v in mods.items():
+            setattr(args, k, v)
+        return args

teleop/carpet_tactile/sensors/app/FramerateMonitor.py

@@ -0,0 +1,32 @@
+import sys, os, re, time, shutil, math, random, datetime, argparse, signal, traceback
+import multiprocessing as mp
+import numpy as np
+
+class FramerateMonitor(object):
+    def __init__(self, maxAgeSec = 2.0, maxSamples = 120):
+        self.maxAgeSec = maxAgeSec
+        self.maxSamples = maxSamples
+        self.reset()
+        super(FramerateMonitor, self).__init__()
+
+    def tick(self):
+        self.ts += [time.time()]
+        self._update()
+
+    def reset(self):
+        self.ts = []
+
+    def _update(self):
+        self.ts = self.ts[-self.maxSamples:]
+        now = time.time()
+        for i in range(len(self.ts) - 1, -1, -1):
+            if now - self.ts[i] > self.maxAgeSec:
+                self.ts = self.ts[i+1:]
+                break
+
+
+    def getFps(self):
+        if len(self.ts) < 2:
+            return -1
+        return (len(self.ts) - 1) / max(self.ts[-1] - self.ts[0], 1e-3)
+

teleop/carpet_tactile/sensors/app/PerformanceMonitor.py

@@ -0,0 +1,70 @@
+import numpy as np
+import sys, os, re, time, shutil, math
+import scipy.io as sio
+import multiprocessing as mp
+import multiprocessing.managers as mpm
+#import torch.multiprocessing as mp
+
+from ..common import myglobals, dataset_tools
+
+''' Loosely inspired by: https://pythonhosted.org/ruffus/html/sharing_data_across_jobs_example.html '''
+
+class PerformanceMonitor(object):
+
+    def __init__(self):
+        super(PerformanceMonitor, self).__init__()
+        self.reset()
+
+    def tick(self, key, desc = ''):
+        ts = dataset_tools.getUnixTimestamp()
+        if not key in self.keyedTicks:
+            self.keyedTicks[key] = []
+        self.keyedTicks[key].append(ts)
+
+        self.timestamps.append(ts)
+        self.keys.append(key)
+        self.descs.append(desc)
+        #print('New keyedTicks is %d: %s' % (len(self.keyedTicks[key]), key))
+
+    def report(self):
+        res = dict()
+        for k,v in self.keyedTicks.items():
+            if len(v) < 2:
+                res[k] = 0.0
+                continue
+            ts = v[-100:]
+            dts = np.diff(ts)
+            fps = 1.0 / np.mean(dts)
+            res[k] = fps
+        return res
+
+    def dumpToFile(self, filename):
+        print('[PerformanceMonitor] Dumping to %s...' % filename)
+        meta = dict()
+        meta['timestamp'] = np.array(self.timestamps, np.float)
+        meta['key'] = np.array(self.keys, np.object)
+        meta['desc'] = np.array(self.descs, np.object)
+        sio.savemat(filename, meta)
+        print('[PerformanceMonitor] Dumped to %s...' % filename)
+
+    def reset(self):
+        self.keyedTicks = dict()        
+        self.timestamps = []
+        self.keys = []
+        self.descs = []
+
+
+def setup_PerformanceMonitor():
+    return PerformanceMonitor()
+
+class PerformanceMonitorProxy(mpm.BaseProxy):
+    def reset(self):
+        return self._callmethod('reset', [])
+    def tick(self, key, desc = ''):
+        return self._callmethod('tick', [key, desc])
+    def report(self):
+        return self._callmethod('report', [])
+    def dumpToFile(self, filename):
+        return self._callmethod('dumpToFile', [filename])
+    def __str__ (self):
+        return "PerformanceMonitorProxy"