def getExplorationForSensor(sensor_name):
from_time_str = request.args.get('from')
to_time_str = request.args.get('to')
sid = db_op.sensorNameToIdMap()[sensor_name]
from_time = parseTime(from_time_str, timezone, constants.RES_DATE_FORMAT)
to_time = parseTime(to_time_str, timezone, constants.RES_DATE_FORMAT)
if ((sid is None) or (from_time > to_time)):
return jsonify({'msg': 'error'})
psd = db_op.fetchPSDAsyncById(from_time,
to_time,
sid,
get_power_dist=False)
response = {'raw': [], 'psd': []}
if sid not in psd:
return make_response(jsonify(response))
psd[sid] = sorted(psd[sid], key=lambda x: x['ts'])
for data in psd[sid]:
response['psd'].append([data['ts'], data['total_power']])
return make_response(jsonify(response))
def floorPSD(floor_num):
ts_from = request.args.get('from')
ts_to = request.args.get('to')
if (ts_from is None) or (ts_to is None):
return make_response(
jsonify({
'msg': 'error',
'reason': 'invalid/empty timestamp'
}))
ts_from = parseTime(ts_from, timezone, constants.RES_DATE_FORMAT)
ts_to = parseTime(ts_to, timezone, constants.RES_DATE_FORMAT)
sensors = db_op.getSensorsByFloor(floor_num)
sids = map(lambda x: x['sid'], sensors)
results = db_op.fetchPSDAsync(ts_from, ts_to, get_power_dist=False)
sids = [sid for sid in results.keys() if sid in sids]
response = defaultdict(list)
for sid in sids:
results[sid] = sorted(results[sid], key=lambda x: x['ts'])
for v in results[sid]:
response[sid].append([
formatTime(v['ts'], timezone, constants.RES_DATE_FORMAT),
v['total_power']
])
return make_response(jsonify(response))
def getCookieValue(st, start_ts, incr=STREAMING_INCR):
if (st is None) or (parseTime(st, timezone, constants.RES_DATE_FORMAT) <
start_ts):
st = formatTime(start_ts, timezone, constants.RES_DATE_FORMAT)
else:
st_parsed = parseTime(st, timezone, constants.RES_DATE_FORMAT)
st_parsed = editedTime(st_parsed, seconds=incr)
st = formatTime(st_parsed, timezone, constants.RES_DATE_FORMAT)
return st
def streaming():
start_ts = request.args.get('t')
incr = int(request.args.get('ns'))
if start_ts:
start_ts = parseTime(start_ts, timezone, constants.RES_DATE_FORMAT)
else:
start_ts = currTime()
from_d_str = getCookieValue(request.cookies.get('st'), start_ts, incr=incr)
from_d = parseTime(from_d_str, timezone, constants.RES_DATE_FORMAT)
to_d = editedTime(from_d, seconds=STREAMING_INCR)
results = db_op.fetchLatestPSD(from_d, to_d=to_d)
sid_list = results.keys()
response = {'v1': [], 'v2': []}
# for v1
value = {}
for sid, val in results.items():
if len(val) > 0:
value[str(sid)] = val[0]['total_power']
response['v1'].append({
'ts': results[sid_list[0]][0]['ts'],
'value': value
})
# for v2
for sid, v in results.items():
if len(v) > 0:
temp = {"id": str(sid), "data": []}
num_freq = len(v[0]['power_dist']) / 2
si = 0
while si < num_freq:
temp['data'].append({
"f": float(si),
"p": v[0]['power_dist'][si]
})
si += 1
response['v2'].append(temp)
resp = make_response(jsonify(response))
resp.set_cookie('st', from_d_str)
return resp
def no_activity_threshold(from_ts, to_ts, fs, sids):
from_time = time_utils.parseTime(from_ts, Constants.APP_TZ,
Constants.RES_DATE_FORMAT)
to_time = time_utils.parseTime(to_ts, Constants.APP_TZ,
Constants.RES_DATE_FORMAT)
duration = int((to_time - from_time).total_seconds())
future_results = db_op.fetchSensorData(from_time, to_time)
records = defaultdict(list)
for future in future_results:
result = future.result()
for row in result:
if row['id'] in sids:
records[row['id']].append(row)
records = OrderedDict(sorted(records.items(), key=lambda x: x[0]))
data = create_matrix(fs * duration, records)
data = data - np.mean(data, axis=0)
return np.reshape(np.std(data, axis=0), (1, len(records)))
def getSensorPSD(sensor_id):
ts = request.args.get('d')
if ts is None:
return make_response(
jsonify({
'msg': 'error',
'reason': 'invalid/empty timestamp'
}))
from_ts = parseTime(ts, timezone, constants.RES_DATE_FORMAT)
results = db_op.fetchPSDAsync(from_ts,
from_ts,
get_avg_power=False,
get_power_dist=True)
response = {'data': []}
for idx, data in enumerate(results[int(sensor_id)][0]['power_dist']):
response['data'].append([idx, data])
return make_response(jsonify(response))
for row in result:
if row['id'] in sids:
records[row['id']].append(row)
records = OrderedDict(sorted(records.items(), key=lambda x: x[0]))
data = create_matrix(fs * duration, records)
data = data - np.mean(data, axis=0)
return np.reshape(np.std(data, axis=0), (1, len(records)))
if __name__ == '__main__':
start_ts = sys.argv[1].strip('\'')
fs = int(sys.argv[2])
duration = 1
end_time = time_utils.parseTime(start_ts, Constants.APP_TZ,
Constants.RES_DATE_FORMAT)
sids = footstep_sensor_name_to_id().values()
sids = sorted(sids)
threshold = no_activity_threshold('2019-04-27 04:00:00',
'2019-04-27 04:00:10', fs, sids)
threshold_data_fname = 'threshold.csv'
np.savetxt(threshold_data_fname, threshold, delimiter=',')
for response in fetch_data(end_time, duration, fs, 'matrix', 1, sids):
response = response - np.mean(response, axis=0)
data_fname = 'footstep_data.csv'
np.savetxt(data_fname, response, delimiter=',')
os.system(
footstep_script_commands.format(data_fname, threshold_data_fname,
fs))