Added Multiple things

app.py

@@ -20,10 +20,11 @@ import numpy as np
 
 from PIL import Image
 import numpy as np
+from models.rcan import rcan_upscale
 
 def edge_directed_interpolation(lr_img_pil, scale=2):
     # Ensure input is a PIL Image
-    
+
     if isinstance(lr_img_pil, np.ndarray):
         lr_img_pil = Image.fromarray(lr_img_pil)
 
@@ -128,11 +129,18 @@ edi_page = gr.Interface(
     title="Edge Directed Interpolation"
 )
 
-# === Tabs === #
+rcan_page = gr.Interface(
+    fn=rcan_upscale,
+    inputs=[gr.Image(label="Low Resolution Image")],
+    outputs=gr.Image(type="pil", label="High Resolution Image"),
+    title="RCAN based Super Resolution"
+)
+
+# Tabs setup
 demo = gr.TabbedInterface(
-    [lancros_page, fourier_page, autoencoder_page, srgan_page, espcn_page, random_forest_page, edi_page],
+    [lancros_page, fourier_page, autoencoder_page, srgan_page, espcn_page, random_forest_page, edi_page, rcan_page],
     ["Lancros Interpolation", "Fourier Interpolation", "Autoencoder based Super Resolution", "GAN based Super Resolution",
-     "EspCN Super Resolution", "Random Forest based Super Resolution", "Edge Directed Interpolation"],
+     "EspCN Super Resolution", "Random Forest based Super Resolution", "Edge Directed Interpolation", "RCAN Super Resolution"],
     title="Image Super Resolution"
 )
 

models/rcan.py

@@ -0,0 +1,67 @@
+import torch
+from PIL import Image
+import io
+from torchvision import transforms
+import torch.nn.functional as F
+
+# Define your RCAN model architecture here (or import if defined elsewhere)
+# Example stub (you should replace this with your actual model definition)
+class RCAN(torch.nn.Module):
+    def __init__(self):
+        super(RCAN, self).__init__()
+        # Dummy model: replace with your actual RCAN layers
+        self.conv = torch.nn.Conv2d(3, 3, kernel_size=3, padding=1)
+
+    def forward(self, x):
+        return self.conv(x)
+
+# Load model once and reuse (optional: use a global cache)
+_model = None
+def load_model(model_path, device='cuda'):
+    global _model
+    if _model is None:
+        _model = torch.load(model_path, map_location=device)
+        _model.eval().to(device)
+    return _model
+
+def super_resolve(model_path, img_bytes, device='cuda'):
+    """
+    Perform super-resolution using RCAN on input image bytes and return upscaled image bytes.
+    """
+    # Load model
+    model = load_model(model_path, device)
+
+    # Decode image bytes to PIL
+    lr_img = Image.open(io.BytesIO(img_bytes)).convert('RGB')
+
+    # Preprocess: PIL -> Tensor
+    transform = transforms.ToTensor()
+    input_tensor = transform(lr_img).unsqueeze(0).to(device)  # shape: (1, 3, H, W)
+
+    # Model inference
+    with torch.no_grad():
+        output_tensor = model(input_tensor)
+
+    # Postprocess: Tensor -> PIL
+    output_tensor = output_tensor.squeeze(0).clamp(0, 1).cpu()  # shape: (3, H, W)
+    upscaled_img = transforms.ToPILImage()(output_tensor)
+
+    # Encode to bytes
+    byte_io = io.BytesIO()
+    upscaled_img.save(byte_io, format='PNG')
+    return byte_io.getvalue()
+
+def rcan_upscale(lr_img):
+    """
+    High-level wrapper to be called from Gradio or anywhere else.
+    Args:
+        lr_img (PIL.Image): Input low-resolution image
+    Returns:
+        PIL.Image: Output high-resolution image
+    """
+    img_byte_arr = io.BytesIO()
+    lr_img.save(img_byte_arr, format='PNG')
+    img_bytes = img_byte_arr.getvalue()
+
+    upscaled_bytes = super_resolve(model_path="weights/rcan_epoch_20.pth", img_bytes=img_bytes, device='cuda')
+    return Image.open(io.BytesIO(upscaled_bytes))

weights/rcan_epoch_20.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1efb22fe861cd418170c0b9527d968dc0f11aee46fa20fd3a58e57c8016418dc
+size 63015800