delete

.gitattributes

@@ -1,37 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-assets/teaser.png filter=lfs diff=lfs merge=lfs -text
-demos/example_003.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,10 +0,0 @@
----
-title: Image Procesing
-emoji: 😻
-colorFrom: purple
-colorTo: red
-sdk: gradio
-sdk_version: 5.3.0
-app_file: app.py
-pinned: false
----

app.py

@@ -1,24 +0,0 @@
-import gradio as gr
-from pixelize_processor import create_pixelize_tab
-from lut_processor import create_lut_tab
-from sharpen_processor import create_sharpen_tab
-from color_match_processor import create_color_match_tab
-from simple_effects_processor import create_effects_tab
-from histogram_processor import create_histogram_tab
-from blend_processor import create_blend_tab
-from matte_processor import create_matte_tab
-
-with gr.Blocks(title="Image Processing Suite") as demo:
-    gr.Markdown("# Image Processing Suite")
-    
-    create_pixelize_tab()
-    create_lut_tab()
-    create_sharpen_tab()
-    create_color_match_tab()
-    create_effects_tab()
-    create_histogram_tab()
-    create_blend_tab()
-    create_matte_tab()  # Add this line
-    
-if __name__ == "__main__":
-    demo.launch(share=True)

blend_processor.py

@@ -1,262 +0,0 @@
-import gradio as gr
-import numpy as np
-import cv2
-from PIL import Image, ImageChops
-from skimage import img_as_float, img_as_ubyte
-import copy
-from typing import Optional, Union
-
-def cv22ski(cv2_image: np.ndarray) -> np.ndarray:
-    """Convert CV2 image to skimage float format"""
-    return img_as_float(cv2_image)
-
-def ski2cv2(ski: np.ndarray) -> np.ndarray:
-    """Convert skimage float format to CV2 image"""
-    return img_as_ubyte(ski)
-
-def cv22pil(cv2_img: np.ndarray) -> Image.Image:
-    """Convert CV2 image to PIL Image"""
-    cv2_img = cv2.cvtColor(cv2_img, cv2.COLOR_BGR2RGB)
-    return Image.fromarray(cv2_img)
-
-def pil2cv2(pil_img: Image.Image) -> np.ndarray:
-    """Convert PIL Image to CV2 image"""
-    np_img_array = np.asarray(pil_img)
-    return cv2.cvtColor(np_img_array, cv2.COLOR_RGB2BGR)
-
-def blend_color_burn(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply color burn blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = 1 - (1 - img_2) / (img_1 + 0.001)
-    mask_1 = img < 0
-    mask_2 = img > 1
-    img = img * (1 - mask_1)
-    img = img * (1 - mask_2) + mask_2
-    return cv22pil(ski2cv2(img))
-
-def blend_color_dodge(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply color dodge blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = img_2 / (1.0 - img_1 + 0.001)
-    mask_2 = img > 1
-    img = img * (1 - mask_2) + mask_2
-    return cv22pil(ski2cv2(img))
-
-def blend_linear_burn(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply linear burn blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = img_1 + img_2 - 1
-    mask_1 = img < 0
-    img = img * (1 - mask_1)
-    return cv22pil(ski2cv2(img))
-
-def blend_linear_dodge(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply linear dodge blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = img_1 + img_2
-    mask_2 = img > 1
-    img = img * (1 - mask_2) + mask_2
-    return cv22pil(ski2cv2(img))
-
-def blend_lighten(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply lighten blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = img_1 - img_2
-    mask = img > 0
-    img = img_1 * mask + img_2 * (1 - mask)
-    return cv22pil(ski2cv2(img))
-
-def blend_dark(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply darken blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = img_1 - img_2
-    mask = img < 0
-    img = img_1 * mask + img_2 * (1 - mask)
-    return cv22pil(ski2cv2(img))
-
-def blend_screen(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply screen blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = 1 - (1 - img_1) * (1 - img_2)
-    return cv22pil(ski2cv2(img))
-
-def blend_overlay(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply overlay blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    mask = img_2 < 0.5
-    img = 2 * img_1 * img_2 * mask + (1 - mask) * (1 - 2 * (1 - img_1) * (1 - img_2))
-    return cv22pil(ski2cv2(img))
-
-def blend_soft_light(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply soft light blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    mask = img_1 < 0.5
-    T1 = (2 * img_1 - 1) * (img_2 - img_2 * img_2) + img_2
-    T2 = (2 * img_1 - 1) * (np.sqrt(img_2) - img_2) + img_2
-    img = T1 * mask + T2 * (1 - mask)
-    return cv22pil(ski2cv2(img))
-
-def blend_hard_light(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply hard light blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    mask = img_1 < 0.5
-    T1 = 2 * img_1 * img_2
-    T2 = 1 - 2 * (1 - img_1) * (1 - img_2)
-    img = T1 * mask + T2 * (1 - mask)
-    return cv22pil(ski2cv2(img))
-
-def blend_vivid_light(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply vivid light blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    mask = img_1 < 0.5
-    T1 = 1 - (1 - img_2) / (2 * img_1 + 0.001)
-    T2 = img_2 / (2 * (1 - img_1) + 0.001)
-    mask_1 = T1 < 0
-    mask_2 = T2 > 1
-    T1 = T1 * (1 - mask_1)
-    T2 = T2 * (1 - mask_2) + mask_2
-    img = T1 * mask + T2 * (1 - mask)
-    return cv22pil(ski2cv2(img))
-
-def blend_pin_light(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply pin light blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    mask_1 = img_2 < (img_1 * 2 - 1)
-    mask_2 = img_2 > 2 * img_1
-    T1 = 2 * img_1 - 1
-    T2 = img_2
-    T3 = 2 * img_1
-    img = T1 * mask_1 + T2 * (1 - mask_1) * (1 - mask_2) + T3 * mask_2
-    return cv22pil(ski2cv2(img))
-
-def blend_linear_light(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply linear light blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = img_2 + img_1 * 2 - 1
-    mask_1 = img < 0
-    mask_2 = img > 1
-    img = img * (1 - mask_1)
-    img = img * (1 - mask_2) + mask_2
-    return cv22pil(ski2cv2(img))
-
-def blend_hard_mix(background_image: Image.Image, layer_image: Image.Image) -> Image.Image:
-    """Apply hard mix blend mode"""
-    img_1 = cv22ski(pil2cv2(background_image))
-    img_2 = cv22ski(pil2cv2(layer_image))
-    img = img_1 + img_2
-    mask = img_1 + img_2 > 1
-    img = img * (1 - mask) + mask
-    img = img * mask
-    return cv22pil(ski2cv2(img))
-
-def chop_image(background_image: Image.Image, layer_image: Image.Image, blend_mode: str, opacity: int) -> Image.Image:
-    """Apply blend mode and opacity to images"""
-    ret_image = background_image
-    
-    blend_functions = {
-        'normal': lambda: copy.deepcopy(layer_image),
-        'multiply': lambda: ImageChops.multiply(background_image, layer_image),
-        'screen': lambda: ImageChops.screen(background_image, layer_image),
-        'add': lambda: ImageChops.add(background_image, layer_image, 1, 0),
-        'subtract': lambda: ImageChops.subtract(background_image, layer_image, 1, 0),
-        'difference': lambda: ImageChops.difference(background_image, layer_image),
-        'darker': lambda: ImageChops.darker(background_image, layer_image),
-        'lighter': lambda: ImageChops.lighter(background_image, layer_image),
-        'color_burn': lambda: blend_color_burn(background_image, layer_image),
-        'color_dodge': lambda: blend_color_dodge(background_image, layer_image),
-        'linear_burn': lambda: blend_linear_burn(background_image, layer_image),
-        'linear_dodge': lambda: blend_linear_dodge(background_image, layer_image),
-        'overlay': lambda: blend_overlay(background_image, layer_image),
-        'soft_light': lambda: blend_soft_light(background_image, layer_image),
-        'hard_light': lambda: blend_hard_light(background_image, layer_image),
-        'vivid_light': lambda: blend_vivid_light(background_image, layer_image),
-        'pin_light': lambda: blend_pin_light(background_image, layer_image),
-        'linear_light': lambda: blend_linear_light(background_image, layer_image),
-        'hard_mix': lambda: blend_hard_mix(background_image, layer_image)
-    }
-    
-    if blend_mode in blend_functions:
-        ret_image = blend_functions[blend_mode]()
-    
-    # Apply opacity
-    if opacity == 0:
-        ret_image = background_image
-    elif opacity < 100:
-        alpha = 1.0 - float(opacity) / 100
-        ret_image = Image.blend(ret_image, background_image, alpha)
-    
-    return ret_image
-
-def process_images(background: Optional[np.ndarray], 
-                  layer: Optional[np.ndarray], 
-                  blend_mode: str,
-                  opacity: float) -> Optional[np.ndarray]:
-    """Process images with selected blend mode and opacity"""
-    if background is None or layer is None:
-        return None
-        
-    # Convert numpy arrays to PIL Images
-    background_pil = Image.fromarray(background)
-    layer_pil = Image.fromarray(layer)
-    
-    # Ensure images are in RGB mode
-    background_pil = background_pil.convert('RGB')
-    layer_pil = layer_pil.convert('RGB')
-    
-    # Apply blend mode
-    result = chop_image(background_pil, layer_pil, blend_mode, int(opacity * 100))
-    
-    # Convert back to numpy array
-    return np.array(result)
-
-def create_blend_tab():
-    """Create the blend modes tab interface"""
-    with gr.Tab("Blend Modes"):
-        with gr.Row():
-            with gr.Column():
-                background_image = gr.Image(label="Background Image", height=256)
-                layer_image = gr.Image(label="Layer Image", height=256)
-                
-                blend_mode = gr.Dropdown(
-                    choices=[
-                        "normal", "multiply", "screen", "overlay",
-                        "soft_light", "hard_light", "color_burn", "color_dodge",
-                        "linear_burn", "linear_dodge", "vivid_light", "linear_light",
-                        "pin_light", "hard_mix", "difference", "add", "subtract",
-                        "darker", "lighter"
-                    ],
-                    value="normal",
-                    label="Blend Mode"
-                )
-                
-                opacity = gr.Slider(
-                    minimum=0.0,
-                    maximum=1.0,
-                    value=1.0,
-                    step=0.01,
-                    label="Opacity"
-                )
-                
-                blend_btn = gr.Button("Apply Blend")
-                
-            with gr.Column():
-                output_image = gr.Image(label="Blended Image")
-        
-        blend_btn.click(
-            fn=process_images,
-            inputs=[background_image, layer_image, blend_mode, opacity],
-            outputs=output_image
-        ) 

color_match_processor.py

@@ -1,210 +0,0 @@
-import gradio as gr
-import torch
-import torch.nn.functional as F
-import kornia
-import numpy as np
-
-def compute_mean_std(tensor, mask=None):
-    if mask is not None:
-        # Apply mask to the tensor
-        masked_tensor = tensor * mask
-        mask_sum = mask.sum(dim=[2, 3], keepdim=True)
-        mask_sum = torch.clamp(mask_sum, min=1e-6)
-        
-        mean = torch.nan_to_num(masked_tensor.sum(dim=[2, 3], keepdim=True) / mask_sum)
-        std = torch.sqrt(torch.nan_to_num(((masked_tensor - mean) ** 2 * mask).sum(dim=[2, 3], keepdim=True) / mask_sum))
-    else:
-        mean = tensor.mean(dim=[2, 3], keepdim=True)
-        std = tensor.std(dim=[2, 3], keepdim=True)
-    return mean, std
-
-def apply_color_match(image, reference, color_space, factor, device='cpu'):
-    if image is None or reference is None:
-        return None
-        
-    # Convert to torch tensors and normalize
-    image = torch.from_numpy(image).float() / 255.0
-    reference = torch.from_numpy(reference).float() / 255.0
-    
-    # Add batch dimension and rearrange to BCHW
-    image = image.unsqueeze(0).permute(0, 3, 1, 2)
-    reference = reference.unsqueeze(0).permute(0, 3, 1, 2)
-    
-    # Convert to target color space
-    if color_space == "LAB":
-        image_conv = kornia.color.rgb_to_lab(image)
-        reference_conv = kornia.color.rgb_to_lab(reference)
-        back_conversion = kornia.color.lab_to_rgb
-    elif color_space == "YCbCr":
-        image_conv = kornia.color.rgb_to_ycbcr(image)
-        reference_conv = kornia.color.rgb_to_ycbcr(reference)
-        back_conversion = kornia.color.ycbcr_to_rgb
-    elif color_space == "LUV":
-        image_conv = kornia.color.rgb_to_luv(image)
-        reference_conv = kornia.color.rgb_to_luv(reference)
-        back_conversion = kornia.color.luv_to_rgb
-    elif color_space == "YUV":
-        image_conv = kornia.color.rgb_to_yuv(image)
-        reference_conv = kornia.color.rgb_to_yuv(reference)
-        back_conversion = kornia.color.yuv_to_rgb
-    elif color_space == "XYZ":
-        image_conv = kornia.color.rgb_to_xyz(image)
-        reference_conv = kornia.color.rgb_to_xyz(reference)
-        back_conversion = kornia.color.xyz_to_rgb
-    else:  # RGB
-        image_conv = image
-        reference_conv = reference
-        back_conversion = lambda x: x
-    
-    # Compute statistics
-    reference_mean, reference_std = compute_mean_std(reference_conv)
-    image_mean, image_std = compute_mean_std(image_conv)
-    
-    # Apply color matching
-    matched = torch.nan_to_num((image_conv - image_mean) / image_std) * reference_std + reference_mean
-    matched = factor * matched + (1 - factor) * image_conv
-    
-    # Convert back to RGB
-    matched = back_conversion(matched)
-    
-    # Convert back to HWC format and to uint8
-    output = matched.squeeze(0).permute(1, 2, 0)
-    output = (output.clamp(0, 1).numpy() * 255).astype(np.uint8)
-    
-    return output
-
-def analyze_color_statistics(image):
-    l, a, b = kornia.color.rgb_to_lab(image).chunk(3, dim=1)
-    mean_l = l.mean()
-    std_l = l.std()
-    mean_a = a.mean()
-    mean_b = b.mean()
-    std_ab = torch.sqrt(a.var() + b.var())
-    return mean_l, std_l, mean_a, mean_b, std_ab
-
-def apply_adobe_color_match(image, reference, color_space, luminance_factor, color_intensity_factor, fade_factor, neutralization_factor):
-    if image is None or reference is None:
-        return None
-        
-    # Convert to torch tensors and normalize
-    image = torch.from_numpy(image).float() / 255.0
-    reference = torch.from_numpy(reference).float() / 255.0
-    
-    # Add batch dimension and rearrange to BCHW
-    image = image.unsqueeze(0).permute(0, 3, 1, 2)
-    reference = reference.unsqueeze(0).permute(0, 3, 1, 2)
-    
-    # Analyze color statistics
-    source_stats = analyze_color_statistics(reference)
-    dest_stats = analyze_color_statistics(image)
-    
-    # Convert to LAB
-    l, a, b = kornia.color.rgb_to_lab(image).chunk(3, dim=1)
-    
-    # Unpack statistics
-    src_mean_l, src_std_l, src_mean_a, src_mean_b, src_std_ab = source_stats
-    dest_mean_l, dest_std_l, dest_mean_a, dest_mean_b, dest_std_ab = dest_stats
-    
-    # Apply transformations
-    l_new = (l - dest_mean_l) * (src_std_l / dest_std_l) * luminance_factor + src_mean_l
-    
-    # Neutralize color cast
-    a = a - neutralization_factor * dest_mean_a
-    b = b - neutralization_factor * dest_mean_b
-    
-    # Adjust color intensity
-    a_new = a * (src_std_ab / dest_std_ab) * color_intensity_factor
-    b_new = b * (src_std_ab / dest_std_ab) * color_intensity_factor
-    
-    # Combine channels
-    lab_new = torch.cat([l_new, a_new, b_new], dim=1)
-    
-    # Convert back to RGB
-    rgb_new = kornia.color.lab_to_rgb(lab_new)
-    
-    # Apply fade factor
-    result = fade_factor * rgb_new + (1 - fade_factor) * image
-    
-    # Convert back to HWC format and to uint8
-    output = result.squeeze(0).permute(1, 2, 0)
-    output = (output.clamp(0, 1).numpy() * 255).astype(np.uint8)
-    
-    return output
-
-def create_color_match_tab():
-    with gr.Tab("Color Matching"):
-        
-        with gr.Row():
-            with gr.Column():
-                input_image = gr.Image(label="Input Image", height=256)
-                reference_image = gr.Image(label="Reference Image", height=256)
-                
-                with gr.Tabs():
-                    with gr.Tab("Standard"):
-                        color_space = gr.Dropdown(
-                            choices=["LAB", "YCbCr", "RGB", "LUV", "YUV", "XYZ"],
-                            value="LAB",
-                            label="Color Space"
-                        )
-                        factor = gr.Slider(
-                            minimum=0.0,
-                            maximum=1.0,
-                            value=1.0,
-                            step=0.05,
-                            label="Factor"
-                        )
-                        standard_btn = gr.Button("Apply Standard Color Match")
-                        
-                    with gr.Tab("Adobe Style"):
-                        adobe_color_space = gr.Dropdown(
-                            choices=["RGB", "LAB"],
-                            value="LAB",
-                            label="Color Space"
-                        )
-                        luminance_factor = gr.Slider(
-                            minimum=0.0,
-                            maximum=2.0,
-                            value=1.0,
-                            step=0.05,
-                            label="Luminance Factor"
-                        )
-                        color_intensity_factor = gr.Slider(
-                            minimum=0.0,
-                            maximum=2.0,
-                            value=1.0,
-                            step=0.05,
-                            label="Color Intensity Factor"
-                        )
-                        fade_factor = gr.Slider(
-                            minimum=0.0,
-                            maximum=1.0,
-                            value=1.0,
-                            step=0.05,
-                            label="Fade Factor"
-                        )
-                        neutralization_factor = gr.Slider(
-                            minimum=0.0,
-                            maximum=1.0,
-                            value=0.0,
-                            step=0.05,
-                            label="Neutralization Factor"
-                        )
-                        adobe_btn = gr.Button("Apply Adobe Style Color Match")
-            
-            with gr.Column():
-                output_image = gr.Image(label="Color Matched Image")
-        
-        standard_btn.click(
-            fn=apply_color_match,
-            inputs=[input_image, reference_image, color_space, factor],
-            outputs=output_image
-        )
-        
-        adobe_btn.click(
-            fn=apply_adobe_color_match,
-            inputs=[
-                input_image, reference_image, adobe_color_space,
-                luminance_factor, color_intensity_factor, fade_factor, neutralization_factor
-            ],
-            outputs=output_image
-        )

histogram_processor.py

@@ -1,119 +0,0 @@
-import gradio as gr
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import numpy as np
-from skimage.exposure import match_histograms
-
-class HistogramMatcher(nn.Module):
-    def __init__(self, differentiable=False):
-        super(HistogramMatcher, self).__init__()
-        self.differentiable = differentiable
-
-    def forward(self, dst, ref):
-        B, C, H, W = dst.size()
-        hist_dst = self.cal_hist(dst)
-        hist_ref = self.cal_hist(ref)
-        tables = self.cal_trans_batch(hist_dst, hist_ref)
-        
-        rst = dst.clone()
-        for b in range(B):
-            for c in range(C):
-                rst[b,c] = tables[b*c, (dst[b,c] * 255).long()]
-        
-        return rst / 255.
-
-    def cal_hist(self, img):
-        B, C, H, W = img.size()
-        if self.differentiable:
-            hists = self.soft_histc_batch(img * 255, bins=256, min=0, max=256, sigma=75)
-        else:
-            hists = torch.stack([torch.histc(img[b,c] * 255, bins=256, min=0, max=255) 
-                               for b in range(B) for c in range(C)])
-        
-        hists = hists.float()
-        hists = F.normalize(hists, p=1)
-        bc, n = hists.size()
-        triu = torch.ones(bc, n, n, device=hists.device).triu()
-        hists = torch.bmm(hists[:,None,:], triu)[:,0,:]
-        return hists
-
-    def soft_histc_batch(self, x, bins=256, min=0, max=256, sigma=75):
-        B, C, H, W = x.size()
-        x = x.view(B*C, -1)
-        delta = float(max - min) / float(bins)
-        centers = float(min) + delta * (torch.arange(bins, device=x.device) + 0.5)
-        
-        x = torch.unsqueeze(x, 1)
-        centers = centers[None,:,None]
-        x = x - centers
-        x = torch.sigmoid(sigma * (x + delta/2)) - torch.sigmoid(sigma * (x - delta/2))
-        x = x.sum(dim=2)
-        return x
-
-    def cal_trans_batch(self, hist_dst, hist_ref):
-        hist_dst = hist_dst[:,None,:].repeat(1,256,1)
-        hist_ref = hist_ref[:,:,None].repeat(1,1,256)
-        table = hist_dst - hist_ref
-        table = torch.where(table>=0, 1., 0.)
-        table = torch.sum(table, dim=1) - 1
-        table = torch.clamp(table, min=0, max=255)
-        return table
-
-def apply_histogram_matching(image, reference, factor):
-    if image is None or reference is None:
-        return None
-        
-    # Convert to torch tensors and normalize
-    image = torch.from_numpy(image).float() / 255.0
-    reference = torch.from_numpy(reference).float() / 255.0
-    
-    # Add batch dimension and rearrange to BCHW
-    image = image.unsqueeze(0).permute(0, 3, 1, 2)
-    reference = reference.unsqueeze(0).permute(0, 3, 1, 2)
-    
-
-
-    matched = match_histograms(
-        image.permute(0, 2, 3, 1).numpy(),
-        reference.permute(0, 2, 3, 1).numpy(),
-        channel_axis=3
-    )
-    matched = torch.from_numpy(matched).permute(0, 3, 1, 2)
-    
-    # Apply factor blending
-    result = factor * matched + (1 - factor) * image
-    
-    # Convert back to HWC format and to uint8
-    output = result.squeeze(0).permute(1, 2, 0)
-    output = (output.clamp(0, 1).numpy() * 255).astype(np.uint8)
-    
-    return output
-
-def create_histogram_tab():
-    with gr.Tab("Histogram Matching"):
-        
-        with gr.Row():
-            with gr.Column():
-                input_image = gr.Image(label="Input Image", height=256)
-                reference_image = gr.Image(label="Reference Image", height=256)
-
-                
-                factor = gr.Slider(
-                    minimum=0.0,
-                    maximum=1.0,
-                    value=0.5,
-                    step=0.05,
-                    label="Blend Factor"
-                )
-                
-                match_btn = gr.Button("Apply Histogram Matching")
-            
-            with gr.Column():
-                output_image = gr.Image(label="Matched Image")
-        
-        match_btn.click(
-            fn=apply_histogram_matching,
-            inputs=[input_image, reference_image, factor],
-            outputs=output_image
-        )