Update app.py

app.py

@@ -412,75 +412,70 @@ class NeuralNetworkSimulator:
 
 # Set up MediaPipe Pose
 mp_pose = mp.solutions.pose
-pose = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.5)
+pose = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.7)
 
+# Humanoid Detection Function
 def detect_humanoid(image_path):
     image = cv2.imread(image_path)
     image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
     results = pose.process(image_rgb)
+    
     if results.pose_landmarks:
         landmarks = results.pose_landmarks.landmark
         image_height, image_width, _ = image.shape
-        keypoints = []
-        for landmark in landmarks:
-            x = int(landmark.x * image_width)
-            y = int(landmark.y * image_height)
-            keypoints.append((x, y))
+        keypoints = [(int(landmark.x * image_width), int(landmark.y * image_height)) for landmark in landmarks]
         return keypoints
     return []
 
+# Apply touch points on detected humanoid keypoints
 def apply_touch_points(image_path, keypoints):
     image = cv2.imread(image_path)
-    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    image = Image.fromarray(image)
-    draw = ImageDraw.Draw(image)
+    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    image_pil = Image.fromarray(image_rgb)
+    draw = ImageDraw.Draw(image_pil)
+    
     for point in keypoints:
-        draw.ellipse([point[0]-5, point[1]-5, point[0]+5, point[1]+5], fill='red')
-    return image
+        draw.ellipse([point[0] - 5, point[1] - 5, point[0] + 5, point[1] + 5], fill='red')
+    
+    return image_pil
 
+# Create Sensation Map with Vectorized Computation for Speed
 def create_sensation_map(width, height, keypoints):
-    sensation_map = np.zeros((height, width, 12))
-    for y in range(height):
-        for x in range(width):
-            base_sensitivities = np.random.rand(12) * 0.5 + 0.5
-            
-            # Enhance sensitivities near keypoints
-            for kp in keypoints:
-                distance = np.sqrt((x - kp[0])**2 + (y - kp[1])**2)
-                if distance < 30:  # Adjust this value to change the area of influence
-                    base_sensitivities *= 1.5
-            
-            sensation_map[y, x, 0] = base_sensitivities[0] * np.random.rand()  # Pain
-            sensation_map[y, x, 1] = base_sensitivities[1] * np.random.rand()  # Pleasure
-            sensation_map[y, x, 2] = base_sensitivities[2] * np.random.rand()  # Pressure
-            sensation_map[y, x, 3] = base_sensitivities[3] * (np.random.rand() * 10 + 30)  # Temperature
-            sensation_map[y, x, 4] = base_sensitivities[4] * np.random.rand()  # Texture
-            sensation_map[y, x, 5] = base_sensitivities[5] * np.random.rand()  # EM field
-            sensation_map[y, x, 6] = base_sensitivities[6] * np.random.rand()  # Tickle
-            sensation_map[y, x, 7] = base_sensitivities[7] * np.random.rand()  # Itch
-            sensation_map[y, x, 8] = base_sensitivities[8] * np.random.rand()  # Quantum
-            sensation_map[y, x, 9] = base_sensitivities[9] * np.random.rand()  # Neural
-            sensation_map[y, x, 10] = base_sensitivities[10] * np.random.rand()  # Proprioception
-            sensation_map[y, x, 11] = base_sensitivities[11] * np.random.rand()  # Synesthesia
+    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
 
     return sensation_map
 
+# 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')
     
-    # Instead of displaying, save to a buffer
+    # Save the heatmap to a buffer
     buf = io.BytesIO()
     plt.savefig(buf, format='png')
     buf.seek(0)
-    plt.close()  # Close the figure to free up memory
+    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
 def generate_ai_response(keypoints, sensation_map):
     num_keypoints = len(keypoints)
     avg_sensations = np.mean(sensation_map, axis=(0, 1))
@@ -493,10 +488,11 @@ def generate_ai_response(keypoints, sensation_map):
     
     return response
 
+# Streamlit UI for Interaction
 uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
 
 if uploaded_file is not None:
-    # Read the image
+    # Read and save uploaded image
     image_path = 'temp.jpg'
     with open(image_path, 'wb') as f:
         f.write(uploaded_file.getvalue())
@@ -512,13 +508,13 @@ 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
+    # Display the processed image with touch points
     fig, ax = plt.subplots()
     ax.imshow(processed_image)
     
-    # Create a list to store the clicked points
+    # List of clicked points for interaction
     clicked_points = []
-    
+
     def onclick(event):
         if event.xdata is not None and event.ydata is not None:
             clicked_points.append((int(event.xdata), int(event.ydata)))
@@ -544,7 +540,7 @@ if uploaded_file is not None:
     # Display the plot
     st.pyplot(fig)
 
-    # Display heatmaps for different sensations
+    # Heatmap for different sensations
     sensation_types = ["Pain", "Pleasure", "Pressure", "Temperature", "Texture", "EM Field", 
                        "Tickle", "Itch", "Quantum", "Neural", "Proprioception", "Synesthesia"]
     
@@ -556,30 +552,21 @@ if uploaded_file is not None:
     if st.button("Generate AI Response"):
         response = generate_ai_response(keypoints, sensation_map)
         st.write("AI Response:", response)
-        
-    # Touch controls and output
+
+    # Additional Neural Interface Controls for Interaction
     st.subheader("Neural Interface Controls")
     
-    # Touch duration
     touch_duration = st.slider("Interaction Duration (s)", 0.1, 5.0, 1.0, 0.1)
-    
-    # Touch pressure
     touch_pressure = st.slider("Interaction Intensity", 0.1, 2.0, 1.0, 0.1)
-    
-    # Toggle quantum feature
     use_quantum = st.checkbox("Enable Quantum Sensing", value=True)
-    
-    # Toggle synesthesia
     use_synesthesia = st.checkbox("Enable Synesthesia", value=False)
-    
-    # Add this with your other UI elements
     show_heatmap = st.checkbox("Show Sensation Heatmap", value=True)
     
     if st.button("Simulate Interaction"):
-    # Simulate interaction at the clicked point
-            if 'clicked_points' in locals() and clicked_points:
-                touch_x, touch_y = clicked_points[-1]
+        if clicked_points:
+            touch_x, touch_y = clicked_points[-1]
             
+            # Retrieve the sensation values at the clicked location
             sensation = sensation_map[touch_y, touch_x]
             (
                 pain, pleasure, pressure_sens, temp_sens, texture_sens,
@@ -587,31 +574,34 @@ if uploaded_file is not None:
                 proprioception_sens, synesthesia_sens
             ) = sensation
 
+            # Adjust the sensations based on user interaction settings
             measured_pressure = pressure_sens * touch_pressure
-            measured_temp = temp_sens  # Assuming temperature doesn't change
-            measured_texture = texture_sens  # Assuming texture doesn't change
-            measured_em = em_sens  # Assuming EM field doesn't change
+            measured_temp = temp_sens  # Assuming temperature doesn't change during touch
+            measured_texture = texture_sens  # Assuming texture is constant
+            measured_em = em_sens  # Assuming electromagnetic field remains constant
             
+            # Quantum sensation handling based on user selection
             if use_quantum:
                 quantum_state = quantum_sens
             else:
                 quantum_state = "N/A"
 
-            # Calculate overall sensations
+            # Calculate overall sensations with interaction modifiers
             pain_level = pain * measured_pressure * touch_pressure
             pleasure_level = pleasure * (measured_temp - 37) / 10
             tickle_level = tickle_sens * (1 - np.exp(-touch_duration / 0.5))
             itch_level = itch_sens * (1 - np.exp(-touch_duration / 1.5))
             
             # Proprioception (sense of body position)
-            proprioception = proprioception_sens * np.linalg.norm([touch_x - image_width/2, touch_y - image_height/2]) / (image_width/2)
+            proprioception = proprioception_sens * np.linalg.norm([touch_x - image_width / 2, touch_y - image_height / 2]) / (image_width / 2)
             
-            # Synesthesia (mixing of senses)
+            # Synesthesia (mixing of senses) handling based on user selection
             if use_synesthesia:
                 synesthesia = synesthesia_sens * (measured_pressure + measured_temp + measured_em) / 3
             else:
                 synesthesia = "N/A"
             
+            # Display simulated interaction results
             st.write("### Simulated Interaction Results")
             st.write(f"Interaction Point: ({touch_x:.1f}, {touch_y:.1f})")
             st.write(f"Duration: {touch_duration:.1f} s | Intensity: {touch_pressure:.2f}")
@@ -620,14 +610,16 @@ if uploaded_file is not None:
             st.write(f"Tickle: {tickle_level:.2f} | Itch: {itch_level:.2f} | Quantum: {quantum_state}")
             st.write(f"Neural: {neural_sens:.2f} | Proprioception: {proprioception:.2f} | Synesthesia: {synesthesia}")
             
-            # Display a heatmap of the sensations
+            # Optionally display heatmap of the sensations
             if show_heatmap:
-                heatmap = create_heatmap(sensation_map, sensation_types.index("Pain"))
+                heatmap = create_heatmap(sensation_map, sensation_types.index("Pain"))  # Example for "Pain"
                 st.image(heatmap, use_column_width=True)
 
-    # Calculate the average pressure value
-    average_pressure = np.mean(sensation_map[:, :, 2])
-
+    # 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"