### Install SimpleElastix Python Module

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/Sphinx/GettingStarted.md

Navigate to the packaging directory and run the setup script to install the module into the system or virtual environment.

```bash
${BUILD_DIRECTORY}/SimpleITK-build/Wrapping/Python/Packaging
```

```bash
$ python Packaging/setup.py install
```

--------------------------------

### Install Python Module for SimpleElastix

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/Sphinx/GettingStarted.md

Navigate to the Python wrapping directory and run the install script to install the SimpleElastix Python module. Omit 'sudo' if installing into a virtual environment.

```bash
sudo python Packaging/setup.py install
```

--------------------------------

### Install SimpleITK Documentation

Source: https://github.com/superelastix/simpleelastix/blob/master/CMakeLists.txt

Installs SimpleITK documentation files to the specified documentation directory. This component is part of the 'Runtime' installation.

```cmake
install(FILES ${SimpleITK_DOC_FILES} DESTINATION "${SimpleITK_INSTALL_DOC_DIR}" COMPONENT Runtime)
```

--------------------------------

### Python Image Registration Method 2 Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod2/Documentation.rst

Shows how to perform image registration with Method 2 in Python. Ensure the SuperElastix Python package is installed.

```python
import SimpleITK as sitk
import elastix

# Load the fixed and moving images
fixed_image = sitk.ReadImage("fixed.mha", sitk.sitkFloat32)
moving_image = sitk.ReadImage("moving.mha", sitk.sitkFloat32)

# Load the parameter object
parameter_object = elastix.ParameterObject.from_file("parameters.txt")

# Create an elastix object
elastix_object = elastix.ElastixRegistrationMethod()
elastix_object.SetFixedImage(fixed_image)
elastix_object.SetMovingImage(moving_image)
elastix_object.SetParameterObject(parameter_object)

# Perform the registration
result_image = elastix_object.Execute()

# Save the resulting image
sitk.WriteImage(result_image, "result.mha")

```

--------------------------------

### Install Sphinx

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/README.md

Install Sphinx documentation generator using apt-get.

```bash
sudo apt-get install python-sphinx
```

--------------------------------

### Add Example Subdirectories

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/CMakeLists.txt

Includes various example subdirectories into the build. Each subdirectory likely contains its own source files and build configurations.

```cmake
add_subdirectory(Segmentation)
add_subdirectory(ITKIntegration)
```

```cmake
set(TEST_HARNESS_TEMP_DIRECTORY ${SimpleITK_BINARY_DIR}/Testing/Temporary)
```

```cmake
add_subdirectory(HelloWorld)
add_subdirectory(FastMarchingSegmentation)
add_subdirectory(SimpleGaussian)
add_subdirectory(ImageRegistrationMethod1)
add_subdirectory(ImageRegistrationMethod2)
add_subdirectory(ImageRegistrationMethod3)
add_subdirectory(ImageRegistrationMethod4)
add_subdirectory(ImageRegistrationMethodBSpline1)
add_subdirectory(ImageRegistrationMethodBSpline2)
add_subdirectory(ImageRegistrationMethodBSpline3)
add_subdirectory(ImageRegistrationMethodDisplacement1)
add_subdirectory(ImageRegistrationMethodExhaustive)
add_subdirectory(N4BiasFieldCorrection)
add_subdirectory(DicomSeriesReader)
add_subdirectory(DicomImagePrintTags)
add_subdirectory(DicomSeriesReadModifyWrite)
add_subdirectory(FilterProgressReporting)
add_subdirectory(DemonsRegistration1)
add_subdirectory(DemonsRegistration2)
```

--------------------------------

### Python Image Registration Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod1/Documentation.rst

A Python script demonstrating image registration with SuperElastix. Ensure SuperElastix Python bindings are installed.

```python
import SuperElastix

#
# Instantiate the registration method
#
registrationMethod = SuperElastix.RegistrationMethod()

#
# Instantiate the optimizer
#
optimizer = SuperElastix.LBFGSBOptimizer()
registrationMethod.SetOptimizer(optimizer)

#
# Instantiate the interpolator
#
interpolator = SuperElastix.LinearInterpolator()
registrationMethod.SetInterpolator(interpolator)

#
# Instantiate the metric
#
metric = SuperElastix.MeanSquaresImageToImageMetric()
registrationMethod.SetMetric(metric)

#
# Instantiate the transform
#
transform = SuperElastix.Euler3DTransform()
registrationMethod.SetTransform(transform)

#
# Instantiate the fixed and moving images
#
fixedImage = SuperElastix.Image("fixed.mha")
movingImage = SuperElastix.Image("moving.mha")

#
# Set the fixed and moving images
#
registrationMethod.SetFixedImage(fixedImage)
registrationMethod.SetMovingImage(movingImage)

#
# Execute the registration
#
resultTransform = registrationMethod.Execute()

#
# Save the resulting transform
#
resultTransform.Save("resultTransform.tfm")

print("Registration complete. Result saved to resultTransform.tfm")
```

--------------------------------

### R Image Registration Method 3 Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod3/Documentation.rst

This R script demonstrates Image Registration Method 3. Ensure the SimpleITK package is installed and loaded.

```r
library(SimpleITK)

# Read the images
fixedImage <- ReadImage(sys.argv[1])
movingImage <- ReadImage(sys.argv[2])

# Setup for Image Registration Method 3
# Use a multi-resolution framework
registrationMethod <- ImageRegistrationMethod$new()
registrationMethod$SetMetricAsMattesMutualInformation(numberOfHistogramBins = 50)
registrationMethod$SetOptimizerAsRegularStepGradientDescent(learningRate = 1, 
                                                          numberOfIterations = 100, 
                                                          relaxationFactor = 0.5)
registrationMethod$SetInterpolator(sitkLinear)

# Setup for the multi-resolution framework
registrationMethod$SetShrinkFactorsPerLevel(shrinkFactorsPerLevel = c(4, 2, 1))
registrationMethod$SetSmoothingSigmasPerLevel(smoothingSigmasPerLevel = c(2, 1, 0))
registrationMethod$SmoothingSigmasAreSpecifiedInPhysicalUnitsOn()

# Connect observer functions
# Note: R does not directly support the same observer pattern as Python for iteration updates.
# This part would typically be handled differently in R, possibly by checking progress periodically or using a different callback mechanism if available.

# Initial alignment
initialTransform <- CenteredTransformInitializer(image1 = fixedImage, 
                                                   image2 = movingImage, 
                                                   transform = Euler3DTransform$new(), 
                                                   initializer = CenteredTransformInitializerFilter$GEOMETRY)
registrationMethod$SetInitialTransform(initialTransform, inPlace = FALSE)

# Execute the registration
finalTransform <- registrationMethod$Execute(fixedImage, movingImage)

# Print optimizer stop condition and final transform
print(paste("Optimizer stop condition: ", registrationMethod$GetOptimizerStopConditionDescription()))
print(paste("Final transform: ", finalTransform))

# Save the final transform
WriteTransform(finalTransform, sys.argv[3])

# Return the final transform (optional, depending on script usage)
# finalTransform

```

--------------------------------

### Install SimpleITK package locally

Source: https://github.com/superelastix/simpleelastix/blob/master/docs/source/building.rst

Install the SimpleITK package into the specified local library directory.

```bash
cd SimpleITK-build/Wrapping/R/Packaging
 R CMD INSTALL -l /path_to/my_R_libs SimpleITK
```

--------------------------------

### Example CMakeCache.txt configuration

Source: https://github.com/superelastix/simpleelastix/blob/master/docs/source/cmake_cplusplus.rst

Shows the required paths for ITK_DIR and SimpleITK_DIR within the CMakeCache.txt file.

```text
//The directory containing a CMake configuration file for ITK.
ITK_DIR:PATH=/home/dchen/SuperBuild/ITK-build

//The directory containing a CMake configuration file for SimpleITK.
SimpleITK_DIR:PATH=/home/dchen/SuperBuild/SimpleITK-build
```

--------------------------------

### Install R Package

Source: https://github.com/superelastix/simpleelastix/blob/master/docs/source/building.rst

Install the built R package 'SimpleITK'. This command installs the package to the default R installation directory or a user-specified location.

```bash
cd SimpleITK-build/Wrapping/R/Packaging
R CMD INSTALL SimpleITK
```

--------------------------------

### Python Image Registration Method 4 Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod4/Documentation.rst

This Python script performs image registration using Method 4. Ensure SimpleITK is installed.

```python
import SimpleITK as sitk
import sys

if __name__ == "__main__" :
    if len( sys.argv ) < 3:
        print( "Usage: " + sys.argv[0] + " <fixedImageFile> <movingImageFile>" )
        sys.exit( 1 )

    # Setup for registration
    image_type = sitk.Image[sitk.sitkFloat32, 2]

    # Read the images
    try:
        fixed_image = sitk.Cast( sitk.ReadImage( sys.argv[1], image_type ), sitk.sitkFloat32 )
    except Exception as e:
        print( "Error reading fixed image: " + str(e) )
        sys.exit( 1 )

    try:
        moving_image = sitk.Cast( sitk.ReadImage( sys.argv[2], image_type ), sitk.sitkFloat32 )
    except Exception as e:
        print( "Error reading moving image: " + str(e) )
        sys.exit( 1 )

    # The registration method is chosen by the "SetMetric" method.
    # For example:
    #   SetMetricAsMattesMutualInformation
    #   SetMetricAsMattesMutualInformationSecondOrder
    #   SetMetricAsCorrelation
    #   SetMetricAsMeanSquares
    #   SetMetricAsDemons
    #   SetMetricAsOtsuMutualInformation
    #   SetMetricAsJointHistogramMutualInformation

    # Setup the registration
    registration_method = sitk.ImageRegistrationMethod()
    registration_method.SetMetricAsMattesMutualInformation( 50 )
    registration_method.SetOptimizerAsRegularStepGradientDescent( learningRate=1.0, numberOfIterations=100, convergenceMinimumValue=1e-6, convergenceWindowSize=10 )
    registration_method.SetInterpolator( sitk.sitkLinear )

    # Setup the multi-resolution framework. 
    # The image is scaled down by a factor of 2 in each dimension. 
    # The number of levels is 3.
    registration_method.SetShrinkFactorsPerLevel( shrinkFactors=[4,2,1] )
    registration_method.SetSmoothingSigmasPerLevel( smoothingSigmas=[2,1,0] )
    registration_method.SmoothingSigmasAreSpecifiedInPhysicalUnitsOn()

    # Connect observer functions
    # registration_method.AddCommand( sitk.sitkStartEvent, lambda: print("Registration Started") )
    # registration_method.AddCommand( sitk.sitkEndEvent, lambda: print("Registration Ended") )
    # registration_method.AddCommand( sitk.sitkIterationEvent, lambda: print(f"Iteration {registration_method.GetOptimizerIteration()}") )

    # Execute the registration
    final_transform = registration_method.Execute( fixed_image, moving_image )

    print( "Optimizer stop condition: " + registration_method.GetOptimizerStopConditionDescription() )
    print( "Final metric value: " + str(registration_method.GetMetricValue()) )

    # Save the result
    # sitk.WriteImage( sitk.Resample( moving_image, fixed_image, final_transform, sitk.sitkLinear, 0.0, fixed_image.GetPixelID() ), "result.mha" )

```

--------------------------------

### Java Filter Progress Reporting Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/FilterProgressReporting/Documentation.rst

Complete Java example demonstrating filter progress reporting using a custom Command class.

```java
import org.simpleitk.*;

public class FilterProgressReporting {

    public static void main(String[] args) {

        Image image = SimpleITK.readImage("Resources/RA_T1_1mm_grise.mha");
        image.setSpacing(new double[]{1.0, 1.0, 1.0});

        Image imageFixed = image;
        Image imageMoving = image;

        ImageRegistrationMethod imageRegistrationMethod = new ImageRegistrationMethod();

        imageRegistrationMethod.setMetricAsMattesMutualInformation(50);
        imageRegistrationMethod.setOptimizerAsRegularStepGradientDescent(1.0, 100, 0.5, 1e-4);
        imageRegistrationMethod.setInterpolator(ImageRegistrationMethod.InterpolatorEnum.LINEAR);

        // Setup for the multi-resolution framework
        double[] imagePyramid = new double[]{4, 2, 1};
        imageRegistrationMethod.setShrinkFactorsPerLevel(new uint[]{4, 2, 1});
        imageRegistrationMethod.setSmoothingSigmasPerLevel(new double[]{2, 1, 0});

        // Make sure that the order of setting the composite scales is the same as the order of the levels
        imageRegistrationMethod.setOptimizerScalesFromPhysicalShift();

        // Don't do this in production code. The scales are not optimized.
        imageRegistrationMethod.setOptimizerScalesFromPhysicalShift();

        // Setup the command observer
        imageRegistrationMethod.addCommand(SimpleITK.Command.EventEnum.PROGRESS_EVENT, new ShowProgress());

        // Connect all the filters that will be used by the pipeline
        imageRegistrationMethod.setFixedImage(imageFixed);
        imageRegistrationMethod.setMovingImage(imageMoving);

        Transform initialTransform = imageRegistrationMethod.execute(imageFixed, imageMoving);

        System.out.println("Read image: " + image);
    }
}

class ShowProgress extends SimpleITK.Command {
    @Override
    public void Execute(Object o) {
        ProcessObject filter = (ProcessObject) o;
        System.out.println(String.format("%0.2f%%", filter.GetProgress()));
    }
}
```

--------------------------------

### Ruby Filter Progress Reporting Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/FilterProgressReporting/Documentation.rst

Complete Ruby example demonstrating filter progress reporting using a custom Command class.

```ruby
require 'SimpleITK'

image = SimpleITK::ReadImage("Resources/RA_T1_1mm_grise.mha")
image.SetSpacing([1.0, 1.0, 1.0])

imageFixed = image
imageMoving = image

imageRegistrationMethod = SimpleITK::ImageRegistrationMethod.new

imageRegistrationMethod.SetMetricAsMattesMutualInformation(:number_of_histogram_bins => 50)
imageRegistrationMethod.SetOptimizerAsRegularStepGradientDescent(:learning_rate => 1.0, :number_of_iterations => 100, :relaxation_factor => 0.5, :minimum_step_length => 1e-4)
imageRegistrationMethod.SetInterpolator(SimpleITK::sitkLinear)

# Setup for the multi-resolution framework
image_pyramid = [4, 2, 1]
imageRegistrationMethod.SetShrinkFactorsPerLevel(:shrink_factors => [4, 2, 1])
imageRegistrationMethod.SetSmoothingSigmasPerLevel(:smoothing_sigmas => [2, 1, 0])

# Make sure that the order of setting the composite scales is the same as the order of the levels
imageRegistrationMethod.SetOptimizerScalesFromPhysicalShift

# Don't do this in production code. The scales are not optimized.
imageRegistrationMethod.SetOptimizerScalesFromPhysicalShift

# Setup the command observer
imageRegistrationMethod.AddCommand(SimpleITK::ProgressEvent, ShowProgress.new)

# Connect all the filters that will be used by the pipeline
imageRegistrationMethod.SetFixedImage(imageFixed)
imageRegistrationMethod.SetMovingImage(imageMoving)

initialTransform = imageRegistrationMethod.Execute(imageFixed, imageMoving)

puts "Read image: " + image.to_s

class ShowProgress < SimpleITK::Command
    def Execute(filter)
        printf("%1.2f%%", filter.GetProgress)
    end
end

```

--------------------------------

### Read and Show Image Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/Python/Documentation.rst

Illustrates reading an image file and displaying it using SimpleITK. Requires an image file path.

```python
import SimpleITK as sitk

# Example usage for ReadAndShow
```

--------------------------------

### Install SimpleITK Header Files

Source: https://github.com/superelastix/simpleelastix/blob/master/CMakeLists.txt

Installs all header files from various SimpleITK source directories into the installation's include directory. This ensures that users can include SimpleITK headers in their projects.

```cmake
file( GLOB __files
  ${CMAKE_SOURCE_DIR}/Code/BasicFilters/include/[^.]*.h
  ${CMAKE_SOURCE_DIR}/Code/BasicFilters/include/[^.]*.hxx
  ${CMAKE_SOURCE_DIR}/Code/Common/include/[^.]*.h
  ${CMAKE_SOURCE_DIR}/Code/Common/include/[^.]*.hxx
  ${CMAKE_SOURCE_DIR}/Code/Elastix/include/[^.]*.h
  ${CMAKE_SOURCE_DIR}/Code/Elastix/include/[^.]*.hxx
  ${CMAKE_SOURCE_DIR}/Code/IO/include/[^.]*.h
  ${CMAKE_SOURCE_DIR}/Code/IO/include/[^.]*.hxx
  ${CMAKE_SOURCE_DIR}/Code/Registration/include/[^.]*.h
  ${CMAKE_SOURCE_DIR}/Code/Registration/include/[^.]*.hxx
  )

install(FILES ${__files}
  DESTINATION ${SimpleITK_INSTALL_INCLUDE_DIR}
  COMPONENT Development)
```

--------------------------------

### Install SimpleITK Configuration Files

Source: https://github.com/superelastix/simpleelastix/blob/master/CMakeLists.txt

Installs the generated CMake configuration files (SimpleITKConfig.cmake, SimpleITKConfigVersion.cmake, UseSimpleITK.cmake) into the development component of the installation directory. This makes SimpleITK easily discoverable by other CMake projects.

```cmake
install(FILES ${SimpleITK_BINARY_DIR}/CMakeFiles/SimpleITKConfig.cmake
              ${SimpleITK_BINARY_DIR}/SimpleITKConfigVersion.cmake
              ${SimpleITK_BINARY_DIR}/UseSimpleITK.cmake
  DESTINATION ${SimpleITK_INSTALL_PACKAGE_DIR}
  COMPONENT Development)
```

--------------------------------

### CSharp Filter Progress Reporting Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/FilterProgressReporting/Documentation.rst

Complete C# example demonstrating filter progress reporting using a custom Command class.

```csharp
using System;
using SimpleITK;

public class FilterProgressReporting
{
    public static void Main(string[] args)
    {
        Image image = SimpleITK.ReadImage("Resources/RA_T1_1mm_grise.mha");
        ImageFixed.SetSpacing(new double[] { 1.0, 1.0, 1.0 });

        Image imageFixed = image;
        Image imageMoving = image;

        ImageRegistrationMethod imageRegistrationMethod = new ImageRegistrationMethod();

        imageRegistrationMethod.SetMetricAsMattesMutualInformation(
            numberOfHistogramBins: 50);
        imageRegistrationMethod.SetOptimizerAsRegularStepGradientDescent(
            learningRate: 1.0,
            numberOfIterations: 100,
            relaxationFactor: 0.5,
            minimumStepLength: 1e-4);
        imageRegistrationMethod.SetInterpolator(ImageRegistrationMethod.InterpolatorEnum.LINEAR);

        // Setup for the multi-resolution frameworkburg
        double[] imagePyramid = new double[] { 4, 2, 1 };
        imageRegistrationMethod.SetShrinkFactorsPerLevel(new uint[] { 4, 2, 1 });
        imageRegistrationMethod.SetSmoothingSigmasPerLevel(new double[] { 2, 1, 0 });

        // Make sure that the order of setting the composite scales is the same as the order of the levels
        imageRegistrationMethod.SetOptimizerScalesFromPhysicalShift();

        // Don't do this in production code. The scales are not optimized.
        imageRegistrationMethod.SetOptimizerScalesFromPhysicalShift();

        // Setup the command observer
        imageRegistrationMethod.AddCommand(SimpleITK.Command.EventEnum.PROGRESS_EVENT, new ShowProgress());

        // Connect all the filters that will be used by the pipeline
        imageRegistrationMethod.SetFixedImage(imageFixed);
        imageRegistrationMethod.SetMovingImage(imageMoving);

        Transform initialTransform = imageRegistrationMethod.Execute(imageFixed, imageMoving);

        Console.WriteLine("Read image: " + image.ToString());
    }
}

public class ShowProgress : SimpleITK.Command
{
    public override void Execute(Object o)
    {
        if (o is ProcessObject filter)
        {
            Console.WriteLine("{0:0.00}%", filter.GetProgress());
        }
    }
}
```

--------------------------------

### Boarder Segmentation Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/Python/Documentation.rst

Demonstrates boarder segmentation using SimpleITK. Ensure necessary imports are present.

```python
import SimpleITK as sitk

# Example usage for boarder segmentation
```

--------------------------------

### Install SimpleITK with Pip

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/Doxygen/PythonDownloads.dox

Use this command to install SimpleITK if a supported binary is available for your system. This command references the download page for package discovery.

```bash
$ pip install -f https://itk.org/SimpleITKDoxygen/html/PyDownloadPage.html SimpleITK
```

--------------------------------

### C++ Filter Progress Reporting Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/FilterProgressReporting/Documentation.rst

Complete C++ example demonstrating filter progress reporting using a lambda function.

```cpp
#include <iostream>
#include <SimpleITK.h>

int main(int argc, char *argv[])
{
    SimpleITK::Image image = SimpleITK::ReadImage("Resources/RA_T1_1mm_grise.mha");
    image.SetSpacing(std::vector<double>{1.0, 1.0, 1.0});

    SimpleITK::Image imageFixed = image;
    SimpleITK::Image imageMoving = image;

    SimpleITK::ImageRegistrationMethod imageRegistrationMethod;

    imageRegistrationMethod.SetMetricAsMattesMutualInformation(50);
    imageRegistrationMethod.SetOptimizerAsRegularStepGradientDescent(1.0, 100, 0.5, 1e-4);
    imageRegistrationMethod.SetInterpolator(SimpleITK::ImageRegistrationMethodEnums::LINEAR);

    // Setup for the multi-resolution framework
    std::vector<double> imagePyramid = {4, 2, 1};
    imageRegistrationMethod.SetShrinkFactorsPerLevel(std::vector<unsigned int>{4, 2, 1});
    imageRegistrationMethod.SetSmoothingSigmasPerLevel(std::vector<double>{2, 1, 0});

    // Make sure that the order of setting the composite scales is the same as the order of the levels
    imageRegistrationMethod.SetOptimizerScalesFromPhysicalShift();

    // Don't do this in production code. The scales are not optimized.
    imageRegistrationMethod.SetOptimizerScalesFromPhysicalShift();

    // Setup the command observer
    auto command = [&]() {
        std::cout << "Progress: " << imageRegistrationMethod.GetProgress() << std::endl;
    };
    imageRegistrationMethod.AddCommand(SimpleITK::ProgressEvent(), command);

    // Connect all the filters that will be used by the pipeline
    imageRegistrationMethod.SetFixedImage(imageFixed);
    imageRegistrationMethod.SetMovingImage(imageMoving);

    SimpleITK::Transform initialTransform = imageRegistrationMethod.Execute(imageFixed, imageMoving);

    std::cout << "Read image: " << image << std::endl;

    return 0;
}

```

--------------------------------

### Python Filter Progress Reporting Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/FilterProgressReporting/Documentation.rst

Complete Python example demonstrating filter progress reporting using both a custom Command class and lambda functions.

```python
import SimpleITK as sitk

image = sitk.ReadImage("Resources/RA_T1_1mm_grise.mha")
image.SetSpacing([1.0, 1.0, 1.0])

imageFixed = image
imageMoving = image

imageRegistrationMethod = sitk.ImageRegistrationMethod()

imageRegistrationMethod.SetMetricAsMattesMutualInformation(numberOfHistogramBins=50)
imageRegistrationMethod.SetOptimizerAsRegularStepGradientDescent(learningRate=1.0, numberOfIterations=100, relaxationFactor=0.5, minimumStepLength=1e-4)
imageRegistrationMethod.SetInterpolator(sitk.sitkLinear)

# Setup for the multi-resolution framework
imagePyramid = [4, 2, 1]
imageRegistrationMethod.SetShrinkFactorsPerLevel(shrinkFactors=[4, 2, 1])
imageRegistrationMethod.SetSmoothingSigmasPerLevel(smoothingSigmas=[2, 1, 0])

# Make sure that the order of setting the composite scales is the same as the order of the levels
imageRegistrationMethod.SetOptimizerScalesFromPhysicalShift()

# Don't do this in production code. The scales are not optimized.
imageRegistrationMethod.SetOptimizerScalesFromPhysicalShift()

# Setup the command observer
imageRegistrationMethod.AddCommand(sitk.sitkProgressEvent, lambda: print("Progress: {0:3.1f}%\n".format(imageRegistrationMethod.GetProgress())))
imageRegistrationMethod.AddCommand(sitk.sitkEndEvent, lambda: print("Done!"))

# Connect all the filters that will be used by the pipeline
imageRegistrationMethod.SetFixedImage(imageFixed)
imageRegistrationMethod.SetMovingImage(imageMoving)

initialTransform = imageRegistrationMethod.Execute(imageFixed, imageMoving)

print("Read image: " + str(image))

# Example using a derived Command class
class ShowProgress(sitk.Command):
    def Execute(self):
        print("{0:3.1f}%".format(self.filter.GetProgress()))

imageRegistrationMethod.AddCommand(sitk.sitkProgressEvent, ShowProgress())

```

--------------------------------

### R Image Registration Method 2 Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod2/Documentation.rst

Provides an example of image registration using Method 2 in R. Requires the SuperElastix R package.

```r
library(Elastix)

# Load the fixed and moving images
fixedImage <- ImageLoad("fixed.mha")
movingImage <- ImageLoad("moving.mha")

# Load the parameter object
parameterObject <- ParameterObjectLoad("parameters.txt")

# Create an Elastix object
elastix <- Elastix()

# Perform the registration
result <- elastix$Register(fixedImage, movingImage, parameterObject)

# Save the resulting image
ImageSave(result$Fixed, "result.mha")

```

--------------------------------

### C++ Image Registration Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod1/Documentation.rst

Demonstrates image registration using SuperElastix in C++. Requires SuperElastix C++ library.

```cpp
#include "SuperElastix.h"
#include <iostream>

int main(int argc, char *argv[])
{
    //
    // Instantiate the registration method
    //
    auto registrationMethod = SuperElastix::RegistrationMethod::New();

    //
    // Instantiate the optimizer
    //
    auto optimizer = SuperElastix::LBFGSBOptimizer::New();
    registrationMethod->SetOptimizer(optimizer);

    //
    // Instantiate the interpolator
    //
    auto interpolator = SuperElastix::LinearInterpolator::New();
    registrationMethod->SetInterpolator(interpolator);

    //
    // Instantiate the metric
    //
    auto metric = SuperElastix::MeanSquaresImageToImageMetric::New();
    registrationMethod->SetMetric(metric);

    //
    // Instantiate the transform
    //
    auto transform = SuperElastix::Euler3DTransform::New();
    registrationMethod->SetTransform(transform);

    //
    // Instantiate the fixed and moving images
    //
    auto fixedImage = SuperElastix::Image::New("fixed.mha");
    auto movingImage = SuperElastix::Image::New("moving.mha");

    //
    // Set the fixed and moving images
    //
    registrationMethod->SetFixedImage(fixedImage);
    registrationMethod->SetMovingImage(movingImage);

    //
    // Execute the registration
    //
    auto resultTransform = registrationMethod->Execute();

    //
    // Save the resulting transform
    //
    resultTransform->Save("resultTransform.tfm");

    std::cout << "Registration complete. Result saved to resultTransform.tfm" << std::endl;

    return 0;
}
```

--------------------------------

### Install Python Package

Source: https://github.com/superelastix/simpleelastix/blob/master/docs/source/building.rst

Install the built Python package into the system Python environment. This command should be run as root.

```bash
cd SimpleITK-build/Wrapping/Python
python Packaging/setup.py install
```

--------------------------------

### Live HTML Documentation with sphinx-autobuild

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/README.md

Automatically regenerate and serve HTML documentation when files change. Install sphinx-autobuild with pip first.

```bash
make livehtml
```

--------------------------------

### Set Default Installation Prefix

Source: https://github.com/superelastix/simpleelastix/blob/master/SuperBuild/CMakeLists.txt

Sets the CMAKE_INSTALL_PREFIX to the current binary directory if it is not already defined.

```cmake
if( NOT DEFINED CMAKE_INSTALL_PREFIX )
  set(CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH "Where all the prerequisite libraries go")
endif()
```

--------------------------------

### R Image Registration Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod1/Documentation.rst

Shows image registration using SuperElastix in R. Requires SuperElastix R package.

```r
#
# Instantiate the registration method
#
registrationMethod <- SuperElastix$RegistrationMethod()

#
# Instantiate the optimizer
#
optimizer <- SuperElastix$LBFGSBOptimizer()
registrationMethod$SetOptimizer(optimizer)

#
# Instantiate the interpolator
#
interpolator <- SuperElastix$LinearInterpolator()
registrationMethod$SetInterpolator(interpolator)

#
# Instantiate the metric
#
metric <- SuperElastix$MeanSquaresImageToImageMetric()
registrationMethod$SetMetric(metric)

#
# Instantiate the transform
#
transform <- SuperElastix$Euler3DTransform()
registrationMethod$SetTransform(transform)

#
# Instantiate the fixed and moving images
#
fixedImage <- SuperElastix$Image("fixed.mha")
movingImage <- SuperElastix$Image("moving.mha")

#
# Set the fixed and moving images
#
registrationMethod$SetFixedImage(fixedImage)
registrationMethod$SetMovingImage(movingImage)

#
# Execute the registration
#
resultTransform <- registrationMethod$Execute()

#
# Save the resulting transform
#
resultTransform$Save("resultTransform.tfm")

cat("Registration complete. Result saved to resultTransform.tfm\n")
```

--------------------------------

### Add Python Test for Image Creation and Setting

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/Python/CMakeLists.txt

Sets up a Python test for the ImageCreateAndSet example, indicating the script to be tested.

```cmake
sitk_add_python_test( Example.ImageCreateAndSet
  "${CMAKE_CURRENT_SOURCE_DIR}/ImageCreateAndSet.py" )
```

--------------------------------

### Implement Fast Marching Segmentation

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/FastMarchingSegmentation/Documentation.rst

Examples demonstrating the fast marching filter configuration and execution across different languages.

```c#
  // Read the image
  Image inputImage = SimpleITK.ReadImage(args[0]);

  // Smooth the image
  CurvatureAnisotropicDiffusionImageFilter smoothing = new CurvatureAnisotropicDiffusionImageFilter();
  smoothing.SetTimeStep(0.0625);
  smoothing.SetNumberOfIterations(5);
  smoothing.SetConductanceParameter(9.0);
  Image smoothedImage = smoothing.Execute(inputImage);

  // Gradient magnitude
  GradientMagnitudeRecursiveGaussianImageFilter gradient = new GradientMagnitudeRecursiveGaussianImageFilter();
  gradient.SetSigma(double.Parse(args[3]));
  Image gradientImage = gradient.Execute(smoothedImage);

  // Sigmoid
  SigmoidImageFilter sigmoid = new SigmoidImageFilter();
  sigmoid.SetOutputMinimum(0.0);
  sigmoid.SetOutputMaximum(1.0);
  sigmoid.SetAlpha(double.Parse(args[4]));
  sigmoid.SetBeta(double.Parse(args[5]));
  Image speedImage = sigmoid.Execute(gradientImage);

  // Fast Marching
  FastMarchingImageFilter fastMarching = new FastMarchingImageFilter();
  VectorUInt32 trialPoint = new VectorUInt32(2);
  trialPoint[0] = (uint)int.Parse(args[6]);
  trialPoint[1] = (uint)int.Parse(args[7]);
  fastMarching.AddTrialPoint(trialPoint);
  fastMarching.SetStoppingValue(double.Parse(args[8]));
  Image timeCrossingMap = fastMarching.Execute(speedImage);

  // Threshold
  BinaryThresholdImageFilter thresholder = new BinaryThresholdImageFilter();
  thresholder.SetLowerThreshold(0.0);
  thresholder.SetUpperThreshold(double.Parse(args[8]));
  thresholder.SetOutsideValue(0);
  thresholder.SetInsideValue(1);
  Image result = thresholder.Execute(timeCrossingMap);

  SimpleITK.WriteImage(result, args[1]);
```

```C++
#include <SimpleITK.h>

namespace sitk = itk::simple;

int main(int argc, char* argv[]) {

  // Read the image
  sitk::Image inputImage = sitk::ReadImage(argv[1]);

  // Smooth the image
  sitk::CurvatureAnisotropicDiffusionImageFilter smoothing;
  smoothing.SetTimeStep(0.0625);
  smoothing.SetNumberOfIterations(5);
  smoothing.SetConductanceParameter(9.0);
  sitk::Image smoothedImage = smoothing.Execute(inputImage);

  // Gradient magnitude
  sitk::GradientMagnitudeRecursiveGaussianImageFilter gradient;
  gradient.SetSigma(std::stod(argv[4]));
  sitk::Image gradientImage = gradient.Execute(smoothedImage);

  // Sigmoid
  sitk::SigmoidImageFilter sigmoid;
  sigmoid.SetOutputMinimum(0.0);
  sigmoid.SetOutputMaximum(1.0);
  sigmoid.SetAlpha(std::stod(argv[5]));
  sigmoid.SetBeta(std::stod(argv[6]));
  sitk::Image speedImage = sigmoid.Execute(gradientImage);

  // Fast Marching
  sitk::FastMarchingImageFilter fastMarching;
  std::vector<unsigned int> trialPoint = { (unsigned int)std::stoi(argv[7]), (unsigned int)std::stoi(argv[8]) };
  fastMarching.AddTrialPoint(trialPoint);
  fastMarching.SetStoppingValue(std::stod(argv[9]));
  sitk::Image timeCrossingMap = fastMarching.Execute(speedImage);

  // Threshold
  sitk::BinaryThresholdImageFilter thresholder;
  thresholder.SetLowerThreshold(0.0);
  thresholder.SetUpperThreshold(std::stod(argv[9]));
  thresholder.SetOutsideValue(0);
  thresholder.SetInsideValue(1);
  sitk::Image result = thresholder.Execute(timeCrossingMap);

  sitk::WriteImage(result, argv[2]);

  return 0;
}
```

```python
import SimpleITK as sitk
import sys

# Read the image
inputImage = sitk.ReadImage(sys.argv[1])

# Smooth the image
smoothing = sitk.CurvatureAnisotropicDiffusionImageFilter()
smoothing.SetTimeStep(0.0625)
smoothing.SetNumberOfIterations(5)
smoothing.SetConductanceParameter(9.0)
smoothedImage = smoothing.Execute(inputImage)

# Gradient magnitude
gradient = sitk.GradientMagnitudeRecursiveGaussianImageFilter()
gradient.SetSigma(float(sys.argv[4]))
gradientImage = gradient.Execute(smoothedImage)

# Sigmoid
sigmoid = sitk.SigmoidImageFilter()
sigmoid.SetOutputMinimum(0.0)
sigmoid.SetOutputMaximum(1.0)
sigmoid.SetAlpha(float(sys.argv[5]))
sigmoid.SetBeta(float(sys.argv[6]))
speedImage = sigmoid.Execute(gradientImage)

# Fast Marching
fastMarching = sitk.FastMarchingImageFilter()
trialPoint = (int(sys.argv[7]), int(sys.argv[8]))
fastMarching.AddTrialPoint(trialPoint)
fastMarching.SetStoppingValue(float(sys.argv[9]))
timeCrossingMap = fastMarching.Execute(speedImage)

# Threshold
thresholder = sitk.BinaryThresholdImageFilter()
thresholder.SetLowerThreshold(0.0)
thresholder.SetUpperThreshold(float(sys.argv[9]))
thresholder.SetOutsideValue(0)
thresholder.SetInsideValue(1)
result = thresholder.Execute(timeCrossingMap)

sitk.WriteImage(result, sys.argv[2])
```

--------------------------------

### Image Creation and Setting Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/Python/Documentation.rst

Shows how to create a new SimpleITK image and set its pixel values. Useful for generating synthetic data.

```python
import SimpleITK as sitk

# Example usage for ImageCreateAndSet
```

--------------------------------

### Set up Java Project with SimpleElastix

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/Sphinx/GettingStarted.md

Instructions for setting up a Java project to use SimpleElastix, involving adding the SimpleITK jar to the classpath and setting the native library path.

```java
1. Add the simpleitk jar to classpath (simpleitk-<version>.jar)
2. Set the path to the Native Library, in this case ${BUILD_DIRECTORY}/SimpleITK-build/Wrapping/Java/lib
```

--------------------------------

### R Image Registration Method 4 Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod4/Documentation.rst

This R script performs image registration using Method 4. Ensure the SimpleITK package is installed and loaded.

```r
library(SimpleITK)

args <- commandArgs(trailingOnly = TRUE)
if (length(args) != 2) {
  stop("Usage: Rscript ImageRegistrationMethod4.R <fixedImageFile> <movingImageFile>", call. = FALSE)
}

# Setup for registration
image_type <- "sitkFloat32"

# Read the images
fixed_image <- tryCatch({
  castImage(readImage(args[1]), image_type)
}, error = function(e) {
  stop("Error reading fixed image: ", e$message)
})

moving_image <- tryCatch({
  castImage(readImage(args[2]), image_type)
}, error = function(e) {
  stop("Error reading moving image: ", e$message)
})

# The registration method is chosen by the "SetMetric" method.
# For example:
#   SetMetricAsMattesMutualInformation
#   SetMetricAsMattesMutualInformationSecondOrder
#   SetMetricAsCorrelation
#   SetMetricAsMeanSquares
#   SetMetricAsDemons
#   SetMetricAsOtsuMutualInformation
#   SetMetricAsJointHistogramMutualInformation

# Setup the registration
registration_method <- ImageRegistrationMethod$new()
registration_method$SetMetricAsMattesMutualInformation(numberOfHistogramBins = 50)
registration_method$SetOptimizerAsRegularStepGradientDescent(learningRate = 1.0, numberOfIterations = 100, convergenceMinimumValue = 1e-6, convergenceWindowSize = 10)
registration_method$SetInterpolator(sitkLinear)

# Setup the multi-resolution framework.
# The image is scaled down by a factor of 2 in each dimension.
# The number of levels is 3.
registration_method$SetShrinkFactorsPerLevel(shrinkFactors = c(4, 2, 1))
registration_method$SetSmoothingSigmasPerLevel(smoothingSigmas = c(2, 1, 0))
registration_method$SmoothingSigmasAreSpecifiedInPhysicalUnitsOn()

# Execute the registration
final_transform <- registration_method$Execute(fixed_image, moving_image)

print(paste("Optimizer stop condition: ", registration_method$GetOptimizerStopConditionDescription()))
print(paste("Final metric value: ", registration_method$GetMetricValue()))

# Save the result
# writeImage(resampleImage(moving_image, fixed_image, final_transform, sitkLinear, 0.0, fixed_image$GetPixelID()), "result.mha")

```

--------------------------------

### Build HTML Documentation

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/README.md

Build the HTML documentation locally by running the make html command in the Documentation/ directory.

```bash
make html
```

--------------------------------

### Clone and Build SimpleElastix on Linux

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/Sphinx/GettingStarted.md

Use these commands to clone the SimpleElastix repository, set up the build directory, configure the build with CMake, and initiate the compilation process. Ensure you have sufficient memory (4GB per core) and avoid using more cores than available.

```bash
git clone https://github.com/SuperElastix/SimpleElastix
mkdir build
cd build
cmake ../SimpleElastix/SuperBuild
make -j4
```

--------------------------------

### Compute SimpleITK Installation Prefix

Source: https://github.com/superelastix/simpleelastix/blob/master/CMakeLists.txt

This CMake code computes the installation prefix for SimpleITK by parsing the SimpleITK_INSTALL_PACKAGE_DIR. It ensures that the installation prefix is correctly determined for subsequent configuration steps.

```cmake
string(REGEX REPLACE "/" ";" _count "${SimpleITK_INSTALL_PACKAGE_DIR}")
foreach(p ${_count})
  set(SimpleITKConfig_CODE "${SimpleITKConfig_CODE}
get_filename_component(SimpleITK_INSTALL_PREFIX \"
${SimpleITK_INSTALL_PREFIX}\" PATH)")
endforeach(p)
set(SimpleITKConfig_CODE "${SimpleITKConfig_CODE}\n")
```

--------------------------------

### Java Image Registration Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod1/Documentation.rst

Shows how to perform image registration with SuperElastix in Java. Ensure SuperElastix Java bindings are set up.

```java
import SuperElastix.*;

public class ImageRegistrationMethod1 {

    public static void main(String[] args) {
        //
        // Instantiate the registration method
        //
        RegistrationMethod registrationMethod = new RegistrationMethod();

        //
        // Instantiate the optimizer
        //
        LBFGSBOptimizer optimizer = new LBFGSBOptimizer();
        registrationMethod.SetOptimizer(optimizer);

        //
        // Instantiate the interpolator
        //
        LinearInterpolator interpolator = new LinearInterpolator();
        registrationMethod.SetInterpolator(interpolator);

        //
        // Instantiate the metric
        //
        MeanSquaresImageToImageMetric metric = new MeanSquaresImageToImageMetric();
        registrationMethod.SetMetric(metric);

        //
        // Instantiate the transform
        //
        Euler3DTransform transform = new Euler3DTransform();
        registrationMethod.SetTransform(transform);

        //
        // Instantiate the fixed and moving images
        //
        Image fixedImage = new Image("fixed.mha");
        Image movingImage = new Image("moving.mha");

        //
        // Set the fixed and moving images
        //
        registrationMethod.SetFixedImage(fixedImage);
        registrationMethod.SetMovingImage(movingImage);

        //
        // Execute the registration
        //
        Transform resultTransform = registrationMethod.Execute();

        //
        // Save the resulting transform
        //
        resultTransform.Save("resultTransform.tfm");

        System.out.println("Registration complete. Result saved to resultTransform.tfm");
    }
}
```

--------------------------------

### Install Ancillary Header Directory

Source: https://github.com/superelastix/simpleelastix/blob/master/CMakeLists.txt

Installs the 'Ancillary' header files from the Common include directory. This ensures that any auxiliary header files are correctly placed in the installation's include path.

```cmake
install(
  DIRECTORY
    ${CMAKE_SOURCE_DIR}/Code/Common/include/Ancillary
  DESTINATION
    ${SimpleITK_INSTALL_INCLUDE_DIR}/
  COMPONENT Development
  FILES_MATCHING PATTERN "*.h"
)
```

--------------------------------

### C++ Image Registration Method 2 Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod2/Documentation.rst

Illustrates image registration using Method 2 in C++. Requires SuperElastix C++ API and appropriate parameter files.

```cpp
#include "Elastix.h"
#include "ParameterObject.h"
#include "Image.h"

#include <iostream>

int main(int argc, char *argv[])
{
    // Create an Elastix object
    Elastix elastix;

    // Load the fixed and moving images
    Image::Pointer fixedImage = Image::Load("fixed.mha");
    Image::Pointer movingImage = Image::Load("moving.mha");

    // Load the parameter object
    ParameterObject::Pointer parameterObject = ParameterObject::Load("parameters.txt");

    // Perform the registration
    Image::Pointer result = elastix.Register(fixedImage, movingImage, parameterObject);

    // Save the resulting image
    result->Save("result.mha");

    return EXIT_SUCCESS;
}
```

--------------------------------

### Enable x64 Build Environment

Source: https://github.com/superelastix/simpleelastix/blob/master/Documentation/Sphinx/GettingStarted.md

Run the vcvarsall script to set up the 64-bit build environment before running CMake.

```bash
vcvarsall amd64
```

--------------------------------

### C# Image Registration Method 2 Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/ImageRegistrationMethod2/Documentation.rst

Demonstrates image registration using Method 2 in C#. Ensure necessary SuperElastix libraries are included.

```csharp
using System;
using System.IO;
using Elastix;

namespace ImageRegistrationMethod2
{
    class ImageRegistrationMethod2
    {
        static void Main(string[] args)
        {
            // Create an Elastix object
            using (var elastix = new Elastix())
            {
                // Load the fixed and moving images
                var fixedImage = Image.Load("fixed.mha");
                var movingImage = Image.Load("moving.mha");

                // Load the parameter object
                var parameterObject = ParameterObject.Load("parameters.txt");

                // Perform the registration
                var result = elastix.Register(fixedImage, movingImage, parameterObject);

                // Save the resulting image
                result.Fixed.Save("result.mha");
            }
        }
    }
}
```

--------------------------------

### Install SimpleITK via Conda

Source: https://github.com/superelastix/simpleelastix/blob/master/docs/source/installation.rst

Installs SimpleITK from the SimpleITK channel using the conda package manager.

```bash
conda install -c simpleitk simpleitk
```

```bash
conda install -c simpleitk/label/dev simpleitk
```

--------------------------------

### Define Compare Driver Executable

Source: https://github.com/superelastix/simpleelastix/blob/master/Testing/Unit/TestBase/CMakeLists.txt

Creates the sitkCompareDriver executable and installs it using the project-specific install macro.

```cmake
add_executable( sitkCompareDriver sitkCompareDriver.cxx )
target_link_libraries( sitkCompareDriver SimpleITKUnitTestBase ${SimpleITK_LIBRARIES} ${ITK_LIBRARIES})
target_compile_options( sitkCompareDriver
  PRIVATE
    ${SimpleITK_PRIVATE_COMPILE_OPTIONS} )

sitk_install_exported_target(sitkCompareDriver)
```

--------------------------------

### R Filter Progress Reporting Example

Source: https://github.com/superelastix/simpleelastix/blob/master/Examples/FilterProgressReporting/Documentation.rst

Complete R example demonstrating filter progress reporting using lambda functions.

```r
library(SimpleITK)

image <- ReadImage("Resources/RA_T1_1mm_grise.mha")
image$SetSpacing(c(1.0, 1.0, 1.0))

imageFixed <- image
imageMoving <- image

imageRegistrationMethod <- ImageRegistrationMethod()

imageRegistrationMethod$SetMetricAsMattesMutualInformation(numberOfHistogramBins=50)
imageRegistrationMethod$SetOptimizerAsRegularStepGradientDescent(learningRate=1.0, numberOfIterations=100, relaxationFactor=0.5, minimumStepLength=1e-4)
imageRegistrationMethod$SetInterpolator(SimpleITK.sitkLinear)

# Setup for the multi-resolution framework
imagePyramid <- c(4, 2, 1)
imageRegistrationMethod$SetShrinkFactorsPerLevel(shrinkFactors=c(4, 2, 1))
imageRegistrationMethod$SetSmoothingSigmasPerLevel(smoothingSigmas=c(2, 1, 0))

# Make sure that the order of setting the composite scales is the same as the order of the levels
imageRegistrationMethod$SetOptimizerScalesFromPhysicalShift()

# Don't do this in production code. The scales are not optimized.
imageRegistrationMethod$SetOptimizerScalesFromPhysicalShift()

# Setup the command observer
imageRegistrationMethod$AddCommand(SimpleITK.ProgressEvent(), function() {
    cat(sprintf("Progress: %f%%\n", imageRegistrationMethod$GetProgress()))
})
imageRegistrationMethod$AddCommand(SimpleITK.EndEvent(), function() {
    cat("Done!\n")
})

# Connect all the filters that will be used by the pipeline
imageRegistrationMethod$SetFixedImage(imageFixed)
imageRegistrationMethod$SetMovingImage(imageMoving)

initialTransform <- imageRegistrationMethod$Execute(imageFixed, imageMoving)

print(paste("Read image: ", image))

```