update

app.py

@@ -3,7 +3,6 @@ import numpy as np
 import os
 import random
 import math
-import json
 import utils
 from channel_mapping import mapping_stage1, mapping_stage2, reorder_to_template, reorder_to_origin
 
@@ -46,48 +45,63 @@ Electroencephalography (EEG) signals are often contaminated with artifacts. It i
 """
 
 chkbox_js = """
-(state_json) => {
-	state_json = JSON.parse(JSON.stringify(state_json));
-	if(state_json.state == "finished") return;
+(app_state, channel_info) => {
+	app_state = JSON.parse(JSON.stringify(app_state));
+	channel_info = JSON.parse(JSON.stringify(channel_info));
+	if(app_state.state == "finished") return;
 	
 	// add figure of in_montage
 	document.querySelector("#chkbox-group> div:nth-of-type(2)").style.cssText = `
 		position: relative;
 		width: 560px;
 		height: 560px;
-		background: url("file=${state_json.files.raw_montage}");
+		background: url("file=${app_state.files.raw_montage}");
 	`;
 	
-	// add indication for the missing channel
-	/*
-	let indicator = document.getElementById("indicator")
-	if(!indicator) document.querySelector("#chkbox-group> div:nth-of-type(2)").innerHTML += '<div id="indicator"></div>'
 	
-	let channel = state_json.missingChannelsIndex[0]
-	channel = state_json.templateByIndex[channel]
-	let left = state_json.templateByName[channel].css_position[0];
-	let bottom = state_json.templateByName[channel].css_position[1];
+	// add indication for the missing channels
+	let channel = channel_info.missingChannelsIndex[0]
+	channel = channel_info.templateByIndex[channel]
+	let left = channel_info.templateByName[channel].css_position[0];
+	let bottom = channel_info.templateByName[channel].css_position[1];
 	
-	document.getElementById("red-dot").style.cssText = `
-		position: absolute;
-		background-color: red;
-		width: 10px;
-		height: 10px;
-		border-radius: 50%;
-		left: ${left};
-		bottom: ${bottom};
+	let rule = `
+		#chkbox-group> div:nth-of-type(2)::after{
+			content: '';
+			position: absolute;
+			background-color: red;
+			width: 10px;
+			height: 10px;
+			border-radius: 50%;
+			left: ${left};
+			bottom: ${bottom};
+		}
 	`;
-	*/
+	
+	// check if indicator already exist
+	let exist = 0;
+	const styleSheet = document.styleSheets[0];
+	for(let i=0; i<styleSheet.cssRules.length; i++){
+		if(styleSheet.cssRules[i].selectorText == "#chkbox-group> div:nth-of-type(2)::after"){
+			exist = 1;
+			console.log('exist!');
+			styleSheet.deleteRule(i);
+			styleSheet.insertRule(rule, styleSheet.cssRules.length);
+			break;
+		}
+	}
+	if(exist == 0) styleSheet.insertRule(rule, styleSheet.cssRules.length);
+
 
 	// move the checkboxes
 	let all_chkbox = document.querySelectorAll("#chkbox-group> div:nth-of-type(2)> label");
-	all_chkbox = Array.apply(null, all_chkbox);
+	//all_chkbox = Array.apply(null, all_chkbox);
 	
-	all_chkbox.forEach((item, index) => {
-		channel = state_json.inputByIndex[index];
-		left = state_json.inputByName[channel].css_position[0];
-		bottom = state_json.inputByName[channel].css_position[1];
-		//console.log(`left: ${left}, bottom: ${bottom}`);
+	Array.from(all_chkbox).forEach((item, index) => {
+		channel = channel_info.inputByIndex[index];
+		left = channel_info.inputByName[channel].css_position[0];
+		bottom = channel_info.inputByName[channel].css_position[1];
+		console.log(`left: ${left}, bottom: ${bottom}`);
 		
 		item.style.cssText = `
 			position: absolute;
@@ -96,36 +110,55 @@ chkbox_js = """
 		`;
 		item.className = "";
 		item.querySelector(":scope> span").innerText = "";
-	});	
+	});
 }
 """
 
-dot_js = """
-(state_json) => {
-	state_json = JSON.parse(JSON.stringify(state_json));
-	if(state_json.state == "finished") return;
+indication_js = """
+(app_state, channel_info) => {
+	app_state = JSON.parse(JSON.stringify(app_state));
+	channel_info = JSON.parse(JSON.stringify(channel_info));
+	if(app_state.state == "finished") return;
 	
-	let channel = state_json.missingChannelsIndex[state_json["fillingCount"]]
-	channel = state_json.templateByIndex[channel]
-	let left = state_json.templateByName[channel].css_position[0];
-	let bottom = state_json.templateByName[channel].css_position[1];
+	let channel = channel_info.missingChannelsIndex[app_state["fillingCount"]-1]
+	channel = channel_info.templateByIndex[channel]
+	let left = channel_info.templateByName[channel].css_position[0];
+	let bottom = channel_info.templateByName[channel].css_position[1];
 	
-	document.getElementById("indicator").style.cssText = `
-		position: absolute;
-		background-color: red;
-		width: 10px;
-		height: 10px;
-		border-radius: 50%;
-		left: ${left};
-		bottom: ${bottom};
+	let rule = `
+		#chkbox-group> div:nth-of-type(2)::after{
+			content: '';
+			position: absolute;
+			background-color: red;
+			width: 10px;
+			height: 10px;
+			border-radius: 50%;
+			left: ${left};
+			bottom: ${bottom};
+		}
 	`;
+	
+	// check if indicator already exist
+	let exist = 0;
+	const styleSheet = document.styleSheets[0];
+	for(let i=0; i<styleSheet.cssRules.length; i++){
+		if(styleSheet.cssRules[i].selectorText == "#chkbox-group> div:nth-of-type(2)::after"){
+			exist = 1;
+			console.log('exist!');
+			styleSheet.deleteRule(i);
+			styleSheet.insertRule(rule, styleSheet.cssRules.length);
+			break;
+		}
+	}
+	if(exist == 0) styleSheet.insertRule(rule, styleSheet.cssRules.length);
 }
 """
 
 
 with gr.Blocks() as demo:
 
-	state_json = gr.JSON(visible=False)
+	app_state_json = gr.JSON(visible=False)
+	channel_info_json = gr.JSON(visible=False)
 
 	with gr.Row():
 		gr.Markdown(
@@ -158,6 +191,7 @@ with gr.Blocks() as demo:
 										label="Imputation")
 					map_btn = gr.Button("Mapping")
 			
+			#indic
 			chkbox_group = gr.CheckboxGroup(elem_id="chkbox-group", label="", visible=False)
 			next_btn = gr.Button("Next", interactive=False, visible=False)
 			
@@ -171,6 +205,9 @@ with gr.Blocks() as demo:
 			with gr.Row():
 				tpl_montage = gr.Image("./template_montage.png", label="Template montage", visible=False)
 				map_montage = gr.Image(label="Matched channels", visible=False)
+			
+			#miss_txtbox = gr.Textbox(label="Missing channels", visible=False)
+			#tpl_loc_file = gr.File("./template_chanlocs.loc", show_label=False, visible=False)
 
 		with gr.Column():
 			gr.Markdown(
@@ -218,14 +255,20 @@ with gr.Blocks() as demo:
 			os.mkdir(filepath+"/temp_data/")
 			#print(e)
 		
+		# initialize app_state, channel_info
 		data = utils.read_train_data(raw_data)
-		state = {
+		app_state = {
 			"filepath": filepath+"/temp_data/",
 			"files": {},
 			"sampleRate": int(samplerate),
+			
+		}
+		channel_info = {
 			"dataShape" : data.shape
 		}
-		return {state_json : state,
+		
+		return {app_state_json : app_state,
+				channel_info_json : channel_info,
 				chkbox_group : gr.CheckboxGroup(choices=[], value=[], label="", visible=False),
 				next_btn : gr.Button("Next", interactive=False, visible=False),
 				run_btn : gr.Button(interactive=False),
@@ -234,36 +277,38 @@ with gr.Blocks() as demo:
 				res_md : gr.Markdown(visible=False),
 				batch_md : gr.Markdown(visible=False)}
     	
-	def mapping_result(state, fill_mode):
+	def mapping_result(app_state, channel_info, fill_mode):
 	
-		in_num = len(state["inputByName"])
-		matched_num = 30 - len(state["missingChannelsIndex"])
+		in_num = len(channel_info["inputByName"])
+		matched_num = 30 - len(channel_info["missingChannelsIndex"])
 		batch_num = math.ceil((in_num-matched_num)/30) + 1
-		state.update({
+		app_state.update({
 			"runnigState" : "stage1",
 			"batchCount" : 1,
 			"totalBatchNum" : batch_num
 		})
 		
-		if fill_mode=="mean_manual" and state["missingChannelsIndex"]!=[]:
-			state.update({
+		if fill_mode=="mean_manual" and channel_info["missingChannelsIndex"]!=[]:
+			app_state.update({
 				"state" : "initializing",
-				"fillingCount" : 0,
-				"totalFillingNum" : len(state["missingChannelsIndex"])-1
+				"totalFillingNum" : len(channel_info["missingChannelsIndex"])
 			})
-			#print("Missing channels:", state["missingChannelsIndex"])
-			return {state_json : state,
+			#print("Missing channels:", channel_info["missingChannelsIndex"])
+			return {app_state_json : app_state,
 					#chkbox_group : gr.CheckboxGroup(visible=True),
 					next_btn : gr.Button(visible=True)}
 		else:
-			state["state"] = "finished"
+			app_state["state"] = "finished"
 			
-			return {state_json : state,
+			return {app_state_json : app_state,
 					res_md : gr.Markdown(visible=True),
 					run_btn : gr.Button(interactive=True)}
 	
-	def show_montage(state, raw_loc):
-		filepath = state["filepath"]
+	def show_montage(app_state, channel_info, raw_loc):
+		if app_state["state"] == "selecting":
+			return {app_state_json : app_state} # change nothing
+			
+		filepath = app_state["filepath"]
 		raw_montage = read_custom_montage(raw_loc)
 		
 		# convert all channel names to uppercase
@@ -271,112 +316,118 @@ with gr.Blocks() as demo:
 			channel = raw_montage.ch_names[i]
 			raw_montage.rename_channels({channel: str.upper(channel)})
 		
-		if state["state"] == "initializing":
+		if app_state["state"] == "initializing":
 			filename = filepath+"raw_montage_"+str(random.randint(1,10000))+".png"
-			state["files"]["raw_montage"] = filename
+			app_state["files"]["raw_montage"] = filename
 			raw_fig = raw_montage.plot()
 			raw_fig.set_size_inches(5.6, 5.6)
 			raw_fig.savefig(filename, pad_inches=0)
 			
-			return {state_json : state}
+			return {app_state_json : app_state}
 		
-		elif state["state"] == "finished":
+		elif app_state["state"] == "finished":
 			filename = filepath+"mapped_montage_"+str(random.randint(1,10000))+".png"
-			state["files"]["map_montage"] = filename
+			app_state["files"]["map_montage"] = filename
 			
 			show_names= []
-			for channel in state["inputByName"]:
-			    if state["inputByName"][channel]["matched"]:
+			for channel in channel_info["inputByName"]:
+			    if channel_info["inputByName"][channel]["matched"]:
 			        show_names.append(channel)
 			mapped_fig = raw_montage.plot(show_names=show_names)
 			mapped_fig.set_size_inches(5.6, 5.6)
 			mapped_fig.savefig(filename, pad_inches=0)
 			
-			return {state_json : state,
+			return {app_state_json : app_state,
 					tpl_montage : gr.Image(visible=True),
 					map_montage : gr.Image(value=filename, visible=True)}
 					
-		else:
-			return {state_json : state} # change nothing
+		#else:
+			#return {app_state_json : app_state} # change nothing
 	
-	def generate_chkbox(state):
-		if state["state"] == "initializing":
-			in_channels = [channel for channel in state["inputByName"]]
-			state["state"] = "selecting"
+	def generate_chkbox(app_state, channel_info):
+		if app_state["state"] == "initializing":
+			in_channels = [channel for channel in channel_info["inputByName"]]
+			app_state["state"] = "selecting"
+			app_state["fillingCount"] = 1
 			
-			first_idx = state["missingChannelsIndex"][0]
-			first_name = state["templateByIndex"][first_idx]
-			chkbox_label = first_name+' (1/'+str(state["totalFillingNum"]+1)+')'
-			return {state_json : state,
+			idx = channel_info["missingChannelsIndex"][0]
+			name = channel_info["templateByIndex"][idx]
+			chkbox_label = name+' (1/'+str(app_state["totalFillingNum"])+')'
+			return {app_state_json : app_state,
 					chkbox_group : gr.CheckboxGroup(choices=in_channels, label=chkbox_label, visible=True),
 					next_btn : gr.Button(interactive=True)}
 		else:
-			return {state_json : state} # change nothing
+			return {app_state_json : app_state} # change nothing
 
 	
 	map_btn.click(
 	    fn = reset_layout,
 	    inputs = [in_raw_data, in_sample_rate],
-		outputs = [state_json, chkbox_group, next_btn, run_btn, tpl_montage, map_montage, res_md, batch_md]
+		outputs = [app_state_json, channel_info_json, chkbox_group, next_btn, run_btn, tpl_montage, map_montage, res_md, batch_md]
 					
 	).success(
 		fn = mapping_stage1, 
-		inputs = [state_json, in_raw_data, in_raw_loc, in_fill_mode], 
-		outputs = state_json
+		inputs = [app_state_json, channel_info_json, in_raw_data, in_raw_loc, in_fill_mode], 
+		outputs = [app_state_json, channel_info_json]
 		
 	).success(
 		fn = mapping_result, 
-		inputs = [state_json, in_fill_mode], 
-		outputs = [state_json, next_btn, res_md, run_btn]
+		inputs = [app_state_json, channel_info_json, in_fill_mode], 
+		outputs = [app_state_json, next_btn, res_md, run_btn]
 		
 	).success(
 		fn = show_montage, 
-		inputs = [state_json, in_raw_loc], 
-		outputs = [state_json, tpl_montage, map_montage]
+		inputs = [app_state_json, channel_info_json, in_raw_loc], 
+		outputs = [app_state_json, tpl_montage, map_montage]
 		
 	).success(
 		fn = generate_chkbox, 
-		inputs = state_json, 
-		outputs = [state_json, chkbox_group, next_btn]
+		inputs = [app_state_json, channel_info_json], 
+		outputs = [app_state_json, chkbox_group, next_btn]
 		
 	).success(
 		fn = None,
 		js = chkbox_js,
-		inputs = state_json,
+		inputs = [app_state_json, channel_info_json],
 		outputs = []
 	)
     
 
-	def check_next(state, selected, raw_data, fill_mode):
+	def check_next(app_state, channel_info, selected, raw_data, fill_mode):
 		#if state["state"] == "selecting":
 			
 		# save info before clicking on next_btn
-		prev_target_idx = state["missingChannelsIndex"][state["fillingCount"]]
-		prev_target_name = state["templateByIndex"][prev_target_idx]
+		prev_target_idx = channel_info["missingChannelsIndex"][app_state["fillingCount"]-1]
+		prev_target_name = channel_info["templateByIndex"][prev_target_idx]
 		
-		selected_idx = [state["inputByName"][channel]["index"] for channel in selected]
-		state["newOrder"][prev_target_idx] = selected_idx
+		selected_idx = [channel_info["inputByName"][channel]["index"] for channel in selected]
+		app_state["newOrder"][prev_target_idx] = selected_idx
 		
-		#if len(selected)==1 and state["inputByName"][selected[0]]["used"]==False:
-			#state["inputByName"][selected[0]]["used"] = True
-			#state["missingChannelsIndex"][state["fillingCount"]] = -1
+		#if len(selected)==1 and channel_info["inputByName"][selected[0]]["used"]==False:
+			#channel_info["inputByName"][selected[0]]["used"] = True
+			#channel_info["missingChannelsIndex"][state["fillingCount"]-1] = -1
 		
 		print('Selection for missing channel "{}"({}): {}'.format(prev_target_name, prev_target_idx, selected))
 		
 		# update next round
-		state["fillingCount"] += 1
-		if state["fillingCount"] <= state["totalFillingNum"]:
-			target_idx = state["missingChannelsIndex"][state["fillingCount"]]
-			target_name = state["templateByIndex"][target_idx]
-			chkbox_label = target_name+' ('+str(state["fillingCount"]+1)+'/'+str(state["totalFillingNum"]+1)+')'
-			btn_label = "Submit" if state["fillingCount"]==state["totalFillingNum"] else "Next"
+		app_state["fillingCount"] += 1
+		
+		if app_state["fillingCount"] <= app_state["totalFillingNum"]:
+			target_idx = channel_info["missingChannelsIndex"][app_state["fillingCount"]-1]
+			target_name = channel_info["templateByIndex"][target_idx]
+			
+			chkbox_label = target_name+' ('+str(app_state["fillingCount"])+'/'+str(app_state["totalFillingNum"])+')'
+			btn_label = "Submit" if app_state["fillingCount"]==app_state["totalFillingNum"] else "Next"
 			
-			return {state_json : state,
+			return {app_state_json : app_state,
+					#channel_info_json : channel_info,
 					chkbox_group : gr.CheckboxGroup(value=[], label=chkbox_label),
 					next_btn : gr.Button(btn_label)}
 		else:
-			state["state"] = "finished"			
-			return {state_json : state,
+			app_state["state"] = "finished"
+			
+			return {app_state_json : app_state,
+					#channel_info_json : channel_info,
 					chkbox_group : gr.CheckboxGroup(visible=False),
 					next_btn : gr.Button(visible=False),
 					res_md : gr.Markdown(visible=True),
@@ -384,48 +435,53 @@ with gr.Blocks() as demo:
 	
 	next_btn.click(
 	    fn = check_next,
-	    inputs = [state_json, chkbox_group, in_raw_data, in_fill_mode],
-	    outputs = [state_json, chkbox_group, next_btn, run_btn, res_md]
+	    inputs = [app_state_json, channel_info_json, chkbox_group, in_raw_data, in_fill_mode],
+	    outputs = [app_state_json, chkbox_group, next_btn, run_btn, res_md]
 	
 	).success(
-	    fn = show_montage, 
-	    inputs = [state_json, in_raw_loc], 
-	    outputs = [state_json, tpl_montage, map_montage]
+	    fn = show_montage,
+	    inputs = [app_state_json, channel_info_json, in_raw_loc],
+		outputs = [app_state_json, tpl_montage, map_montage]
+		
+	).success(
+		fn = None,
+		js = indication_js,
+		inputs = [app_state_json, channel_info_json],
+		outputs = []
 	)
 	
-	@run_btn.click(inputs = [state_json, in_raw_data, in_model_name, in_fill_mode], outputs = out_denoised_data)
-	def run_model(state, raw_data, model_name, fill_mode):
-		filepath = state["filepath"]
-		samplerate = state["sampleRate"]
-		
-		#if batch > total_batch:
-			#return {batch_md : gr.Markdown("error", visible=True)}
+	@run_btn.click(inputs = [app_state_json, channel_info_json, in_raw_data, in_model_name, in_fill_mode],
+				   outputs = [batch_md, out_denoised_data])
+	def run_model(app_state, channel_info, raw_data, model_name, fill_mode):
+		filepath = app_state["filepath"]
+		samplerate = app_state["sampleRate"]
 		
 		input_name = os.path.basename(str(raw_data))
 		output_name = os.path.splitext(input_name)[0]+'_'+model_name+'.csv'
 		
-		while(state["runnigState"] != "finished"):
-			if state["batchCount"] > state["totalBatchNum"]:
+		while(app_state["runnigState"] != "finished"):
+			if app_state["batchCount"] > app_state["totalBatchNum"]:
+				app_state["runnigState"] = "finished"
 				break
-			if state["batchCount"] > 1:
-				state["runnigState"] = "stage2"
-				state = mapping_stage2(state, fill_mode)
-			state["batchCount"] += 1
+			if app_state["batchCount"] > 1:
+				app_state["runnigState"] = "stage2"
+				app_state, channel_info = mapping_stage2(app_state, channel_info, fill_mode)
+			app_state["batchCount"] += 1
 			
-			reorder_to_template(state, raw_data)
+			reorder_to_template(app_state, raw_data)
 			# step1: Data preprocessing
 			total_file_num = utils.preprocessing(filepath, 'mapped.csv', samplerate)
 			# step2: Signal reconstruction
 			utils.reconstruct(model_name, total_file_num, filepath, 'denoised.csv', samplerate)
-			reorder_to_origin(state, filepath+'denoised.csv', filepath+output_name)
+			reorder_to_origin(app_state, channel_info, filepath+'denoised.csv', filepath+output_name)
 			
 			if model_name == "(mapped data)":
 				return {out_denoised_data : filepath + 'mapped.csv'}
 			elif model_name == "(denoised data)":
 				return {out_denoised_data : filepath + 'denoised.csv'}
-		
+			
 		return {out_denoised_data : filepath + output_name}
 		
 	
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)

channel_mapping.py

@@ -10,11 +10,11 @@ from scipy.interpolate import Rbf
 from scipy.optimize import linear_sum_assignment
 from sklearn.neighbors import NearestNeighbors
 
-def reorder_to_template(state, filename):
-	old_idx = state["newOrder"]
+def reorder_to_template(app_state, filename):
+	old_idx = app_state["newOrder"]
 	old_data = utils.read_train_data(filename) # original raw data
 	new_data = np.zeros((30, old_data.shape[1])) # reordered raw data
-	new_filename = state["filepath"]+'mapped.csv'
+	new_filename = app_state["filepath"]+'mapped.csv'
 	
 	zero_arr = np.zeros((1, old_data.shape[1]))
 	old_data = np.concatenate((old_data, zero_arr), axis=0)
@@ -33,13 +33,13 @@ def reorder_to_template(state, filename):
 	utils.save_data(new_data, new_filename)
 	return
 
-def reorder_to_origin(state, filename, new_filename):
-	old_idx = state["newOrder"]
+def reorder_to_origin(app_state, channel_info, filename, new_filename):
+	old_idx = app_state["newOrder"]
 	old_data = utils.read_train_data(filename) # denoised data
-	template_order = state["templateByIndex"]
+	template_order = channel_info["templateByIndex"]
 	
-	if state["runnigState"] == "stage1":
-		new_data = np.zeros((len(state["inputByName"]), old_data.shape[1]))
+	if app_state["runnigState"] == "stage1":
+		new_data = np.zeros((len(channel_info["inputByName"]), old_data.shape[1]))
 	else:
 		new_data = utils.read_train_data(new_filename)
 	
@@ -47,7 +47,7 @@ def reorder_to_origin(state, filename, new_filename):
 		idx_set = old_idx[i]
 		
 		# ignore if this channel doesn't exist
-		if len(idx_set)==1 and state["templateByName"][channel]["matched"]==True:
+		if len(idx_set)==1 and channel_info["templateByName"][channel]["matched"]==True:
 			new_data[idx_set[0], :] = old_data[i, :]
 	
 	print('old.shape, new.shape: ', old_data.shape, new_data.shape)
@@ -86,12 +86,12 @@ def read_montage_data(loc_file):
 	
 	return template_montage, input_montage, template_dict, input_dict
 
-def align_coords(state, template_montage, input_montage):
+def align_coords(channel_info, template_montage, input_montage):
 
-	template_dict = state["templateByName"]
-	input_dict = state["inputByName"]
-	template_order = state["templateByIndex"]
-	input_order = state["inputByIndex"]
+	template_dict = channel_info["templateByName"]
+	input_dict = channel_info["inputByName"]
+	template_order = channel_info["templateByIndex"]
+	input_order = channel_info["inputByIndex"]
 	matched = [channel for channel in input_dict if input_dict[channel]["matched"]==True]
 	
 	# 2-d (fot the indication of missing template channel's position when fill_mode:'mean_manual')
@@ -153,24 +153,23 @@ def align_coords(state, template_montage, input_montage):
 	for i, channel in enumerate(input_order):
 		input_dict[channel]["coord"] = transformed_in[i].tolist()
 	
-	state.update({
+	channel_info.update({
 	    "templateByName" : template_dict,
 	    "inputByName" : input_dict,
 	})
-	
-	return state
+	return channel_info
 
-def fill_channels(state, fill_mode):
+def fill_channels(app_state, channel_info, fill_mode):
 
-	new_idx = state["newOrder"]
-	template_dict = state["templateByName"]
-	input_dict = state["inputByName"]
-	template_order = state["templateByIndex"]
-	input_order = state["inputByIndex"]
-	z_row_idx = state["dataShape"][0]
+	new_idx = app_state["newOrder"]
+	template_dict = channel_info["templateByName"]
+	input_dict = channel_info["inputByName"]
+	template_order = channel_info["templateByIndex"]
+	input_order = channel_info["inputByIndex"]
+	z_row_idx = channel_info["dataShape"][0]
 	unmatched = [channel for channel in template_dict if template_dict[channel]["matched"]==False]
 	if unmatched == []:
-		return state
+		return app_state
 	
 	if fill_mode == 'zero':
 		for channel in unmatched:
@@ -194,10 +193,12 @@ def fill_channels(state, fill_mode):
 			idx = template_dict[channel]["index"]
 			new_idx[idx] = indices[0].tolist()
 
-	state["newOrder"] = new_idx
-	return state
+	app_state.update({
+	    "newOrder" : new_idx
+	})
+	return app_state
 
-def mapping_stage1(state, data_file, loc_file, fill_mode):
+def mapping_stage1(app_state, channel_info, data_file, loc_file, fill_mode):
 	second1 = time.time()
 	
 	template_montage, input_montage, template_dict, input_dict = read_montage_data(loc_file)
@@ -230,34 +231,36 @@ def mapping_stage1(state, data_file, loc_file, fill_mode):
 		else:
 			missing_channels.append(i)
 	
-	state.update({
-	    "newOrder" : new_idx,
+	channel_info.update({
 	    "missingChannelsIndex" : missing_channels,
 	    "templateByName" : {k : v.__dict__ for k,v in template_dict.items()},
 	    "inputByName" : {k : v.__dict__ for k,v in input_dict.items()},
 	    "templateByIndex" : template_montage.ch_names,
 		"inputByIndex" : input_montage.ch_names
 	})
+	app_state.update({
+	    "newOrder" : new_idx
+	})
 	
 	# align input, template's coordinates
-	state = align_coords(state, template_montage, input_montage)
+	channel_info = align_coords(channel_info, template_montage, input_montage)
 	# fill the unmatched channels
-	state = fill_channels(state, fill_mode)
+	app_state = fill_channels(app_state, channel_info, fill_mode)
 	
 	second2 = time.time()
 	print('Mapping (stage1) finished in',second2 - second1,'s.')
-	return state
+	return app_state, channel_info
 
-def mapping_stage2(state, fill_mode):
+def mapping_stage2(app_state, channel_info, fill_mode):
 	second1 = time.time()
 
-	template_dict = state["templateByName"]
-	input_dict = state["inputByName"]
-	template_order = state["templateByIndex"]
+	template_dict = channel_info["templateByName"]
+	input_dict = channel_info["inputByName"]
+	template_order = channel_info["templateByIndex"]
 	unassigned = [channel for channel in input_dict if input_dict[channel]["assigned"]==False]
 	if unassigned == []:
-		state["runnigState"] = "finished"
-		return state
+		app_state["runnigState"] = "finished"
+		return app_state, channel_info
 	
 	tpl_coords = np.array([template_dict[channel]["coord"] for channel in template_order])
 	unassigned_coords = np.array([input_dict[channel]["coord"] for channel in unassigned])
@@ -290,16 +293,18 @@ def mapping_stage2(state, fill_mode):
 			input_dict[in_channel]["assigned"] = True
 			new_idx[i] = [input_dict[in_channel]["index"]]
 	
-	state.update({
-	    "newOrder" : new_idx,
+	channel_info.update({
 	    "templateByName" : template_dict,
 	    "inputByName" : input_dict
 	})
+	app_state.update({
+	    "newOrder" : new_idx
+	})
 	
 	# fill the unmatched channels
-	state = fill_channels(state, fill_mode)
+	app_state = fill_channels(app_state, channel_info, fill_mode)
 	
 	second2 = time.time()
-	print(f'Mapping (stage2-{state["batchCount"]-1}) finished in {second2 - second1}s.')
-	return state
+	print(f'Mapping (stage2-{app_state["batchCount"]-1}) finished in {second2 - second1}s.')
+	return app_state, channel_info
 

utils.py

@@ -223,8 +223,7 @@ def preprocessing(filepath, filename, samplerate):
     signal = read_train_data(filepath+filename)
     #print(signal.shape)
     # resample
-    signal = resample(signal, samplerate)
-    #signal = resample_(signal, samplerate, 256)
+    signal = resample(signal, samplerate) #signal = resample_(signal, samplerate, 256)
     #print(signal.shape)
     # FIR_filter
     signal = FIR_filter(signal, 1, 50)