import VolAlign
print("VolAlign installed successfully!")

# Verify Git dependencies are available
try:
    import exm
    print("ExSeq-Toolbox available!")
except ImportError:
    print("ExSeq-Toolbox not available - check installation")

try:
    import cellpose
    print("Cellpose fork available!")
except ImportError:
    print("Cellpose not available - check installation")

from VolAlign import MicroscopyProcessingPipeline

# Initialize pipeline with YAML configuration file path
pipeline = MicroscopyProcessingPipeline('my_config.yaml')

# Run the complete multi-round processing pipeline
results = pipeline.run_complete_pipeline_from_config()

# The pipeline will automatically:
# 1. Convert all TIFF files to Zarr format
# 2. Register all rounds to the reference round
# 3. Perform nuclei segmentation on the reference round
# 4. Apply registration transformations to all channels
# 5. Generate comprehensive reports and summaries

print("Pipeline completed successfully!")
print(f"Results saved to: {pipeline.working_directory}")

from VolAlign import MicroscopyProcessingPipeline

# Initialize pipeline with YAML configuration file
pipeline = MicroscopyProcessingPipeline('my_config.yaml')

# Step 1: Process all rounds from configuration
all_round_data = pipeline.process_all_rounds_from_config()

# Step 2: Run registration for each round against reference
reference_round = pipeline.reference_round
registration_results = {}

for round_name in pipeline.rounds_data.keys():
    if round_name != reference_round:
        registration_results[round_name] = pipeline.run_registration_workflow(
            fixed_round_data=all_round_data[reference_round],
            moving_round_data=all_round_data[round_name],
            registration_output_dir=f"{pipeline.working_directory}/registration",
            registration_name=f"{reference_round}_to_{round_name}"
        )

# Step 3: Run segmentation on reference round
segmentation_results = pipeline.run_segmentation_workflow(
    input_channel=all_round_data[reference_round][pipeline.segmentation_channel],
    segmentation_output_dir=f"{pipeline.working_directory}/segmentation",
    segmentation_name=f"{reference_round}_nuclei"
)

# Step 4: Apply registration to all channels
for round_name, reg_results in registration_results.items():
    aligned_channels = pipeline.apply_registration_to_all_channels(
        reference_round_data=all_round_data[reference_round],
        target_round_data=all_round_data[round_name],
        deformation_field_path=reg_results['deformation_field'],
        output_directory=f"{pipeline.working_directory}/aligned_channels/{round_name}"
    )

from VolAlign import (
    downsample_zarr_volume,
    merge_zarr_channels,
    compute_affine_registration,
    compute_deformation_field_registration,
    distributed_nuclei_segmentation
)

# Downsample large volume
downsample_zarr_volume(
    input_zarr_path='large_volume.zarr',
    output_zarr_path='downsampled.zarr',
    downsample_factors=(4, 7, 7)
)

# Merge registration channels
merge_zarr_channels(
    channel_a_path='405nm.zarr',
    channel_b_path='488nm.zarr',
    output_path='merged_registration.zarr',
    merge_strategy='mean'
)

# Compute affine registration
affine_matrix = compute_affine_registration(
    fixed_volume_path='fixed.zarr',
    moving_volume_path='moving.zarr',
    voxel_spacing=[0.2, 0.1625, 0.1625],
    output_matrix_path='affine_matrix.txt'
)

# Compute deformation field
aligned_path = compute_deformation_field_registration(
    fixed_zarr_path='fixed.zarr',
    moving_zarr_path='moving.zarr',
    affine_matrix_path='affine_matrix.txt',
    output_directory='./output',
    output_name='registration_result',
    voxel_spacing=[0.2, 0.1625, 0.1625]
)

# Distributed segmentation
segments, boxes = distributed_nuclei_segmentation(
    input_zarr_path='405nm_channel.zarr',
    output_zarr_path='segmentation_masks.zarr',
    model_type='cpsam'
)