Merge server

pi/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "venv\\Scripts\\python.exe"
+}

server/analysis.py

@@ -6,6 +6,7 @@
 import os
 import re
 import matplotlib.pyplot as plt
+import noisereduce as nr
 
 # PATH = os.cwd()
 # OUTPUT_DIR = "/pi/output/"
@@ -19,18 +20,18 @@
 frame_total = 1000
 chunk_size = 1
 num_sounds = 0
-zoom = 30
+zoom = 50
 
 UPLOADS_PATH = os.path.join(os.getcwd(),"uploads")
 
 def read_files(clear_after_read = False):
     global channel1, channel2, channel3
     file_list = os.listdir(UPLOADS_PATH)
     for file_name in file_list:
-        print(file_list)
+        # print(file_list)
         if re.match(r".*\.wav", file_name):
             file_info = file_name.split("-")
-            print(file_info)
+            # print(file_info)
             if (file_info[1] == '0'):
                 sample_rate, channel1 = read(os.path.join(UPLOADS_PATH, file_name))
                 if (clear_after_read):
@@ -44,6 +45,25 @@ def read_files(clear_after_read = False):
                 if (clear_after_read):
                     os.remove(os.path.join(UPLOADS_PATH, file_name))
 
+NOISE_PATH = os.path.join(os.getcwd(), "noise")
+def read_noise(clear_after_read = False):
+    global noisefile
+    for file_name in os.listdir(NOISE_PATH):
+        if re.match(r".*\.wav", file_name):
+                sample_rate, noisefile = read(os.path.join(NOISE_PATH, file_name))
+                if (clear_after_read):
+                    os.remove(os.path.join(UPLOADS_PATH, file_name))
+
+def process_noise():
+    global noisefile, frame_total
+    try:
+        noisefile = abs(noisefile[:,0]/2) + abs(noisefile[:,1]/2)
+    except:
+        noisefile = abs(noisefile[:])
+    noisefile = noisefile[::len(noisefile)//(frame_total-1)]
+
+
+
 def process_files():
     global channel1, channel2, channel3, frame_total
     try:
@@ -68,9 +88,11 @@ def smooth(x, window_len = 15):
     return y
 
 #Smoothing function that is currently in use
-def chonk_avg(arr, chunk_size):
+def denoise_and_smooth(arr, chunk_sizem):
     #Produces a new array of the average value in each chunk of  chunk_size
     #New array contains (len(arr)//chunk_size) chunks
+
+
     chonks = []
     newLen = frame_total//chunk_size
     for i in range(newLen + 1):
@@ -88,12 +110,12 @@ def find_module_events(s1, s2, s3):
     module_thresh = (find_event_thresh(s1) + find_event_thresh(s2) +find_event_thresh(s3))/3
 
     e1 = find_mic_events(s1, module_thresh)
-    print("             e1 is:", e1)
+    # print("             e1 is:", e1)
     e2 = find_mic_events(s2, module_thresh)
-    print("             e2 is:", e2)
+    # print("             e2 is:", e2)
     e3 = find_mic_events(s3, module_thresh)
 
-    print("Merge of e1 and e2:", e_merge_two(e1, e2))
+    # print("Merge of e1 and e2:", e_merge_two(e1, e2))
 
     #Final module list
     e_module = e_merge_two(e_merge_two(e1, e2), e3)
@@ -295,7 +317,7 @@ def convertToVolumeList(event_list, c1, c2, c3):
 #Create plot of original sound file
 #g = drawPlot(channel1, 0)
 
-#smoothChannel = chonk_avg(channel1, 20)
+#smoothChannel = denoise_and_smooth(channel1, 20)
 #threshold = find_event_thresh(smoothChannel)
 
 #f = Plot of smoothed sound file
@@ -312,24 +334,29 @@ def convertToVolumeList(event_list, c1, c2, c3):
 
 def main():
     read_files()
+    read_noise()
     process_files()
 
-    smooth1 = chonk_avg(channel1, zoom)
-    smooth2 = chonk_avg(channel2, zoom)
-    smooth3 = chonk_avg(channel3, zoom)
+    smooth1 = denoise_and_smooth(channel1, zoom)
+    smooth2 = denoise_and_smooth(channel2, zoom)
+    smooth3 = denoise_and_smooth(channel3, zoom)
+
+    drawPlot(noisefile, 1)
+
 
-    drawPlot(smooth1, 1)
-    plt.axhline(y=find_event_thresh(smooth1), color='r', linestyle='-')
-    plt.xticks(range(0, len(smooth1), 1))
+    # drawPlot(smooth1, 1)
+    # plt.axhline(y=find_event_thresh(smooth1), color='r', linestyle='-')
+    # plt.xticks(range(0, len(smooth1), 1))
 
-    drawPlot(smooth2, 2)
-    drawPlot(smooth3, 3)
+    # drawPlot(smooth2, 2)
+    # drawPlot(smooth3, 3)
 
     # print(find_module_events(smooth1, smooth2, smooth3))
     # volumes_list = convertToVolumeList(find_module_events(smooth1, smooth2, smooth3), smooth1, smooth2, smooth3)
     # print(volumes_list)
 
     plt.show()
+
 
     find_module_events(smooth1 ,smooth2, smooth3)
 

server/app.py

@@ -1,75 +1,123 @@
-import os, requests, analysis as an
+import os
+import requests
+import module
+import re
 from flask import *
 from functions import *
+import matplotlib.pyplot as plt
 
-# Sound sample
+###############################################################################
+# OBJECTS
+###############################################################################
+# Sound sample (for relative position to one module)
 class Sound:
 	def __init__(self, vol = 0, direc = 0, time = 0):
 		self.vol = vol
 		self.dir = direc
 		self.time = time
 
+# Sound sources
+class Source:
+	def __init__(self, vol = 0, x = 0, y = 0, time = 0):
+		self.vol = vol
+		self.x = x
+		self.y = y
+		self.time = time
+
 # Data transfer to website
 class Data:
 	def __init__(self, n = 0, avgvol = 0, time = 0):
 		self.n = n
 		self.avgvol = avgvol
 		self.time = time
 
-# Constants
-UPLOAD_FOLDER = 'uploads'
+# Module Location (coordinates)
+class Module_Location:
+	def __init__(self, x = 0, y = 0):
+		self.x = x
+		self.y = y
+
+###############################################################################
+# CONSTANTS
+###############################################################################
+UPLOAD_FOLDER = os.path.join(os.getcwd(), "uploads")
 x = 3 # size of grid: width
 y = 3 # size of grid: height
 grid = []
+module_locations = [] # list of Module_Location objects (contains locations of modules)
+times = [] # list of times of files in folder
 tdelta = 3.0 # refresh delay
 FILE_NAME = ''
 nSamples = 5
-zoom = an.zoom
+zoom = 20
+modules = {}
 
 # App initialization
 app = Flask(__name__)
 app.config['TEMPLATES_AUTO_RELOAD'] = True
 
+###############################################################################
+# HELPERS
+###############################################################################
 # Run a function periodically
 def refresh(f, delay):
 	t = Timer(delay, f)
 	t.start()
 
 # Update sample data datetime.now().strftime('%I:%M:%S%p')
 def update():
-	global grid, nSamples, zoom
-	an.read_files()
-	an.process_files()
-
-	smooth1 = an.chonk_avg(an.channel1, zoom)
-	smooth2 = an.chonk_avg(an.channel2, zoom)
-	smooth3 = an.chonk_avg(an.channel3, zoom)
-	drawPlot(smooth1, 1)
-	grid = an.convertToVolumeList(an.find_module_events(smooth1, smooth2, smooth3), smooth1, smooth2, smooth3)
+	global grid, nSamples, zoom, times, UPLOAD_FOLDER
+	# Initialize times
+	for file in os.listdir(UPLOAD_FOLDER):
+		if re.match(r".*\.wav", file):
+			currTime = file.split('-')[2]
+			if currTime not in times:
+				times.append(currTime)
+
+	for time in times:
+		modules[time] = module.get_modules(time) # list of Modules
+
+	grid = []
+	try:
+		mostRecent = modules[max(modules.keys())]
+	except:
+		mostRecent = []
+	for mod in mostRecent:
+		grid.append(mod.convertToVolumeList())
+
+	# grid = Module.convertToVolumeList(Module.find_module_events(smooth1, smooth2, smooth3), smooth1, smooth2, smooth3)
 	convert(grid)
-	nSamples = len(grid)
+
+	if len(grid) and grid[0]:
+		nSamples = len(grid[0])
+	else:
+		nSamples = 1
+
+
+
+	# module.read_files(times)
+	# module.process_files()
+
 	# nSamples = round(random() * 8 + 1)
-	# grid = []
-	# for i in range(nSamples):
-	# 	grid.append(gen_random())
-	# refresh(update, tdelta)
 
 # Print info to console
-def printGrid():
+def print_grid():
 	global tdelta, x, y, grid
-	points = list(map(exact, grid))
+	points = list(map(relative_location, grid))
 	for data in points:
 		print('-------------------------------')
 		print('Volume: ' + str(data.vol) + ', Direction: ' + str(data.dir) + ', Time: ' + str(data.time))
 		print('-------------------------------')
-	# refresh(printGrid, tdelta)
 
 # Put relevant data in Data object to send to front-end
-def genData(points):
+def generate_data(points):
 	global nSamples
 	average = round(sum([point.vol for point in points]) / nSamples, 2)
 	return Data(nSamples, average, points[0].time)
 
+###############################################################################
+# ROUTES
+###############################################################################
 # Upload
 @app.route('/upload', methods = ['GET', 'POST'])
 def upload():
@@ -83,14 +131,18 @@ def upload():
 def index():
 	global grid, tdelta, nSamples
 	update()
-	# printGrid()
-	points = list(map(exact, grid))
+	print("Past update")
+	# print_grid()
+	############################################################################
+	# TODO: Only take the most recent recordings and put them in a Sound object, ignore all others
+	for elem in grid:
+		points = list(map(relative_location, elem))
 	for display in points:
 		display.vol = round(display.vol, 2)
 		display.dir = round(display.dir, 2)
-		print(display.dir)
-	address = gen_radar(points)
-	data = genData(points)
+	address = generate_radar(points)
+	# address2 = generate_map(points)
+	data = generate_data(points)
 	return render_template('index.html', data=data, address=address, tdelta=tdelta)
 
 # Test POST Requests
@@ -103,6 +155,14 @@ def listen():
 		f.save(os.path.join('uploads', f.filename))
 		FILE_NAME = f.filename
 		print('File name: ' + FILE_NAME)
+		# print('IP Address:' + request.text)
+	return redirect('/')
+
+@app.route('/test', methods = ['POST'])
+def test():
+	if request.method == 'POST':
+		print('RECEIVED TEST')
+		print(request.data)
 	return redirect('/')
 
 if __name__ == '__main__':

server/app2.py → server/backup_app.py

@@ -41,9 +41,9 @@ def update():
 	an.read_files()
 	an.process_files()
 
-	smooth1 = an.chonk_avg(an.channel1, zoom)
-	smooth2 = an.chonk_avg(an.channel2, zoom)
-	smooth3 = an.chonk_avg(an.channel3, zoom)
+	smooth1 = an.denoise_and_smooth(an.channel1, zoom)
+	smooth2 = an.denoise_and_smooth(an.channel2, zoom)
+	smooth3 = an.denoise_and_smooth(an.channel3, zoom)
 	drawPlot(smooth1, 1)
 	grid = an.convertToVolumeList(an.find_module_events(smooth1, smooth2, smooth3), smooth1, smooth2, smooth3)
 	convert(grid)
@@ -88,10 +88,10 @@ def index():
 	for display in points:
 		display.vol = round(display.vol, 2)
 		display.dir = round(display.dir, 2)
-		print(display.dir)
+		# print(display.dir)
 	address = gen_radar(points)
 	data = genData(points)
-	return render_template('index.html', data=data, address='static/img/plot.png', tdelta=tdelta)
+	return render_template('index.html', data=data, address=address, tdelta=tdelta)
 
 # Test POST Requests
 @app.route('/listen', methods = ['POST'])
@@ -100,7 +100,7 @@ def listen():
 	if request.method == 'POST':
 		print('RECEIVED')
 		f = request.files['file']
-		f.save(os.path.join('uploads', f.filename))
+		f.save(os.path.join('uploads2', f.filename))
 		FILE_NAME = f.filename
 		print('File name: ' + FILE_NAME)
 	return redirect('/')