Update app.py

app.py

@@ -1,42 +1,41 @@
 import gradio as gr  
-import torch  
+import cv2  
+import numpy as np  
 from PIL import Image  
-from transformers import AutoFeatureExtractor, AutoModelForImageUpscaling  
 
-def load_model():  
-    try:  
-        feature_extractor = AutoFeatureExtractor.from_pretrained("keras-io/super-resolution")  
-        model = AutoModelForImageUpscaling.from_pretrained("keras-io/super-resolution")  
-        return feature_extractor, model  
-    except Exception as e:  
-        print(f"Model loading error: {e}")  
-        return None, None  
-
-def super_resolve_image(input_image):  
-    # Validate input  
+def super_resolve_image(input_image, scale_factor=4):  
     if input_image is None:  
         return None  
     
-    # Load model (do this once, not in every function call for efficiency)  
-    feature_extractor, model = load_model()  
-    
-    if model is None:  
-        return "Error: Could not load model"  
-    
     try:  
-        # Convert to PIL Image if not already  
-        if not isinstance(input_image, Image.Image):  
-            input_image = Image.fromarray(input_image)  
+        # Convert to numpy array if it's a PIL Image  
+        if isinstance(input_image, Image.Image):  
+            input_image = np.array(input_image)  
         
-        # Prepare image  
-        inputs = feature_extractor(images=input_image, return_tensors="pt")  
+        # Convert to grayscale if needed  
+        if len(input_image.shape) == 2:  
+            input_image = cv2.cvtColor(input_image, cv2.COLOR_GRAY2RGB)  
         
-        # Super-resolve  
-        with torch.no_grad():  
-            outputs = model(**inputs)  
-            enhanced_image = feature_extractor.post_process_image(outputs.image)[0]  
+        # Different interpolation methods  
+        methods = [  
+            cv2.INTER_LINEAR,  
+            cv2.INTER_CUBIC,  
+            cv2.INTER_LANCZOS4  
+        ]  
         
-        return enhanced_image  
+        # Try different interpolation methods  
+        for method in methods:  
+            try:  
+                upscaled = cv2.resize(  
+                    input_image,   
+                    (input_image.shape[1] * scale_factor, input_image.shape[0] * scale_factor),   
+                    interpolation=method  
+                )  
+                return upscaled  
+            except Exception as e:  
+                print(f"Interpolation method failed: {method}")  
+        
+        return None  
     
     except Exception as e:  
         print(f"Super-resolution error: {e}")  
@@ -44,17 +43,24 @@ def super_resolve_image(input_image):
 
 def create_gradio_interface():  
     with gr.Blocks() as demo:  
-        gr.Markdown("# 🖼️ Simple Image Super-Resolution")  
+        gr.Markdown("# 🖼️ Simple Image Upscaling")  
         
         with gr.Row():  
             input_image = gr.Image(label="Input Image", type="pil")  
-            output_image = gr.Image(label="Super-Resolved Image")  
+            output_image = gr.Image(label="Upscaled Image")  
+        
+        with gr.Row():  
+            scale_dropdown = gr.Dropdown(  
+                choices=[2, 4, 8],   
+                value=4,   
+                label="Upscale Factor"  
+            )  
         
         enhance_btn = gr.Button("Enhance Image Resolution")  
         
         enhance_btn.click(  
             fn=super_resolve_image,   
-            inputs=input_image,   
+            inputs=[input_image, scale_dropdown],   
             outputs=output_image  
         )