Added streamlit app with dataset viewer tab

Author: SakhinetiPraveena

app.py

@@ -0,0 +1,18 @@
+import streamlit as st
+from tabs.dataset_viewer import dataset_viewer_tab
+from tabs.inference import inference_tab
+from tabs.evaluator import evaluator_tab
+
+st.set_page_config(page_title="DetectionMetrics", layout="wide")
+
+# st.title("DetectionMetrics")
+
+PAGES = {
+    "Dataset Viewer": dataset_viewer_tab,
+    "Inference": inference_tab,
+    "Evaluator": evaluator_tab
+}
+
+page = st.sidebar.radio("DetectionMetrics", list(PAGES.keys()))
+
+PAGES[page]() 

detectionmetrics/datasets/__init__.py

@@ -16,7 +16,7 @@
 )
 from detectionmetrics.datasets.rugd import RUGDImageSegmentationDataset
 from detectionmetrics.datasets.wildscenes import WildscenesImageSegmentationDataset
-
+from detectionmetrics.datasets.coco import CocoDataset
 
 REGISTRY = {
     "gaia_image_segmentation": GaiaImageSegmentationDataset,
@@ -29,4 +29,5 @@
     "rellis3d_lidar_segmentation": Rellis3DLiDARSegmentationDataset,
     "rugd_image_segmentation": RUGDImageSegmentationDataset,
     "wildscenes_image_segmentation": WildscenesImageSegmentationDataset,
+    "coco_image_detection": CocoDataset,
 }

detectionmetrics/datasets/coco.py

@@ -72,11 +72,11 @@ def __init__(self, annotation_file: str, image_dir: str):
 
         super().__init__(dataset=dataset, dataset_dir=image_dir, ontology=ontology)
 
-    def read_annotation(self, fname: str) -> Tuple[List[List[float]], List[int]]:
-        """Return bounding boxes and labels for a given image ID.
+    def read_annotation(self, fname: str) -> Tuple[List[List[float]], List[int], List[int]]:
+        """Return bounding boxes, labels, and category_ids for a given image ID.
 
         :param fname: str (image_id in string form)
-        :return: Tuple of (boxes, labels)
+        :return: Tuple of (boxes, labels, category_ids)
         """
         # Extract image ID (fname might be a path or ID string)
         try:
@@ -89,12 +89,14 @@ def read_annotation(self, fname: str) -> Tuple[List[List[float]], List[int]]:
 
         boxes = []
         labels = []
+        category_ids = []
 
         for ann in anns:
             # Convert [x, y, width, height] to [x1, y1, x2, y2]
             x, y, w, h = ann["bbox"]
             boxes.append([x, y, x + w, y + h])
             labels.append(ann["category_id"])
+            category_ids.append(ann["category_id"])
 
-        return boxes, labels
+        return boxes, labels, category_ids
 

pyproject.toml

@@ -23,6 +23,9 @@ click = "^8.1.8"
 tensorboard = "^2.18.0"
 pycocotools = { version = "^2.0.7", markers = "sys_platform != 'win32'" }
 pycocotools-windows = { version = "^2.0.0.2", markers = "sys_platform == 'win32'" }
+Streamlit = "1.46.0"
+streamlit-image-select = "^0.6.0"
+supervision = "^0.18.0"
 
 
 [tool.poetry.group.dev.dependencies]

tabs/dataset_viewer.py

@@ -0,0 +1,273 @@
+import streamlit as st
+import os
+import sys
+import subprocess
+from streamlit_image_select import image_select
+
+def browse_folder():
+    """
+    Opens a native folder selection dialog and returns the selected folder path.
+    Works on Windows, macOS, and Linux (with zenity or kdialog).
+    Returns None if cancelled or error.
+    """
+    try:
+        if sys.platform.startswith("win"):
+            script = (
+                'Add-Type -AssemblyName System.windows.forms;'
+                '$f=New-Object System.Windows.Forms.FolderBrowserDialog;'
+                'if($f.ShowDialog() -eq "OK"){Write-Output $f.SelectedPath}'
+            )
+            result = subprocess.run(
+                ["powershell", "-NoProfile", "-Command", script],
+                capture_output=True, text=True, timeout=30
+            )
+            folder = result.stdout.strip()
+            return folder if folder else None
+        elif sys.platform == "darwin":
+            script = 'POSIX path of (choose folder with prompt "Select dataset folder:")'
+            result = subprocess.run(
+                ["osascript", "-e", script],
+                capture_output=True, text=True, timeout=30
+            )
+            folder = result.stdout.strip()
+            return folder if folder else None
+        else:
+            # Linux: try zenity, then kdialog
+            for cmd in [
+                ["zenity", "--file-selection", "--directory", "--title=Select dataset folder"],
+                ["kdialog", "--getexistingdirectory", "--title", "Select dataset folder"]
+            ]:
+                try:
+                    result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+                    folder = result.stdout.strip()
+                    if folder:
+                        return folder
+                except Exception:
+                    continue
+            return None
+    except Exception:
+        return None
+
+def dataset_viewer_tab():
+    from detectionmetrics.datasets.coco import CocoDataset
+
+    st.header("Dataset Viewer")
+    col1, col2, col3 = st.columns([1, 4, 1])
+
+    # Initialize session state for dataset_path
+    st.session_state.setdefault("dataset_path", "")
+
+    with col1:
+        dataset_type = st.selectbox("Type", ["Coco", "Custom"], key="dataset_type_selectbox")
+    with col2:
+        dataset_path = st.text_input(
+            "Dataset Folder Path",
+            value=st.session_state["dataset_path"],
+            key="dataset_path_input"
+        )
+    with col3:
+        st.markdown("<div style='height: 1.6rem;'></div>", unsafe_allow_html=True)
+        if st.button("Browse", key="browse_button"):
+            folder = browse_folder()
+            if folder and os.path.isdir(folder):
+                st.session_state["dataset_path"] = folder
+                st.rerun()
+            elif folder is not None:
+                st.warning("Selected path is not a valid folder.")
+
+    # Sync session state with text input
+    if dataset_path != st.session_state["dataset_path"]:
+        st.session_state["dataset_path"] = dataset_path
+    dataset_path = st.session_state["dataset_path"]
+
+    if not dataset_path:
+        return
+
+    if not os.path.isdir(dataset_path):
+        st.error("Invalid folder path.")
+        return
+
+    split = st.selectbox("Select dataset split", ["train", "val"], key="split_selectbox")
+
+    # Assign img_dir and ann_file based on split and dataset_type
+    if dataset_type.lower() == "coco":
+        img_dir = os.path.join(dataset_path, f"images/{split}2017")
+        ann_file = os.path.join(dataset_path, "annotations", f"instances_{split}2017.json")
+    else:
+        img_dir = os.path.join(dataset_path, split)
+        ann_file = os.path.join(dataset_path, "annotations", f"{split}.json")
+
+    # Instantiate dataset class after getting img_dir and ann_file
+    dataset = None
+    if dataset_type.lower() == "coco":
+        if os.path.isdir(img_dir) and os.path.isfile(ann_file):
+            try:
+                dataset = CocoDataset(annotation_file=ann_file, image_dir=img_dir)
+            except Exception as e:
+                st.error(f"Failed to load COCO dataset: {e}")
+                return
+        else:
+            if not os.path.isdir(img_dir):
+                st.warning("Image directory does not exist.")
+            elif not os.path.isfile(ann_file):
+                st.write(ann_file)
+                st.warning("Annotation file does not exist.")
+            return
+    else:
+        if not os.path.isdir(img_dir):
+            st.warning("Image directory does not exist.")
+            return
+        if not os.path.isfile(ann_file):
+            st.warning("Annotation file does not exist.")
+            return
+        # Placeholder for custom dataset class instantiation
+        # dataset = CustomDataset(annotation_file=ann_file, image_dir=img_dir)
+
+    if dataset is None:
+        # If dataset instantiation failed or not implemented, stop here
+        return
+
+    # Use dataset.dataset (the DataFrame) to get image file names
+    image_files = [f for f in os.listdir(img_dir) if f.lower().endswith((".jpg", ".jpeg", ".png"))]
+    if not image_files:
+        st.warning("No images found in the selected folder.")
+        return
+
+    # --- Begin Pagination Logic ---
+    IMAGES_PER_PAGE = 12
+    total_images = len(image_files)
+    total_pages = (total_images + IMAGES_PER_PAGE - 1) // IMAGES_PER_PAGE
+
+    # Use a unique key for session state based on dataset_path and split
+    page_key = f"image_page_{dataset_path}_{split}"
+    if page_key not in st.session_state:
+        st.session_state[page_key] = 0
+    current_page = st.session_state[page_key]
+
+    # Clamp current_page to valid range
+    if current_page < 0:
+        current_page = 0
+        st.session_state[page_key] = 0
+    if current_page > total_pages - 1:
+        current_page = total_pages - 1
+        st.session_state[page_key] = total_pages - 1
+
+    start_idx = current_page * IMAGES_PER_PAGE
+    end_idx = min(start_idx + IMAGES_PER_PAGE, total_images)
+    sample_images = image_files[start_idx:end_idx]
+    image_paths = [os.path.join(img_dir, img_name) for img_name in sample_images]
+    # --- End Pagination Logic ---
+
+    # Inject CSS to make images in the grid smaller (fallback for image_select)
+    st.markdown(
+        """
+        <style>
+        .image-selector__image, .image-selector__image img {
+            max-width: 40px ;
+            max-height: 40px ;
+            width:40px ;
+            height: 40px ;
+            object-fit: contain ;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    # Add navigation buttons and image_select in a horizontal layout
+    nav_col1, nav_col2, nav_col3 = st.columns([1, 8, 1])
+    with nav_col1:
+        if st.button("⟨", key="prev_page_btn", disabled=(current_page == 0)):
+            st.session_state[page_key] = max(0, current_page - 1)
+            st.rerun()
+    with nav_col2:
+        st.markdown(
+            f"<div style='text-align:center;font-weight:bold;'>Select an image (Page {current_page+1} of {total_pages})</div>",
+            unsafe_allow_html=True,
+        )
+    with nav_col3:
+        if st.button("⟩", key="next_page_btn", disabled=(current_page >= total_pages - 1)):
+            st.session_state[page_key] = min(total_pages - 1, current_page + 1)
+            st.rerun()
+
+    # Show all images in the current page in a single image_select, then display below
+    selected_img_path = image_select(
+        label="",
+        images=image_paths,
+        captions=sample_images,
+        use_container_width=True,
+        key=f"img_select_all_{current_page}"
+    ) if image_paths else None
+
+    if selected_img_path is not None:
+        selected_img_name = os.path.basename(selected_img_path)
+        try:
+            import supervision as sv
+            import numpy as np
+            from PIL import Image
+
+            img = Image.open(selected_img_path).convert("RGB")
+            img_np = np.array(img)
+
+            ann_row = dataset.dataset[dataset.dataset["image"] == selected_img_name]
+            if not ann_row.empty:
+                annotation_id = ann_row.iloc[0]["annotation"]
+                boxes, labels, category_ids = dataset.read_annotation(annotation_id)
+
+                # Get ontology for color coding and class name mapping
+                ontology = getattr(dataset, "ontology", None)
+                if ontology is None and hasattr(dataset.dataset, "attrs"):
+                    ontology = dataset.dataset.attrs.get("ontology", None)
+
+                # Prepare class names and unique class names
+                if ontology is not None:
+                    catid_to_name = {v["idx"]: k for k, v in ontology.items()}
+                    class_names = [catid_to_name.get(cat_id, str(cat_id)) for cat_id in category_ids]
+                else:
+                    class_names = [str(cat_id) for cat_id in category_ids]
+                unique_class_names = list({name for name in class_names})
+
+                from supervision.draw.color import ColorPalette
+                from supervision.detection.annotate import BoxAnnotator
+                from supervision.detection.core import Detections
+
+                palette = ColorPalette.default()
+                class_name_to_color = {name: palette.by_idx(i) for i, name in enumerate(unique_class_names)}
+                box_colors = [class_name_to_color[name] for name in class_names]
+
+                # Prepare detections for supervision
+                xyxy = np.array(boxes)
+                class_id = np.array(category_ids)  # Use integer category IDs
+
+                detections = Detections(
+                    xyxy=xyxy,
+                    class_id=class_id
+                )
+                # Annotate with class names (not just IDs) using the labels argument
+                annotator = BoxAnnotator(color=palette, text_scale=0.7, text_thickness=1, text_padding=2)
+                annotated_img = annotator.annotate(
+                    scene=img_np,
+                    detections=detections,
+                    labels=[f"{name}" for name in class_names]
+                )
+
+                # Resize the annotated image to a uniform, smaller size for display
+                from PIL import Image as PILImage
+                max_display_width = 500  # px, adjust as needed for your UI
+                max_display_height = 500  # px, adjust as needed for your UI
+
+                # Convert numpy array back to PIL Image for resizing
+                annotated_pil = PILImage.fromarray(annotated_img)
+                # Use "Resampling.LANCZOS" for Pillow >= 10, fallback to "LANCZOS" for older
+                try:
+                    resample = getattr(PILImage, "Resampling", PILImage).LANCZOS
+                except AttributeError:
+                    resample = PILImage.LANCZOS
+                annotated_pil.thumbnail((max_display_width, max_display_height), resample)
+                st.image(annotated_pil, use_container_width=False)
+            else:
+                st.warning("No annotation found for this image.")
+        except Exception as e:
+            st.write(f"Error displaying annotated image: {e}")
+    else:
+        st.info("Select an image to view with annotations.")

tabs/evaluator.py

@@ -0,0 +1,13 @@
+import streamlit as st
+import os
+
+def evaluator_tab():
+    st.header("Evaluator")
+    dataset_path = st.text_input("Enter dataset folder path for evaluation:")
+    model_path = st.text_input("Enter model file path for evaluation:")
+    if st.button("Run Evaluation"):
+        if os.path.isdir(dataset_path) and os.path.isfile(model_path):
+            # Placeholder for evaluation logic and metrics display
+            st.success("Evaluation complete. Metrics will be shown here.")
+        else:
+            st.error("Invalid dataset or model path.") 

tabs/inference.py

@@ -0,0 +1,14 @@
+import streamlit as st
+import os
+
+def inference_tab():
+    st.header("Inference")
+    model_path = st.text_input("Enter model file path:")
+    image_path = st.text_input("Enter image file path:")
+    if st.button("Run Inference"):
+        if os.path.isfile(model_path) and os.path.isfile(image_path):
+            st.image(image_path, caption="Input Image")
+            # Placeholder for model inference and prediction display
+            st.info("Prediction results will be shown here.")
+        else:
+            st.error("Invalid model or image file path.")