Added Multiple things

app.py

@@ -0,0 +1,194 @@
+import gradio as gr
+from PIL import Image
+import os
+import numpy as np
+import cv2
+
+# Existing imports
+from models.lancros_interpolation import upsample_lancros
+from models.fourier_interpolation import fourier_upscale
+from models.autoencoder import autoencoder_upscale
+from models.espcn import espcn_upscale
+from models.sr_gan import srgan_upscale
+from models.cnn import srcnn_upscale
+
+# ✅ New import for Random Forest Super Resolution
+from models.random_forest_sr import random_forest_upscale
+
+# ✅ EDI (Edge Directed Interpolation) method
+from PIL import Image
+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)
+
+    # Convert to RGB
+    lr_img_rgb = lr_img_pil.convert("RGB")
+    lr_img = np.array(lr_img_rgb)
+
+    h, w, c = lr_img.shape
+    hr_h, hr_w = h * scale, w * scale
+    hr_img = np.zeros((hr_h, hr_w, c), dtype=np.uint8)
+
+    # Copy original pixels to even positions
+    for i in range(h):
+        for j in range(w):
+            hr_img[i * scale, j * scale] = lr_img[i, j]
+
+    # Interpolate diagonal pixels per channel
+    for i in range(0, hr_h, scale):
+        for j in range(0, hr_w, scale):
+            if i + scale < hr_h and j + scale < hr_w:
+                for ch in range(c):
+                    p1 = hr_img[i, j, ch]
+                    p2 = hr_img[i, j + scale, ch]
+                    p3 = hr_img[i + scale, j, ch]
+                    p4 = hr_img[i + scale, j + scale, ch]
+
+                    d1 = abs(int(p1) - int(p4))
+                    d2 = abs(int(p2) - int(p3))
+
+                    interp = (int(p1) + int(p4)) // 2 if d1 < d2 else (int(p2) + int(p3)) // 2
+                    hr_img[i + scale // 2, j + scale // 2, ch] = interp
+
+    # Fill remaining zero pixels per channel
+    for i in range(hr_h):
+        for j in range(hr_w):
+            for ch in range(c):
+                if hr_img[i, j, ch] == 0:
+                    neighbors = []
+                    if i - 1 >= 0:
+                        neighbors.append(hr_img[i - 1, j, ch])
+                    if i + 1 < hr_h:
+                        neighbors.append(hr_img[i + 1, j, ch])
+                    if j - 1 >= 0:
+                        neighbors.append(hr_img[i, j - 1, ch])
+                    if j + 1 < hr_w:
+                        neighbors.append(hr_img[i, j + 1, ch])
+                    if neighbors:
+                        hr_img[i, j, ch] = int(np.mean(neighbors))
+
+    return Image.fromarray(hr_img)
+
+
+
+# === Interfaces === #
+lancros_page = gr.Interface(
+    fn=upsample_lancros,
+    inputs=[gr.Image(label="Low Resolution Image"),
+            gr.Slider(2, 6, step=1, value=2, label="Upscaling Factor"),],
+    outputs=gr.Image(type="pil", label="High Resolution Images"),
+    title="Lancros Upsampling",
+    examples=[
+        ["sample_images/0001.png"],
+        ["sample_images/0172.png"]
+    ]
+)
+
+fourier_page = gr.Interface(
+    fn=fourier_upscale,
+    inputs=[gr.Image(label="Low Resolution Image"),
+            gr.Slider(2, 6, step=1, value=2, label="Upscaling Factor"),],
+    outputs=gr.Image(type="pil", label="High Resolution Images"),
+    title="Fourier Upsampling",
+    examples=[
+        ["sample_images/0004.png"],
+        ["sample_images/0012.png"]
+    ]
+)
+
+autoencoder_page = gr.Interface(
+    fn=autoencoder_upscale,
+    inputs=[gr.Image(label="Low Resolution Image")],
+    outputs=gr.Image(type="pil", label="High Resolution Images"),
+    title="Autoencoder based Super Resolution",
+    examples=[
+        ["sample_images/0019.png"],
+        ["sample_images/0064.png"]
+    ]
+)
+
+espcn_page = gr.Interface(
+    fn=espcn_upscale,
+    inputs=[gr.Image(label="Low Resolution Image")],
+    outputs=gr.Image(type="pil", label="High Resolution Images"),
+    title="ESPCN based Super Resolution",
+    examples=[
+        ["sample_images/0024.png"],
+        ["sample_images/0068.png"]
+    ]
+)
+
+srgan_page = gr.Interface(
+    fn=srgan_upscale,
+    inputs=[gr.Image(label="Low Resolution Image")],
+    outputs=gr.Image(type="pil", label="High Resolution Images"),
+    title="GAN based Super Resolution",
+    examples=[
+        ["sample_images/0055.png"],
+        ["sample_images/0003.png"]
+    ]
+)
+
+random_forest_page = gr.Interface(
+    fn=random_forest_upscale,
+    inputs=[gr.Image(label="Low Resolution Image")],
+    outputs=gr.Image(type="pil", label="High Resolution Images"),
+    title="Random Forest based Super Resolution",
+    examples=[
+        ["sample_images/0097.png"],
+        ["sample_images/0086.png"]
+    ]
+)
+
+# ✅ EDI Page
+edi_page = gr.Interface(
+    fn=edge_directed_interpolation,
+    inputs=[gr.Image(label="Low Resolution Image"), gr.Slider(2, 4, step=1, value=2, label="Upscaling Factor")],
+    outputs=gr.Image(type="pil", label="High Resolution Image"),
+    title="Edge Directed Interpolation",
+    examples=[
+        ["sample_images/0002.png"],
+        ["sample_images/0006.png"]
+    ]
+)
+
+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",
+    examples=[
+        ["sample_images/0007.png"],
+        ["sample_images/0010.png"]
+    ]
+)
+
+srcnn_page = gr.Interface(
+    fn=srcnn_upscale,
+    inputs=[gr.Image(label="Low Resolution Image")],
+    outputs=gr.Image(type="pil", label="High Resolution Image"),
+    title="SRCNN based Super Resolution",
+    examples=[
+        ["sample_images/0007.png"],
+        ["sample_images/0010.png"]
+    ]
+)
+
+# Tabs setup
+demo = gr.TabbedInterface(
+    [srgan_page, lancros_page, fourier_page, autoencoder_page, espcn_page, random_forest_page, edi_page, rcan_page,srcnn_page],
+    ["GAN based Super Resolution", "Lancros Interpolation", "Fourier Interpolation", "Autoencoder based Super Resolution",
+     "EspCN Super Resolution", "Random Forest based Super Resolution", "Edge Directed Interpolation", "RCAN Super Resolution","SRCNN Super Resolution"],
+    title="Image Super Resolution"
+)
+
+if __name__ == "__main__":
+    demo.launch(debug=True)

models/autoencoder.py

@@ -0,0 +1,65 @@
+import torch
+import torch.nn as nn
+from collections import OrderedDict
+from PIL import Image,ImageOps
+import numpy as np
+
+class Autoencoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+        # ENCODER — compress from 128 -> 64 -> 32
+        self.enc1 = nn.Conv2d(3, 64, 3, stride=2, padding=1)   # 128 → 64
+        self.enc2 = nn.Conv2d(64, 128, 3, stride=2, padding=1) # 64 → 32
+
+        # DECODER — upsample from 32 → 64 → 128 → 256 → 512
+        self.dec1 = nn.ConvTranspose2d(128, 64, 3, stride=2, padding=1, output_padding=1)   # 32 → 64
+        self.dec2 = nn.ConvTranspose2d(64, 32, 3, stride=2, padding=1, output_padding=1)    # 64 → 128
+        self.dec3 = nn.ConvTranspose2d(32, 16, 3, stride=2, padding=1, output_padding=1)    # 128 → 256
+        self.dec4 = nn.ConvTranspose2d(16, 3, 3, stride=2, padding=1, output_padding=1)     # 256 → 512
+
+        # Activations
+        self.relu = nn.ReLU()
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        # Encoder
+        x = self.relu(self.enc1(x))  # [B, 64, 64, 64]
+        x = self.relu(self.enc2(x))  # [B, 128, 32, 32]
+
+        # Decoder
+        x = self.relu(self.dec1(x))  # [B, 64, 64, 64]
+        x = self.relu(self.dec2(x))  # [B, 32, 128, 128]
+        x = self.relu(self.dec3(x))  # [B, 16, 256, 256]
+        x = self.sigmoid(self.dec4(x))  # [B, 3, 512, 512]
+
+        return x
+    
+def autoencoder_upscale(image):
+    image = Image.fromarray(image)
+    target_size = (128, 128)
+    pad_color=(0, 0, 0)
+    ImageOps.pad(image, target_size, method=Image.BICUBIC, color=pad_color)
+    image = np.array(image)
+
+    image = image/255
+    image = torch.from_numpy(image).float().unsqueeze(dim=0).permute(0,3,1,2)
+
+    model = Autoencoder()
+    checkpoint = torch.load("weights/model_auto_2.pth", map_location=torch.device('cpu'))  # or 'cuda' if using GPU
+    state_dict = checkpoint['state_dict']
+
+    new_state_dict = OrderedDict()
+    for k, v in state_dict.items():
+        new_key = k.replace("module.", "")  # Remove "module." from each key
+        new_state_dict[new_key] = v
+
+    model.load_state_dict(new_state_dict)
+    model.eval()
+
+    with torch.no_grad():
+        output = model(image)
+
+    output = output.squeeze(0).permute(1, 2, 0).cpu().numpy()
+    output = (output * 255.0).clip(0, 255).astype("uint8")
+    return output 

models/cnn.py

@@ -0,0 +1,82 @@
+import torch
+import torch.nn as nn
+from collections import OrderedDict
+
+# SRCNN Model Definition 
+class SuperResolutionCNN(nn.Module):
+    def __init__(self):
+        super(SuperResolutionCNN, self).__init__()
+        
+        # Feature extraction
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=9, padding=4),
+            nn.ReLU(),
+            nn.Conv2d(64, 32, kernel_size=1, padding=0),
+            nn.ReLU()
+        )
+        
+        # Upsampling blocks
+        self.upsample = nn.Sequential(
+            nn.ConvTranspose2d(32, 32, kernel_size=3, stride=2, padding=1, output_padding=1),
+            nn.ReLU(),
+            nn.ConvTranspose2d(32, 32, kernel_size=3, stride=2, padding=1, output_padding=1),
+            nn.ReLU()
+        )
+        
+        # Reconstruction
+        self.reconstruction = nn.Conv2d(32, 3, kernel_size=5, padding=2)
+        
+    def forward(self, x):
+        x = self.features(x)
+        x = self.upsample(x)
+        x = self.reconstruction(x)
+        return torch.sigmoid(x)
+    
+
+def srcnn_upscale(image, model_path="weights/model_cnn.pth", device='cpu'):
+    """
+    Upscale image using SRCNN model
+    Input: numpy array (H,W,3) in range 0-255
+    Output: numpy array (H,W,3) in range 0-255
+    
+    Args:
+        image: Input image as numpy array (H,W,3) in range 0-255
+        model_path: Path to the trained SRCNN model weights
+        device: 'cpu' or 'cuda' for GPU acceleration
+    """
+    # Normalize and convert to tensor [1,3,H,W]
+    image = image / 255.0
+    image = torch.from_numpy(image).float().unsqueeze(0).permute(0, 3, 1, 2).to(device)
+    
+    # Load model
+    model = SuperResolutionCNN().to(device)
+    
+    # Load weights
+    checkpoint = torch.load(model_path, map_location=torch.device(device))
+    
+    # Handle different checkpoint formats
+    if 'state_dict' in checkpoint:
+        state_dict = checkpoint['state_dict']
+    elif 'model_state_dict' in checkpoint:
+        state_dict = checkpoint['model_state_dict']
+    else:
+        state_dict = checkpoint  # Assume direct state dict
+    
+    # Remove "module." prefix if present (for DataParallel models)
+    new_state_dict = OrderedDict()
+    for k, v in state_dict.items():
+        new_key = k.replace("module.", "")
+        new_state_dict[new_key] = v
+    
+    model.load_state_dict(new_state_dict)
+    model.eval()
+    
+    # Process image
+    with torch.no_grad():
+        output = model(image)
+    
+    # Convert back to numpy array [H,W,3] 0-255
+    output = output.squeeze(0).permute(1, 2, 0).cpu().numpy()
+    output = (output * 255.0).clip(0, 255).astype("uint8")
+    
+    return output

models/edge_directed_interpolation.py

@@ -0,0 +1,49 @@
+import numpy as np
+import cv2
+
+def edge_directed_interpolation(lr_img_pil, scale=2):
+    lr_img = np.array(lr_img_pil.convert("L"))
+    h, w = lr_img.shape
+    hr_h, hr_w = h * scale, w * scale
+
+    hr_img = np.zeros((hr_h, hr_w), dtype=np.uint8)
+
+    for i in range(h):
+        for j in range(w):
+            hr_img[i * scale, j * scale] = lr_img[i, j]
+
+    for i in range(0, hr_h, scale):
+        for j in range(0, hr_w, scale):
+            if i + scale < hr_h and j + scale < hr_w:
+                p1 = hr_img[i, j]
+                p2 = hr_img[i, j + scale]
+                p3 = hr_img[i + scale, j]
+                p4 = hr_img[i + scale, j + scale]
+
+                d1 = abs(int(p1) - int(p4))
+                d2 = abs(int(p2) - int(p3))
+
+                if d1 < d2:
+                    interp = (int(p1) + int(p4)) // 2
+                else:
+                    interp = (int(p2) + int(p3)) // 2
+
+                hr_img[i + scale // 2, j + scale // 2] = interp
+
+    for i in range(hr_h):
+        for j in range(hr_w):
+            if hr_img[i, j] == 0:
+                neighbors = []
+                if i - 1 >= 0:
+                    neighbors.append(hr_img[i - 1, j])
+                if i + 1 < hr_h:
+                    neighbors.append(hr_img[i + 1, j])
+                if j - 1 >= 0:
+                    neighbors.append(hr_img[i, j - 1])
+                if j + 1 < hr_w:
+                    neighbors.append(hr_img[i, j + 1])
+                if neighbors:
+                    hr_img[i, j] = np.mean(neighbors).astype(np.uint8)
+
+    hr_img_pil = Image.fromarray(hr_img)
+    return hr_img_pil

models/espcn.py

@@ -0,0 +1,41 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from collections import OrderedDict
+
+class ESPCN(nn.Module):
+    def __init__(self):
+        super(ESPCN, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=5, padding=2)
+        self.conv2 = nn.Conv2d(64, 32, kernel_size=3, padding=1)
+        self.conv3 = nn.Conv2d(32, (4 ** 2) * 3, kernel_size=3, padding=1)  # Handle 3-channel output
+        self.pixel_shuffle = nn.PixelShuffle(4)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = self.pixel_shuffle(self.conv3(x))
+        return x
+
+def espcn_upscale(image):
+    image = image/255
+    image = torch.from_numpy(image).float().unsqueeze(dim=0).permute(0,3,1,2)
+
+    model = ESPCN()
+    checkpoint = torch.load("weights/model_espcn.pth", map_location=torch.device('cpu'))  # or 'cuda' if using GPU
+    state_dict = checkpoint['state_dict']
+
+    new_state_dict = OrderedDict()
+    for k, v in state_dict.items():
+        new_key = k.replace("module.", "")  # Remove "module." from each key
+        new_state_dict[new_key] = v
+
+    model.load_state_dict(new_state_dict)
+    model.eval()
+
+    with torch.no_grad():
+        output = model(image)
+
+    output = output.squeeze(0).permute(1, 2, 0).cpu().numpy()
+    output = (output * 255.0).clip(0, 255).astype("uint8")
+    return output 

models/fourier_interpolation.py

@@ -0,0 +1,41 @@
+import cv2
+import numpy as np
+
+from scipy.fft import fft2, ifft2, fftshift, ifftshift
+from PIL import Image
+
+def fourier_upscale(image, scale_factor=4):
+    upscaled_channels = []
+
+    for c in range(3):  # For R, G, B channels
+        # Get single channel
+        channel = image[:, :, c]
+
+        # Forward FFT
+        F = fft2(channel)
+        F_shifted = fftshift(F)
+
+        # Zero-padding in frequency domain
+        h, w = channel.shape
+        new_h, new_w = h * scale_factor, w * scale_factor
+        F_padded = np.zeros((new_h, new_w), dtype=complex)
+
+        # Place the original spectrum in the center of the padded one
+        h_center, w_center = new_h // 2, new_w // 2
+        h_half, w_half = h // 2, w // 2
+        F_padded[h_center - h_half:h_center + h_half, w_center - w_half:w_center + w_half] = F_shifted
+
+        # Inverse FFT
+        F_unshifted = ifftshift(F_padded)
+        upscaled = np.real(ifft2(F_unshifted))
+
+        # ✅ Rescale intensities
+        upscaled *= scale_factor ** 2  # Rescale to preserve brightness
+
+        # Normalize to [0, 255]
+        upscaled = np.clip(upscaled, 0, 255)
+        upscaled_channels.append(upscaled.astype(np.uint8))
+
+    # Stack the 3 upscaled channels
+    upscaled_img = np.stack(upscaled_channels, axis=2)
+    return upscaled_img

models/lancros_interpolation.py

@@ -0,0 +1,76 @@
+import cv2
+import numpy as np
+
+def upsample_lancros(image_x,scale=4):
+    h, w = image_x.shape[:2]
+    new_w, new_h = int(w * scale), int(h * scale)
+
+    # Upsample using Lanczos interpolation
+    pred = cv2.resize(image_x, (new_w, new_h), interpolation=cv2.INTER_LANCZOS4)
+    return pred
+
+# def lanczos_kernel(x, a):
+#     """Lanczos kernel function."""
+#     if x == 0:
+#         return 1
+#     elif -a < x < a:
+#         return a * np.sinc(x) * np.sinc(x / a)
+#     else:
+#         return 0
+
+# def upsample_lancros_2(image, scale=4, a=3):
+#     """
+#     Upsample an image using Lanczos interpolation.
+    
+#     Parameters:
+#         image: numpy array (grayscale or RGB)
+#         scale: scaling factor (default 4x)
+#         a: size of Lanczos window (default 3)
+
+#     Returns:
+#         Upsampled image as numpy array.
+#     """
+#     if image.ndim == 2:  # Grayscale
+#         h, w = image.shape
+#         channels = 1
+#     else:  # RGB
+#         h, w, channels = image.shape
+
+#     new_h, new_w = int(h * scale), int(w * scale)
+#     output = np.zeros((new_h, new_w, channels)) if channels > 1 else np.zeros((new_h, new_w))
+
+#     for y_new in range(new_h):
+#         for x_new in range(new_w):
+#             print(y_new,x_new)
+#             # Map new pixel to original image space
+#             x_orig = x_new / scale
+#             y_orig = y_new / scale
+
+#             x0 = int(np.floor(x_orig))
+#             y0 = int(np.floor(y_orig))
+
+#             # Accumulators
+#             pixel = np.zeros(channels) if channels > 1 else 0.0
+#             norm = 0.0
+
+#             for j in range(y0 - a + 1, y0 + a + 1):
+#                 for i in range(x0 - a + 1, x0 + a + 1):
+#                     if 0 <= i < w and 0 <= j < h:
+#                         wx = lanczos_kernel(x_orig - i, a)
+#                         wy = lanczos_kernel(y_orig - j, a)
+#                         weight = wx * wy
+#                         if channels > 1:
+#                             pixel += image[j, i] * weight
+#                         else:
+#                             pixel += image[j, i] * weight
+#                         norm += weight
+
+#             if norm > 0:
+#                 output[y_new, x_new] = pixel / norm
+
+#     if channels == 1:
+#         output = output.astype(image.dtype)
+#     else:
+#         output = output.clip(0, 255).astype(image.dtype)
+
+#     return output

models/nn_interpolation.py

@@ -0,0 +1,40 @@
+import cv2
+import numpy as np
+
+def nn_upscale(image, scale_factor=4):
+    """
+    Upscale image using Nearest Neighbor interpolation
+    
+    Args:
+        image: Input image (numpy array or file path)
+        scale_factor: Scaling multiplier (default=4)
+    
+    Returns:
+        Upscaled image as numpy array (uint8)
+    """
+    # Load image if path provided
+    if isinstance(image, str):
+        img = cv2.imread(image)
+        if img is None:
+            raise ValueError(f"Could not load image from {image}")
+    else:
+        img = image.copy()
+    
+    # Get original dimensions
+    h, w = img.shape[:2]
+    new_h, new_w = h * scale_factor, w * scale_factor
+    
+    # Create empty output image
+    if len(img.shape) == 3:  # Color image
+        upscaled = np.zeros((new_h, new_w, 3), dtype=img.dtype)
+    else:  # Grayscale
+        upscaled = np.zeros((new_h, new_w), dtype=img.dtype)
+    
+    # Nearest Neighbor interpolation
+    for y in range(new_h):
+        for x in range(new_w):
+            orig_y = min(int(y / scale_factor), h - 1)
+            orig_x = min(int(x / scale_factor), w - 1)
+            upscaled[y, x] = img[orig_y, orig_x]
+    
+    return upscaled

models/random_forest_sr.py

@@ -0,0 +1,79 @@
+import numpy as np
+from skimage import transform, util, color
+from sklearn.ensemble import RandomForestRegressor
+from skimage.util import view_as_windows
+from PIL import Image
+
+# CONFIGURATION
+PATCH_SIZE = (3, 3)
+STEP = 1
+N_ESTIMATORS = 10
+MAX_DEPTH = 10
+SCALE_FACTOR = 2
+SAMPLE_PATCHES = 10000  # Controls speed/accuracy trade-off
+
+def extract_patches(img, patch_size, step):
+    patches = view_as_windows(img, patch_size, step)
+    h, w = patches.shape[:2]
+    return patches.reshape(h * w, -1)
+
+def train_rf(X, y):
+    rf = RandomForestRegressor(
+        n_estimators=N_ESTIMATORS,
+        max_depth=MAX_DEPTH,
+        n_jobs=-1
+    )
+    rf.fit(X, y)
+    return rf
+
+def predict_and_reconstruct(model, lr_img, patch_size, step, out_shape):
+    lr_patches = extract_patches(lr_img, patch_size, step)
+    preds = model.predict(lr_patches)
+
+    patch_h, patch_w = patch_size
+    img_h = (lr_img.shape[0] - patch_h) // step + 1
+    img_w = (lr_img.shape[1] - patch_w) // step + 1
+
+    result = np.zeros(out_shape)
+    weight = np.zeros(out_shape)
+
+    idx = 0
+    for i in range(img_h):
+        for j in range(img_w):
+            patch = preds[idx].reshape(patch_h, patch_w)
+            result[i*step:i*step+patch_h, j*step:j*step+patch_w] += patch
+            weight[i*step:i*step+patch_h, j*step:j*step+patch_w] += 1
+            idx += 1
+
+    weight[weight == 0] = 1
+    return result / weight
+
+def random_forest_upscale(pil_img: Image.Image) -> Image.Image:
+    img = np.array(pil_img) / 255.0  # Normalize
+    if img.ndim == 2:
+        img = np.expand_dims(img, axis=-1)
+
+    hr_shape = (img.shape[0] * SCALE_FACTOR, img.shape[1] * SCALE_FACTOR)
+    sr_channels = []
+
+    for c in range(img.shape[2]):
+        channel = img[:, :, c]
+        hr_channel = transform.resize(channel, hr_shape, anti_aliasing=True)
+        lr_channel = transform.resize(hr_channel, (hr_shape[0] // SCALE_FACTOR, hr_shape[1] // SCALE_FACTOR), anti_aliasing=True)
+        lr_channel_up = transform.resize(lr_channel, hr_shape, anti_aliasing=True)
+
+        X = extract_patches(lr_channel_up, PATCH_SIZE, STEP)
+        y = extract_patches(hr_channel, PATCH_SIZE, STEP)
+
+        if X.shape[0] > SAMPLE_PATCHES:
+            idx = np.random.choice(X.shape[0], SAMPLE_PATCHES, replace=False)
+            X = X[idx]
+            y = y[idx]
+
+        rf_model = train_rf(X, y)
+        sr = predict_and_reconstruct(rf_model, lr_channel_up, PATCH_SIZE, STEP, hr_shape)
+        sr_channels.append(sr)
+
+    sr_image = np.stack(sr_channels, axis=-1)
+    sr_image = np.clip(sr_image * 255, 0, 255).astype(np.uint8)
+    return Image.fromarray(sr_image)

models/random_forest_sr1.py

@@ -0,0 +1,68 @@
+import numpy as np
+from skimage import transform, util
+from sklearn.ensemble import RandomForestRegressor
+from skimage.util import view_as_windows
+from PIL import Image
+
+# CONFIGURATION
+PATCH_SIZE = (5, 5)
+STEP = 1
+N_ESTIMATORS = 50
+MAX_DEPTH = 20
+SCALE_FACTOR = 2
+
+def extract_patches(img, patch_size, step):
+    patches = view_as_windows(img, patch_size, step)
+    h, w = patches.shape[:2]
+    return patches.reshape(h * w, -1)
+
+def train_rf(X, y):
+    rf = RandomForestRegressor(n_estimators=N_ESTIMATORS, max_depth=MAX_DEPTH, n_jobs=-1)
+    rf.fit(X, y)
+    return rf
+
+def predict_and_reconstruct(model, lr_img, patch_size, step, out_shape):
+    lr_patches = extract_patches(lr_img, patch_size, step)
+    preds = model.predict(lr_patches)
+
+    patch_h, patch_w = patch_size
+    img_h = (lr_img.shape[0] - patch_h) // step + 1
+    img_w = (lr_img.shape[1] - patch_w) // step + 1
+
+    result = np.zeros(out_shape)
+    weight = np.zeros(out_shape)
+
+    idx = 0
+    for i in range(img_h):
+        for j in range(img_w):
+            patch = preds[idx].reshape(patch_h, patch_w)
+            result[i*step:i*step+patch_h, j*step:j*step+patch_w] += patch
+            weight[i*step:i*step+patch_h, j*step:j*step+patch_w] += 1
+            idx += 1
+
+    weight[weight == 0] = 1
+    return result / weight
+
+def random_forest_upscale(pil_img: Image.Image) -> Image.Image:
+    img = np.array(pil_img) / 255.0  # Normalize
+    if img.ndim == 2:
+        img = np.expand_dims(img, axis=-1)
+
+    hr_shape = (img.shape[0] * SCALE_FACTOR, img.shape[1] * SCALE_FACTOR)
+    sr_channels = []
+
+    for c in range(img.shape[2]):
+        channel = img[:, :, c]
+        hr_channel = transform.resize(channel, hr_shape)
+        lr_channel = transform.resize(hr_channel, (hr_shape[0] // SCALE_FACTOR, hr_shape[1] // SCALE_FACTOR))
+        lr_channel_up = transform.resize(lr_channel, hr_shape)
+
+        X = extract_patches(lr_channel_up, PATCH_SIZE, STEP)
+        y = extract_patches(hr_channel, PATCH_SIZE, STEP)
+        rf_model = train_rf(X, y)
+        sr = predict_and_reconstruct(rf_model, lr_channel_up, PATCH_SIZE, STEP, hr_shape)
+        sr_channels.append(sr)
+
+    sr_image = np.stack(sr_channels, axis=-1)
+    sr_image = np.clip(sr_image * 255, 0, 255).astype(np.uint8)
+    return Image.fromarray(sr_image)

models/rcan.py

@@ -0,0 +1,111 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision.io import read_image
+from torchvision.utils import save_image
+import os
+from torchvision.transforms.functional import to_tensor, to_pil_image
+
+# === RCAN MODULES ===
+
+class CALayer(nn.Module):
+    def __init__(self, channels, reduction=16):
+        super().__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Sequential(
+            nn.Conv2d(channels, channels // reduction, 1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(channels // reduction, channels, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        w = self.fc(self.avg_pool(x))
+        return x * w
+
+
+class RCAB(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.body = nn.Sequential(
+            nn.Conv2d(channels, channels, 3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(channels, channels, 3, padding=1),
+            CALayer(channels)
+        )
+
+    def forward(self, x):
+        return x + self.body(x)
+
+
+class ResidualGroup(nn.Module):
+    def __init__(self, channels, n_rcab):
+        super().__init__()
+        modules = [RCAB(channels) for _ in range(n_rcab)]
+        modules.append(nn.Conv2d(channels, channels, 3, padding=1))
+        self.body = nn.Sequential(*modules)
+
+    def forward(self, x):
+        return x + self.body(x)
+
+
+class Upsampler(nn.Sequential):
+    def __init__(self, scale, channels):
+        m = []
+        for _ in range(int(torch.log2(torch.tensor(scale)))):
+            m.append(nn.Conv2d(channels, channels * 4, 3, padding=1))
+            m.append(nn.PixelShuffle(2))
+        super().__init__(*m)
+
+
+class RCAN(nn.Module):
+    def __init__(self, in_channels=3, out_channels=3, n_feat=64, n_rg=10, n_rcab=20, scale=4):
+        super().__init__()
+        self.head = nn.Conv2d(in_channels, n_feat, 3, padding=1)
+        self.body = nn.Sequential(
+            *[ResidualGroup(n_feat, n_rcab) for _ in range(n_rg)],
+            nn.Conv2d(n_feat, n_feat, 3, padding=1)
+        )
+        self.upsample = Upsampler(scale, n_feat)
+        self.tail = nn.Conv2d(n_feat, out_channels, 3, padding=1)
+
+    def forward(self, x):
+        x = self.head(x)
+        res = self.body(x)
+        x = x + res
+        x = self.upsample(x)
+        return self.tail(x)
+
+# === INFERENCE ===
+
+def rcan_upscale(lr_img_pil, model_path="weights/rcan_epoch_20.pth", device='cpu'):
+    """
+    Super resolves a low-resolution PIL image using the RCAN model.
+
+    Args:
+        lr_img_pil (PIL.Image): Low-resolution input image.
+        model_path (str): Path to the model weights.
+        device (str): 'cuda' or 'cpu'.
+
+    Returns:
+        PIL.Image: High-resolution output image.
+    """
+    # Load model
+    device = torch.device(device if torch.cuda.is_available() else 'cpu')
+    model = RCAN(scale=4)
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    model.to(device).eval()
+
+    # Convert PIL image to normalized tensor
+    lr_tensor = to_tensor(lr_img_pil).unsqueeze(0).to(device)  # Add batch dim
+
+    # Inference
+    with torch.no_grad():
+        sr_tensor = model(lr_tensor).squeeze(0).clamp(0, 1).cpu()  # Remove batch
+
+    # Convert tensor back to PIL image
+    sr_img_pil = to_pil_image(sr_tensor)
+
+    return sr_img_pil
+
+

models/spline_interpolation.py

@@ -0,0 +1,33 @@
+import cv2
+import numpy as np
+
+def spline_upscale(image, scale_factor=4):
+    """
+    Upscale image using Bicubic spline interpolation
+    
+    Args:
+        image: Input image (numpy array or file path)
+        scale_factor: Scaling multiplier (default=4)
+    
+    Returns:
+        Upscaled image as numpy array (uint8)
+    """
+    # Load image if path provided
+    if isinstance(image, str):
+        img = cv2.imread(image)
+        if img is None:
+            raise ValueError(f"Could not load image from {image}")
+    else:
+        img = image.copy()
+    
+    # Get original dimensions
+    h, w = img.shape[:2]
+    
+    # Calculate new dimensions
+    new_w = int(w * scale_factor)
+    new_h = int(h * scale_factor)
+    
+    # Perform bicubic interpolation
+    upscaled = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_CUBIC)
+    
+    return upscaled

models/sr_gan.py

@@ -0,0 +1,87 @@
+import torch
+import torch.nn as nn
+from collections import OrderedDict
+import numpy as np
+from PIL import Image,ImageOps
+
+class ResidualBlock(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.Conv2d(channels, channels, 3, 1, 1),
+            nn.BatchNorm2d(channels),
+            nn.PReLU(),
+            nn.Conv2d(channels, channels, 3, 1, 1),
+            nn.BatchNorm2d(channels)
+        )
+
+    def forward(self, x):
+        return x + self.block(x)
+
+class Generator(nn.Module):
+    def __init__(self, in_channels=3, num_res_blocks=16):
+        super().__init__()
+
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels, 64, kernel_size=9, stride=1, padding=4),
+            nn.PReLU()
+        )
+
+        self.res_blocks = nn.Sequential(*[ResidualBlock(64) for _ in range(num_res_blocks)])
+
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(64)
+        )
+
+        # Upsampling by 2x → 256x256, then another 2x → 512x512
+        self.upsample = nn.Sequential(
+            nn.Conv2d(64, 256, kernel_size=3, stride=1, padding=1),
+            nn.PixelShuffle(2),  # 128 → 256
+            nn.PReLU(),
+
+            nn.Conv2d(64, 256, kernel_size=3, stride=1, padding=1),
+            nn.PixelShuffle(2),  # 256 → 512
+            nn.PReLU()
+        )
+
+        self.conv3 = nn.Conv2d(64, in_channels, kernel_size=9, stride=1, padding=4)
+
+    def forward(self, x):
+        initial = self.conv1(x)
+        res = self.res_blocks(initial)
+        res = self.conv2(res)
+        out = initial + res
+        out = self.upsample(out)
+        out = self.conv3(out)
+        return torch.clamp(out, 0.0, 1.0)  # to keep output in [0,1]
+    
+
+def srgan_upscale(image):
+    image = Image.fromarray(image)
+    target_size = (128, 128)
+    pad_color=(0, 0, 0)
+    ImageOps.pad(image, target_size, method=Image.BICUBIC, color=pad_color)
+    image = np.array(image)
+
+    image = image/255
+    image = torch.from_numpy(image).float().unsqueeze(dim=0).permute(0,3,1,2)
+
+    model = Generator()
+    checkpoint = torch.load("weights/model_srgan.pth", map_location=torch.device('cpu'))  # or 'cuda' if using GPU
+    state_dict = checkpoint['G_state_dict']
+
+    new_state_dict = OrderedDict()
+    for k, v in state_dict.items():
+        new_key = k.replace("module.", "")  # Remove "module." from each key
+        new_state_dict[new_key] = v
+
+    model.load_state_dict(new_state_dict)
+    model.eval()
+
+    with torch.no_grad():
+        output = model(image)
+
+    output = output.squeeze(0).permute(1, 2, 0).cpu().numpy()
+    output = (output * 255.0).clip(0, 255).astype("uint8")
+    return output 

requirements.txt

@@ -0,0 +1,9 @@
+gradio
+Pillow
+numpy
+opencv-python
+scipy
+scikit-learn
+torch
+scikit-image
+torchvision

weights/model_auto_2.pth

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

weights/model_cnn.pth

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

weights/model_espcn.pth

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

weights/model_srgan.pth

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

weights/rcan_epoch_20.pth

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