cleaning repo

.gitignore

@@ -9,7 +9,6 @@ build/
 dist/
 *.egg-info/
 .env
-.claude/
 oneformer/modeling/pixel_decoder/ops/build/
 oneformer/modeling/pixel_decoder/ops/dist/
 oneformer/modeling/pixel_decoder/ops/*.egg-info/

gradio_app.py

@@ -1,222 +0,0 @@
-import torch
-
-print("Installed the dependencies!")
-
-import numpy as np
-from PIL import Image
-import cv2
-import imutils
-import os
-import sys
-import time
-from detectron2.config import get_cfg
-from detectron2.projects.deeplab import add_deeplab_config
-from detectron2.data import MetadataCatalog
-torch.set_num_threads(16)  # Use 16 CPU threads
-torch.set_num_interop_threads(16)  # Inter-op parallelism
-from oneformer import (
-    add_oneformer_config,
-    add_common_config,
-    add_swin_config,
-    add_dinat_config,
-)
-
-from demo.defaults import DefaultPredictor
-from demo.visualizer import Visualizer, ColorMode
-
-import gradio as gr
-from huggingface_hub import hf_hub_download
-
-KEY_DICT = {"Cityscapes (19 classes)": "cityscapes",
-            "COCO (133 classes)": "coco",
-            "ADE20K (150 classes)": "ade20k",}
-
-SWIN_CFG_DICT = {"cityscapes": "configs/cityscapes/oneformer_swin_large_IN21k_384_bs16_90k.yaml",
-            "coco": "configs/coco/oneformer_swin_large_IN21k_384_bs16_100ep.yaml",
-            "ade20k": "configs/ade20k/oneformer_swin_large_IN21k_384_bs16_160k.yaml",}
-
-SWIN_MODEL_DICT = {"cityscapes": hf_hub_download(repo_id="shi-labs/oneformer_cityscapes_swin_large", 
-                                            filename="250_16_swin_l_oneformer_cityscapes_90k.pth"),
-              "coco": hf_hub_download(repo_id="shi-labs/oneformer_coco_swin_large", 
-                                            filename="150_16_swin_l_oneformer_coco_100ep.pth"),
-              "ade20k": hf_hub_download(repo_id="shi-labs/oneformer_ade20k_swin_large", 
-                                            filename="250_16_swin_l_oneformer_ade20k_160k.pth")
-            }
-
-DINAT_CFG_DICT = {"cityscapes": "configs/cityscapes/oneformer_dinat_large_bs16_90k.yaml",
-            "coco": "configs/coco/oneformer_dinat_large_bs16_100ep.yaml",
-            "ade20k": "configs/ade20k/oneformer_dinat_large_IN21k_384_bs16_160k.yaml",}
-
-DINAT_MODEL_DICT = {"cityscapes": hf_hub_download(repo_id="shi-labs/oneformer_cityscapes_dinat_large", 
-                                            filename="250_16_dinat_l_oneformer_cityscapes_90k.pth"),
-              "coco": hf_hub_download(repo_id="shi-labs/oneformer_coco_dinat_large", 
-                                            filename="150_16_dinat_l_oneformer_coco_100ep.pth"),
-              "ade20k": hf_hub_download(repo_id="shi-labs/oneformer_ade20k_dinat_large", 
-                                            filename="250_16_dinat_l_oneformer_ade20k_160k.pth")
-            }
-
-MODEL_DICT = {"DiNAT-L": DINAT_MODEL_DICT,
-        "Swin-L": SWIN_MODEL_DICT }
-
-CFG_DICT = {"DiNAT-L": DINAT_CFG_DICT,
-        "Swin-L": SWIN_CFG_DICT }
-
-WIDTH_DICT = {"cityscapes": 512,
-              "coco": 512,
-              "ade20k": 640}
-
-cpu_device = torch.device("cpu")
-
-PREDICTORS = {
-    "DiNAT-L": {
-        "Cityscapes (19 classes)": None,
-        "COCO (133 classes)": None,
-        "ADE20K (150 classes)": None
-    },
-    "Swin-L": {
-        "Cityscapes (19 classes)": None,
-        "COCO (133 classes)": None,
-        "ADE20K (150 classes)": None
-    }
-}
-
-METADATA = {
-    "DiNAT-L": {
-        "Cityscapes (19 classes)": None,
-        "COCO (133 classes)": None,
-        "ADE20K (150 classes)": None
-    },
-    "Swin-L": {
-        "Cityscapes (19 classes)": None,
-        "COCO (133 classes)": None,
-        "ADE20K (150 classes)": None
-    }
-}
-
-def setup_modules():
-    for dataset in ["Cityscapes (19 classes)", "COCO (133 classes)", "ADE20K (150 classes)"]:
-        for backbone in ["DiNAT-L", "Swin-L"]:
-            cfg = setup_cfg(dataset, backbone)
-            metadata = MetadataCatalog.get(
-            cfg.DATASETS.TEST_PANOPTIC[0] if len(cfg.DATASETS.TEST_PANOPTIC) else "__unused"
-            )
-            if 'cityscapes_fine_sem_seg_val' in cfg.DATASETS.TEST_PANOPTIC[0]:
-                from cityscapesscripts.helpers.labels import labels
-                stuff_colors = [k.color for k in labels if k.trainId != 255]
-                metadata = metadata.set(stuff_colors=stuff_colors)
-            PREDICTORS[backbone][dataset] = DefaultPredictor(cfg)
-            METADATA[backbone][dataset] = metadata
-
-def setup_cfg(dataset, backbone):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    add_deeplab_config(cfg)
-    add_common_config(cfg)
-    add_swin_config(cfg)
-    add_oneformer_config(cfg)
-    add_dinat_config(cfg)
-    dataset = KEY_DICT[dataset]
-    cfg_path = CFG_DICT[backbone][dataset]
-    cfg.merge_from_file(cfg_path)
-    if torch.cuda.is_available():
-        cfg.MODEL.DEVICE = 'cuda'
-    else:
-        cfg.MODEL.DEVICE = 'cpu'
-    cfg.MODEL.WEIGHTS = MODEL_DICT[backbone][dataset]
-    cfg.freeze()
-    return cfg
-
-# def setup_modules(dataset, backbone):
-#     cfg = setup_cfg(dataset, backbone)
-#     predictor = DefaultPredictor(cfg)
-#     # predictor = PREDICTORS[backbone][dataset]
-#     metadata = MetadataCatalog.get(
-#         cfg.DATASETS.TEST_PANOPTIC[0] if len(cfg.DATASETS.TEST_PANOPTIC) else "__unused"
-#     )
-#     if 'cityscapes_fine_sem_seg_val' in cfg.DATASETS.TEST_PANOPTIC[0]:
-#         from cityscapesscripts.helpers.labels import labels
-#         stuff_colors = [k.color for k in labels if k.trainId != 255]
-#         metadata = metadata.set(stuff_colors=stuff_colors)
-    
-#     return predictor, metadata
-
-def panoptic_run(img, predictor, metadata):
-    visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, instance_mode=ColorMode.IMAGE)
-    predictions = predictor(img, "panoptic")
-    panoptic_seg, segments_info = predictions["panoptic_seg"]
-    out = visualizer.draw_panoptic_seg_predictions(
-        panoptic_seg.to(cpu_device), segments_info, alpha=0.5
-    )
-    visualizer_map = Visualizer(img[:, :, ::-1], is_img=False, metadata=metadata, instance_mode=ColorMode.IMAGE)
-    out_map = visualizer_map.draw_panoptic_seg_predictions(
-        panoptic_seg.to(cpu_device), segments_info, alpha=1, is_text=False
-    )
-    return out, out_map
-
-def instance_run(img, predictor, metadata):
-    visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, instance_mode=ColorMode.IMAGE)
-    predictions = predictor(img, "instance")
-    instances = predictions["instances"].to(cpu_device)
-    out = visualizer.draw_instance_predictions(predictions=instances, alpha=0.5)
-    visualizer_map = Visualizer(img[:, :, ::-1], is_img=False, metadata=metadata, instance_mode=ColorMode.IMAGE)
-    out_map = visualizer_map.draw_instance_predictions(predictions=instances, alpha=1, is_text=False)
-    return out, out_map
-
-def semantic_run(img, predictor, metadata):
-    visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, instance_mode=ColorMode.IMAGE)
-    predictions = predictor(img, "semantic")
-    out = visualizer.draw_sem_seg(
-        predictions["sem_seg"].argmax(dim=0).to(cpu_device), alpha=0.5
-    )
-    visualizer_map = Visualizer(img[:, :, ::-1], is_img=False, metadata=metadata, instance_mode=ColorMode.IMAGE)
-    out_map = visualizer_map.draw_sem_seg(
-        predictions["sem_seg"].argmax(dim=0).to(cpu_device), alpha=1, is_text=False
-    )
-    return out, out_map
-
-TASK_INFER = {"the task is panoptic": panoptic_run, "the task is instance": instance_run, "the task is semantic": semantic_run}
-
-def segment(path, task, dataset, backbone):
-    # predictor, metadata = setup_modules(dataset, backbone)
-    predictor = PREDICTORS[backbone][dataset]
-    metadata = METADATA[backbone][dataset]
-    img = cv2.imread(path)
-    width = WIDTH_DICT[KEY_DICT[dataset]]
-    img = imutils.resize(img, width=width)
-    out, out_map = TASK_INFER[task](img, predictor, metadata)
-    out = Image.fromarray(out.get_image())
-    out_map = Image.fromarray(out_map.get_image())
-    return out, out_map
-
-title = "<h1 style='text-align: center'>OneFormer:DIEGO MENTORIA MILIONÁRIA - APP 1</h1>"
-# style='margin-bottom: -10px;
-description = "<p style='font-size: 14px; margin: 5px; font-weight: w300; text-align: center'> <a href='https://praeclarumjj3.github.io/' style='text-decoration:none' target='_blank'>Jitesh Jain, </a> <a href='https://chrisjuniorli.github.io/' style='text-decoration:none' target='_blank'>Jiachen Li<sup>*</sup>, </a> <a href='https://www.linkedin.com/in/mtchiu/' style='text-decoration:none' target='_blank'>MangTik Chiu<sup>*</sup>, </a> <a href='https://alihassanijr.com/' style='text-decoration:none' target='_blank'>Ali Hassani, </a> <a href='https://www.linkedin.com/in/nukich74/' style='text-decoration:none' target='_blank'>Nikita Orlov, </a> <a href='https://www.humphreyshi.com/home' style='text-decoration:none' target='_blank'>Humphrey Shi</a></p>" \
-            + "<p style='font-size: 16px; margin: 5px; font-weight: w600; text-align: center'> <a href='https://praeclarumjj3.github.io/oneformer/' target='_blank'>Project Page</a> | <a href='https://arxiv.org/abs/2211.06220' target='_blank'>ArXiv Paper</a> | <a href='https://github.com/SHI-Labs/OneFormer' target='_blank'>Github Repo</a></p>" \
-            + "<p style='text-align: center; margin: 5px; font-size: 14px; font-weight: w300;'>  \
-                OneFormer is the first multi-task universal image segmentation framework based on transformers. Our single OneFormer model achieves state-of-the-art performance across all three segmentation tasks with a single task-conditioned joint training process. OneFormer uses a task token to condition the model on the task in focus, making our architecture task-guided for training, and task-dynamic for inference, all with a single model. We believe OneFormer is a significant step towards making image segmentation more universal and accessible.\
-                </p>" \
-            + "<p style='text-align: center; font-size: 14px; margin: 5px; font-weight: w300;'> [Note: Inference on CPU may take upto 2 minutes. On a single RTX A6000 GPU, OneFormer is able to inference at more than 15 FPS.]</p>"
-
-setup_modules()
-
-gradio_inputs = [gr.Image(label="Input Image",type="filepath"),
-            gr.Radio(choices=["the task is panoptic" ,"the task is instance", "the task is semantic"], type="value", value="the task is panoptic", label="Task Token Input"),
-            gr.Radio(choices=["COCO (133 classes)" ,"Cityscapes (19 classes)", "ADE20K (150 classes)"], type="value", value="COCO (133 classes)", label="Model"),
-            gr.Radio(choices=["DiNAT-L" ,"Swin-L"], type="value", value="DiNAT-L", label="Backbone"),
-            ]
-gradio_outputs = [gr.Image(type="pil", label="Segmentation Overlay"), gr.Image(type="pil", label="Segmentation Map")]
-
-
-examples = [["examples/coco.jpeg", "the task is panoptic", "COCO (133 classes)", "DiNAT-L"],
-            ["examples/cityscapes.png", "the task is panoptic", "Cityscapes (19 classes)", "DiNAT-L"],
-            ["examples/ade20k.jpeg", "the task is panoptic", "ADE20K (150 classes)", "DiNAT-L"]]
-
-
-iface = gr.Interface(fn=segment, inputs=gradio_inputs,
-                     outputs=gradio_outputs,
-                     examples_per_page=5,
-                     allow_flagging="never",
-                     examples=examples, title=title,
-                     description=description)
-
-iface.launch(server_name="0.0.0.0",share=True)

gradio_combine.py

@@ -1,384 +0,0 @@
-import torch
-import numpy as np
-from PIL import Image
-import cv2
-import imutils
-import os
-import sys
-import time
-import colorsys
-from scipy import ndimage
-import gradio as gr
-from huggingface_hub import hf_hub_download
-
-# Detectron2 imports
-from detectron2.config import get_cfg
-from detectron2.projects.deeplab import add_deeplab_config
-from detectron2.data import MetadataCatalog
-from detectron2.engine import DefaultPredictor as DetectronPredictor
-from detectron2 import model_zoo
-
-# OneFormer imports
-from oneformer import (
-    add_oneformer_config,
-    add_common_config,
-    add_swin_config,
-    add_dinat_config,
-)
-from demo.defaults import DefaultPredictor as OneFormerPredictor
-from demo.visualizer import Visualizer, ColorMode
-
-# NeuroNest contrast detection imports
-from utils.contrast_detector import ContrastDetector
-from utils.luminance_contrast import LuminanceContrastDetector
-from utils.hue_contrast import HueContrastDetector
-from utils.saturation_contrast import SaturationContrastDetector
-from utils.combined_contrast import CombinedContrastDetector
-
-# Set threads for CPU optimization
-torch.set_num_threads(4)
-
-########################################
-# GLOBAL CONFIGURATIONS
-########################################
-
-# OneFormer configurations
-KEY_DICT = {"ADE20K (150 classes)": "ade20k"}
-
-SWIN_CFG_DICT = {
-    "ade20k": "configs/ade20k/oneformer_swin_large_IN21k_384_bs16_160k.yaml",
-}
-
-SWIN_MODEL_DICT = {
-    "ade20k": hf_hub_download(
-        repo_id="shi-labs/oneformer_ade20k_swin_large",
-        filename="250_16_swin_l_oneformer_ade20k_160k.pth"
-    )
-}
-
-DINAT_CFG_DICT = {
-    "ade20k": "configs/ade20k/oneformer_dinat_large_IN21k_384_bs16_160k.yaml",
-}
-
-DINAT_MODEL_DICT = {
-    "ade20k": hf_hub_download(
-        repo_id="shi-labs/oneformer_ade20k_dinat_large",
-        filename="250_16_dinat_l_oneformer_ade20k_160k.pth"
-    )
-}
-
-MODEL_DICT = {"DiNAT-L": DINAT_MODEL_DICT, "Swin-L": SWIN_MODEL_DICT}
-CFG_DICT = {"DiNAT-L": DINAT_CFG_DICT, "Swin-L": SWIN_CFG_DICT}
-WIDTH_DICT = {"ade20k": 640}
-
-# Contrast detector mapping
-CONTRAST_DETECTORS = {
-    "Luminance (WCAG)": LuminanceContrastDetector(),
-    "Hue": HueContrastDetector(),
-    "Saturation": SaturationContrastDetector(),
-    "Combined": CombinedContrastDetector()
-}
-
-# Device configuration
-cpu_device = torch.device("cpu")
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-print(f"Using device: {device}")
-
-# Model storage
-ONEFORMER_PREDICTORS = {
-    "DiNAT-L": {"ADE20K (150 classes)": None},
-    "Swin-L": {"ADE20K (150 classes)": None}
-}
-
-ONEFORMER_METADATA = {
-    "DiNAT-L": {"ADE20K (150 classes)": None},
-    "Swin-L": {"ADE20K (150 classes)": None}
-}
-
-########################################
-# MASK R-CNN SETUP AND FUNCTIONS
-########################################
-
-def load_maskrcnn_model(weights_path, device="cuda", threshold=0.5):
-    """Load Mask R-CNN model for blackspot detection"""
-    cfg = get_cfg()
-    cfg.merge_from_file(
-        model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")
-    )
-    cfg.MODEL.ROI_HEADS.NUM_CLASSES = 2  # [Floors, blackspot]
-    cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = threshold
-    cfg.MODEL.WEIGHTS = weights_path
-    # Fix: Convert torch.device to string
-    cfg.MODEL.DEVICE = str(device) if isinstance(device, torch.device) else device
-    return DetectronPredictor(cfg)
-def postprocess_blackspot_masks(im, instances, show_floor=True, show_blackspot=True):
-    """Extract floor and blackspot masks from Mask R-CNN predictions"""
-    height, width = im.shape[:2]
-    pred_classes = instances.pred_classes.cpu().numpy()
-    pred_masks = instances.pred_masks.cpu().numpy()
-    
-    combined_floor_mask = np.zeros((height, width), dtype=bool)
-    final_blackspot = np.zeros((height, width), dtype=bool)
-    
-    for cls_id, mask in zip(pred_classes, pred_masks):
-        if cls_id == 0 and show_floor:  # Floor class
-            combined_floor_mask |= mask
-        elif cls_id == 1 and show_blackspot:  # Blackspot class
-            final_blackspot |= mask
-    
-    return combined_floor_mask.astype(np.uint8), final_blackspot.astype(np.uint8)
-
-########################################
-# ONEFORMER SETUP AND FUNCTIONS
-########################################
-
-def setup_oneformer_modules():
-    """Initialize OneFormer models"""
-    for dataset in ["ADE20K (150 classes)"]:
-        for backbone in ["DiNAT-L", "Swin-L"]:
-            cfg = setup_oneformer_cfg(dataset, backbone)
-            metadata = MetadataCatalog.get(
-                cfg.DATASETS.TEST_PANOPTIC[0] if len(cfg.DATASETS.TEST_PANOPTIC) else "__unused"
-            )
-            ONEFORMER_PREDICTORS[backbone][dataset] = OneFormerPredictor(cfg)
-            ONEFORMER_METADATA[backbone][dataset] = metadata
-
-def setup_oneformer_cfg(dataset, backbone):
-    """Setup OneFormer configuration"""
-    cfg = get_cfg()
-    add_deeplab_config(cfg)
-    add_common_config(cfg)
-    add_swin_config(cfg)
-    add_oneformer_config(cfg)
-    add_dinat_config(cfg)
-    dataset = KEY_DICT[dataset]
-    cfg_path = CFG_DICT[backbone][dataset]
-    cfg.merge_from_file(cfg_path)
-    cfg.MODEL.DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
-    cfg.MODEL.WEIGHTS = MODEL_DICT[backbone][dataset]
-    cfg.freeze()
-    return cfg
-
-def semantic_run(img, predictor, metadata):
-    """Run OneFormer semantic segmentation"""
-    visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, instance_mode=ColorMode.IMAGE)
-    predictions = predictor(img, "semantic")
-    out = visualizer.draw_sem_seg(
-        predictions["sem_seg"].argmax(dim=0).to(cpu_device), alpha=0.5
-    )
-    return out, predictions["sem_seg"].argmax(dim=0).to(cpu_device).numpy()
-
-########################################
-# INTEGRATED ANALYSIS FUNCTION
-########################################
-
-def integrated_analysis(image_path, 
-                       # Blackspot detection parameters
-                       blackspot_threshold, show_floor, show_blackspot,
-                       # Contrast detection parameters
-                       enable_contrast, backbone, contrast_method, contrast_threshold):
-    """
-    Perform integrated analysis with both blackspot detection and contrast analysis
-    """
-    # Read the image
-    im = cv2.imread(image_path)
-    if im is None:
-        return "Error: could not read image!", None, None, None
-    
-    # Resize for OneFormer if contrast analysis is enabled
-    if enable_contrast:
-        width = WIDTH_DICT["ade20k"]
-        im_resized = imutils.resize(im, width=width)
-    else:
-        im_resized = im
-    
-    # Part 1: Blackspot Detection with Mask R-CNN
-    blackspot_text = []
-    blackspot_viz = None
-    
-    if show_floor or show_blackspot:
-        weights_path = "./output_floor_blackspot/model_0004999.pth"
-        maskrcnn_predictor = load_maskrcnn_model(weights_path, device, blackspot_threshold)
-        
-        # Run blackspot detection
-        outputs = maskrcnn_predictor(im)
-        instances = outputs["instances"]
-        
-        # Post-process masks
-        floor_mask, blackspot_mask = postprocess_blackspot_masks(im, instances, show_floor, show_blackspot)
-        
-        # Create visualization
-        blackspot_overlay = im.copy()
-        overlay = np.zeros_like(im)
-        
-        if show_floor:
-            overlay[floor_mask > 0] = (0, 255, 0)  # Green for floor
-        if show_blackspot:
-            overlay[blackspot_mask > 0] = (0, 0, 255)  # Red for blackspot
-        
-        blackspot_overlay = cv2.addWeighted(im, 1.0, overlay, 0.5, 0)
-        blackspot_viz = Image.fromarray(cv2.cvtColor(blackspot_overlay, cv2.COLOR_BGR2RGB))
-        
-        # Calculate statistics
-        blackspot_area = int(blackspot_mask.sum())
-        floor_area = int(floor_mask.sum())
-        
-        blackspot_text.append(f"### Blackspot Detection Results")
-        blackspot_text.append(f"**Threshold:** {blackspot_threshold:.2f}")
-        
-        if show_floor:
-            blackspot_text.append(f"**Floor area:** {floor_area} pixels")
-        if show_blackspot:
-            blackspot_text.append(f"**Blackspot area:** {blackspot_area} pixels")
-            if floor_area > 0 and show_floor:
-                percentage = (blackspot_area / floor_area) * 100
-                blackspot_text.append(f"**Blackspot coverage:** {percentage:.2f}% of floor area")
-    
-    # Part 2: Contrast Analysis with OneFormer
-    segmentation_viz = None
-    contrast_viz = None
-    contrast_text = []
-    
-    if enable_contrast:
-        dataset = "ADE20K (150 classes)"
-        predictor = ONEFORMER_PREDICTORS[backbone][dataset]
-        metadata = ONEFORMER_METADATA[backbone][dataset]
-        
-        # Get segmentation
-        out, seg_mask = semantic_run(im_resized, predictor, metadata)
-        segmentation_viz = Image.fromarray(out.get_image())
-        
-        # Analyze contrast
-        img_rgb = cv2.cvtColor(im_resized, cv2.COLOR_BGR2RGB)
-        detector = CONTRAST_DETECTORS[contrast_method]
-        contrast_image, problem_areas, stats = detector.analyze(
-            img_rgb, seg_mask, contrast_threshold
-        )
-        
-        contrast_viz = Image.fromarray(contrast_image)
-        
-        # Create stats text
-        contrast_text.append(f"### Contrast Analysis Results")
-        contrast_text.append(f"**Method:** {contrast_method}")
-        contrast_text.append(f"**Threshold:** {contrast_threshold:.2f}")
-        contrast_text.append(f"**Problem Areas:** {stats['problem_count']}")
-        
-        if 'min_contrast' in stats:
-            contrast_text.append(f"**Min Contrast:** {stats['min_contrast']:.2f}")
-        if 'max_contrast' in stats:
-            contrast_text.append(f"**Max Contrast:** {stats['max_contrast']:.2f}")
-        if 'average_contrast' in stats:
-            contrast_text.append(f"**Average Contrast:** {stats['average_contrast']:.2f}")
-    
-    # Combine results
-    combined_text = []
-    if blackspot_text:
-        combined_text.extend(blackspot_text)
-    if contrast_text:
-        if blackspot_text:
-            combined_text.append("\n")
-        combined_text.extend(contrast_text)
-    
-    return "\n".join(combined_text), blackspot_viz, segmentation_viz, contrast_viz
-
-########################################
-# GRADIO INTERFACE
-########################################
-
-# Initialize models
-print("Initializing OneFormer models...")
-setup_oneformer_modules()
-
-title = "NeuroNest: Integrated Blackspot & Contrast Detection"
-description = """
-This integrated system combines:
-1. **Blackspot Detection**: Uses Mask R-CNN to detect blackspots on floors
-2. **Contrast Analysis**: Uses OneFormer segmentation to analyze contrast between objects
-
-Both analyses help identify potential accessibility issues for individuals with Alzheimer's disease.
-"""
-
-# Create the Gradio interface
-with gr.Blocks(title=title) as demo:
-    gr.Markdown(f"# {title}")
-    gr.Markdown(description)
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            # Input image
-            image_input = gr.Image(label="Input Image", type="filepath")
-            
-            # Blackspot detection controls
-            with gr.Accordion("Blackspot Detection Settings", open=True):
-                blackspot_threshold = gr.Slider(
-                    minimum=0.1, maximum=0.9, value=0.5, step=0.05,
-                    label="Blackspot Detection Threshold"
-                )
-                with gr.Row():
-                    show_floor = gr.Checkbox(value=True, label="Show Floor")
-                    show_blackspot = gr.Checkbox(value=True, label="Show Blackspots")
-            
-            # Contrast analysis controls
-            with gr.Accordion("Contrast Analysis Settings", open=True):
-                enable_contrast = gr.Checkbox(value=True, label="Enable Contrast Analysis")
-                backbone = gr.Radio(
-                    choices=["Swin-L", "DiNAT-L"], 
-                    value="Swin-L", 
-                    label="OneFormer Backbone"
-                )
-                contrast_method = gr.Radio(
-                    choices=["Luminance (WCAG)", "Hue", "Saturation", "Combined"],
-                    value="Luminance (WCAG)",
-                    label="Contrast Detection Method"
-                )
-                contrast_threshold = gr.Slider(
-                    minimum=1.0, maximum=10.0, value=4.5, step=0.1,
-                    label="Contrast Threshold"
-                )
-            
-            analyze_btn = gr.Button("Analyze", variant="primary")
-        
-        with gr.Column(scale=2):
-            # Output displays
-            with gr.Tabs():
-                with gr.Tab("Analysis Report"):
-                    analysis_text = gr.Textbox(label="Analysis Results", lines=10)
-                
-                with gr.Tab("Blackspot Detection"):
-                    blackspot_output = gr.Image(label="Blackspot Visualization")
-                
-                with gr.Tab("Segmentation"):
-                    segmentation_output = gr.Image(label="OneFormer Segmentation")
-                
-                with gr.Tab("Contrast Analysis"):
-                    contrast_output = gr.Image(label="Contrast Visualization")
-    
-    # Connect the interface
-    analyze_btn.click(
-        fn=integrated_analysis,
-        inputs=[
-            image_input,
-            blackspot_threshold, show_floor, show_blackspot,
-            enable_contrast, backbone, contrast_method, contrast_threshold
-        ],
-        outputs=[
-            analysis_text, blackspot_output, segmentation_output, contrast_output
-        ]
-    )
-    
-    # Examples
-    gr.Examples(
-        examples=[
-            ["examples/indoor_room.jpg", 0.5, True, True, True, "Swin-L", "Luminance (WCAG)", 4.5],
-            ["examples/living_room.jpg", 0.7, True, True, True, "DiNAT-L", "Combined", 3.0],
-        ],
-        inputs=[
-            image_input,
-            blackspot_threshold, show_floor, show_blackspot,
-            enable_contrast, backbone, contrast_method, contrast_threshold
-        ]
-    )
-
-if __name__ == "__main__":
-    print(f"Launching integrated NeuroNest app on device: {device}")
-    demo.queue().launch(server_name="0.0.0.0", share=True)

gradio_contrast.py

@@ -1,455 +0,0 @@
-import torch
-import os
-import sys
-import time
-import numpy as np
-from PIL import Image
-import cv2
-import imutils
-import colorsys
-from scipy import ndimage
-
-# Set CUDA device explicitly at the start
-if torch.cuda.is_available():
-    torch.cuda.set_device(0)  # Use first GPU
-    print(f"Using GPU: {torch.cuda.get_device_name(0)}")
-else:
-    print("WARNING: No GPU available, using CPU")
-
-print("Installed the dependencies!")
-
-from detectron2.config import get_cfg
-from detectron2.projects.deeplab import add_deeplab_config
-from detectron2.data import MetadataCatalog
-
-from oneformer import (
-    add_oneformer_config,
-    add_common_config,
-    add_swin_config,
-    add_dinat_config,
-)
-
-from demo.defaults import DefaultPredictor
-from demo.visualizer import Visualizer, ColorMode
-
-import gradio as gr
-from huggingface_hub import hf_hub_download
-
-# Force unbuffered output for SLURM logs
-sys.stdout = sys.__stdout__
-sys.stderr = sys.__stderr__
-
-# Set environment variables for better GPU performance
-os.environ['CUDA_LAUNCH_BLOCKING'] = '1'
-os.environ['TORCH_USE_CUDA_DSA'] = '1'
-
-# Contrast Detection Classes
-class ContrastDetector:
-    """Base class for contrast detection between segments"""
-    
-    @staticmethod
-    def calculate_luminance_contrast(color1, color2):
-        """Calculate WCAG luminance contrast ratio"""
-        def get_relative_luminance(rgb):
-            r, g, b = [val/255.0 for val in rgb]
-            r = r/12.92 if r <= 0.03928 else ((r + 0.055)/1.055) ** 2.4
-            g = g/12.92 if g <= 0.03928 else ((g + 0.055)/1.055) ** 2.4
-            b = b/12.92 if b <= 0.03928 else ((b + 0.055)/1.055) ** 2.4
-            return 0.2126 * r + 0.7152 * g + 0.0722 * b
-        
-        lum1 = get_relative_luminance(color1)
-        lum2 = get_relative_luminance(color2)
-        
-        lighter = max(lum1, lum2)
-        darker = min(lum1, lum2)
-        
-        return (lighter + 0.05) / (darker + 0.05)
-    
-    @staticmethod
-    def calculate_hue_contrast(color1, color2):
-        """Calculate hue difference between two colors"""
-        hsv1 = colorsys.rgb_to_hsv(color1[0]/255.0, color1[1]/255.0, color1[2]/255.0)
-        hsv2 = colorsys.rgb_to_hsv(color2[0]/255.0, color2[1]/255.0, color2[2]/255.0)
-        
-        hue_diff = abs(hsv1[0] - hsv2[0])
-        if hue_diff > 0.5:
-            hue_diff = 1 - hue_diff
-        
-        return hue_diff * 2
-    
-    @staticmethod
-    def calculate_saturation_contrast(color1, color2):
-        """Calculate saturation difference between two colors"""
-        hsv1 = colorsys.rgb_to_hsv(color1[0]/255.0, color1[1]/255.0, color1[2]/255.0)
-        hsv2 = colorsys.rgb_to_hsv(color2[0]/255.0, color2[1]/255.0, color2[2]/255.0)
-        
-        return abs(hsv1[1] - hsv2[1])
-    
-    @staticmethod
-    def analyze_contrast(image, segmentation, method="luminance", threshold=4.5):
-        """Analyze contrast between adjacent segments"""
-        unique_segments = np.unique(segmentation)
-        h, w = segmentation.shape
-        contrast_mask = np.zeros((h, w), dtype=bool)
-        problem_areas = []
-        
-        # Calculate average colors for each segment
-        segment_colors = {}
-        for seg_id in unique_segments:
-            mask = segmentation == seg_id
-            if np.any(mask):
-                segment_colors[seg_id] = np.mean(image[mask], axis=0).astype(int)
-        
-        # Check contrast between adjacent segments
-        for i in range(h):
-            for j in range(w):
-                current_seg = segmentation[i, j]
-                
-                # Check 4-connected neighbors
-                for di, dj in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
-                    ni, nj = i + di, j + dj
-                    if 0 <= ni < h and 0 <= nj < w:
-                        neighbor_seg = segmentation[ni, nj]
-                        
-                        if current_seg != neighbor_seg:
-                            color1 = segment_colors[current_seg]
-                            color2 = segment_colors[neighbor_seg]
-                            
-                            if method == "luminance":
-                                contrast = ContrastDetector.calculate_luminance_contrast(color1, color2)
-                            elif method == "hue":
-                                contrast = ContrastDetector.calculate_hue_contrast(color1, color2)
-                                threshold = 0.3  # Adjust threshold for hue
-                            elif method == "saturation":
-                                contrast = ContrastDetector.calculate_saturation_contrast(color1, color2)
-                                threshold = 0.3  # Adjust threshold for saturation
-                            
-                            if contrast < threshold:
-                                contrast_mask[i, j] = True
-                                problem_areas.append((current_seg, neighbor_seg, contrast))
-        
-        return contrast_mask, problem_areas, segment_colors
-
-# Rest of your code remains the same until setup_cfg function
-KEY_DICT = {"Cityscapes (19 classes)": "cityscapes",
-            "COCO (133 classes)": "coco",
-            "ADE20K (150 classes)": "ade20k",}
-
-SWIN_CFG_DICT = {"cityscapes": "configs/cityscapes/oneformer_swin_large_IN21k_384_bs16_90k.yaml",
-            "coco": "configs/coco/oneformer_swin_large_IN21k_384_bs16_100ep.yaml",
-            "ade20k": "configs/ade20k/oneformer_swin_large_IN21k_384_bs16_160k.yaml",}
-
-SWIN_MODEL_DICT = {"cityscapes": hf_hub_download(repo_id="shi-labs/oneformer_cityscapes_swin_large",
-                                            filename="250_16_swin_l_oneformer_cityscapes_90k.pth"),
-              "coco": hf_hub_download(repo_id="shi-labs/oneformer_coco_swin_large",
-                                            filename="150_16_swin_l_oneformer_coco_100ep.pth"),
-              "ade20k": hf_hub_download(repo_id="shi-labs/oneformer_ade20k_swin_large",
-                                            filename="250_16_swin_l_oneformer_ade20k_160k.pth")
-            }
-
-DINAT_CFG_DICT = {"cityscapes": "configs/cityscapes/oneformer_dinat_large_bs16_90k.yaml",
-            "coco": "configs/coco/oneformer_dinat_large_bs16_100ep.yaml",
-            "ade20k": "configs/ade20k/oneformer_dinat_large_IN21k_384_bs16_160k.yaml",}
-
-DINAT_MODEL_DICT = {"cityscapes": hf_hub_download(repo_id="shi-labs/oneformer_cityscapes_dinat_large",
-                                            filename="250_16_dinat_l_oneformer_cityscapes_90k.pth"),
-              "coco": hf_hub_download(repo_id="shi-labs/oneformer_coco_dinat_large",
-                                            filename="150_16_dinat_l_oneformer_coco_100ep.pth"),
-              "ade20k": hf_hub_download(repo_id="shi-labs/oneformer_ade20k_dinat_large",
-                                            filename="250_16_dinat_l_oneformer_ade20k_160k.pth")
-            }
-
-MODEL_DICT = {"DiNAT-L": DINAT_MODEL_DICT,
-        "Swin-L": SWIN_MODEL_DICT }
-
-CFG_DICT = {"DiNAT-L": DINAT_CFG_DICT,
-        "Swin-L": SWIN_CFG_DICT }
-
-WIDTH_DICT = {"cityscapes": 512,
-              "coco": 512,
-              "ade20k": 640}
-
-# Modified to ensure CUDA device
-if torch.cuda.is_available():
-    device = torch.device("cuda:0")
-    print(f"Using device: {device}")
-else:
-    device = torch.device("cpu")
-    print(f"WARNING: Using CPU device")
-
-cpu_device = torch.device("cpu")
-
-PREDICTORS = {
-    "DiNAT-L": {
-        "Cityscapes (19 classes)": None,
-        "COCO (133 classes)": None,
-        "ADE20K (150 classes)": None
-    },
-    "Swin-L": {
-        "Cityscapes (19 classes)": None,
-        "COCO (133 classes)": None,
-        "ADE20K (150 classes)": None
-    }
-}
-
-METADATA = {
-    "DiNAT-L": {
-        "Cityscapes (19 classes)": None,
-        "COCO (133 classes)": None,
-        "ADE20K (150 classes)": None
-    },
-    "Swin-L": {
-        "Cityscapes (19 classes)": None,
-        "COCO (133 classes)": None,
-        "ADE20K (150 classes)": None
-    }
-}
-
-def setup_modules():
-    print("Setting up modules...")
-    for dataset in ["Cityscapes (19 classes)", "COCO (133 classes)", "ADE20K (150 classes)"]:
-        for backbone in ["DiNAT-L", "Swin-L"]:
-            print(f"Loading {backbone} for {dataset}...")
-            cfg = setup_cfg(dataset, backbone)
-            metadata = MetadataCatalog.get(
-            cfg.DATASETS.TEST_PANOPTIC[0] if len(cfg.DATASETS.TEST_PANOPTIC) else "__unused"
-            )
-            if 'cityscapes_fine_sem_seg_val' in cfg.DATASETS.TEST_PANOPTIC[0]:
-                from cityscapesscripts.helpers.labels import labels
-                stuff_colors = [k.color for k in labels if k.trainId != 255]
-                metadata = metadata.set(stuff_colors=stuff_colors)
-
-            # Create predictor with explicit device
-            predictor = DefaultPredictor(cfg)
-            predictor.model.to(device)
-
-            PREDICTORS[backbone][dataset] = predictor
-            METADATA[backbone][dataset] = metadata
-            print(f"✓ Loaded {backbone} for {dataset}")
-    print("All modules setup complete!")
-
-def setup_cfg(dataset, backbone):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    add_deeplab_config(cfg)
-    add_common_config(cfg)
-    add_swin_config(cfg)
-    add_oneformer_config(cfg)
-    add_dinat_config(cfg)
-    dataset = KEY_DICT[dataset]
-    cfg_path = CFG_DICT[backbone][dataset]
-    cfg.merge_from_file(cfg_path)
-
-    # Explicitly set device to CUDA if available
-    if torch.cuda.is_available():
-        cfg.MODEL.DEVICE = 'cuda:0'
-        print(f"Config set to use CUDA device")
-    else:
-        cfg.MODEL.DEVICE = 'cpu'
-        print(f"Config set to use CPU device")
-
-    cfg.MODEL.WEIGHTS = MODEL_DICT[backbone][dataset]
-    cfg.freeze()
-    return cfg
-
-# Rest of your functions remain the same
-def panoptic_run(img, predictor, metadata):
-    visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, instance_mode=ColorMode.IMAGE)
-    predictions = predictor(img, "panoptic")
-    panoptic_seg, segments_info = predictions["panoptic_seg"]
-    out = visualizer.draw_panoptic_seg_predictions(
-        panoptic_seg.to(cpu_device), segments_info, alpha=0.5
-    )
-    visualizer_map = Visualizer(img[:, :, ::-1], is_img=False, metadata=metadata, instance_mode=ColorMode.IMAGE)
-    out_map = visualizer_map.draw_panoptic_seg_predictions(
-        panoptic_seg.to(cpu_device), segments_info, alpha=1, is_text=False
-    )
-    return out, out_map, predictions
-
-def instance_run(img, predictor, metadata):
-    visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, instance_mode=ColorMode.IMAGE)
-    predictions = predictor(img, "instance")
-    instances = predictions["instances"].to(cpu_device)
-    out = visualizer.draw_instance_predictions(predictions=instances, alpha=0.5)
-    visualizer_map = Visualizer(img[:, :, ::-1], is_img=False, metadata=metadata, instance_mode=ColorMode.IMAGE)
-    out_map = visualizer_map.draw_instance_predictions(predictions=instances, alpha=1, is_text=False)
-    return out, out_map, predictions
-
-def semantic_run(img, predictor, metadata):
-    visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, instance_mode=ColorMode.IMAGE)
-    predictions = predictor(img, "semantic")
-    out = visualizer.draw_sem_seg(
-        predictions["sem_seg"].argmax(dim=0).to(cpu_device), alpha=0.5
-    )
-    visualizer_map = Visualizer(img[:, :, ::-1], is_img=False, metadata=metadata, instance_mode=ColorMode.IMAGE)
-    out_map = visualizer_map.draw_sem_seg(
-        predictions["sem_seg"].argmax(dim=0).to(cpu_device), alpha=1, is_text=False
-    )
-    return out, out_map, predictions
-
-TASK_INFER = {"the task is panoptic": panoptic_run, "the task is instance": instance_run, "the task is semantic": semantic_run}
-
-def create_contrast_visualization(img, contrast_mask, problem_areas, segment_colors):
-    """Create visualization of contrast issues"""
-    # Copy original image
-    contrast_viz = img.copy()
-    
-    # Highlight low contrast boundaries
-    boundary_color = (255, 0, 0)  # Red for problem areas
-    contrast_viz[contrast_mask] = boundary_color
-    
-    # Add information overlay
-    info_text = f"Low contrast areas detected: {len(problem_areas)}"
-    cv2.putText(contrast_viz, info_text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
-    
-    return contrast_viz
-
-def segment_and_analyze(path, task, dataset, backbone, enable_contrast, contrast_method, contrast_threshold):
-    # Get predictions and segmentation visualization
-    predictor = PREDICTORS[backbone][dataset]
-    metadata = METADATA[backbone][dataset]
-    img = cv2.imread(path)
-    width = WIDTH_DICT[KEY_DICT[dataset]]
-    img = imutils.resize(img, width=width)
-    
-    out, out_map, predictions = TASK_INFER[task](img, predictor, metadata)
-    out_img = Image.fromarray(out.get_image())
-    out_map_img = Image.fromarray(out_map.get_image())
-    
-    if not enable_contrast:
-        return out_img, out_map_img, None, None
-    
-    # Extract segmentation mask from predictions
-    if task == "the task is semantic":
-        seg_mask = predictions["sem_seg"].argmax(dim=0).cpu().numpy()
-    elif task == "the task is panoptic":
-        seg_mask, _ = predictions["panoptic_seg"]
-        seg_mask = seg_mask.cpu().numpy()
-    elif task == "the task is instance":
-        # For instance segmentation, create a mask from instances
-        instances = predictions["instances"].to("cpu")
-        seg_mask = np.zeros(img.shape[:2], dtype=np.int32)
-        for i, mask in enumerate(instances.pred_masks):
-            seg_mask[mask] = i + 1
-    
-    # Analyze contrast
-    contrast_mask, problem_areas, segment_colors = ContrastDetector.analyze_contrast(
-        img, seg_mask, method=contrast_method, threshold=contrast_threshold
-    )
-    
-    # Create contrast visualization
-    contrast_viz = create_contrast_visualization(img, contrast_mask, problem_areas, segment_colors)
-    contrast_viz_img = Image.fromarray(contrast_viz[:, :, ::-1])  # Convert BGR to RGB
-    
-    # Generate analysis report
-    report = f"### Contrast Analysis Report\n\n"
-    report += f"**Method:** {contrast_method.capitalize()}\n"
-    report += f"**Threshold:** {contrast_threshold}\n"
-    report += f"**Total segments:** {len(segment_colors)}\n"
-    report += f"**Low contrast boundaries found:** {len(problem_areas)}\n\n"
-    
-    if problem_areas:
-        report += "**Problem Areas:**\n"
-        for i, (seg1, seg2, contrast_value) in enumerate(problem_areas[:10]):  # Show first 10
-            report += f"- Segments {seg1} and {seg2}: Contrast ratio = {contrast_value:.2f}\n"
-        if len(problem_areas) > 10:
-            report += f"... and {len(problem_areas) - 10} more\n"
-    
-    return out_img, out_map_img, contrast_viz_img, report
-
-title = "<h1 style='text-align: center'>OneFormer:DIEGO MENTORIA MILIONÁRIA - APP 1</h1>"
-description = "<p style='font-size: 14px; margin: 5px; font-weight: w300; text-align: center'> <a href='https://github.com/lolout1/sam2Contrast' style='text-decoration:none' target='_blank'>NeuroNest Contrast Model</a></p>" \
-            + "<p style='font-size: 16px; margin: 5px; font-weight: w600; text-align: center'> <a href='https://praeclarumjj3.github.io/oneformer/' target='_blank'>Project Page</a> | <a href='https://arxiv.org/abs/2211.06220' target='_blank'>ArXiv Paper</a> | <a href='https://github.com/SHI-Labs/OneFormer' target='_blank'>Github Repo</a></p>" \
-            + "<p style='text-align: center; margin: 5px; font-size: 14px; font-weight: w300;'>  \
-                This model leverages the OneFormer architecture to perform comprehensive image segmentation and labeling across multiple tasks. The system can identify and segment various objects, structures, and regions within images with high accuracy. It supports semantic, instance, and panoptic segmentation modes, enabling detailed analysis of indoor and outdoor environments. The model excels at distinguishing between different classes of objects, from common everyday items to complex urban structures, making it particularly useful for environmental analysis and scene understanding applications.\
-                </p>" \
-            + "<p style='text-align: center; font-size: 14px; margin: 5px; font-weight: w300;'> [Note: Inference on CPU may take upto 2 minutes. On a single RTX A6000 GPU, OneFormer is able to inference at more than 15 FPS.]</p>"
-
-# Main execution with error handling
-if __name__ == "__main__":
-    try:
-        print("Starting setup...")
-        setup_modules()
-
-        print("Creating Gradio interface...")
-        with gr.Blocks(title="OneFormer with Contrast Detection") as iface:
-            gr.Markdown(title)
-            gr.Markdown(description)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    input_image = gr.Image(label="Input Image", type="filepath")
-                    task = gr.Radio(
-                        choices=["the task is panoptic", "the task is instance", "the task is semantic"], 
-                        value="the task is panoptic", 
-                        label="Task Token Input"
-                    )
-                    dataset = gr.Radio(
-                        choices=["COCO (133 classes)", "Cityscapes (19 classes)", "ADE20K (150 classes)"], 
-                        value="COCO (133 classes)", 
-                        label="Model"
-                    )
-                    backbone = gr.Radio(
-                        choices=["DiNAT-L", "Swin-L"], 
-                        value="DiNAT-L", 
-                        label="Backbone"
-                    )
-                    
-                    with gr.Accordion("Contrast Detection Options", open=False):
-                        enable_contrast = gr.Checkbox(
-                            label="Enable Contrast Detection", 
-                            value=False
-                        )
-                        contrast_method = gr.Radio(
-                            choices=["luminance", "hue", "saturation"], 
-                            value="luminance", 
-                            label="Contrast Method"
-                        )
-                        contrast_threshold = gr.Slider(
-                            minimum=1.0, 
-                            maximum=10.0, 
-                            value=4.5, 
-                            step=0.1, 
-                            label="Contrast Threshold (WCAG AA is 4.5)"
-                        )
-                    
-                    submit_btn = gr.Button("Analyze", variant="primary")
-                
-                with gr.Column(scale=2):
-                    with gr.Tabs():
-                        with gr.TabItem("Segmentation Results"):
-                            seg_output = gr.Image(type="pil", label="Segmentation Overlay")
-                            seg_map = gr.Image(type="pil", label="Segmentation Map")
-                        
-                        with gr.TabItem("Contrast Analysis"):
-                            contrast_viz = gr.Image(type="pil", label="Contrast Visualization")
-                            contrast_report = gr.Markdown(label="Contrast Analysis Report")
-            
-            examples = [
-                ["examples/coco.jpeg", "the task is panoptic", "COCO (133 classes)", "DiNAT-L", False, "luminance", 4.5],
-                ["examples/cityscapes.png", "the task is panoptic", "Cityscapes (19 classes)", "DiNAT-L", False, "luminance", 4.5],
-                ["examples/ade20k.jpeg", "the task is panoptic", "ADE20K (150 classes)", "DiNAT-L", False, "luminance", 4.5]
-            ]
-            
-            gr.Examples(
-                examples=examples,
-                inputs=[input_image, task, dataset, backbone, enable_contrast, contrast_method, contrast_threshold],
-                outputs=[seg_output, seg_map, contrast_viz, contrast_report],
-                fn=segment_and_analyze,
-                cache_examples=False
-            )
-            
-            submit_btn.click(
-                fn=segment_and_analyze,
-                inputs=[input_image, task, dataset, backbone, enable_contrast, contrast_method, contrast_threshold],
-                outputs=[seg_output, seg_map, contrast_viz, contrast_report]
-            )
-
-        print("Launching Gradio app...")
-        iface.launch(server_name="0.0.0.0", server_port=7860, share=True)
-
-    except Exception as e:
-        print(f"Error occurred: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)

gradio_gpu.py

@@ -1,234 +0,0 @@
-import torch
-import numpy as np
-from PIL import Image
-import cv2
-import imutils
-import os
-import sys
-import time
-from detectron2.config import get_cfg
-from detectron2.projects.deeplab import add_deeplab_config
-from detectron2.data import MetadataCatalog
-from scipy import ndimage
-import colorsys
-import math
-
-torch.set_num_threads(16)
-torch.set_num_interop_threads(16)
-
-from oneformer import (
-    add_oneformer_config,
-    add_common_config,
-    add_swin_config,
-    add_dinat_config,
-)
-
-from demo.defaults import DefaultPredictor
-from demo.visualizer import Visualizer, ColorMode
-
-import gradio as gr
-from huggingface_hub import hf_hub_download
-
-# NeuroNest specific imports
-from utils.contrast_detector import ContrastDetector
-from utils.luminance_contrast import LuminanceContrastDetector
-from utils.hue_contrast import HueContrastDetector
-from utils.saturation_contrast import SaturationContrastDetector
-from utils.combined_contrast import CombinedContrastDetector
-
-KEY_DICT = {
-    "ADE20K (150 classes)": "ade20k",
-}
-
-SWIN_CFG_DICT = {
-    "ade20k": "configs/ade20k/oneformer_swin_large_IN21k_384_bs16_160k.yaml",
-}
-
-SWIN_MODEL_DICT = {
-    "ade20k": hf_hub_download(
-        repo_id="shi-labs/oneformer_ade20k_swin_large",
-        filename="250_16_swin_l_oneformer_ade20k_160k.pth"
-    )
-}
-
-DINAT_CFG_DICT = {
-    "ade20k": "configs/ade20k/oneformer_dinat_large_IN21k_384_bs16_160k.yaml",
-}
-
-DINAT_MODEL_DICT = {
-    "ade20k": hf_hub_download(
-        repo_id="shi-labs/oneformer_ade20k_dinat_large",
-        filename="250_16_dinat_l_oneformer_ade20k_160k.pth"
-    )
-}
-
-MODEL_DICT = {"DiNAT-L": DINAT_MODEL_DICT, "Swin-L": SWIN_MODEL_DICT}
-CFG_DICT = {"DiNAT-L": DINAT_CFG_DICT, "Swin-L": SWIN_CFG_DICT}
-WIDTH_DICT = {"ade20k": 640}
-
-cpu_device = torch.device("cpu")
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-print(f"Using device: {device}")
-
-PREDICTORS = {
-    "DiNAT-L": {"ADE20K (150 classes)": None},
-    "Swin-L": {"ADE20K (150 classes)": None}
-}
-
-METADATA = {
-    "DiNAT-L": {"ADE20K (150 classes)": None},
-    "Swin-L": {"ADE20K (150 classes)": None}
-}
-
-# Contrast detector mapping
-CONTRAST_DETECTORS = {
-    "Luminance (WCAG)": LuminanceContrastDetector(),
-    "Hue": HueContrastDetector(),
-    "Saturation": SaturationContrastDetector(),
-    "Combined": CombinedContrastDetector()
-}
-
-def setup_modules():
-    for dataset in ["ADE20K (150 classes)"]:
-        for backbone in ["DiNAT-L", "Swin-L"]:
-            cfg = setup_cfg(dataset, backbone)
-            metadata = MetadataCatalog.get(
-                cfg.DATASETS.TEST_PANOPTIC[0] if len(cfg.DATASETS.TEST_PANOPTIC) else "__unused"
-            )
-            PREDICTORS[backbone][dataset] = DefaultPredictor(cfg)
-            METADATA[backbone][dataset] = metadata
-
-def setup_cfg(dataset, backbone):
-    cfg = get_cfg()
-    add_deeplab_config(cfg)
-    add_common_config(cfg)
-    add_swin_config(cfg)
-    add_oneformer_config(cfg)
-    add_dinat_config(cfg)
-    dataset = KEY_DICT[dataset]
-    cfg_path = CFG_DICT[backbone][dataset]
-    cfg.merge_from_file(cfg_path)
-    cfg.MODEL.DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
-    cfg.MODEL.WEIGHTS = MODEL_DICT[backbone][dataset]
-    cfg.freeze()
-    return cfg
-
-def semantic_run(img, predictor, metadata):
-    visualizer = Visualizer(img[:, :, ::-1], metadata=metadata, instance_mode=ColorMode.IMAGE)
-    predictions = predictor(img, "semantic")
-    out = visualizer.draw_sem_seg(
-        predictions["sem_seg"].argmax(dim=0).to(cpu_device), alpha=0.5
-    )
-    return out, predictions["sem_seg"].argmax(dim=0).to(cpu_device).numpy()
-
-def analyze_contrast(image, segmentation, contrast_method, threshold):
-    """Analyze contrast between segments using selected method"""
-    detector = CONTRAST_DETECTORS[contrast_method]
-    
-    # Perform contrast analysis
-    contrast_image, problem_areas, stats = detector.analyze(
-        image, segmentation, threshold
-    )
-    
-    return contrast_image, problem_areas, stats
-
-def segment_and_analyze_contrast(path, backbone, contrast_method, threshold):
-    """Main function to segment and analyze contrast"""
-    dataset = "ADE20K (150 classes)"
-    predictor = PREDICTORS[backbone][dataset]
-    metadata = METADATA[backbone][dataset]
-    
-    # Read and resize image
-    img = cv2.imread(path)
-    if img is None:
-        return None, None, "Error: Could not load image"
-    
-    width = WIDTH_DICT[KEY_DICT[dataset]]
-    img = imutils.resize(img, width=width)
-    
-    # Get segmentation
-    out, seg_mask = semantic_run(img, predictor, metadata)
-    out_img = Image.fromarray(out.get_image())
-    
-    # Analyze contrast
-    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    contrast_img, problem_areas, stats = analyze_contrast(
-        img_rgb, seg_mask, contrast_method, threshold
-    )
-    
-    # Create stats text
-    stats_text = f"### Contrast Analysis Results\n\n"
-    stats_text += f"**Method:** {contrast_method}\n"
-    stats_text += f"**Threshold:** {threshold:.2f}\n"
-    stats_text += f"**Problem Areas:** {stats['problem_count']}\n"
-    
-    if 'min_contrast' in stats:
-        stats_text += f"**Min Contrast:** {stats['min_contrast']:.2f}\n"
-    if 'max_contrast' in stats:
-        stats_text += f"**Max Contrast:** {stats['max_contrast']:.2f}\n"
-    if 'average_contrast' in stats:
-        stats_text += f"**Average Contrast:** {stats['average_contrast']:.2f}\n"
-    
-    # Convert contrast image to PIL
-    contrast_pil = Image.fromarray(contrast_img)
-    
-    return out_img, contrast_pil, stats_text
-
-# Initialize models
-setup_modules()
-
-# Gradio Interface
-title = "<h1 style='text-align: center'>NeuroNest: Abheek Pradhan - Contrast Model</h1>"
-description = "<p style='font-size: 16px; margin: 5px; font-weight: w600; text-align: center'> "\
-              "<a href='https://github.com/lolout1/sam2Contrast' target='_blank'>Github Repo</a></p>" \
-              "<p style='text-align: center; margin: 5px; font-size: 14px; font-weight: w300;'>" \
-              "I am developing NeuroNest, a contrast detection system designed to identify areas with insufficient contrast " \
-              "for individuals with Alzheimer's disease. This tool leverages OneFormer's state-of-the-art segmentation " \
-              "capabilities trained on ADE20K dataset to detect indoor objects like floors, furniture, walls, and ceilings. " \
-              "By analyzing contrast ratios between adjacent segments, NeuroNest flags potential visual accessibility issues " \
-              "that may trigger confusion or disorientation in elderly individuals with cognitive impairments.</p>" \
-              "<p style='text-align: center; font-size: 14px; margin: 5px; font-weight: w300;'>" \
-              "[Note: When running on my Linux cluster, please request a GPU node for optimal performance. " \
-              "On login nodes, CUDA may not be available.]</p>"
-
-gradio_inputs = [
-    gr.Image(label="Input Image", type="filepath"),
-    gr.Radio(choices=["Swin-L", "DiNAT-L"], value="Swin-L", label="Backbone"),
-    gr.Radio(
-        choices=["Luminance (WCAG)", "Hue", "Saturation", "Combined"],
-        value="Luminance (WCAG)",
-        label="Contrast Detection Method"
-    ),
-    gr.Slider(
-        minimum=1.0,
-        maximum=10.0,
-        value=4.5,
-        step=0.1,
-        label="Contrast Threshold (Lower = More Strict)"
-    )
-]
-
-gradio_outputs = [
-    gr.Image(type="pil", label="Segmentation Result"),
-    gr.Image(type="pil", label="Contrast Analysis"),
-    gr.Markdown(label="Analysis Results")
-]
-
-examples = [
-    ["examples/indoor_room.jpg", "Swin-L", "Luminance (WCAG)", 4.5],
-    ["examples/living_room.jpg", "DiNAT-L", "Combined", 3.0],
-]
-
-iface = gr.Interface(
-    fn=segment_and_analyze_contrast,
-    inputs=gradio_inputs,
-    outputs=gradio_outputs,
-    examples_per_page=5,
-    allow_flagging="never",
-    examples=examples,
-    title=title,
-    description=description
-)
-
-if __name__ == "__main__":
-    iface.launch(server_name="0.0.0.0", share=True)