Add files using upload-large-folder tool

RUSCHN/extract_unique_questions.py

@@ -0,0 +1,195 @@
+import json
+import os
+import random
+import csv
+from typing import List, Dict
+from PIL import Image
+
+
+def get_random_image_path(answer: str) -> str:
+    """
+    Get a random image path from the appropriate subdirectory based on the answer.
+    Each answer type corresponds to a specific subdirectory in RUSCHN/images/.
+    For 'x_ray.', it searches in the main RUSCHN/images directory.
+    Images are located in numbered subdirectories (e.g., RUSCHN/images/DIP/1/).
+    Ensures that no image is reused from the original dataset.
+    """
+    # Map answer to directory path
+    answer_to_dir = {
+        'Distal Interphalangeal': 'RUSCHN/images/DIP',
+        'First Distal Interphalangeal': 'RUSCHN/images/DIPFirst',
+        'First Metacarpophalangeal': 'RUSCHN/images/MCPFirst',
+        'First Proximal Interphalangeal': 'RUSCHN/images/PIPFirst',
+        'Metacarpophalangeal': 'RUSCHN/images/MCP',
+        'Middle Interphalangeal': 'RUSCHN/images/MIP',
+        'Proximal Interphalangeal': 'RUSCHN/images/PIP',
+        'Radius': 'RUSCHN/images/Radius',
+        'Ulna': 'RUSCHN/images/Ulna',
+        'x_ray.': 'RUSCHN/images'
+    }
+
+    if answer not in answer_to_dir:
+        raise ValueError(f"Unknown answer type: {answer}")
+    
+    # Load existing image filenames from the original JSON file
+    with open('Original_open/RUS CHN.json', 'r') as f:
+        original_data = json.load(f)
+    
+    # Create sets of both full paths and base filenames from original data
+    used_full_paths = {item['image_path'] for item in original_data}
+    used_filenames = {os.path.basename(item['image_path']).split('.')[0] for item in original_data}
+
+    # Get all images from the appropriate directory
+    image_dir = answer_to_dir[answer]
+    all_images = []
+    
+    def collect_images_from_dir(directory):
+        """Helper function to recursively collect all PNG files from a directory and its subdirectories."""
+        for item in os.listdir(directory):
+            item_path = os.path.join(directory, item)
+            if os.path.isdir(item_path):
+                collect_images_from_dir(item_path)
+            elif item.endswith('.png'):
+                # Get the relative path from the base image directory
+                rel_path = os.path.relpath(item_path, image_dir)
+                all_images.append(rel_path)
+
+    # Collect all images from the directory structure
+    collect_images_from_dir(image_dir)
+    
+    # Filter out already used images
+    matching_images = []
+    for img in all_images:
+        base_name = os.path.basename(img).split('.')[0]  # Remove .png extension
+        full_path = f"{image_dir}/{img}"
+        
+        # Check both the base filename and full path to ensure uniqueness
+        if base_name not in used_filenames and full_path not in used_full_paths:
+            matching_images.append(img)
+
+    if not matching_images:
+        raise ValueError(f"No unused images found for answer: {answer}")
+
+    # Select a random image from matching ones
+    chosen_file = random.choice(matching_images)
+    return f"{image_dir}/{chosen_file}"
+
+def extract_unique_questions(json_data: List[Dict]) -> Dict[str, Dict]:
+    """
+    Extract unique questions from the JSON data where questions with different answers are considered different.
+    Saves the complete original question item for each unique question.
+    
+    Args:
+        json_data (List[Dict]): List of dictionaries containing question data
+        
+    Returns:
+        Dict[str, Dict]: Dictionary mapping unique questions to their complete original items
+    """
+    unique_questions = {}
+    
+    for item in json_data:
+        question = item['question']
+        answer = item['gt_answer']
+        
+        # Create a key that combines question and answer to ensure uniqueness
+        key = f"{question}|{answer}"
+        
+        if key not in unique_questions:
+            # Create a copy of the item to avoid modifying the original
+            new_item = item.copy()
+            # Replace the image path with a random one based on the answer
+            new_item['image_path'] = get_random_image_path(answer)
+            unique_questions[key] = new_item
+    
+    return unique_questions
+
+def extend_to_100_questions(unique_questions: Dict[str, Dict]) -> List[Dict]:
+    """
+    Extend the number of questions to 100 by randomly duplicating existing questions.
+    
+    Args:
+        unique_questions (Dict[str, Dict]): Dictionary of unique questions
+        
+    Returns:
+        List[Dict]: List of 100 questions
+    """
+    questions_list = list(unique_questions.values())
+    current_count = len(questions_list)
+    
+    # If we already have more than 100 questions, just return the first 100
+    if current_count >= 50:
+        return questions_list#[:100]
+    
+    # Calculate how many more questions we need
+    needed = 50 - current_count
+    
+    # Randomly select questions to duplicate
+    for _ in range(needed):
+        # Select a random question
+        random_question = random.choice(questions_list)
+        # Create a copy of the question
+        new_question = random_question.copy()
+        # Generate a new random image path based on the answer
+        new_question['image_path'] = get_random_image_path(new_question['gt_answer'])
+        # Add to the list
+        questions_list.append(new_question)
+    
+    return questions_list
+
+def refill_question_ids(questions: List[Dict]) -> List[Dict]:
+    """
+    Refill question_ids with sequential IDs.
+    
+    Args:
+        questions (List[Dict]): List of questions
+        
+    Returns:
+        List[Dict]: List of questions with sequential IDs
+    """
+    for i, question in enumerate(questions):
+        # Format the ID with leading zeros to maintain 4 digits
+        question['question_id'] = f"PulmonaryChestMC_{i:04d}"
+    return questions
+
+def main():
+    # Set random seed for reproducibility
+    random.seed(42)
+    
+    # First convert all BMP images to png
+    # convert_bmp_to_png()
+    
+    # Read the JSON file
+    with open('Original_open/RUS CHN.json', 'r') as f:
+        data = json.load(f)
+    
+    # Print all unique answers
+    unique_answers = set(item['gt_answer'] for item in data)
+    print("\nUnique answers in the original file:")
+    for answer in sorted(unique_answers):
+        print(f"- {answer}")
+    print(f"\nTotal number of unique answers: {len(unique_answers)}")
+    
+    # Extract unique questions
+    unique_questions = extract_unique_questions(data)
+    
+    # Save the unique questions first
+    unique_questions_list = list(unique_questions.values())
+    with open('RUSCHN/ruschn_unique_questions_original.json', 'w') as f:
+        json.dump(unique_questions_list, f, indent=4)
+    print(f"\nOriginal unique questions have been saved to 'RUSCHN/ruschn_unique_questions_original.json'")
+    print(f"Number of unique questions: {len(unique_questions_list)}")
+    
+    # Extend to 100 questions
+    extended_questions = extend_to_100_questions(unique_questions)
+    
+    # Refill question IDs sequentially
+    final_questions = refill_question_ids(extended_questions)
+    
+    # Save the extended questions to a new JSON file
+    with open('PulmonaryChestSZ/pulmonary_chest_sz_unique_questions.json', 'w') as f:
+        json.dump(final_questions, f, indent=4)
+    print(f"\nExtended questions have been saved to 'PulmonaryChestSZ/pulmonary_chest_sz_unique_questions.json'")
+    # print(f"Extended to {len(final_questions)} questions")
+
+if __name__ == "__main__":
+    main()