Update app.py

app.py

@@ -1,15 +1,11 @@
 import streamlit as st
 import numpy as np
 import matplotlib.pyplot as plt
-from matplotlib.backends.backend_agg import FigureCanvasAgg
-from streamlit_drawable_canvas import st_canvas
-import time
 from PIL import Image, ImageDraw
-import io
+import time
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 # Constants
-WIDTH, HEIGHT = 1000, 600
 AVATAR_WIDTH, AVATAR_HEIGHT = 400, 600
 
 # Set up DialoGPT model
@@ -22,64 +18,68 @@ def load_model():
 tokenizer, model = load_model()
 
 # Simulated Sensor Classes
-class PressureSensor:
-    def __init__(self, sensitivity=1.0):
-        self.sensitivity = sensitivity
-    
-    def measure(self, pressure):
-        return pressure * self.sensitivity
+class Sensors:
+    @staticmethod
+    def measure_pressure(base_sensitivity, duration):
+        return base_sensitivity * (1 - np.exp(-duration / 2))
 
-class TemperatureSensor:
-    def __init__(self, base_temp=37.0):
-        self.base_temp = base_temp
-    
-    def measure(self, touch_temp):
-        return self.base_temp + (touch_temp - self.base_temp) * 0.1
+    @staticmethod
+    def measure_temperature(base_temp, duration):
+        return base_temp + 5 * (1 - np.exp(-duration / 3))
 
-class TextureSensor:
-    def __init__(self):
-        self.textures = ["smooth", "rough", "bumpy", "silky", "grainy"]
-    
-    def measure(self, x, y):
-        return self.textures[hash((x, y)) % len(self.textures)]
+    @staticmethod
+    def measure_texture(x, y):
+        textures = ["smooth", "rough", "bumpy", "silky", "grainy"]
+        return textures[hash((x, y)) % len(textures)]
 
-class EMFieldSensor:
-    def measure(self, x, y):
-        return np.sin(x / 50) * np.cos(y / 50) * 10  # simulated EM field
+    @staticmethod
+    def measure_em_field(x, y):
+        return np.sin(x/50) * np.cos(y/50) * 10
 
-# Create sensation map for the avatar
+# Create more detailed sensation map for the avatar
 def create_sensation_map(width, height):
-    sensation_map = np.zeros((height, width, 7))  # RGBPVTE channels for pain, pleasure, neutral, pressure, velocity, temperature, and EM sensitivity
+    sensation_map = np.zeros((height, width, 7))  # pain, pleasure, pressure, temp, texture, em, tickle
     for y in range(height):
         for x in range(width):
-            pain = np.exp(-((x - 100)**2 + (y - 150)**2) / 5000) + np.exp(-((x - 300)**2 + (y - 450)**2) / 5000)
-            pleasure = np.exp(-((x - 200)**2 + (y - 300)**2) / 5000) + np.exp(-((x - 100)**2 + (y - 500)**2) / 5000)
-            neutral = 1 - (pain + pleasure)
-            pressure = (np.exp(-((x - 50)**2 + (y - 150)**2) / 2000) + np.exp(-((x - 350)**2 + (y - 150)**2) / 2000) + 
-                        np.exp(-((x - 100)**2 + (y - 550)**2) / 2000) + np.exp(-((x - 300)**2 + (y - 550)**2) / 2000))
-            velocity = np.exp(-((x - 200)**2 + (y - 100)**2) / 5000) + np.exp(-((x - 200)**2 + (y - 300)**2) / 5000)
-            temperature = np.exp(-((x - 200)**2 + (y - 200)**2) / 10000)  # more sensitive in the core
-            em_sensitivity = np.exp(-((x - 200)**2 + (y - 100)**2) / 8000)  # more sensitive in the head
-            
-            sensation_map[y, x] = [pain, pleasure, neutral, pressure, velocity, temperature, em_sensitivity]
+            # Head
+            if 150 < x < 250 and 50 < y < 150:
+                sensation_map[y, x] = [0.7, 0.5, 0.8, 0.6, 0.9, 0.9, 0.3]
+            # Torso
+            elif 175 < x < 225 and 150 < y < 400:
+                sensation_map[y, x] = [0.5, 0.6, 0.7, 0.8, 0.6, 0.7, 0.5]
+            # Arms
+            elif (125 < x < 175 or 225 < x < 275) and 150 < y < 350:
+                sensation_map[y, x] = [0.6, 0.5, 0.9, 0.7, 0.8, 0.6, 0.7]
+            # Hands
+            elif (100 < x < 150 or 250 < x < 300) and 300 < y < 350:
+                sensation_map[y, x] = [0.8, 0.7, 1.0, 0.9, 1.0, 0.8, 0.9]
+            # Legs
+            elif 175 < x < 225 and 400 < y < 550:
+                sensation_map[y, x] = [0.7, 0.4, 0.8, 0.6, 0.7, 0.5, 0.6]
+            # Feet
+            elif 175 < x < 225 and 550 < y < 600:
+                sensation_map[y, x] = [0.9, 0.6, 1.0, 0.8, 0.9, 0.7, 1.0]
+            else:
+                sensation_map[y, x] = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]
     
     return sensation_map
 
 avatar_sensation_map = create_sensation_map(AVATAR_WIDTH, AVATAR_HEIGHT)
 
-# Initialize sensors
-pressure_sensor = PressureSensor()
-temp_sensor = TemperatureSensor()
-texture_sensor = TextureSensor()
-em_sensor = EMFieldSensor()
-
-# Create human-like avatar (same as before)
+# Create more detailed human-like avatar
 def create_avatar():
     img = Image.new('RGB', (AVATAR_WIDTH, AVATAR_HEIGHT), color='white')
     draw = ImageDraw.Draw(img)
     
     # Head
     draw.ellipse([150, 50, 250, 150], fill='beige', outline='black')
+    # Eyes
+    draw.ellipse([175, 80, 190, 95], fill='white', outline='black')
+    draw.ellipse([210, 80, 225, 95], fill='white', outline='black')
+    draw.ellipse([180, 85, 185, 90], fill='black')
+    draw.ellipse([215, 85, 220, 90], fill='black')
+    # Mouth
+    draw.arc([185, 110, 215, 130], start=0, end=180, fill='black')
     
     # Body
     draw.rectangle([175, 150, 225, 400], fill='beige', outline='black')
@@ -88,10 +88,18 @@ def create_avatar():
     draw.rectangle([125, 150, 175, 350], fill='beige', outline='black')
     draw.rectangle([225, 150, 275, 350], fill='beige', outline='black')
     
+    # Hands
+    draw.ellipse([100, 300, 150, 350], fill='beige', outline='black')
+    draw.ellipse([250, 300, 300, 350], fill='beige', outline='black')
+    
     # Legs
     draw.rectangle([175, 400, 200, 550], fill='beige', outline='black')
     draw.rectangle([200, 400, 225, 550], fill='beige', outline='black')
     
+    # Feet
+    draw.ellipse([165, 550, 210, 600], fill='beige', outline='black')
+    draw.ellipse([190, 550, 235, 600], fill='beige', outline='black')
+    
     return img
 
 avatar_image = create_avatar()
@@ -99,101 +107,91 @@ avatar_image = create_avatar()
 # Streamlit app
 st.title("Advanced Humanoid Techno-Sensory Simulation")
 
-# Create two columns
-col1, col2 = st.columns(2)
-
-# Avatar column
-with col1:
-    st.subheader("Humanoid Avatar")
-    st.image(avatar_image, use_column_width=True)
-
-# Touch interface column
-with col2:
-    st.subheader("Touch Interface")
-    canvas_result = st_canvas(
-        fill_color="rgba(255, 165, 0, 0.3)",
-        stroke_width=3,
-        stroke_color="#e00",
-        background_color="#eee",
-        background_image=avatar_image,
-        update_streamlit=True,
-        height=AVATAR_HEIGHT,
-        width=AVATAR_WIDTH,
-        drawing_mode="freedraw",
-        key="canvas",
-    )
-
-def calculate_sensation(x, y, pressure, velocity):
-    sensation = avatar_sensation_map[int(y), int(x)]
-    pain, pleasure, neutral, pressure_sensitivity, velocity_sensitivity, temp_sensitivity, em_sensitivity = sensation
-    
-    measured_pressure = pressure_sensor.measure(pressure * pressure_sensitivity)
-    measured_temp = temp_sensor.measure(37 + pressure * 5)  # Simulating temperature increase with pressure
-    measured_texture = texture_sensor.measure(x, y)
-    measured_em = em_sensor.measure(x, y) * em_sensitivity
-    
-    modified_pain = pain * measured_pressure / 10
-    modified_pleasure = pleasure * velocity * velocity_sensitivity
-    modified_neutral = neutral * (1 - (measured_pressure + velocity) / 2)
-    
-    return modified_pain, modified_pleasure, modified_neutral, measured_pressure, measured_temp, measured_texture, measured_em
-
-def generate_description(x, y, pressure, velocity, pain, pleasure, neutral, measured_pressure, measured_temp, measured_texture, measured_em):
-    prompt = f"""Human: Describe the sensation when touched at ({x:.1f}, {y:.1f}) with these measurements:
+# Display avatar
+st.image(avatar_image, use_column_width=True)
+
+# Touch input
+touch_x = st.slider("Touch X coordinate", 0, AVATAR_WIDTH, AVATAR_WIDTH // 2)
+touch_y = st.slider("Touch Y coordinate", 0, AVATAR_HEIGHT, AVATAR_HEIGHT // 2)
+
+# Touch duration
+touch_duration = st.slider("Touch duration (seconds)", 0.1, 5.0, 1.0, 0.1)
+
+if st.button("Apply Touch"):
+    sensation = avatar_sensation_map[touch_y, touch_x]
+    pain, pleasure, pressure_sens, temp_sens, texture_sens, em_sens, tickle_sens = sensation
+
+    measured_pressure = Sensors.measure_pressure(pressure_sens, touch_duration)
+    measured_temp = Sensors.measure_temperature(37, touch_duration)
+    measured_texture = Sensors.measure_texture(touch_x, touch_y)
+    measured_em = Sensors.measure_em_field(touch_x, touch_y) * em_sens
+
+    # Calculate overall sensation
+    pain_level = pain * measured_pressure
+    pleasure_level = pleasure * (measured_temp - 37) / 5
+    tickle_level = tickle_sens * (1 - np.exp(-touch_duration / 0.5))
+
+    st.write(f"Touch applied at ({touch_x}, {touch_y}) for {touch_duration:.1f} seconds")
+    st.write(f"Pressure: {measured_pressure:.2f}")
+    st.write(f"Temperature: {measured_temp:.2f}°C")
+    st.write(f"Texture: {measured_texture}")
+    st.write(f"Electromagnetic field: {measured_em:.2f}")
+    st.write(f"Pain level: {pain_level:.2f}")
+    st.write(f"Pleasure level: {pleasure_level:.2f}")
+    st.write(f"Tickle level: {tickle_level:.2f}")
+
+    # Generate description
+    prompt = f"""Human: Describe the sensation when touched at ({touch_x}, {touch_y}) for {touch_duration:.1f} seconds with these measurements:
     Pressure: {measured_pressure:.2f}
     Temperature: {measured_temp:.2f}°C
     Texture: {measured_texture}
     Electromagnetic field: {measured_em:.2f}
     Resulting in:
-    Pain: {pain:.2f}, Pleasure: {pleasure:.2f}, Neutral: {neutral:.2f}
+    Pain: {pain_level:.2f}, Pleasure: {pleasure_level:.2f}, Tickle: {tickle_level:.2f}
     Avatar:"""
     
     input_ids = tokenizer.encode(prompt, return_tensors="pt")
     output = model.generate(input_ids, max_length=200, num_return_sequences=1, no_repeat_ngram_size=2, top_k=50, top_p=0.95, temperature=0.7)
     
-    return tokenizer.decode(output[0], skip_special_tokens=True).split("Avatar: ")[-1].strip()
-
-# Initialize session state
-if 'touch_history' not in st.session_state:
-    st.session_state.touch_history = []
-
-# Handle touch events
-if canvas_result.json_data is not None:
-    objects = canvas_result.json_data["objects"]
-    if len(objects) > 0:
-        new_points = objects[-1].get("points", [])
-        if new_points:
-            for i in range(1, len(new_points)):
-                x1, y1 = new_points[i-1]["x"], new_points[i-1]["y"]
-                x2, y2 = new_points[i]["x"], new_points[i]["y"]
-                
-                # Calculate pressure and velocity
-                distance = np.sqrt((x2 - x1)**2 + (y2 - y1)**2)
-                velocity = distance / 0.01  # Assuming 10ms between points
-                pressure = 1 + velocity / 100  # Simple pressure model
-                
-                x, y = (x1 + x2) / 2, (y1 + y2) / 2
-                pain, pleasure, neutral, measured_pressure, measured_temp, measured_texture, measured_em = calculate_sensation(x, y, pressure, velocity)
-                
-                st.session_state.touch_history.append((x, y, pressure, velocity, pain, pleasure, neutral, measured_pressure, measured_temp, measured_texture, measured_em))
-
-# Display touch history and generate descriptions
-if st.session_state.touch_history:
-    st.subheader("Touch History and Sensations")
-    for (x, y, pressure, velocity, pain, pleasure, neutral, measured_pressure, measured_temp, measured_texture, measured_em) in \
-        st.session_state.touch_history[-5:]:
-        st.write(f"Touch at ({x:.1f}, {y:.1f})")
-        st.write(f"Pressure: {measured_pressure:.2f}, Temperature: {measured_temp:.2f}°C")
-        st.write(f"Texture: {measured_texture}, EM Field: {measured_em:.2f}")
-        st.write(f"Sensations - Pain: {pain:.2f}, Pleasure: {pleasure:.2f}, Neutral: {neutral:.2f}")
-        description = generate_description(x, y, pressure, velocity, pain, pleasure, neutral, measured_pressure, measured_temp, measured_texture, measured_em)
-        st.write("Avatar's response:")
-        st.write(description)
-        st.write("---")
-
-st.write("Draw on the avatar to simulate touch. The simulation will process pressure, temperature, texture, and electromagnetic sensations.")
-
-# Add a button to clear the touch history
-if st.button("Clear Touch History"):
-    st.session_state.touch_history = []
-    st.experimental_rerun()
+    response = tokenizer.decode(output[0], skip_special_tokens=True).split("Avatar: ")[-1].strip()
+    
+    st.write("Avatar's response:")
+    st.write(response)
+
+# Visualize sensation map
+st.subheader("Sensation Map Visualization")
+fig, axs = plt.subplots(2, 4, figsize=(20, 10))
+titles = ['Pain', 'Pleasure', 'Pressure', 'Temperature', 'Texture', 'EM Field', 'Tickle']
+
+for i, title in enumerate(titles):
+    ax = axs[i // 4, i % 4]
+    im = ax.imshow(avatar_sensation_map[:, :, i], cmap='viridis')
+    ax.set_title(title)
+    fig.colorbar(im, ax=ax)
+
+axs[1, 3].axis('off')  # Turn off the last unused subplot
+plt.tight_layout()
+st.pyplot(fig)
+
+st.write("The sensation map shows the sensitivity of different body parts to various stimuli. Brighter colors indicate higher sensitivity.")
+
+# Add some context about the avatar's sensory capabilities
+st.subheader("Avatar Sensory Capabilities")
+st.write("""
+This advanced humanoid avatar is equipped with cutting-edge sensory technology:
+
+1. Pressure Sensors: Highly sensitive to touch, with increased sensitivity in hands and feet.
+2. Temperature Sensors: Can detect slight changes in temperature, simulating human thermal perception.
+3. Texture Analysis: Capable of distinguishing between various textures, from smooth to rough.
+4. Electromagnetic Field Detection: Mimics the subtle EM sensitivity some humans report.
+5. Pain and Pleasure Processing: Simulates the complex interplay of pain and pleasure responses.
+6. Tickle Sensation: Replicates the unique tickle response, which can be pleasurable or uncomfortable.
+
+The avatar's responses are generated using an advanced language model, attempting to describe the sensations in human-like terms.
+""")
+
+# Footer
+st.write("---")
+st.write("Advanced Humanoid Techno-Sensory Simulation v1.0")
+st.write("Disclaimer: This is a simulation and does not represent actual human sensory experiences.")
+