Create parsing_code.py

parsing_code.py

@@ -0,0 +1,233 @@
+import os
+import json
+import fiftyone as fo
+from PIL import Image
+from pathlib import Path
+
+def load_sample_files(subdir):
+    """
+    Load all required files for a single sample.
+    
+    Args:
+        subdir (Path): Path to the sample subdirectory
+        
+    Returns:
+        tuple: (detections_data, questions_data, mask_file_path, source_file_path, img_dimensions)
+        Returns None if any required files are missing.
+    """
+    subdir_name = subdir.name
+    
+    # Define file paths
+    detection_file = subdir / "detection.json"
+    question_file = subdir / "question.json"
+    mask_file = subdir / f"mask_{subdir_name}.png"
+    source_file = subdir / f"source_{subdir_name}.jpg"
+    
+    # Check all files exist
+    if not all(f.exists() for f in [detection_file, question_file, mask_file, source_file]):
+        return None
+    
+    # Load JSON data
+    with open(detection_file, 'r') as f:
+        detections_data = json.load(f)
+    
+    with open(question_file, 'r') as f:
+        questions_data = json.load(f)
+    
+    # Get image dimensions
+    with Image.open(source_file) as img:
+        img_dimensions = img.size
+    
+    return detections_data, questions_data, mask_file, source_file, img_dimensions
+
+def convert_detections_to_relative(detections_data, img_width, img_height):
+    """
+    Convert absolute bounding boxes to relative coordinates for FiftyOne.
+    
+    Args:
+        detections_data (list): List of detection dictionaries
+        img_width (int): Image width in pixels
+        img_height (int): Image height in pixels
+        
+    Returns:
+        fo.Detections: FiftyOne Detections object
+    """
+    detections = []
+    
+    for detection_dict in detections_data:
+        for label, bbox in detection_dict.items():
+            x, y, width, height = bbox
+            # Convert to relative coordinates
+            rel_x = x / img_width
+            rel_y = y / img_height
+            rel_width = width / img_width
+            rel_height = height / img_height
+            
+            detection = fo.Detection(
+                label=label,
+                bounding_box=[rel_x, rel_y, rel_width, rel_height]
+            )
+            detections.append(detection)
+    
+    return fo.Detections(detections=detections)
+
+def add_sample_metadata(sample, english_questions):
+    """
+    Add sample-level metadata from questions data.
+    
+    Args:
+        sample (fo.Sample): FiftyOne sample to modify
+        english_questions (list): List of English question dictionaries
+    """
+    if not english_questions:
+        return
+    
+    # Sample-level metadata (same for all questions in a sample)
+    first_question = english_questions[0]
+    sample['location'] = fo.Classification(label=first_question['location'])
+    sample['modality'] = fo.Classification(label=first_question['modality'])
+    sample['base_type'] = fo.Classification(label=first_question['base_type'])
+    sample['answer_type'] = fo.Classification(label=first_question['answer_type'])
+
+def add_questions_and_answers(sample, english_questions):
+    """
+    Add individual questions and answers to the sample.
+    
+    Args:
+        sample (fo.Sample): FiftyOne sample to modify
+        english_questions (list): List of English question dictionaries
+    """
+    for i, q_data in enumerate(english_questions):
+        sample[f'question_{i}'] = q_data['question']
+        sample[f'answer_{i}'] = fo.Classification(label=q_data['answer'])
+
+def process_single_sample(subdir):
+    """
+    Process a single sample directory into a FiftyOne sample.
+    
+    Args:
+        subdir (Path): Path to the sample subdirectory
+        
+    Returns:
+        fo.Sample or None: FiftyOne sample, or None if processing failed
+    """
+    subdir_name = subdir.name
+    
+    # Load all files for this sample
+    file_data = load_sample_files(subdir)
+    if file_data is None:
+        print(f"Warning: Missing files in {subdir_name}, skipping...")
+        return None
+    
+    detections_data, questions_data, mask_file, source_file, (img_width, img_height) = file_data
+    
+    # Create FiftyOne sample
+    sample = fo.Sample(filepath=str(source_file.absolute()))
+    
+    # Add detections
+    sample['detections'] = convert_detections_to_relative(detections_data, img_width, img_height)
+    
+    # Add segmentation mask
+    sample['segmentation'] = fo.Segmentation(mask_path=str(mask_file.absolute()))
+    
+    # Filter to English questions only and preserve order
+    english_questions = [q for q in questions_data if q.get('q_lang') == 'en']
+    
+    # Add sample-level metadata
+    add_sample_metadata(sample, english_questions)
+    
+    # Add individual questions and answers
+    add_questions_and_answers(sample, english_questions)
+    
+    return sample
+
+def parse_slake_dataset(data_root="SLAKE/imgs", dataset_name="SLAKE"):
+    """
+    Parse SLAKE dataset into FiftyOne format.
+    
+    Args:
+        data_root (str): Path to the SLAKE/imgs directory
+        dataset_name (str): Name for the FiftyOne dataset
+    
+    Returns:
+        fo.Dataset: FiftyOne dataset with parsed samples
+    """
+    dataset = fo.Dataset(dataset_name, overwrite=True)
+    
+    data_root = Path(data_root)
+    samples = []
+    
+    # Process each subdirectory
+    for subdir in data_root.iterdir():
+        if not subdir.is_dir():
+            continue
+            
+        print(f"Processing {subdir.name}...")
+        sample = process_single_sample(subdir)
+        
+        if sample is not None:
+            samples.append(sample)
+    
+    # Add all samples to dataset efficiently
+    dataset.add_samples(samples)
+    dataset.compute_metadata()
+    
+    return dataset
+
+import fiftyone as fo
+from pathlib import Path
+
+def load_mask_targets_from_file(mask_targets_file):
+    """
+    Load mask targets mapping from file.
+    
+    Args:
+        mask_targets_file (str): Path to the mask targets file
+        
+    Returns:
+        dict: Mapping of pixel values to organ labels
+    """
+    mask_targets = {}
+    
+    with open(mask_targets_file, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if ':' in line:
+                pixel_value, label = line.split(':', 1)
+                mask_targets[int(pixel_value)] = label
+    
+    return mask_targets
+
+def set_dataset_mask_targets(dataset_name, mask_targets_file, segmentation_field="segmentation"):
+    """
+    Set mask targets for an existing FiftyOne dataset.
+    
+    Args:
+        dataset_name (str): Name of the FiftyOne dataset
+        mask_targets_file (str): Path to the mask targets mapping file
+        segmentation_field (str): Name of the segmentation field (default: "segmentation")
+    """
+    # Load dataset
+    dataset = fo.load_dataset(dataset_name)
+    
+    # Load mask targets from file
+    mask_targets = load_mask_targets_from_file(mask_targets_file)
+    
+    # Set mask targets
+    dataset.mask_targets = {segmentation_field: mask_targets}
+    dataset.save()  # Must save after setting mask targets
+
+    for i, (pixel_val, label) in enumerate(list(mask_targets.items())[:5]):
+        print(f"  {pixel_val}: {label}")
+    if len(mask_targets) > 5:
+        print(f"  ... and {len(mask_targets) - 5} more")
+
+
+
+dataset = parse_slake_dataset("SLAKE/imgs", "SLAKE")
+
+set_dataset_mask_targets(
+    dataset_name="SLAKE",  # Your dataset name
+    mask_targets_file="SLAKE/mask.txt",  # Your mapping file
+    segmentation_field="segmentation"
+)