Update app.py

app.py

@@ -410,11 +410,11 @@ class NeuralNetworkSimulator:
 
 
 
-# Set up MediaPipe Pose
+# Set up MediaPipe Pose for humanoid detection
 mp_pose = mp.solutions.pose
 pose = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.7)
 
-# Humanoid Detection Function
+# Function to detect humanoid keypoints
 def detect_humanoid(image_path):
     image = cv2.imread(image_path)
     image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
@@ -427,7 +427,7 @@ def detect_humanoid(image_path):
         return keypoints
     return []
 
-# Apply touch points on detected humanoid keypoints
+# Function to apply touch points on detected humanoid keypoints
 def apply_touch_points(image_path, keypoints):
     image = cv2.imread(image_path)
     image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
@@ -439,43 +439,35 @@ def apply_touch_points(image_path, keypoints):
     
     return image_pil
 
-# Create Sensation Map with Vectorized Computation for Speed
+# Function to create a sensation map
 def create_sensation_map(width, height, keypoints):
     sensation_map = np.random.rand(height, width, 12) * 0.5 + 0.5
 
-    # Create coordinate grids for vectorized calculation
     x_grid, y_grid = np.meshgrid(np.arange(width), np.arange(height))
 
     for kp in keypoints:
         kp_x, kp_y = kp
-        
-        # Using vectorized distance calculation
         dist = np.sqrt((x_grid - kp_x) ** 2 + (y_grid - kp_y) ** 2)
-        
-        # Apply Gaussian influence on sensation based on distance
-        influence = np.exp(-dist / 100)  # Smoother, larger area of influence
-        sensation_map[:, :, :12] *= 1 + (influence[..., np.newaxis]) * 1.2  # Apply to all sensation channels
+        influence = np.exp(-dist / 100)
+        sensation_map[:, :, :12] *= 1 + (influence[..., np.newaxis]) * 1.2
 
     return sensation_map
 
-# Create Heatmap for a Specific Sensation Type
+# Function to create heatmap for a specific sensation type
 def create_heatmap(sensation_map, sensation_type):
     plt.figure(figsize=(10, 15))
     sns.heatmap(sensation_map[:, :, sensation_type], cmap='viridis')
-    plt.title(f'{["Pain", "Pleasure", "Pressure", "Temperature", "Texture", "EM Field", "Tickle", "Itch", "Quantum", "Neural", "Proprioception", "Synesthesia"][sensation_type]} Sensation Map')
     plt.axis('off')
     
-    # Save the heatmap to a buffer
     buf = io.BytesIO()
     plt.savefig(buf, format='png')
     buf.seek(0)
     plt.close()
     
-    # Create an image from the buffer
     heatmap_img = Image.open(buf)
     return heatmap_img
 
-# Generate AI response based on keypoints and sensation map
+# Function to generate AI response
 def generate_ai_response(keypoints, sensation_map):
     num_keypoints = len(keypoints)
     avg_sensations = np.mean(sensation_map, axis=(0, 1))
@@ -488,11 +480,12 @@ def generate_ai_response(keypoints, sensation_map):
     
     return response
 
-# Streamlit UI for Interaction
+### Streamlit UI Logic ###
+
 uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
 
 if uploaded_file is not None:
-    # Read and save uploaded image
+    # Save and read the uploaded image
     image_path = 'temp.jpg'
     with open(image_path, 'wb') as f:
         f.write(uploaded_file.getvalue())
@@ -508,36 +501,28 @@ if uploaded_file is not None:
     image_height, image_width, _ = image.shape
     sensation_map = create_sensation_map(image_width, image_height, keypoints)
     
-    # Display the processed image with touch points
+    # Display the image with touch points
     fig, ax = plt.subplots()
     ax.imshow(processed_image)
     
-    # List of clicked points for interaction
     clicked_points = []
 
     def onclick(event):
-        if event.xdata is not None and event.ydata is not None:
+        if event.xdata and event.ydata:
             clicked_points.append((int(event.xdata), int(event.ydata)))
             st.write(f"Clicked point: ({int(event.xdata)}, {int(event.ydata)})")
             
-            # Update sensation values based on the clicked point
+            # Display sensation values at the clicked point
             sensation = sensation_map[int(event.ydata), int(event.xdata)]
-            (
-                pain, pleasure, pressure_sens, temp_sens, texture_sens,
-                em_sens, tickle_sens, itch_sens, quantum_sens, neural_sens,
-                proprioception_sens, synesthesia_sens
-            ) = sensation
-            
             st.write("### Sensory Data Analysis")
-            st.write(f"Interaction Point: ({int(event.xdata):.1f}, {int(event.ydata):.1f})")
-            st.write(f"Pain: {pain:.2f} | Pleasure: {pleasure:.2f} | Pressure: {pressure_sens:.2f}")
-            st.write(f"Temperature: {temp_sens:.2f} | Texture: {texture_sens:.2f} | EM Field: {em_sens:.2f}")
-            st.write(f"Tickle: {tickle_sens:.2f} | Itch: {itch_sens:.2f} | Quantum: {quantum_sens:.2f}")
-            st.write(f"Neural: {neural_sens:.2f} | Proprioception: {proprioception_sens:.2f} | Synesthesia: {synesthesia_sens:.2f}")
+            st.write(f"Pain: {sensation[0]:.2f} | Pleasure: {sensation[1]:.2f} | Pressure: {sensation[2]:.2f}")
+            st.write(f"Temperature: {sensation[3]:.2f} | Texture: {sensation[4]:.2f} | EM Field: {sensation[5]:.2f}")st.write(f"Tickle: {sensation[6]:.2f} | Itch: {sensation[7]:.2f} | Quantum: {sensation[8]:.2f}")
+            st.write(f"Neural: {sensation[9]:.2f} | Proprioception: {sensation[10]:.2f} | Synesthesia: {sensation[11]:.2f}")
     
+    # Connect the click event to the matplotlib figure
     fig.canvas.mpl_connect('button_press_event', onclick)
     
-    # Display the plot
+    # Display the plot in Streamlit
     st.pyplot(fig)
 
     # Heatmap for different sensations
@@ -564,7 +549,7 @@ if uploaded_file is not None:
     
     if st.button("Simulate Interaction"):
         if clicked_points:
-            # Ensure valid clicked points exist before accessing them
+            # Get the last clicked point
             touch_x, touch_y = clicked_points[-1]
             
             # Retrieve the sensation values at the clicked location
@@ -615,35 +600,35 @@ if uploaded_file is not None:
             if show_heatmap:
                 heatmap = create_heatmap(sensation_map, sensation_types.index("Pain"))  # Example for "Pain"
                 st.image(heatmap, use_column_width=True)
-    
+
     # Optionally, calculate and display the average pressure value in the image
     average_pressure = np.mean(sensation_map[:, :, 2])  # Pressure channel
     st.write(f"Average Pressure across the image: {average_pressure:.2f}")
                 
-            
     # Create a futuristic data display
-data_display = (
-            "```\n"
-            "+---------------------------------------------+\n"
-            f"| Pressure     : {average_pressure:.2f}".ljust(45) + "|\n"
-            f"| Temperature  : {np.mean(sensation_map[:, :, 3]):.2f}°C".ljust(45) + "|\n"
-            f"| Texture      : {np.mean(sensation_map[:, :, 4]):.2f}".ljust(45) + "|\n"
-            f"| EM Field     : {np.mean(sensation_map[:, :, 5]):.2f} μT".ljust(45) + "|\n"
-            f"| Quantum State: {np.mean(sensation_map[:, :, 8]):.2f}".ljust(45) + "|\n"
-            "+---------------------------------------------+\n"
-            f"| Location: ({touch_x:.1f}, {touch_y:.1f})".ljust(45) + "|\n"
-            f"| Pain Level   : {np.mean(sensation_map[:, :, 0]):.2f}".ljust(45) + "|\n"
-            f"| Pleasure     : {np.mean(sensation_map[:, :, 1]):.2f}".ljust(45) + "|\n"
-            f"| Tickle       : {np.mean(sensation_map[:, :, 6]):.2f}".ljust(45) + "|\n"
-            f"| Itch         : {np.mean(sensation_map[:, :, 7]):.2f}".ljust(45) + "|\n"
-            f"| Proprioception: {np.mean(sensation_map[:, :, 10]):.2f}".ljust(44) + "|\n"
-            f"| Synesthesia  : {np.mean(sensation_map[:, :, 11]):.2f}".ljust(45) + "|\n"
-            f"| Neural Response: {np.mean(sensation_map[:, :, 9]):.2f}".ljust(43) + "|\n"
-            "+---------------------------------------------+\n"
-            "```"
-        )
-
-st.code(data_display, language="")
+    data_display = (
+        "```\n"
+        "+---------------------------------------------+\n"
+        f"| Pressure     : {average_pressure:.2f}".ljust(45) + "|\n"
+        f"| Temperature  : {np.mean(sensation_map[:, :, 3]):.2f}°C".ljust(45) + "|\n"
+        f"| Texture      : {np.mean(sensation_map[:, :, 4]):.2f}".ljust(45) + "|\n"
+        f"| EM Field     : {np.mean(sensation_map[:, :, 5]):.2f} μT".ljust(45) + "|\n"
+        f"| Quantum State: {np.mean(sensation_map[:, :, 8]):.2f}".ljust(45) + "|\n"
+        "+---------------------------------------------+\n"
+        f"| Location: ({touch_x:.1f}, {touch_y:.1f})".ljust(45) + "|\n"
+        f"| Pain Level   : {np.mean(sensation_map[:, :, 0]):.2f}".ljust(45) + "|\n"
+        f"| Pleasure     : {np.mean(sensation_map[:, :, 1]):.2f}".ljust(45) + "|\n"
+        f"| Tickle       : {np.mean(sensation_map[:, :, 6]):.2f}".ljust(45) + "|\n"
+        f"| Itch         : {np.mean(sensation_map[:, :, 7]):.2f}".ljust(45) + "|\n"
+        f"| Proprioception: {np.mean(sensation_map[:, :, 10]):.2f}".ljust(44) + "|\n"
+        f"| Synesthesia  : {np.mean(sensation_map[:, :, 11]):.2f}".ljust(45) + "|\n"
+        f"| Neural Response: {np.mean(sensation_map[:, :, 9]):.2f}".ljust(43) + "|\n"
+        "+---------------------------------------------+\n"
+        "```"
+    )
+
+    # Display the futuristic data display using Streamlit's code block feature
+    st.code(data_display, language="")
 
 # Generate description
 prompt = (