create_metadata_360.py

import os
import re
import glob
import json
import argparse
from tqdm import tqdm
from pathlib import Path

def parse_ground_truth(name):
    """Extract ground truth rotation axis and angle from filename or folder name"""
    # Remove file extension if present
    basename = name.split(".")[0] if "." in name else name
    
    parts = basename.split("_")
    if len(parts) >= 4:  # figXXXX_XXX_axis_angle
        rotation_axis = parts[-2]  # Second to last element is axis
        rotation_angle = int(parts[-1])  # Last element is angle
        
        # Convert negative angles to 0-360 range
        if rotation_angle < 0:
            rotation_angle += 360
            
        return rotation_axis, rotation_angle
    
    print(f"Warning: Could not parse name: {basename}")
    return None, None

def construct_prompt(axis, angle_increment, difficulty="easy", generation_mode="combined"):
    """Create prompt for the VLM based on difficulty mode and generation mode"""
    # Generate list of all possible rotation angles based on angle increment
    possible_angles = []
    current_angle = 0 + angle_increment
    while current_angle < 360:
        possible_angles.append(current_angle)
        current_angle += angle_increment
    
    # Common instructions for both modes
    coordinate_system = (
        f"The 3D Cartesian coordinate system is defined as follows: "
        f"\n- x-axis: points horizontally from left to right (positive direction is right)"
        f"\n- y-axis: points vertically from bottom to top (positive direction is up)"
        f"\n- z-axis: points from inside the image toward the viewer (positive direction is out of the screen)"
        f"\n\nWhen discussing rotations around an axis, imagine looking along the positive direction of that axis (as if looking from the origin toward the positive end)."
    )
    
    angle_constraints = (
        f"The rotation angle is always a multiple of {angle_increment} degrees between 0 and 360 degrees inclusive. "
        f"A positive angle means rotation in the CLOCKWISE direction when looking along the positive direction of the axis. "
    )
    
    # Different instructions based on difficulty
    if difficulty == "easy":
        # For easy mode - axis is provided
        thinking_instructions = (
            f"IMPORTANT: Please follow this systematic approach to determine the rotation angle:"
            f"\n\n1. First, analyze the object's features in both views to understand its structure."
            f"\n\n2. For the {axis}-axis rotation, you must evaluate ALL of these possible rotation angles: {possible_angles}"
            f"\n   - For each angle in the list, describe what the object would look like after rotating around the {axis}-axis by that amount"
            f"\n   - Compare these descriptions with the actual second view"
            f"\n   - DO NOT make a decision until you have evaluated all possible angles in the list"
            f"\n\n3. After evaluating all angles, choose the one that best matches the observed changes"
            f"\n\n4. Verify your answer by mentally applying the rotation to confirm it matches the second view"
        )
        
        response_format = (
            f"Place your detailed reasoning process in <think></think> tags. Your reasoning should include:"
            f"\n- Systematic evaluation of possible rotation angles from the provided list"
            f"\n- Specific visual features you used to determine your answer"
            f"\n\nThen provide your final answer in <rotation_angle></rotation_angle> tags (use only a number from the list for angle)."
            f"\ni.e., <think> your reasoning process here </think><rotation_angle> your predicted degrees here </rotation_angle>"
        )
        
        task_description = (
            f"Your task is to determine the angle of rotation around the {axis}-axis in degrees."
        )
        
    else:  # hard mode - axis is not provided
        thinking_instructions = (
            f"IMPORTANT: Please follow this systematic approach to determine the rotation:"
            f"\n\n1. First, analyze the object's features in both views to understand its structure."
            f"\n\n2. Consider what would happen if rotation occurred around each of the three axes (x, y, and z):"
            f"\n   - For x-axis rotation: What specific features would change and how?"
            f"\n   - For y-axis rotation: What specific features would change and how?"
            f"\n   - For z-axis rotation: What specific features would change and how?"
            f"\n   - Based on the observed changes, explain which axis makes the most sense and why."
            f"\n\n3. Once you've determined the most likely axis, evaluate ALL of these possible rotation angles: {possible_angles}"
            f"\n   - For each angle in the list, describe what the object would look like after rotating around your chosen axis by that amount"
            f"\n   - Compare these descriptions with the actual second view"
            f"\n   - DO NOT make a decision until you have evaluated all angles in the list"
            f"\n\n4. After evaluating all angles, choose the one that best matches the observed changes"
        )
        
        response_format = (
            f"Place your detailed reasoning process in <thinking></thinking> tags. Your reasoning should include:"
            f"\n- Analysis of how rotation around each axis would affect the object"
            f"\n- Systematic evaluation of possible rotation angles from the provided list"
            f"\n- Specific visual features you used to determine your answer"
            f"\n\nThen provide your final answer in <rotation_axis></rotation_axis> and <rotation_angle></rotation_angle> tags respectively (use only x, y, or z for axis and only a number from the list for angle)."
            f"\ni.e., <thinking> your reasoning process here </thinking><rotation_axis> your predicted axis here </rotation_axis><rotation_angle> your predicted degrees here </rotation_angle>"
        )
        
        task_description = (
            f"Your task is to determine which axis the object was rotated around and by what angle."
        )
    
    # Generate the prompt based on generation mode
    if generation_mode == "combined":
        prompt = (
            f"IMPORTANT: The image I'm showing you contains TWO separate 3D renderings side-by-side. "
            f"This is a single image file with two distinct rendered views placed next to each other. "
            f"\n\nThe LEFT HALF shows a 3D object in its initial orientation. "
            f"The RIGHT HALF shows the SAME 3D object after being rotated. "
            f"\n\n{task_description}"
            f"\n\n{coordinate_system}"
            f"\n\n{angle_constraints}"
            f"\n\n{thinking_instructions}"
            f"\n\n{response_format}"
        )
    else:  # separate mode
        prompt = (
            f"I'm showing you TWO images of the same 3D object. "
            f"The FIRST image shows the object in its initial orientation. "
            f"The SECOND image shows the object after being rotated. "
            f"\n\n{task_description}"
            f"\n\n{coordinate_system}"
            f"\n\n{angle_constraints}"
            f"\n\n{thinking_instructions}"
            f"\n\n{response_format}"
        )
            
    return prompt

def create_metadata_jsonl_combined(input_dir, output_file, angle_increment=30, difficulty="easy"):
    """Create metadata JSONL file for all images in input_dir (combined mode)"""
    # Get all PNG files in the input directory
    png_files = glob.glob(os.path.join(input_dir, "*.png"))
    
    # Sort files to ensure consistent order
    png_files = sorted(png_files)
    
    if not png_files:
        print(f"No PNG files found in {input_dir}")
        return
    
    print(f"Found {len(png_files)} PNG files in {input_dir}")
    
    # Create output directory if it doesn't exist
    output_dir = os.path.dirname(output_file)
    os.makedirs(output_dir, exist_ok=True)
    
    # Get the last folder name from the input directory
    last_folder = os.path.basename(os.path.normpath(input_dir))
    
    # Define the target base directory
    target_base_dir = f"/lustre/fsw/portfolios/av/users/shiyil/yunfei/MM-EUREKA/data/{last_folder}"
    
    # Process each file and create metadata entries
    entries = []
    
    for png_file in tqdm(png_files, desc="Creating metadata for combined mode"):
        # Parse ground truth from filename
        axis, angle = parse_ground_truth(os.path.basename(png_file))
        
        if axis is None or angle is None:
            print(f"Skipping {png_file} - could not parse ground truth")
            continue
        
        # Get the basename
        basename = os.path.basename(png_file)
        
        # Create the new image path for the target system
        target_image_path = f"{target_base_dir}/{basename}"
        
        # Construct prompt for combined mode
        prompt = construct_prompt(axis, angle_increment, difficulty, generation_mode="combined")
        
        # Create answer format based on difficulty WITH image path
        if difficulty == "easy":
            # For easy mode, only include angle in the answer (axis is provided in the prompt)
            answer = f"<angle>{angle}</angle><image_path>{target_image_path}</image_path>"
        else:
            # For hard mode, include both axis and angle
            answer = f"<axis>{axis}</axis><angle>{angle}</angle><image_path>{target_image_path}</image_path>"
        
        # Create entry with the modified image path
        entry = {
            "message": json.dumps([{
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "image": target_image_path
                    },
                    {
                        "type": "text",
                        "text": prompt
                    }
                ]
            }]),
            "answer": answer
        }
        
        entries.append(entry)
    
    # Write entries to JSONL file
    with open(output_file, 'w') as f:
        for entry in entries:
            f.write(json.dumps(entry) + '\n')
    
    print(f"\nSummary for combined mode:")
    print(f"  Found {len(png_files)} PNG files")
    print(f"  Created metadata for {len(entries)} entries")
    print(f"  Output file: {output_file}")
    print(f"  Image paths are set to: {target_base_dir}/[filename].png")

def create_metadata_jsonl_separate(input_dir, output_file, angle_increment=30, difficulty="easy"):
    """Create metadata JSONL file for folders in input_dir (separate mode)"""
    # Get all directories in the input directory
    folders = [f for f in glob.glob(os.path.join(input_dir, "*")) if os.path.isdir(f)]
    
    # Sort folders to ensure consistent order
    folders = sorted(folders)
    
    if not folders:
        print(f"No folders found in {input_dir}")
        return
    
    print(f"Found {len(folders)} folders in {input_dir}")
    
    # Create output directory if it doesn't exist
    output_dir = os.path.dirname(output_file)
    os.makedirs(output_dir, exist_ok=True)
    
    # Get the last folder name from the input directory
    last_folder = os.path.basename(os.path.normpath(input_dir))
    
    # Define the target base directory
    target_base_dir = f"/lustre/fsw/portfolios/av/users/shiyil/yunfei/MM-EUREKA/data/{last_folder}"
    
    # Process each folder and create metadata entries
    entries = []
    valid_folders = 0
    
    for folder in tqdm(folders, desc="Creating metadata for separate mode"):
        folder_name = os.path.basename(folder)
        
        # Parse ground truth from folder name
        axis, angle = parse_ground_truth(folder_name)
        
        if axis is None or angle is None:
            print(f"Skipping {folder} - could not parse ground truth")
            continue
        
        # Check for the two required images in the folder
        ini_path = os.path.join(folder, f"{folder_name}_ini.png")
        rot_path = os.path.join(folder, f"{folder_name}_rot.png")
        
        if not os.path.exists(ini_path):
            print(f"Skipping {folder} - missing initial view image")
            continue
            
        if not os.path.exists(rot_path):
            print(f"Skipping {folder} - missing rotated view image")
            continue
        
        # Create target paths for remote system
        target_folder_path = f"{target_base_dir}/{folder_name}"
        target_ini_path = f"{target_base_dir}/{folder_name}/{folder_name}_ini.png"
        target_rot_path = f"{target_base_dir}/{folder_name}/{folder_name}_rot.png"
        
        # Construct prompt for separate mode
        prompt = construct_prompt(axis, angle_increment, difficulty, generation_mode="separate")
        
        # Create answer format based on difficulty WITH folder path
        if difficulty == "easy":
            # For easy mode, only include angle in the answer (axis is provided in the prompt)
            answer = f"<angle>{angle}</angle><image_path>{target_folder_path}</image_path>"
        else:
            # For hard mode, include both axis and angle
            answer = f"<axis>{axis}</axis><angle>{angle}</angle><image_path>{target_folder_path}</image_path>"
        
        # Create entry with both image paths
        entry = {
            "message": json.dumps([{
                "role": "user",
                "content": [
                    {"type": "image", "image": target_ini_path},
                    {"type": "image", "image": target_rot_path},
                    {"type": "text", "text": prompt}
                ]
            }]),
            "answer": answer
        }
        
        entries.append(entry)
        valid_folders += 1
    
    # Write entries to JSONL file
    with open(output_file, 'w') as f:
        for entry in entries:
            f.write(json.dumps(entry) + '\n')
    
    print(f"\nSummary for separate mode:")
    print(f"  Found {len(folders)} folders")
    print(f"  Created metadata for {valid_folders} valid folders")
    print(f"  Output file: {output_file}")
    print(f"  Image paths format: {target_base_dir}/[folder_name]/[folder_name]_[ini/rot].png")

def main():
    parser = argparse.ArgumentParser(description="Create metadata JSONL for rotation dataset")
    parser.add_argument('--input-dir', type=str, required=True,
                      help="Directory containing rotation dataset images or folders")
    parser.add_argument('--output-file', type=str, default="rotation_metadata.jsonl",
                      help="Output JSONL file path")
    parser.add_argument('--angle-increment', type=int, default=30,
                      help="Angle increment used in the dataset (e.g., 30, 45, 90)")
    parser.add_argument('--difficulty', type=str, choices=["easy", "hard"], default="easy",
                      help="Difficulty mode: easy (axis provided) or hard (axis not provided)")
    parser.add_argument('--generation-mode', type=str, choices=["combined", "separate"], default="combined",
                      help="Mode for dataset generation (combined = one image with both views, separate = folder with two images)")
    
    args = parser.parse_args()
    
    print(f"Creating metadata JSONL for rotation dataset:")
    print(f"Input directory: {args.input_dir}")
    print(f"Output file: {args.output_file}")
    print(f"Angle increment: {args.angle_increment} degrees")
    print(f"Difficulty mode: {args.difficulty}")
    print(f"Generation mode: {args.generation_mode}")
    
    if args.generation_mode == "combined":
        create_metadata_jsonl_combined(
            input_dir=args.input_dir,
            output_file=args.output_file,
            angle_increment=args.angle_increment,
            difficulty=args.difficulty
        )
    else:  # separate mode
        create_metadata_jsonl_separate(
            input_dir=args.input_dir,
            output_file=args.output_file,
            angle_increment=args.angle_increment,
            difficulty=args.difficulty
        )

if __name__ == "__main__":
    main()