Update app.py

app.py

@@ -3,6 +3,8 @@ import numpy as np
 from typing import List, Tuple
 from transformers import pipeline
 import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import RendererAgg
+from streamlit_drawable_canvas import st_canvas
 import time
 
 # Constants
@@ -10,16 +12,12 @@ WIDTH, HEIGHT = 600, 600
 ELASTICITY = 0.3
 DAMPING = 0.7
 
-# Create touch points
-num_points = 20
-touch_points: List[Tuple[float, float]] = [(x, y) for x in range(50, WIDTH-50, int((WIDTH-100)/(num_points-1))) for y in range(50, HEIGHT-50, int((HEIGHT-100)/(num_points-1)))]
-original_points = touch_points.copy()
-velocities: List[Tuple[float, float]] = [(0.0, 0.0)] * len(touch_points)
-is_affected: List[bool] = [False] * len(touch_points)
-
-# Create pain and pleasure points
-pain_points = [(100, 100), (500, 500)]
-pleasure_points = [(300, 300), (200, 400)]
+# Create sensation map
+sensation_map = np.zeros((HEIGHT, WIDTH))
+for y in range(HEIGHT):
+    for x in range(WIDTH):
+        # Create a complex sensation map with various regions
+        sensation_map[y, x] = np.sin(x/30) * np.cos(y/30) * 5 + np.random.normal(0, 0.5)
 
 # Set up the Hugging Face pipeline
 @st.cache_resource
@@ -34,50 +32,16 @@ st.title("Advanced Artificial Touch Simulation")
 # Create a Streamlit container for the touch simulation
 touch_container = st.container()
 
-def update_points():
-    global touch_points, velocities, is_affected
-    
-    # Apply spring force
-    for i, (x, y) in enumerate(touch_points):
-        force_x = (original_points[i][0] - x) * ELASTICITY
-        force_y = (original_points[i][1] - y) * ELASTICITY
-        velocities[i] = (velocities[i][0] + force_x, velocities[i][1] + force_y)
-    
-    # Apply damping
-    for i, (vx, vy) in enumerate(velocities):
-        velocities[i] = (vx * DAMPING, vy * DAMPING)
-    
-    # Update position
-    for i, (x, y) in enumerate(touch_points):
-        vx, vy = velocities[i]
-        touch_points[i] = (x + vx, y + vy)
-    
-    # Reset affected flags
-    is_affected = [False] * len(touch_points)
-
 def calculate_sensation(x, y, pressure, duration):
-    sensation = 0
-    for px, py in pain_points:
-        distance = np.sqrt((x - px)**2 + (y - py)**2)
-        if distance < 50:
-            sensation -= (50 - distance) * pressure * (duration ** 1.5) / 50
-    for px, py in pleasure_points:
-        distance = np.sqrt((x - px)**2 + (y - py)**2)
-        if distance < 50:
-            sensation += (50 - distance) * pressure / 50
-    return sensation
-
-def on_tap(x, y, pressure, duration):
-    global touch_points, velocities, is_affected
+    # Get sensation from the map
+    base_sensation = sensation_map[int(y), int(x)]
     
-    for i, (tx, ty) in enumerate(touch_points):
-        distance = ((tx - x)**2 + (ty - y)**2)**0.5
-        if distance < 30:
-            force_x = (tx - x) / distance
-            force_y = (ty - y) / distance
-            velocities[i] = (velocities[i][0] - force_x * 10 * pressure, velocities[i][1] - force_y * 10 * pressure)
-            is_affected[i] = True
+    # Modify sensation based on pressure and duration
+    modified_sensation = base_sensation * pressure * (1 + np.log(duration + 1))
     
+    return modified_sensation
+
+def on_touch(x, y, pressure, duration):
     sensation = calculate_sensation(x, y, pressure, duration)
     
     # Generate a description of the touch
@@ -87,53 +51,60 @@ def on_tap(x, y, pressure, duration):
     prompt = f"The user touched the screen at ({x:.2f}, {y:.2f}) with a pressure of {pressure:.2f} for {duration:.2f} seconds, resulting in a sensation of {sensation:.2f}. Describe the experience:"
     text = text_generator(prompt, max_length=100, num_return_sequences=1, do_sample=True, top_k=50, top_p=0.95, num_beams=1)[0]['generated_text']
     st.write(text)
-    
-    update_points()
 
 # Initialize session state
-if 'x' not in st.session_state:
-    st.session_state.x = 0
-if 'y' not in st.session_state:
-    st.session_state.y = 0
-if 'pressure' not in st.session_state:
-    st.session_state.pressure = 1.0
-if 'duration' not in st.session_state:
-    st.session_state.duration = 0.0
 if 'touch_start_time' not in st.session_state:
     st.session_state.touch_start_time = None
+if 'last_touch_position' not in st.session_state:
+    st.session_state.last_touch_position = None
 
 # Main app logic
 fig, ax = plt.subplots(figsize=(6, 6))
-ax.set_xlim(0, WIDTH)
-ax.set_ylim(0, HEIGHT)
-
-for i, (x, y) in enumerate(touch_points):
-    color = "red" if is_affected[i] else "navy"
-    ax.add_artist(plt.Circle((x, y), 5, color=color, alpha=0.5))
-
-for x, y in pain_points:
-    ax.add_artist(plt.Circle((x, y), 10, color="red", alpha=0.3))
-
-for x, y in pleasure_points:
-    ax.add_artist(plt.Circle((x, y), 10, color="green", alpha=0.3))
-
-touch_container.pyplot(fig)
-
-col1, col2 = st.columns(2)
-with col1:
-    st.session_state.x = st.slider("X coordinate", 0, WIDTH, st.session_state.x)
-    st.session_state.y = st.slider("Y coordinate", 0, HEIGHT, st.session_state.y)
-with col2:
-    st.session_state.pressure = st.slider("Pressure", 0.1, 2.0, st.session_state.pressure)
-
-if touch_container.button("Start Touch"):
-    st.session_state.touch_start_time = time.time()
-
-if touch_container.button("End Touch"):
-    if st.session_state.touch_start_time is not None:
-        st.session_state.duration = time.time() - st.session_state.touch_start_time
-        on_tap(st.session_state.x, st.session_state.y, st.session_state.pressure, st.session_state.duration)
+ax.imshow(sensation_map, cmap='coolwarm', extent=[0, WIDTH, HEIGHT, 0])
+ax.axis('off')
+
+# Use streamlit-drawable-canvas for interaction
+canvas_result = st_canvas(
+    fill_color="rgba(255, 165, 0, 0.3)",
+    stroke_width=3,
+    stroke_color="#e00",
+    background_color="#eee",
+    background_image=fig,
+    update_streamlit=True,
+    height=HEIGHT,
+    width=WIDTH,
+    drawing_mode="point",
+    point_display_radius=0,
+    key="canvas",
+)
+
+# Handle touch events
+if canvas_result.json_data is not None:
+    objects = canvas_result.json_data["objects"]
+    if len(objects) > 0:
+        last_object = objects[-1]
+        current_position = (last_object["left"], last_object["top"])
+        
+        if st.session_state.touch_start_time is None:
+            st.session_state.touch_start_time = time.time()
+            st.session_state.last_touch_position = current_position
+        else:
+            # Calculate pressure based on movement
+            if st.session_state.last_touch_position is not None:
+                dx = current_position[0] - st.session_state.last_touch_position[0]
+                dy = current_position[1] - st.session_state.last_touch_position[1]
+                distance = np.sqrt(dx**2 + dy**2)
+                pressure = 1 + distance / 10  # Adjust this formula as needed
+            else:
+                pressure = 1.0
+
+            duration = time.time() - st.session_state.touch_start_time
+            on_touch(current_position[0], current_position[1], pressure, duration)
+            
+            st.session_state.last_touch_position = current_position
+    else:
         st.session_state.touch_start_time = None
-        st.session_state.duration = 0.0
+        st.session_state.last_touch_position = None
 
-update_points()
+st.write("Click and drag on the image to simulate touch. The color represents different sensations.")
+st.write("Red areas are more sensitive (pain or intense pleasure), while blue areas are less sensitive.")