update

app.py

@@ -20,6 +20,7 @@ Upload your data's channel locations in `.loc` format, which can be obtained usi
 >If you cannot obtain it, we recommend you to download the standard montage <a href="">here</a>. If the channels in those files doesn't match yours, you can use **EEGLAB** to modify them to your needed montage.
 
 ## Mapping
+...
 
 ### Step1: Mapping result
 After clicking the mapping button, the **template montage** and the **input montage** will be displayed, with the unmatched input channels highlighted in red.
@@ -27,30 +28,20 @@ After clicking the mapping button, the **template montage** and the **input mont
 - If some of your channels didn't match the template, you will be guided to **Step2**.
 - If all of your channels can find corresponding template channels, but the number of channels is less then 30, you will be guided to **Step3**.
 
-### Step2:
+### Step2: Assign unmatched input channels into some template channels
 In this step, the template channels that didn't match yours will be displyed sequentially. You will then have the option to choose whether to fill some of your unmatched channels into them.
-- If you
-- 
-### Step3:
+- If you filled all the template channels with your unmatched channels, you can then proceed to **run the model**.
+- If there're still some template channels that have not been filled with your unmatched channels, you will be guided to **Step3**.
 
+### Step3: Fill the remaining template channels
+The purpose of this step is to select a method to fill the unmatched template channels that were not filled in Step2.  
+There're two methods you can choose from:  
+- Mean : The remaining template channels will be displyed sequentially, and you can choose to fill them using multiple input channels. For each remaining template channels, the average value of the selected input channels will be assigned to it. By default, the 4 nearest input channels to each remaining template channels will be pre-selected, but you can choose whether to modify this selection. (If you uncheck the 4 selections, zeros will be filled to that channel.)
+- Zero : Zeros will be filled into all the remaining template channels.  
+After filling all the template channels, you can then proceed to **run the model**.
 
-# Run model
-
-### Imputation
-The models was trained using the EEG signals of 30 channels, including: `Fp1, Fp2, F7, F3, Fz, F4, F8, FT7, FC3, FCz, FC4, FT8, T7, C3, Cz, C4, T8, TP7, CP3, CPz, CP4, TP8, P7, P3, Pz, P4, P8, O1, Oz, O2`.
-We expect your input data to include these channels as well.  
-If your data doesn't contain all of the mentioned channels, there are 3 imputation ways you can choose from:
-
-- **zero**: fill the missing channels with zeros.
-- **mean(auto)**: select 4 neareat channels for each missing channels, and we will average their values.
-- **mean(manual)**: select the channels you wish to use for imputing the required one, and we will average their values. If you select nothing, zeros will be imputed. For example, you didn't have **FCZ** and you choose **FC1, FC2, FZ, CZ** to impute it(depending on the channels you have), we will compute the mean of these 4 channels and assign this new value to **FCZ**.
-
-### Mapping result
-Once the mapping process is finished, the **template montage** and the **input montage**(with the matched channels displaying their names) will be shown.
-
-### Model
-Select the model you want to use.  
-The detailed description of the models can be found in other pages.
+## Run model
+...
 
 """
 
@@ -89,8 +80,8 @@ init_js = """
 	let all_elem = document.querySelectorAll(selector+" > label");
 	Array.from(all_elem).forEach((item) => {
 		channel = item.querySelector("input").getAttribute(attribute);
-		left = channel_info.inputByName[channel].css_position[0];
-		bottom = channel_info.inputByName[channel].css_position[1];
+		left = channel_info.inputDict[channel].css_position[0];
+		bottom = channel_info.inputDict[channel].css_position[1];
 		//console.log(`channel: ${channel}, left: ${left}, bottom: ${bottom}`);
 		
 		item.style.cssText = `
@@ -105,8 +96,8 @@ init_js = """
 	
 	// add indication for the missing channels
 	channel = app_state.missingTemplates[0]
-	left = channel_info.templateByName[channel].css_position[0];
-	bottom = channel_info.templateByName[channel].css_position[1];
+	left = channel_info.templateDict[channel].css_position[0];
+	bottom = channel_info.templateDict[channel].css_position[1];
 	
 	let rule = `
 		${selector}::after{
@@ -150,8 +141,8 @@ update_js = """
 		let all_elem = document.querySelectorAll(selector+" > label");
 		Array.from(all_elem).forEach((item) => {
 			channel = item.querySelector("input").value;
-			left = channel_info.inputByName[channel].css_position[0];
-			bottom = channel_info.inputByName[channel].css_position[1];
+			left = channel_info.inputDict[channel].css_position[0];
+			bottom = channel_info.inputDict[channel].css_position[1];
 			//console.log(`channel: ${channel}, left: ${left}, bottom: ${bottom}`);
 			
 			item.style.cssText = `
@@ -168,8 +159,8 @@ update_js = """
 	
 	// update indication
 	channel = app_state.missingTemplates[app_state["fillingCount"]-1]
-	left = channel_info.templateByName[channel].css_position[0];
-	bottom = channel_info.templateByName[channel].css_position[1];
+	left = channel_info.templateDict[channel].css_position[0];
+	bottom = channel_info.templateDict[channel].css_position[1];
 	
 	let rule = `
 		${selector}::after{
@@ -207,7 +198,7 @@ with gr.Blocks() as demo:
 	with gr.Row():
 		gr.Markdown(
 			"""
-			<p style="text-align: center;">(...)</p>
+			<p style="text-align: center;">...</p>
 			"""
 		)
 	with gr.Row():
@@ -239,7 +230,7 @@ with gr.Blocks() as demo:
 			with gr.Row():
 				in_fill_mode = gr.Dropdown(choices=["mean", "zero"],
 									value="mean",
-									label="Imputation", #......
+									label="Filling method",
 									visible=False,
 									scale=2)
 				fillmode_btn = gr.Button("OK", visible=False, scale=1)
@@ -258,9 +249,7 @@ with gr.Blocks() as demo:
 									("ART", "EEGART"),
 									("IC-U-Net", "ICUNet"),
 									("IC-U-Net++", "UNetpp"),
-									("IC-U-Net-Attn", "AttUnet"),
-									"(mapped data)",
-									"(denoised data)"],
+									("IC-U-Net-Attn", "AttUnet")],
 									value="EEGART",
 									label="Model",
 									scale=2)
@@ -359,20 +348,20 @@ with gr.Blocks() as demo:
 		# plot red dots on unmatched input channels
 		ax = raw_fig.axes[0]
 		coords = ax.collections[0].get_offsets().data
-		idx = [channel_info["inputByName"][channel]["index"] for channel in app_state["stage1UnassignedInputs"]]
+		idx = [channel_info["inputDict"][channel]["index"] for channel in app_state["stage1UnassignedInputs"]]
 		ax.scatter(coords[idx,0]-0.0001, coords[idx,1]+0.0001, color='red')
 		raw_fig.savefig(filename2, pad_inches=0)
 		
 		# ------------------determine the next step-----------------------
 		
-		in_num = len(channel_info["inputByIndex"])
+		in_num = len(channel_info["inputOrder"])
 		matched_num = 30 - len(app_state["missingTemplates"])
 		
 		# if the input channels(>=30) has all the 30 template channels
 		# -> Stage2.decode data
 		if matched_num == 30:
 			app_state["stage1State"] = "finished"
-			gr.Info('The mapping process is finished!')
+			gr.Info('The mapping process has been finished.')
 			
 			return {app_state_json : app_state,
 					desc_md : gr.Markdown("### Mapping result", visible=True),
@@ -418,8 +407,8 @@ with gr.Blocks() as demo:
 		# stage1-1 -> stage1-2
 		if app_state["stage1State"] == "step2-initializing":
 			print('step1 -> step2')
-			app_state["missingTemplates"] = [channel for channel in channel_info["templateByIndex"]
-											if channel_info["templateByName"][channel]["matched"]==False]
+			app_state["missingTemplates"] = [channel for channel in channel_info["templateOrder"]
+											if channel_info["templateDict"][channel]["matched"]==False]
 			app_state.update({
 				"stage1State" : "step2-selecting",
 				"fillingCount" : 1,
@@ -432,7 +421,7 @@ with gr.Blocks() as demo:
 			if len(app_state["stage1UnassignedInputs"])==1 or app_state["totalFillingNum"]==1:
 				return {app_state_json : app_state,
 					    channel_info_json : channel_info,
-					    desc_md : gr.Markdown("### Step2"),
+					    desc_md : gr.Markdown("### Step2: Assign unmatched input channels"),
 					    tpl_montage : gr.Image(visible=False),
 					    in_montage : gr.Image(visible=False),
 					    radio : gr.Radio(choices=app_state["stage1UnassignedInputs"], value=[], label=label, visible=True),
@@ -440,7 +429,7 @@ with gr.Blocks() as demo:
 			else:
 			    return {app_state_json : app_state,
 					    channel_info_json : channel_info,
-					    desc_md : gr.Markdown("### Step2"),
+					    desc_md : gr.Markdown("### Step2: Assign unmatched input channels"),
 					    tpl_montage : gr.Image(visible=False),
 					    in_montage : gr.Image(visible=False),
 					    radio : gr.Radio(choices=app_state["stage1UnassignedInputs"], value=[], label=label, visible=True),
@@ -450,8 +439,8 @@ with gr.Blocks() as demo:
 		# stage1-1 -> stage1-3
 		elif app_state["stage1State"] == "step3-initializing":
 			print('step1 -> step3')
-			app_state["missingTemplates"] = [channel for channel in channel_info["templateByIndex"]
-											if channel_info["templateByName"][channel]["matched"]==False]
+			app_state["missingTemplates"] = [channel for channel in channel_info["templateOrder"]
+											if channel_info["templateDict"][channel]["matched"]==False]
 			app_state.update({
 				"stage1State" : "step3-initializing",
 				"fillingCount" : 1,
@@ -459,7 +448,7 @@ with gr.Blocks() as demo:
 			})
 			return {app_state_json : app_state,
 			        channel_info_json : channel_info,
-					desc_md : gr.Markdown("### Step3"),
+					desc_md : gr.Markdown("### Step3: Fill the remaining template channels"),
 					tpl_montage : gr.Image(visible=False),
 					in_montage : gr.Image(visible=False),
 					in_fill_mode : gr.Dropdown(visible=True),
@@ -471,29 +460,29 @@ with gr.Blocks() as demo:
 		
 			# save info before clicking on next_btn
 			prev_target_name = app_state["missingTemplates"][app_state["fillingCount"]-1]
-			prev_target_idx = channel_info["templateByName"][prev_target_name]["index"]
+			prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
 			if selected_radio == []:
 				app_state["stage1NewOrder"][prev_target_idx] = []
 			else:
-				selected_idx = channel_info["inputByName"][selected_radio]["index"]
+				selected_idx = channel_info["inputDict"][selected_radio]["index"]
 				app_state["stage1NewOrder"][prev_target_idx] = [selected_idx]
 			
-				channel_info["templateByName"][prev_target_name]["matched"] = True
-				channel_info["inputByName"][selected_radio]["assigned"] = True				
+				channel_info["templateDict"][prev_target_name]["matched"] = True
+				channel_info["inputDict"][selected_radio]["assigned"] = True				
 			print(prev_target_name, '<-', selected_radio)
 			
 			app_state.update({
-				"stage1UnassignedInputs" : [channel for channel in channel_info["inputByIndex"]
-									if channel_info["inputByName"][channel]["assigned"]==False],
-				"missingTemplates" : [channel for channel in channel_info["templateByIndex"]
-									if channel_info["templateByName"][channel]["matched"]==False]
+				"stage1UnassignedInputs" : [channel for channel in channel_info["inputOrder"]
+									if channel_info["inputDict"][channel]["assigned"]==False],
+				"missingTemplates" : [channel for channel in channel_info["templateOrder"]
+									if channel_info["templateDict"][channel]["matched"]==False]
 			})
 			
 			# if all the unmatched template channels were filled by input channels
 			# -> stage2
 			if len(app_state["missingTemplates"]) == 0:
 				print('step2 -> Stage2')
-				gr.Info('The mapping process is finished!')
+				gr.Info('The mapping process has been finished.')
 				app_state["stage1State"] = "finished"
 				
 				return {app_state_json : app_state,
@@ -513,7 +502,7 @@ with gr.Blocks() as demo:
 				})
 				return {app_state_json : app_state,
 						channel_info_json : channel_info,
-						desc_md : gr.Markdown("### Step3"),
+						desc_md : gr.Markdown("### Step3: Fill the remaining template channels"),
 						radio : gr.Radio(visible=False),
 						in_fill_mode : gr.Dropdown(visible=True),
 						fillmode_btn : gr.Button(visible=True),
@@ -524,20 +513,20 @@ with gr.Blocks() as demo:
 			
 			# save info before clicking on next_btn
 			prev_target_name = app_state["missingTemplates"][app_state["fillingCount"]-1]
-			prev_target_idx = channel_info["templateByName"][prev_target_name]["index"]
+			prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
 			if selected_chkbox == []:
 				app_state["stage1NewOrder"][prev_target_idx] = []
 			else:
-				selected_idx = [channel_info["inputByName"][channel]["index"] for channel in selected_chkbox]
+				selected_idx = [channel_info["inputDict"][channel]["index"] for channel in selected_chkbox]
 				app_state["stage1NewOrder"][prev_target_idx] = selected_idx				
 			#print(f'{prev_target_name}({prev_target_idx}): {selected_chkbox}')
 			
-			gr.Info('The mapping process is finished!')
+			gr.Info('The mapping process has been finished.')
 			app_state["stage1State"] = "finished"
 			print('step3 -> Stage2')
 			
-			app_state["missingTemplates"] = [channel for channel in channel_info["templateByIndex"]
-											if channel_info["templateByName"][channel]["matched"]==False]
+			app_state["missingTemplates"] = [channel for channel in channel_info["templateOrder"]
+											if channel_info["templateDict"][channel]["matched"]==False]
 			
 			return {app_state_json : app_state,
 					desc_md : gr.Markdown(visible=False),
@@ -563,21 +552,21 @@ with gr.Blocks() as demo:
 		
 		# save info before clicking on next_btn
 		prev_target_name = app_state["missingTemplates"][app_state["fillingCount"]-1]
-		prev_target_idx = channel_info["templateByName"][prev_target_name]["index"]
+		prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
 		if selected == []:
 			app_state["stage1NewOrder"][prev_target_idx] = []
 		else:
-			selected_idx = channel_info["inputByName"][selected]["index"]
+			selected_idx = channel_info["inputDict"][selected]["index"]
 			app_state["stage1NewOrder"][prev_target_idx] = [selected_idx]
 		
-			channel_info["templateByName"][prev_target_name]["matched"] = True
-			channel_info["inputByName"][selected]["assigned"] = True
+			channel_info["templateDict"][prev_target_name]["matched"] = True
+			channel_info["inputDict"][selected]["assigned"] = True
 		print(prev_target_name, '<-', selected)
 		
 		# update the current round
 		app_state["fillingCount"] += 1
-		app_state["stage1UnassignedInputs"] = [channel for channel in channel_info["inputByIndex"]
-												if channel_info["inputByName"][channel]["assigned"]==False]
+		app_state["stage1UnassignedInputs"] = [channel for channel in channel_info["inputOrder"]
+												if channel_info["inputDict"][channel]["assigned"]==False]
 		
 		target_name = app_state["missingTemplates"][app_state["fillingCount"]-1]
 		radio_label = target_name+' ('+str(app_state["fillingCount"])+'/'+str(app_state["totalFillingNum"])+')'
@@ -610,7 +599,7 @@ with gr.Blocks() as demo:
 		
 		if fill_mode == 'zero':
 			app_state["stage1State"] = "finished"
-			gr.Info('The mapping process is finished!')
+			gr.Info('The mapping process has been finished.')
 			
 			return {app_state_json : app_state,
 					desc_md : gr.Markdown(visible=False),
@@ -623,23 +612,23 @@ with gr.Blocks() as demo:
 			app_state = find_neighbors(app_state, channel_info, fill_mode)
 			
 			name = app_state["missingTemplates"][0]
-			idx = channel_info["templateByName"][name]["index"]
+			idx = channel_info["templateDict"][name]["index"]
 			value = app_state["stage1NewOrder"][idx]
-			value = [channel_info["inputByIndex"][i] for i in value]
+			value = [channel_info["inputOrder"][i] for i in value]
 			label = name+' (1/'+str(app_state["totalFillingNum"])+')'
 			
 			if app_state["totalFillingNum"] == 1:
 			    return {app_state_json : app_state,
 					    in_fill_mode : gr.Dropdown(visible=False),
 		        		fillmode_btn : gr.Button(visible=False),
-		        		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputByIndex"],
+		        		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputOrder"],
 													    value=value, label=label, visible=True),
 		                next_btn : gr.Button(visible=True)}
 			else:
 			    return {app_state_json : app_state,
 					    in_fill_mode : gr.Dropdown(visible=False),
 		        		fillmode_btn : gr.Button(visible=False),
-		        		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputByIndex"],
+		        		chkbox_group : gr.CheckboxGroup(choices=channel_info["inputOrder"],
 													    value=value, label=label, visible=True),
 		                step3_btn : gr.Button(visible=True)}
 	
@@ -658,11 +647,11 @@ with gr.Blocks() as demo:
 	
 		# save info before clicking on next_btn
 		prev_target_name = app_state["missingTemplates"][app_state["fillingCount"]-1]
-		prev_target_idx = channel_info["templateByName"][prev_target_name]["index"]
+		prev_target_idx = channel_info["templateDict"][prev_target_name]["index"]
 		if selected == []:
 			app_state["stage1NewOrder"][prev_target_idx] = []
 		else:
-			selected_idx = [channel_info["inputByName"][channel]["index"] for channel in selected]
+			selected_idx = [channel_info["inputDict"][channel]["index"] for channel in selected]
 			app_state["stage1NewOrder"][prev_target_idx] = selected_idx
 		#print('Selection for missing channel "{}"({}): {}'.format(prev_target_name, prev_target_idx, selected))
 		
@@ -670,10 +659,10 @@ with gr.Blocks() as demo:
 		app_state["fillingCount"] += 1
 		
 		target_name = app_state["missingTemplates"][app_state["fillingCount"]-1]
-		target_idx = channel_info["templateByName"][target_name]["index"]
+		target_idx = channel_info["templateDict"][target_name]["index"]
 		
 		chkbox_value = app_state["stage1NewOrder"][target_idx]
-		chkbox_value = [channel_info["inputByIndex"][i] for i in chkbox_value]
+		chkbox_value = [channel_info["inputOrder"][i] for i in chkbox_value]
 		chkbox_label = target_name+' ('+str(app_state["fillingCount"])+'/'+str(app_state["totalFillingNum"])+')'
 		
 		if app_state["fillingCount"] == app_state["totalFillingNum"]:
@@ -706,6 +695,11 @@ with gr.Blocks() as demo:
 	
 	# stage2
 	def reset_run(app_state, channel_info, raw_data, model_name):
+	    
+	    # reset in.assigned back to the state after Stage1
+		for channel in app_state["stage1UnassignedInputs"]:
+			channel_info["inputDict"][channel]["assigned"] = False
+		
 		filepath = app_state["filepath"]
 		delete_file(filepath+'mapped.csv')
 		delete_file(filepath+'denoised.csv')
@@ -713,10 +707,9 @@ with gr.Blocks() as demo:
 		input_name = os.path.basename(str(raw_data))
 		output_name = os.path.splitext(input_name)[0]+'_'+model_name+'.csv'
 		
-		in_num = len(channel_info["inputByIndex"])
-		matched_num = len([channel for channel in channel_info["inputByIndex"]
-							if channel_info["inputByName"][channel]["matched"]==True])
-		batch_num = math.ceil((in_num-matched_num)/30) + 1
+		in_num = len(channel_info["inputOrder"])
+		assigned_num = len(app_state["stage1UnassignedInputs"])
+		batch_num = math.ceil((in_num-assigned_num)/30) + 1
 		
 		app_state["filenames"]["denoised"] = filepath + output_name
 		app_state.update({
@@ -726,11 +719,6 @@ with gr.Blocks() as demo:
 			"stage2UnassignedInputs" : app_state["stage1UnassignedInputs"],
 			"stage2NewOrder" : [[]]*30,
 		})
-		
-		# reset in.assigned back to the state after Stage1
-		for channel in app_state["stage1UnassignedInputs"]:
-			channel_info["inputByName"][channel]["assigned"] = False
-		
 		return {app_state_json : app_state,
 				channel_info_json : channel_info,
 				run_btn : gr.Button(interactive=False),
@@ -787,4 +775,4 @@ with gr.Blocks() as demo:
 	)
 	
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch()

channel_mapping.py

@@ -38,10 +38,10 @@ def reorder_to_template(app_state, filename):
 def reorder_to_origin(app_state, channel_info, filename, new_filename):
 	old_idx = app_state["stage1NewOrder"] if app_state["runningState"]=="stage1" else app_state["stage2NewOrder"]
 	old_data = utils.read_train_data(filename) # denoised data
-	template_order = channel_info["templateByIndex"]
+	template_order = channel_info["templateOrder"]
 	
 	if app_state["runningState"] == "stage1":
-		new_data = np.zeros((len(channel_info["inputByIndex"]), old_data.shape[1]))
+		new_data = np.zeros((len(channel_info["inputOrder"]), old_data.shape[1]))
 	else:
 		new_data = utils.read_train_data(new_filename)
 	
@@ -49,7 +49,7 @@ def reorder_to_origin(app_state, channel_info, filename, new_filename):
 		idx_set = old_idx[i]
 		
 		# ignore if this channel doesn't exist
-		if len(idx_set)==1 and channel_info["templateByName"][channel]["matched"]==True:
+		if len(idx_set)==1 and channel_info["templateDict"][channel]["matched"]==True:
 			new_data[idx_set[0], :] = old_data[i, :]
 	
 	print('old.shape, new.shape: ', old_data.shape, new_data.shape)
@@ -90,10 +90,10 @@ def read_montage_data(loc_file):
 
 def align_coords(channel_info, template_montage, input_montage):
 
-	template_dict = channel_info["templateByName"]
-	input_dict = channel_info["inputByName"]
-	template_order = channel_info["templateByIndex"]
-	input_order = channel_info["inputByIndex"]
+	template_dict = channel_info["templateDict"]
+	input_dict = channel_info["inputDict"]
+	template_order = channel_info["templateOrder"]
+	input_order = channel_info["inputOrder"]
 	matched = [channel for channel in input_order if input_dict[channel]["matched"]==True]
 	
 	# 2-d (for the indication of missing template channel's position when fill_mode:'mean_manual')
@@ -156,17 +156,17 @@ def align_coords(channel_info, template_montage, input_montage):
 		input_dict[channel]["coord"] = transformed_in[i].tolist()
 	
 	channel_info.update({
-	    "templateByName" : template_dict,
-	    "inputByName" : input_dict,
+	    "templateDict" : template_dict,
+	    "inputDict" : input_dict,
 	})
 	return channel_info
 
 def find_neighbors(app_state, channel_info, fill_mode):
 	new_idx = app_state["stage1NewOrder"] if app_state["runningState"]=="stage1" else app_state["stage2NewOrder"]
-	template_dict = channel_info["templateByName"]
-	input_dict = channel_info["inputByName"]
-	template_order = channel_info["templateByIndex"]
-	input_order = channel_info["inputByIndex"]
+	template_dict = channel_info["templateDict"]
+	input_dict = channel_info["inputDict"]
+	template_order = channel_info["templateOrder"]
+	input_order = channel_info["inputOrder"]
 	#z_row_idx = channel_info["dataShape"][0]
 	missing_channels = app_state["missingTemplates"]
 	if missing_channels == []:
@@ -184,7 +184,7 @@ def find_neighbors(app_state, channel_info, fill_mode):
 	for channel in missing_channels:
 		distances, indices = knn.kneighbors(np.array(template_dict[channel]["coord"]).reshape(1,-1))
 		selected = [input_order[i] for i in indices[0]]
-		print(channel, ':', selected)
+		#print(channel, ':', selected)
 		
 		idx = template_dict[channel]["index"]
 		new_idx[idx] = indices[0].tolist()
@@ -233,10 +233,10 @@ def mapping_stage1(app_state, channel_info, loc_file):
 	input_order = input_montage.ch_names
 	
 	channel_info.update({
-	    "templateByName" : {k : v.__dict__ for k,v in template_dict.items()},
-	    "inputByName" : {k : v.__dict__ for k,v in input_dict.items()},
-	    "templateByIndex" : template_order,
-		"inputByIndex" : input_order
+	    "templateDict" : {k : v.__dict__ for k,v in template_dict.items()},
+	    "inputDict" : {k : v.__dict__ for k,v in input_dict.items()},
+	    "templateOrder" : template_order,
+		"inputOrder" : input_order
 	})
 	app_state.update({
 	    "stage1NewOrder" : new_idx,
@@ -257,10 +257,10 @@ def mapping_stage1(app_state, channel_info, loc_file):
 def mapping_stage2(app_state, channel_info, fill_mode):
 	second1 = time.time()
 
-	template_dict = channel_info["templateByName"]
-	input_dict = channel_info["inputByName"]
-	template_order = channel_info["templateByIndex"]
-	input_order = channel_info["inputByIndex"]
+	template_dict = channel_info["templateDict"]
+	input_dict = channel_info["inputDict"]
+	template_order = channel_info["templateOrder"]
+	input_order = channel_info["inputOrder"]
 	unassigned = app_state["stage2UnassignedInputs"]
 	if unassigned == []:
 		app_state["runningState"] = "finished"
@@ -301,8 +301,8 @@ def mapping_stage2(app_state, channel_info, fill_mode):
 			print(template_order[row_idx[i]], '<-', unassigned[col_idx[i]])
 	
 	channel_info.update({
-	    "templateByName" : template_dict,
-	    "inputByName" : input_dict
+	    "templateDict" : template_dict,
+	    "inputDict" : input_dict
 	})
 	app_state.update({
 	    "stage2NewOrder" : new_idx,