Environment & Diagnostics

def checkup(output=print):
    """
    Check environment for health problems that could prevent PyImageJ from functioning.
    
    Args:
        output: Function to use for displaying results (default: print)
        
    Analyzes:
        - Python executable and version
        - Java installation and version  
        - Required dependencies and versions
        - Environment variables and paths
        - Known compatibility issues
    """

import imagej.doctor

# Run comprehensive checkup with default output
imagej.doctor.checkup()

# Capture checkup results to custom function
results = []
def capture_output(message):
    results.append(message)

imagej.doctor.checkup(output=capture_output)

# Review captured results
for result in results:
    print(f"CHECKUP: {result}")

# Run checkup before ImageJ initialization
imagej.doctor.checkup()
ij = imagej.init()

def debug_to_stderr(logger=None, debug_maven=False):
    """
    Enable debug logging to standard error stream.
    
    Args:
        logger: Specific logger name, or None for all PyImageJ loggers
        debug_maven: Enable verbose Maven debug logging (default: False)
    """

import imagej.doctor

# Enable debug logging for all PyImageJ components
imagej.doctor.debug_to_stderr()

# Enable debug logging with Maven details
imagej.doctor.debug_to_stderr(debug_maven=True)

# Enable for specific logger only
imagej.doctor.debug_to_stderr(logger="scyjava._logger")

# Now initialize with verbose logging
import imagej
ij = imagej.init()

import imagej.doctor

# Check specific dependencies
def check_dependencies():
    """Custom dependency verification example."""
    required_packages = [
        'numpy', 'scyjava', 'jpype1', 'xarray', 
        'imglyb', 'labeling', 'jgo'
    ]
    
    optional_packages = [
        'matplotlib', 'scikit-image', 'pandas'
    ]
    
    for package in required_packages:
        try:
            __import__(package)
            print(f"✓ {package} - Available")
        except ImportError:
            print(f"✗ {package} - Missing (Required)")
    
    for package in optional_packages:
        try:
            __import__(package)
            print(f"✓ {package} - Available (Optional)")
        except ImportError:
            print(f"- {package} - Missing (Optional)")

# Run dependency check
check_dependencies()

import imagej.doctor
import scyjava as sj

# Analyze Java environment
def analyze_java_environment():
    """Analyze Java setup for PyImageJ compatibility."""
    
    print("=== Java Environment Analysis ===")
    
    # Check Java version before JVM start
    try:
        java_version = sj.jvm_version()
        print(f"Java version: {java_version}")
    except RuntimeError as e:
        print(f"Java detection issue: {e}")
    
    # Check Java memory configuration
    heap_size = sj.config.get_max_heap_size()
    print(f"Max heap size: {heap_size}")
    
    # Check for Java fetch configuration
    fetch_java = sj.config.get_fetch_java()
    print(f"Auto-fetch Java: {fetch_java}")
    
    # Start JVM and get runtime info
    if not sj.jvm_started():
        sj.start_jvm()
    
    Runtime = sj.jimport('java.lang.Runtime')
    runtime = Runtime.getRuntime()
    
    total_memory = runtime.totalMemory() // (1024 * 1024)  # MB
    free_memory = runtime.freeMemory() // (1024 * 1024)    # MB  
    max_memory = runtime.maxMemory() // (1024 * 1024)      # MB
    
    print(f"JVM Memory - Total: {total_memory}MB, Free: {free_memory}MB, Max: {max_memory}MB")

# Run Java analysis
analyze_java_environment()

import imagej.doctor

def diagnose_common_issues():
    """Diagnose and suggest fixes for common PyImageJ issues."""
    
    issues_found = []
    suggestions = []
    
    # Check for common environment problems
    try:
        import jpype
        if jpype.isJVMStarted():
            issues_found.append("JVM already started")
            suggestions.append("Restart Python interpreter to reinitialize PyImageJ")
    except ImportError:
        issues_found.append("JPype not available")
        suggestions.append("Install JPype: pip install jpype1")
    
    try:
        import imagej
        # Try basic initialization
        ij = imagej.init()
        print("✓ Basic PyImageJ initialization successful")
    except Exception as e:
        issues_found.append(f"Initialization failed: {e}")
        suggestions.append("Run imagej.doctor.checkup() for detailed analysis")
    
    # Report findings
    if issues_found:
        print("\n=== Issues Found ===")
        for issue in issues_found:
            print(f"- {issue}")
        
        print("\n=== Suggested Solutions ===")
        for suggestion in suggestions:
            print(f"- {suggestion}")
    else:
        print("✓ No common issues detected")

# Run diagnostic
diagnose_common_issues()

import time
import psutil
import imagej

def monitor_performance():
    """Monitor PyImageJ initialization and operation performance."""
    
    print("=== Performance Monitoring ===")
    
    # Monitor initialization time
    start_time = time.time()
    process = psutil.Process()
    initial_memory = process.memory_info().rss // (1024 * 1024)  # MB
    
    print(f"Initial memory usage: {initial_memory}MB")
    print("Initializing PyImageJ...")
    
    ij = imagej.init()
    
    init_time = time.time() - start_time
    post_init_memory = process.memory_info().rss // (1024 * 1024)  # MB
    memory_increase = post_init_memory - initial_memory
    
    print(f"Initialization time: {init_time:.2f} seconds")
    print(f"Memory after init: {post_init_memory}MB (+{memory_increase}MB)")
    
    # Test basic operations
    start_time = time.time()
    test_array = ij.py.to_dataset(np.random.rand(512, 512))
    conversion_time = time.time() - start_time
    
    print(f"Array conversion time: {conversion_time:.4f} seconds")
    
    return {
        'init_time': init_time,
        'memory_increase': memory_increase,
        'conversion_time': conversion_time
    }

# Run performance monitoring
performance = monitor_performance()

import logging
import imagej

# Configure logging to see PyImageJ internals
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger('imagej')
logger.setLevel(logging.DEBUG)

# Now PyImageJ operations will show detailed logs
ij = imagej.init()