Datasets:

pmchard
/

3D-ADAM

@@ -1,326 +0,0 @@
-import os
-import shutil
-import argparse
-import random
-from pathlib import Path
-from tqdm import tqdm
-import logging
-from collections import defaultdict
-def reorganize_for_supervised_learning(source_dir, target_dir, test_val_ratio=0.6,
-                                      random_seed=42, dry_run=False, log_file=None):
-    """
-    Reorganize data from source_dir by category into train/val/test splits.
-    Args:
-        source_dir: Path to the source directory organized by part name
-        target_dir: Path to the target directory to be organized by category and splits
-        test_val_ratio: Ratio of defect parts to include in test set (vs validation)
-        random_seed: Seed for random split reproducibility
-        dry_run: If True, only log what would be done without actually copying files
-        log_file: Path to log file to record actions and errors
-    """
-    # Set up logging
-    if log_file:
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(asctime)s - %(levelname)s - %(message)s',
-            handlers=[
-                logging.FileHandler(log_file),
-                logging.StreamHandler()
-            ]
-        )
-    else:
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(asctime)s - %(levelname)s - %(message)s'
-        )
-    # Set random seed for reproducibility
-    random.seed(random_seed)
-    source_path = Path(source_dir)
-    target_path = Path(target_dir)
-    logging.info(f"{'DRY RUN: ' if dry_run else ''}Reorganizing from {source_dir} to {target_dir}")
-    logging.info(f"Split approach: All defect-free parts to Train, defect parts split Test:{test_val_ratio:.0%}, Val:{1-test_val_ratio:.0%}")
-    # Create target directory if it doesn't exist and not in dry run mode
-    if not dry_run:
-        target_path.mkdir(parents=True, exist_ok=True)
-    # Statistics for reporting
-    stats = {
-        'parts_processed': 0,
-        'categories_found': set(),
-        'defect_free_parts': 0,
-        'parts_with_defects': 0,
-        'train_set': 0,
-        'val_set': 0,
-        'test_set': 0,
-        'directories_to_create': 0,
-        'files_to_copy': 0,
-        'errors': 0
-    }
-    # Keep track of directory structure
-    directory_structure = defaultdict(lambda: defaultdict(list))
-    # Get all part directories
-    part_dirs = [d for d in source_path.iterdir() if d.is_dir()]
-    logging.info(f"Found {len(part_dirs)} part directories in {source_dir}")
-    # First pass: categorize parts and check for defects
-    parts_by_category = defaultdict(list)
-    part_has_defects = {}
-    logging.info("Pass 1: Analyzing parts and checking for defects...")
-    for part_dir in tqdm(part_dirs, desc="Analyzing parts"):
-        part_name = part_dir.name
-        try:
-            # Extract category name (first segment before underscore)
-            category = part_name.split('_')[0]
-            stats['categories_found'].add(category)
-            # Check for MechMind-Nano camera directory
-            nano_dir = part_dir / "MechMind-Nano"
-            if not nano_dir.exists() or not nano_dir.is_dir():
-                logging.warning(f"MechMind-Nano directory not found for part: {part_name}, skipping...")
-                continue
-            # Check for defects
-            has_defects = False
-            # Check defect_masks directory
-            defect_masks_dir = nano_dir / "defect_masks"
-            if defect_masks_dir.exists() and defect_masks_dir.is_dir():
-                # Check if any mask files exist
-                mask_files = list(defect_masks_dir.glob("*.*"))
-                if mask_files:
-                    has_defects = True
-            # Store part information
-            parts_by_category[category].append(part_name)
-            part_has_defects[part_name] = has_defects
-            # Update stats
-            if has_defects:
-                stats['parts_with_defects'] += 1
-            else:
-                stats['defect_free_parts'] += 1
-        except Exception as e:
-            logging.error(f"Error analyzing part {part_name}: {str(e)}")
-            stats['errors'] += 1
-    # Second pass: Determine split assignment and copy files
-    logging.info("Pass 2: Assigning parts to splits and copying data...")
-    for category, parts in parts_by_category.items():
-        logging.info(f"Processing category: {category} ({len(parts)} parts)")
-        # Create category directories
-        if not dry_run:
-            (target_path / category / "train").mkdir(parents=True, exist_ok=True)
-            (target_path / category / "val").mkdir(parents=True, exist_ok=True)
-            (target_path / category / "test").mkdir(parents=True, exist_ok=True)
-        # Separate defect-free and defect parts
-        defect_free_parts = []
-        defect_parts = []
-        for part in parts:
-            if part_has_defects[part]:
-                defect_parts.append(part)
-            else:
-                defect_free_parts.append(part)
-        logging.info(f"  Category {category}: {len(defect_free_parts)} defect-free parts, "
-                    f"{len(defect_parts)} parts with defects")
-        # Shuffle defect parts for random assignment
-        random.shuffle(defect_parts)
-        # Determine split counts for defect parts using the test:val ratio
-        defect_count = len(defect_parts)
-        test_count = max(1, int(defect_count * test_val_ratio)) if defect_count > 0 else 0
-        val_count = defect_count - test_count
-        # Assign defect parts to test and validation
-        test_parts = defect_parts[:test_count]
-        val_parts = defect_parts[test_count:]
-        # All defect-free parts go to training
-        train_parts = defect_free_parts
-        logging.info(f"  Split assignment - Train: {len(train_parts)} (all defect-free), "
-                     f"Test: {len(test_parts)}, Val: {len(val_parts)}")
-        # Update stats
-        stats['train_set'] += len(train_parts)
-        stats['val_set'] += len(val_parts)
-        stats['test_set'] += len(test_parts)
-        # Update directory structure tracking
-        for part in train_parts:
-            directory_structure[category]['train'].append(part)
-        for part in val_parts:
-            directory_structure[category]['val'].append(part)
-        for part in test_parts:
-            directory_structure[category]['test'].append(part)
-        # Process each part according to its split assignment
-        for split, parts_list in [('train', train_parts), ('val', val_parts), ('test', test_parts)]:
-            for part_name in parts_list:
-                stats['parts_processed'] += 1
-                # Source part directory
-                part_dir = source_path / part_name
-                nano_dir = part_dir / "MechMind-Nano"
-                # Target directory
-                target_split_dir = target_path / category / split
-                target_part_dir = target_split_dir / part_name
-                logging.info(f"  {'Would assign' if dry_run else 'Assigning'} {part_name} to {split} split")
-                # In dry run, just count what would be done
-                if dry_run:
-                    # Count directories and files that would be created/copied
-                    count_directory_contents(nano_dir, stats)
-                else:
-                    # Create part directory under category/split
-                    target_part_dir.mkdir(exist_ok=True)
-                    # Copy all contents from MechMind-Nano to the target part directory
-                    copy_directory_contents(nano_dir, target_part_dir, stats)
-    # Print summary
-    logging.info("\n" + "="*50)
-    logging.info(f"{'DRY RUN SUMMARY:' if dry_run else 'REORGANIZATION COMPLETE:'}")
-    logging.info("="*50)
-    logging.info(f"Parts processed: {stats['parts_processed']}")
-    logging.info(f"Categories found: {len(stats['categories_found'])}")
-    logging.info(f"Categories: {', '.join(sorted(stats['categories_found']))}")
-    logging.info(f"Defect-free parts (Training set): {stats['defect_free_parts']}")
-    logging.info(f"Parts with defects (Test+Val sets): {stats['parts_with_defects']}")
-    # Calculate overall ratios
-    total_parts = stats['train_set'] + stats['val_set'] + stats['test_set']
-    if total_parts > 0:
-        train_pct = stats['train_set'] / total_parts * 100
-        val_pct = stats['val_set'] / total_parts * 100
-        test_pct = stats['test_set'] / total_parts * 100
-        logging.info(f"Overall split - Train: {stats['train_set']} ({train_pct:.1f}%), "
-                    f"Val: {stats['val_set']} ({val_pct:.1f}%), "
-                    f"Test: {stats['test_set']} ({test_pct:.1f}%)")
-    if dry_run:
-        logging.info(f"Directories that would be created: {stats['directories_to_create']}")
-        logging.info(f"Files that would be copied: {stats['files_to_copy']}")
-    else:
-        logging.info(f"Directories created: {stats['directories_to_create']}")
-        logging.info(f"Files copied: {stats['files_to_copy']}")
-    logging.info(f"Errors encountered: {stats['errors']}")
-    # Log directory structure
-    logging.info("\n" + "="*50)
-    logging.info("DIRECTORY STRUCTURE:")
-    logging.info("="*50)
-    for category in sorted(directory_structure.keys()):
-        logging.info(f"Category: {category}")
-        for split in ['train', 'val', 'test']:
-            parts_in_split = directory_structure[category][split]
-            logging.info(f"  {split.upper()} ({len(parts_in_split)} parts):")
-            for part in sorted(parts_in_split)[:5]:  # Show first 5 parts in each split
-                logging.info(f"    - {part}")
-            if len(parts_in_split) > 5:
-                logging.info(f"    ... and {len(parts_in_split) - 5} more parts")
-    if dry_run:
-        logging.info("\nThis was a dry run. No files were actually copied.")
-        logging.info(f"To perform the actual reorganization, run without the --dry-run option.")
-    return stats, directory_structure
-def count_directory_contents(src_dir, stats):
-    """
-    Count directories and files in src_dir for dry run statistics.
-    Args:
-        src_dir: Source directory
-        stats: Statistics dictionary to update
-    """
-    # Walk through all directories and files in the source
-    for root, dirs, files in os.walk(src_dir):
-        # Count directories
-        stats['directories_to_create'] += len(dirs)
-        # Count files
-        stats['files_to_copy'] += len(files)
-def copy_directory_contents(src_dir, dst_dir, stats):
-    """
-    Copy all contents from src_dir to dst_dir, preserving the directory structure.
-    Args:
-        src_dir: Source directory
-        dst_dir: Destination directory
-        stats: Statistics dictionary to update
-    """
-    # Walk through all directories and files in the source
-    for root, dirs, files in os.walk(src_dir):
-        # Get the relative path from src_dir
-        rel_path = os.path.relpath(root, src_dir)
-        # Create the corresponding directory in dst_dir
-        if rel_path != '.':
-            target_dir = dst_dir / rel_path
-            target_dir.mkdir(exist_ok=True)
-            stats['directories_to_create'] += 1
-        else:
-            target_dir = dst_dir
-        # Copy all files in this directory
-        for file in files:
-            src_file = Path(root) / file
-            dst_file = target_dir / file
-            # Copy the file
-            shutil.copy2(src_file, dst_file)
-            stats['files_to_copy'] += 1
-def main():
-    parser = argparse.ArgumentParser(description='Reorganize dataset for supervised learning (MechMind-Nano only)')
-    parser.add_argument('source_dir', help='Path to the source directory organized by part name')
-    parser.add_argument('target_dir', help='Path to the target directory to be organized by category and splits')
-    parser.add_argument('--test-val-ratio', type=float, default=0.6,
-                        help='Ratio of defect parts to include in test set vs validation set (default: 0.6)')
-    parser.add_argument('--seed', type=int, default=42,
-                        help='Random seed for reproducibility (default: 42)')
-    parser.add_argument('--dry-run', '-d', action='store_true',
-                        help='Perform a dry run without actually copying files')
-    parser.add_argument('--log', '-l', default=None, help='Path to log file (optional)')
-    args = parser.parse_args()
-    # Validate ratio
-    if args.test_val_ratio <= 0 or args.test_val_ratio >= 1:
-        parser.error("The test_val_ratio must be between 0 and 1")
-    reorganize_for_supervised_learning(
-        args.source_dir,
-        args.target_dir,
-        args.test_val_ratio,
-        args.seed,
-        args.dry_run,
-        args.log
-    )
-if __name__ == "__main__":
-    main()