Update app.py

app.py

@@ -12,9 +12,6 @@ import spaces
 import numpy as np
 import cv2
 from pyzxing import BarCodeReader
-import tempfile
-from io import BytesIO
-import base64
 
 from diffusers import (
     StableDiffusionPipeline,
@@ -36,8 +33,8 @@ qrcode_generator = qrcode.QRCode(
 )
 
 controlnet = ControlNetModel.from_pretrained(
-    #"monster-labs/control_v1p_sd15_qrcode_monster",
-    "DionTimmer/controlnet_qrcode-control_v1p_sd15", 
+    "monster-labs/control_v1p_sd15_qrcode_monster",
+    #"DionTimmer/controlnet_qrcode-control_v1p_sd15", 
     torch_dtype=torch.float16
 ).to("cuda")
 
@@ -72,7 +69,7 @@ SAMPLER_MAP = {
     "DEIS": lambda config: DEISMultistepScheduler.from_config(config),
 }
 
-def scan_qr_code(image, sensitivity=0.5):
+def scan_qr_code(image):
     # Convert gradio image to PIL Image if necessary
     if isinstance(image, np.ndarray):
         image = Image.fromarray(image)
@@ -83,85 +80,34 @@ def scan_qr_code(image, sensitivity=0.5):
     # Convert to numpy array
     np_image = np.array(gray_image)
     
-    # Preprocess the image
-    _, binary_image = cv2.threshold(np_image, int(255 * sensitivity), 255, cv2.THRESH_BINARY)
-    
-    # List to store successful scans
-    successful_scans = []
-    
     # Method 1: Using qrcode library
     try:
         qr = qrcode.QRCode()
         qr.add_data('')
         qr.decode(gray_image)
-        successful_scans.append(("qrcode library", qr.data.decode('utf-8')))
-    except Exception as e:
-        print(f"qrcode library failed: {str(e)}")
+        return qr.data.decode('utf-8')
+    except Exception:
+        pass
     
     # Method 2: Using OpenCV
     try:
         qr_detector = cv2.QRCodeDetector()
         retval, decoded_info, points, straight_qrcode = qr_detector.detectAndDecodeMulti(np_image)
         if retval:
-            successful_scans.extend([("OpenCV", info) for info in decoded_info if info])
-    except Exception as e:
-        print(f"OpenCV failed: {str(e)}")
+            return decoded_info[0]
+    except Exception:
+        pass
     
-    # Method 3: Using zxing-cpp
+    # Method 3: Fallback to zxing-cpp
     try:
         reader = BarCodeReader()
         results = reader.decode(np_image)
         if results:
-            successful_scans.extend([("zxing-cpp", result.parsed) for result in results])
-        
-        # If no results, try with the binary image
-        if not results:
-            results = reader.decode(binary_image)
-            if results:
-                successful_scans.extend([("zxing-cpp (binary)", result.parsed) for result in results])
-    except Exception as e:
-        print(f"zxing-cpp failed: {str(e)}")
+            return results[0].parsed
+    except Exception:
+        pass
     
-    # If still no successful scans, try saving the image and scanning from file
-    if not successful_scans:
-        try:
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as temp_file:
-                image.save(temp_file.name)
-                reader = BarCodeReader()
-                results = reader.decode(temp_file.name)
-                if results:
-                    successful_scans.extend([("zxing-cpp (file)", result.parsed) for result in results])
-            os.unlink(temp_file.name)
-        except Exception as e:
-            print(f"Temporary file scanning failed: {str(e)}")
-    
-    return successful_scans
-
-def generate_qr_code(
-    data,
-    version=None,
-    error_correction=qrcode.constants.ERROR_CORRECT_H,
-    box_size=10,
-    border=4,
-    fill_color="black",
-    back_color="white"
-):
-    qr = qrcode.QRCode(
-        version=version,
-        error_correction=error_correction,
-        box_size=box_size,
-        border=border,
-    )
-    qr.add_data(data)
-    qr.make(fit=True)
-    
-    img = qr.make_image(fill_color=fill_color, back_color=back_color)
-    return img
-
-def image_to_base64(img):
-    buffered = BytesIO()
-    img.save(buffered, format="PNG")
-    return base64.b64encode(buffered.getvalue()).decode()
+    return None
 
 @spaces.GPU()
 def inference(
@@ -176,13 +122,6 @@ def inference(
     qrcode_image: Image.Image | None = None,
     use_qr_code_as_init_image = True,
     sampler = "DPM++ Karras SDE",
-    verify_sensitivity: float = 0.5,
-    qr_version: int = 1,
-    qr_error_correction: str = "H",
-    qr_box_size: int = 10,
-    qr_border: int = 4,
-    qr_fill_color: str = "black",
-    qr_back_color: str = "white",
 ):
     try:
         if prompt is None or prompt == "":
@@ -197,29 +136,21 @@ def inference(
 
         if qr_code_content != "" or qrcode_image.size == (1, 1):
             print("Generating QR Code from content")
-            error_correction_map = {
-                "L": qrcode.constants.ERROR_CORRECT_L,
-                "M": qrcode.constants.ERROR_CORRECT_M,
-                "Q": qrcode.constants.ERROR_CORRECT_Q,
-                "H": qrcode.constants.ERROR_CORRECT_H,
-            }
-            qrcode_image = generate_qr_code(
-                qr_code_content,
-                version=qr_version,
-                error_correction=error_correction_map[qr_error_correction],
-                box_size=qr_box_size,
-                border=qr_border,
-                fill_color=qr_fill_color,
-                back_color=qr_back_color,
+            qr = qrcode.QRCode(
+                version=1,
+                error_correction=qrcode.constants.ERROR_CORRECT_H,
+                box_size=10,
+                border=4,
             )
+            qr.add_data(qr_code_content)
+            qr.make(fit=True)
+
+            qrcode_image = qr.make_image(fill_color="black", back_color="white")
             qrcode_image = resize_for_condition_image(qrcode_image, 768)
         else:
             print("Using QR Code Image")
             qrcode_image = resize_for_condition_image(qrcode_image, 768)
 
-        # Generate base64 string of the initial QR code
-        initial_qr_base64 = image_to_base64(qrcode_image)
-
         # hack due to gradio examples
         init_image = qrcode_image
 
@@ -236,19 +167,15 @@ def inference(
             strength=float(strength),
             num_inference_steps=50,
         )
-        
-        # Verify the generated QR code
-        verify_result = scan_qr_code(out.images[0], sensitivity=verify_sensitivity)
-        
-        return out.images[0], verify_result, initial_qr_base64
+        return out.images[0]  # type: ignore
     except Exception as e:
         print(f"Error in inference: {str(e)}")
         # Return a blank image in case of an error
-        return Image.new('RGB', (768, 768), color='white'), [], ""
+        return Image.new('RGB', (768, 768), color='white')
 
 
 
-with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
+with gr.Blocks(theme='Hev832/Applio') as blocks:
     gr.Markdown(
         """
         ![Yamamoto Logo](https://cdn-uploads.huggingface.co/production/uploads/64740cf7485a7c8e1bd51ac9/_VyYxp5qE_nRZ_LJqBxmL.webp)
@@ -302,7 +229,7 @@ with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
             use_qr_code_as_init_image = gr.Checkbox(
                 label="Use QR code as init image", 
                 value=True, 
-                interactive=True, 
+                interactive=False, 
                 info="Whether init image should be QR code. Unclick to pass init image or generate init image with Stable Diffusion 2.1"
             )
             with gr.Accordion(label="Init Images (Optional)", open=False, visible=True) as init_image_acc:
@@ -315,7 +242,7 @@ with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
                     minimum=0.0,
                     maximum=5.0,
                     step=0.01,
-                    value=1.5,
+                    value=1.3,
                     label="QR Code Visibility",
                 )
                 gr.Markdown(
@@ -324,9 +251,9 @@ with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
             
                     - **Low settings (0.0-0.5)**: If you choose a lower value, the QR code will blend more into the art, and it might be hard to scan with a phone. This setting is great if you want the image to look amazing, but you might lose some of the scannability. Try this if you care more about art and less about the QR code being easily recognized.
                     
-                    - **Medium settings (0.6-2)**: This is the sweet spot where the QR code remains clearly visible while still blending in with the art. You can still scan it easily with a phone, but it looks more creative. For most users, setting it around **1.1** is a great start to balance both art and function.
+                    - **Medium settings (0.6-1.5)**: This is the sweet spot where the QR code remains clearly visible while still blending in with the art. You can still scan it easily with a phone, but it looks more creative. For most users, setting it around **1.1** is a great start to balance both art and function.
             
-                    - **High settings (2-5.0)**: If you need to make sure that the QR code is super easy to scan, even if it means the image looks less like art and more like a regular QR code, then choose a higher value. This is ideal when functionality is the main goal, and the artistic side can take a backseat.
+                    - **High settings (1.6-5.0)**: If you need to make sure that the QR code is super easy to scan, even if it means the image looks less like art and more like a regular QR code, then choose a higher value. This is ideal when functionality is the main goal, and the artistic side can take a backseat.
                     
                     Start with **1.3** if you're unsure, and adjust up or down depending on whether you want the QR code to be more artistic or more functional.
                     """
@@ -355,7 +282,7 @@ with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
                     minimum=0.0,
                     maximum=50.0,
                     step=0.25,
-                    value=10,
+                    value=7.5,
                     label="Follow the Prompt",
                 )
                 gr.Markdown(
@@ -410,28 +337,11 @@ with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
                     Try **-1** if you want to explore and generate different designs. If you find something you really love, write down the seed number and use it again to recreate the same design.
                     """
                 )
-            
-                verify_sensitivity = gr.Slider(
-                    minimum=0.1,
-                    maximum=1.0,
-                    step=0.05,
-                    value=0.5,
-                    label="Verify Sensitivity",
-                )
-                gr.Markdown(
-                    """
-                    **Verify Sensitivity** controls how sensitive the QR code scanner is when verifying the generated image. 
-                    A lower value (closer to 0.1) makes the scanner more sensitive and able to detect less clear QR codes, 
-                    while a higher value (closer to 1.0) requires clearer, more distinct QR codes to be detected.
-                    """
-                )
             with gr.Row():
                 run_btn = gr.Button("🎨 Create Your QR Art", variant="primary")
                 
         with gr.Column():
             result_image = gr.Image(label="Your Artistic QR Code")
-            initial_qr_image = gr.Image(label="Initial QR Code", visible=False)
-            download_initial_qr = gr.Button("Download Initial QR Code")
             scan_button = gr.Button("Scan QR Code")
             scan_result = gr.Textbox(label="Scan Result", interactive=False)
             
@@ -452,14 +362,11 @@ with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
         if image is None:
             return "No image to scan"
         
-        try:
-            scanned_text = scan_qr_code(image)
-            if scanned_text:
-                return f"Scanned successfully: {scanned_text}"
-            else:
-                return "Failed to scan QR code. The image might be too artistic or the QR code might not be clear enough. Try adjusting the 'QR Code Visibility' setting for better results."
-        except Exception as e:
-            return f"An error occurred while scanning: {str(e)}"
+        scanned_text = scan_qr_code(image)
+        if scanned_text:
+            return f"Scanned successfully: {scanned_text}"
+        else:
+            return "Failed to scan QR code. Try adjusting the settings for better visibility."
 
     scan_button.click(
         scan_and_display,
@@ -467,9 +374,7 @@ with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
         outputs=[scan_result]
     )
 
-    def update_initial_qr(base64_string):
-        return gr.Image.update(value=base64_string, visible=True)
-
+            
     run_btn.click(
         inference,
         inputs=[
@@ -484,13 +389,10 @@ with gr.Blocks(theme=gr.themes.Monochrome()) as blocks:
             qr_code_image,
             use_qr_code_as_init_image,
             sampler,
-            verify_sensitivity,
         ],
-        outputs=[result_image, scan_result, initial_qr_image],
+        outputs=[result_image],
         concurrency_limit=20
     )
 
-    download_initial_qr.click(lambda x: x, inputs=[initial_qr_image], outputs=[initial_qr_image])
-
 blocks.queue(max_size=20,api_open=False)
 blocks.launch(share=bool(os.environ.get("SHARE", False)), show_api=True)