Update app.py

app.py

@@ -47,8 +47,6 @@ latest_data = {
     "status": "N/A",
     "update_time": "Waiting for data...",
     "image_url": "N/A",
-    "progress": 0,  
-    "message": "",  
 }
 
 bambu_client = None
@@ -96,61 +94,36 @@ def bambu_on_message(client, userdata, message):
         logger.error(f"Error parsing MQTT message: {e}")
 
 
-def rpi_on_message(client, userdata, msg):
+def rpi_on_message(client, userdata, message):
     global latest_data
-    
+    logger.info("Received message")
     try:
-        payload = msg.payload.decode("utf-8")
-        logger.info(f"Received message from RPI: {payload}")
-        
-        data = json.loads(payload)
-        status = data.get("status", "Unknown")
-        
-        latest_data["status"] = status
-        latest_data["update_time"] = data.get("update_time", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
-        
-        if "nozzle_temperature" in data:
-            latest_data["nozzle_temperature"] = data["nozzle_temperature"]
-        
-        if "bed_temperature" in data:
-            latest_data["bed_temperature"] = data["bed_temperature"]
-        
-        if "error" in data:
-            logger.error(f"Error from RPI: {data['error']}")
-       
-        if status == "Ready":
-            latest_data["progress"] = 0
-            latest_data["message"] = "Printer ready"
-        elif status == "Processing":
-            latest_data["progress"] = 25
-            latest_data["message"] = "Processing G-code..."
-        
-    except Exception as e:
-        logger.error(f"Error processing message from RPI: {e}")
-        
-        try:
-            result = json.loads(payload)
-            
-            if "status" in result:
-                status = result["status"]
-                latest_data["status"] = status
- 
-            if "command" in result and result["command"] == "capture_image" and result.get("auto_triggered", False):
-                logger.info("receive capture command")
-                threading.Thread(target=handle_auto_capture, args=(result,), daemon=True).start()
-                
-        except json.JSONDecodeError:
-            logger.error(f"Invalid JSON in message: {payload}")
-            
+        data = json.loads(message.payload)
+        latest_data["image_url"] = data.get("image_url", "N/A")
     except Exception as e:
-        logger.error(f"Error processing RPI message: {e}")
+        logger.error(f"Error parsing MQTT message: {e}")
 
 
 def get_data(serial=DEFAULT_SERIAL):
     global bambu_client, response_topic
 
+    retries = 5
+    while bambu_client is None and retries > 0:
+        try:
+            create_client("bambu")
+        except Exception as e:
+            bambu_client = None
+            logger.error(f"Failed to initialize Bambu MQTT: {e}")
+
+            retries -= 1
+
     if bambu_client is None:
-        create_client("bambu")
+        return (
+            latest_data["status"],
+            latest_data["bed_temperature"],
+            latest_data["nozzle_temperature"],
+            latest_data["update_time"],
+        )
 
     request_topic = f"bambu_a1_mini/request/{serial}"
     response_topic = f"bambu_a1_mini/response/{serial}"
@@ -177,15 +150,12 @@ def get_data(serial=DEFAULT_SERIAL):
 
 
 def send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed):
-    global rpi_client
+    global bambu_client
 
     serial = DEFAULT_SERIAL
-
     logger.info(
-        f"Sending parameters to RPi for G-code generation: nozzle={nozzle_temp}, bed={bed_temp}, "
-        f"speed={print_speed}, fan={fan_speed}"
+        f"Sending parameters to {serial}: nozzle={nozzle_temp}, bed={bed_temp}, speed={print_speed}, fan={fan_speed}"
     )
-
     try:
         params = {
             "nozzle_temp": nozzle_temp,
@@ -196,18 +166,13 @@ def send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed):
 
         request_topic = f"bambu_a1_mini/request/{serial}"
 
-        if rpi_client:
-            rpi_client.publish(
+        if bambu_client:
+            bambu_client.publish(
                 request_topic,
-                json.dumps({"command": "generate_gcode", "parameters": params}),
+                json.dumps({"command": "set_parameters", "parameters": params}),
             )
-            logger.info("Parameters sent successfully to RPi for G-code generation")
-            
-            global latest_data
-            latest_data["status"] = "Sent"
-            latest_data["update_time"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
-            
-            return "Parameters sent successfully to RPi. Status: Sent"
+            logger.info("Parameters sent successfully")
+            return "Parameters sent successfully"
         else:
             logger.warning("MQTT not connected, parameters not sent")
             return "MQTT not connected, parameters not sent"
@@ -215,12 +180,6 @@ def send_print_parameters(nozzle_temp, bed_temp, print_speed, fan_speed):
         logger.error(f"Error sending parameters: {e}")
         return f"Error sending parameters: {e}"
 
-      
-    latest_data["status"] = "Sending"
-    latest_data["progress"] = 10
-    latest_data["message"] = "Sending parameters to printer..."
-
-
 
 def get_image_base64(image):
     if image is None:
@@ -241,21 +200,35 @@ def get_image_base64(image):
         return None
 
 
-def handle_auto_capture(message):
+def get_test_image(image_name=None):
+    test_dir = os.path.join(os.path.dirname(__file__), "test_images")
+
+    if not os.path.exists(test_dir):
+        logger.error(f"Test images directory not found: {test_dir}")
+        return None
+
+    image_files = [
+        f
+        for f in os.listdir(test_dir)
+        if f.lower().endswith((".png", ".jpg", ".jpeg", ".bmp"))
+    ]
+
+    if not image_files:
+        logger.error("No test images found")
+        return None
+
+    if image_name and image_name in image_files:
+        image_path = os.path.join(test_dir, image_name)
+    else:
+        image_path = os.path.join(test_dir, random.choice(image_files))
+
+    logger.info(f"Using test image: {image_path}")
+
     try:
-        logger.info(f"receive capture command: {message}")
-        
-        print_job = message.get("print_job", "unknown_job")
-        timestamp = message.get("timestamp", time.strftime("%Y-%m-%d %H:%M:%S"))
-        
-        latest_data["auto_capture_requested"] = True
-        latest_data["last_capture_job"] = print_job
-        latest_data["last_capture_time"] = timestamp
-        
-        return capture_image()
+        return Image.open(image_path)
     except Exception as e:
-        logger.error(f"error: {e}")
-        return None, f"capture failed: {str(e)}"
+        logger.error(f"Failed to open test image: {e}")
+        return None
 
 
 def capture_image(url=None, use_test_image=False, test_image_name=None):
@@ -310,17 +283,6 @@ def capture_image(url=None, use_test_image=False, test_image_name=None):
     else:
         raise Exception("url is 'N/A'")
 
-def update_print_status():
-   global latest_data
-   return (
-       latest_data["status"],
-       latest_data["nozzle_temperature"],
-       latest_data["bed_temperature"],
-       latest_data["update_time"],
-       latest_data.get("progress", 0),
-       latest_data.get("message", ""),
-   )
-
 
 def health_check():
     status = {
@@ -367,7 +329,7 @@ with demo:
             <div style="position: relative; width: 100%; padding-top: 56.25%;">
                 <iframe 
                     style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;" 
-                    src="https://www.youtube.com/embed/x8Iii1cKWB8" 
+                    src="https://www.youtube.com/embed/K1TJie3NmHM" 
                     title="Bambu A1mini Livestream" 
                     frameborder="0" 
                     allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" 
@@ -442,6 +404,123 @@ with demo:
             logger.error(f"Error in capture_frame: {e}")
             return {"success": False, "error": str(e)}
 
+    def api_lambda(
+        img_data=None,
+        param_1=200,
+        param_2=60,
+        param_3=60,
+        param_4=100,
+        use_test_image=False,
+        test_image_name=None,
+    ):
+        logger.info(
+            f"API call: lambda with params: {param_1}, {param_2}, {param_3}, {param_4}, use_test_image: {use_test_image}, test_image_name: {test_image_name}"
+        )
+        try:
+            img = None
+
+            if use_test_image:
+                logger.info(f"Lambda using test image: {test_image_name}")
+                img = get_test_image(test_image_name)
+
+            elif (
+                img_data
+                and isinstance(img_data, str)
+                and (img_data.startswith("http://") or img_data.startswith("https://"))
+            ):
+                logger.info(f"Lambda received image URL: {img_data}")
+                img = capture_image(img_data)
+
+            elif img_data and isinstance(img_data, str):
+                try:
+                    logger.info("Lambda received base64 image data")
+                    img_bytes = base64.b64decode(img_data)
+                    img = Image.open(io.BytesIO(img_bytes))
+                except Exception as e:
+                    logger.error(f"Failed to decode base64 image: {e}")
+
+            if img is None:
+                logger.info("No valid image data received, using default test image")
+                img = get_test_image()
+
+            if img:
+                img_array = np.array(img)
+
+                quality_level = "low"
+                if 190 <= param_1 <= 210 and param_3 <= 50 and param_4 >= 80:
+                    quality_level = "high"
+                elif 185 <= param_1 <= 215 and param_3 <= 70 and param_4 >= 60:
+                    quality_level = "medium"
+
+                if quality_level == "high":
+                    missing_rate = 0.02
+                    excess_rate = 0.01
+                    stringing_rate = 0.01
+                elif quality_level == "medium":
+                    missing_rate = 0.05
+                    excess_rate = 0.03
+                    stringing_rate = 0.02
+                else:  # low
+                    missing_rate = 0.10
+                    excess_rate = 0.07
+                    stringing_rate = 0.05
+
+                uniformity_score = 1.0 - (missing_rate + excess_rate + stringing_rate)
+
+                print_quality_score = 1.0 - (
+                    missing_rate * 2.0 + excess_rate * 1.5 + stringing_rate * 1.0
+                )
+                print_quality_score = max(0, min(1, print_quality_score))
+
+                print_speed_score = param_3 / 150.0
+                print_speed_score = max(0, min(1, print_speed_score))
+
+                material_efficiency_score = 1.0 - excess_rate * 3.0
+                material_efficiency_score = max(0, min(1, material_efficiency_score))
+
+                total_performance_score = (
+                    0.5 * print_quality_score
+                    + 0.3 * print_speed_score
+                    + 0.2 * material_efficiency_score
+                )
+
+                img_draw = img.copy()
+                draw = ImageDraw.Draw(img_draw)
+                draw.text(
+                    (10, 10), f"Quality: {quality_level.upper()}", fill=(255, 0, 0)
+                )
+                draw.text((10, 30), f"Missing: {missing_rate:.2f}", fill=(255, 0, 0))
+                draw.text((10, 50), f"Excess: {excess_rate:.2f}", fill=(255, 0, 0))
+                draw.text(
+                    (10, 70), f"Stringing: {stringing_rate:.2f}", fill=(255, 0, 0)
+                )
+
+                result = {
+                    "success": True,
+                    "missing_rate": missing_rate,
+                    "excess_rate": excess_rate,
+                    "stringing_rate": stringing_rate,
+                    "uniformity_score": uniformity_score,
+                    "print_quality_score": print_quality_score,
+                    "print_speed_score": print_speed_score,
+                    "material_efficiency_score": material_efficiency_score,
+                    "total_performance_score": total_performance_score,
+                }
+
+                if img_draw.mode == "RGBA":
+                    img_draw = img_draw.convert("RGB")
+
+                buffered = io.BytesIO()
+                img_draw.save(buffered, format="JPEG")
+                img_str = base64.b64encode(buffered.getvalue()).decode()
+                result["image"] = img_str
+
+                return result
+            else:
+                return {"success": False, "error": "Failed to get image"}
+        except Exception as e:
+            logger.error(f"Error in lambda: {e}")
+            return {"error": str(e)}
 
     def api_send_print_parameters(
         nozzle_temp=200, bed_temp=60, print_speed=60, fan_speed=100
@@ -465,6 +544,20 @@ with demo:
         api_name="capture_frame",
     )
 
+    lambda_api = demo.load(
+        fn=api_lambda,
+        inputs=[
+            gr.Textbox(label="Image Base64 or URL"),
+            gr.Number(label="Nozzle Temperature", value=200),
+            gr.Number(label="Bed Temperature", value=60),
+            gr.Number(label="Print Speed", value=60),
+            gr.Number(label="Fan Speed", value=100),
+            gr.Checkbox(label="Use Test Image", value=False),
+            gr.Textbox(label="Test Image Name", value=""),
+        ],
+        outputs=api_json_output,
+        api_name="lambda",
+    )
 
     get_data_api = demo.load(
         fn=api_get_data, inputs=None, outputs=api_json_output, api_name="get_data"
@@ -482,27 +575,6 @@ with demo:
         api_name="send_print_parameters",
     )
 
-    get_status_api = demo.load(
-        fn=update_print_status,
-        inputs=[],
-        outputs=[
-            gr.Textbox(label="Status"),
-            gr.Textbox(label="Nozzle Temperature"),
-            gr.Textbox(label="Bed Temperature"),
-            gr.Textbox(label="Update Time"),
-            gr.Number(label="Progress"),
-            gr.Textbox(label="Message"),
-        ],
-        api_name="get_status",
-    )
-
-    health_check_api = demo.load(
-        fn=health_check,
-        inputs=[],
-        outputs=gr.JSON(),
-        api_name="health_check",
-    )
-
 if __name__ == "__main__":
     logger.info("Starting Bambu A1 Mini Print Control application")
 
@@ -510,12 +582,14 @@ if __name__ == "__main__":
         logger.info("Initializing Bambu MQTT client")
         create_client("bambu")
     except Exception as e:
+        bambu_client = None
         logger.error(f"Failed to initialize Bambu MQTT: {e}")
 
     try:
         logger.info("Initializing RPI MQTT client")
         create_client("rpi")
     except Exception as e:
+        rpi_client = None
         logger.error(f"Failed to initialize RPI MQTT: {e}")
 
     demo.queue().launch(