diff --git a/content/_index.md b/content/_index.md index 44c54ba..fcd5225 100644 --- a/content/_index.md +++ b/content/_index.md @@ -69,7 +69,34 @@ Temporal: --- -## Fundamental Technique #1 - Feature Detection & Transformation +## Integrated Techniques: One-Step Registration + +{{< notes >}} +Introducing registration methods that integrate detection and transformation into a single process. +{{}} + +- **Intensity-Based Registration** + - Iterative - Optimize pixel intensity similarities directly to align images +- **Mutual Information-Based Registration** + - Iterative - Use statistical dependence to align multimodal images +- **Frequency Domain Methods** + - Compute transformations using Fourier transforms in the frequency domain. +- **Deep Learning-Based Registration** + - Neural networks predict transformations directly from image data + +--- + +## Example Technique: Mutual Information + +Mutual Information iterations + +- [https://github.com/bellonet/image-registration-workshop/blob/main/example_notebooks/mutual_information.ipynb +](https://github.com/bellonet/image-registration-workshop/blob/main/example_notebooks/mutual_information.ipynb +) + +--- + +## 2 Step Techniques - Feature Detection & Transformation {{< notes >}} An overview of common methods used in image registration, highlighting the two main steps involved. @@ -215,23 +242,6 @@ Image by [Cmglee](https://commons.wikimedia.org/wiki/User:Cmglee), license: CC B --- -## Integrated Techniques: One-Step Registration - -{{< notes >}} -Introducing registration methods that integrate detection and transformation into a single process. -{{}} - -- **Intensity-Based Registration** - - Iterative - Optimize pixel intensity similarities directly to align images -- **Mutual Information-Based Registration** - - Iterative - Use statistical dependence to align multimodal images -- **Frequency Domain Methods** - - Compute transformations using Fourier transforms in the frequency domain. -- **Deep Learning-Based Registration** - - Neural networks predict transformations directly from image data - ---- - ## Challenges & Considerations {{< horizontal >}} @@ -274,12 +284,17 @@ Overview of common tools, libraries, and plugins for image registration. - Popular plugins: **Feature Extraction**, **Warpy** (QPath), **TrakEM2**, **Register Virtual Stack Slices** - **Python Libraries** - **OpenCV** (C++), **scikit-image** -- **Elastix** +- **[Elastix](https://elastix.dev/index.php)** - ITKElastix (C++) is a powerful open-source tool (standalone or as a python package) for intensity-based registration. -- **DeepLabCut** - - Open-source deep learning based pose estimation and model based feature detection (and tracking) -- **MATLAB** - - Image Processing Toolbox (functions like `imregister`, `cpselect`) +- **[DeepLabCut](https://github.com/DeepLabCut/DeepLabCut)** + - Open-source deep learning based pose estimation and model based feature detection (and tracking). + +
+ +- VoltRon: R package that includes an interactive GUI for image registration. +[https://bioinformatics.mdc-berlin.de/VoltRon/index.html](https://bioinformatics.mdc-berlin.de/VoltRon/index.html) +- SIFT based image registration Python package: +[https://gitlab.com/ida-mdc/image-registration-tool](https://gitlab.com/ida-mdc/image-registration-tool) --- diff --git a/example_notebooks/kevin-rotated-20.jpg b/example_notebooks/kevin-rotated-20.jpg new file mode 100644 index 0000000..461b323 Binary files /dev/null and b/example_notebooks/kevin-rotated-20.jpg differ diff --git a/example_notebooks/kevin.jpg b/example_notebooks/kevin.jpg new file mode 100644 index 0000000..1b521c8 Binary files /dev/null and b/example_notebooks/kevin.jpg differ diff --git a/example_notebooks/mutual_information.ipynb b/example_notebooks/mutual_information.ipynb new file mode 100644 index 0000000..84ce44d --- /dev/null +++ b/example_notebooks/mutual_information.ipynb @@ -0,0 +1,663 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "319c20e3-32c9-43ac-84d4-45378f1b7e2f", + "metadata": {}, + "source": [ + "The image registration process implemented utilizes SimpleITK to align a moving image to a fixed reference image through an iterative optimization framework. \n", + "The registration employs a Mattes Mutual Information metric, which quantifies the statistical dependence between the intensity distributions of the two images, making it particularly effective for multimodal image registration. \n", + "\n", + "It also outputs a tif file where each slice is the mutual information joint histogram at a specific iteration of the registration process. \n", + "Each histogram visualizes the distribution and correlation of intensity values between the fixed and moving images at that iteration, with color intensity representing the frequency of intensity co-occurrences." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d2720494-ec55-442a-9cdd-133079f2d6ee", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import SimpleITK as sitk\n", + "from scipy.stats import entropy\n", + "import tifffile\n", + "from typing import Tuple, List\n", + "import logging\n", + "from scipy.ndimage import zoom" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f30e6752-029f-4f5b-a956-f298e1212038", + "metadata": {}, + "outputs": [], + "source": [ + "# Configure logging\n", + "logging.basicConfig(\n", + " level=logging.INFO,\n", + " format='%(asctime)s - %(levelname)s - %(message)s',\n", + " handlers=[\n", + " logging.StreamHandler()\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8d89afe2-264d-495e-bd49-4103dd9afe89", + "metadata": {}, + "outputs": [], + "source": [ + "def normalize_image(img: np.ndarray) -> np.ndarray:\n", + "\n", + " img_min = np.min(img)\n", + " img_max = np.max(img)\n", + " if img_max > img_min:\n", + " img_normalized = (img - img_min) / (img_max - img_min)\n", + " else:\n", + " img_normalized = np.zeros_like(img)\n", + " img_uint8 = (img_normalized * 255).astype(np.uint8)\n", + " return img_uint8\n", + "\n", + "\n", + "def show_images(fixed: np.ndarray, moving: np.ndarray, title: str = \"\") -> None:\n", + "\n", + " fig, axes = plt.subplots(1, 2, figsize=(10, 5))\n", + " axes[0].imshow(fixed, cmap=\"gray\")\n", + " axes[0].set_title(\"Fixed Image\")\n", + " axes[1].imshow(moving, cmap=\"gray\")\n", + " axes[1].set_title(\"Moving Image\")\n", + " plt.suptitle(title)\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0c1e5514-88ea-4b3c-82fe-8795327433f0", + "metadata": {}, + "outputs": [], + "source": [ + "def resize_image(img: np.ndarray, target_height: int) -> np.ndarray:\n", + "\n", + " original_height, original_width = img.shape[:2]\n", + " scale_factor = target_height / original_height\n", + " target_width = int(original_width * scale_factor)\n", + " \n", + " if len(img.shape) == 3:\n", + " # RGB image\n", + " resized_img = zoom(img, (scale_factor, scale_factor, 1), order=1)\n", + " else:\n", + " # Grayscale image\n", + " resized_img = zoom(img, (scale_factor, scale_factor), order=1)\n", + " \n", + " # Ensure the resized image has the exact target height\n", + " resized_img = resized_img[:target_height, :target_width]\n", + " \n", + " return resized_img.astype(np.uint8)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "173c4825-131f-4bf9-ab79-28befe2172a3", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_mutual_information(fixed: np.ndarray, moving: np.ndarray, iteration: int = None, bins: int = 50) -> Tuple[float, np.ndarray]:\n", + "\n", + " # Compute joint histogram\n", + " hist_2d, x_edges, y_edges = np.histogram2d(fixed.ravel(), moving.ravel(), bins=bins)\n", + " \n", + " # Normalize to get joint probabilities\n", + " pxy = hist_2d / np.sum(hist_2d)\n", + " \n", + " # Marginal probabilities\n", + " px = np.sum(pxy, axis=1)\n", + " py = np.sum(pxy, axis=0)\n", + " \n", + " # Entropies\n", + " Hx = entropy(px)\n", + " Hy = entropy(py)\n", + " Hxy = entropy(pxy.ravel())\n", + " \n", + " # Mutual Information\n", + " mutual_info = Hx + Hy - Hxy\n", + " \n", + " # Create joint histogram plot with RGB colormap\n", + " fig, ax = plt.subplots(figsize=(4, 4))\n", + " cax = ax.imshow(hist_2d.T, origin='lower', cmap='hot', aspect='auto')\n", + " if iteration is not None:\n", + " ax.set_title(f'Iteration: {iteration}\\nMutual Information: {mutual_info:.4f}')\n", + " else:\n", + " ax.set_title(f'Mutual Information: {mutual_info:.4f}')\n", + " ax.set_xlabel('Fixed Image Intensity')\n", + " ax.set_ylabel('Moving Image Intensity')\n", + " fig.colorbar(cax, label='Joint Histogram Count')\n", + " \n", + " # Render the plot to a NumPy array using buffer_rgba\n", + " fig.canvas.draw()\n", + " mi_image_rgba = np.frombuffer(fig.canvas.buffer_rgba(), dtype=np.uint8)\n", + " mi_image_rgba = mi_image_rgba.reshape(fig.canvas.get_width_height()[::-1] + (4,))\n", + " plt.close(fig)\n", + " \n", + " # Convert RGBA to RGB by discarding the alpha channel\n", + " mi_image = mi_image_rgba[..., :3]\n", + " \n", + " return mutual_info, mi_image" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ce7cf0df-fa6d-4453-812c-fb911eb14e5f", + "metadata": {}, + "outputs": [], + "source": [ + "def combine_visualizations(fixed_img: np.ndarray, moving_img: np.ndarray, mi_img: np.ndarray) -> np.ndarray:\n", + "\n", + " # Normalize and convert grayscale images to uint8\n", + " fixed_uint8 = normalize_image(fixed_img)\n", + " moving_uint8 = normalize_image(moving_img)\n", + " \n", + " # Convert grayscale to RGB by stacking\n", + " fixed_rgb = np.stack([fixed_uint8]*3, axis=-1)\n", + " moving_rgb = np.stack([moving_uint8]*3, axis=-1)\n", + " \n", + " # Resize images to a smaller height for reduced resolution\n", + " target_height = 300 # Example target height for smaller resolution\n", + " fixed_resized = resize_image(fixed_rgb, target_height)\n", + " moving_resized = resize_image(moving_rgb, target_height)\n", + " mi_resized = resize_image(mi_img, target_height)\n", + " \n", + " # Ensure all images have the same height\n", + " if mi_resized.shape[0] != target_height:\n", + " # If resizing didn't achieve the exact target height, pad the image\n", + " pad_height = target_height - mi_resized.shape[0]\n", + " if pad_height > 0:\n", + " mi_resized = np.pad(mi_resized, ((0, pad_height), (0,0), (0,0)), mode='constant', constant_values=0)\n", + " else:\n", + " mi_resized = mi_resized[:target_height, :, :]\n", + " \n", + " # Concatenate images horizontally\n", + " combined_img = np.concatenate((fixed_resized, moving_resized, mi_resized), axis=1)\n", + " \n", + " return combined_img" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "761561c6-c8b1-4e5b-aa8c-28b6b4ef7052", + "metadata": {}, + "outputs": [], + "source": [ + "class RegistrationIterationCallback:\n", + " \"\"\"\n", + " Callback class to monitor and record mutual information during registration iterations.\n", + " \"\"\"\n", + " \n", + " def __init__(\n", + " self,\n", + " fixed_image: sitk.Image,\n", + " moving_image: sitk.Image,\n", + " initial_transform: sitk.Transform,\n", + " registration_method: sitk.ImageRegistrationMethod,\n", + " save_every: int = 1\n", + " ):\n", + " \"\"\"\n", + " Initialize the callback with necessary references.\n", + " \n", + " Parameters:\n", + " - fixed_image (sitk.Image): Fixed image.\n", + " - moving_image (sitk.Image): Moving image.\n", + " - initial_transform (sitk.Transform): Initial transform.\n", + " - registration_method (sitk.ImageRegistrationMethod): Registration method instance.\n", + " - save_every (int): Interval of iterations to save combined images.\n", + " \"\"\"\n", + " self.fixed = fixed_image\n", + " self.moving = moving_image\n", + " self.initial_transform = initial_transform\n", + " self.registration_method = registration_method\n", + " self.combined_images: List[np.ndarray] = []\n", + " self.save_every = save_every # Save combined image every 'save_every' iterations\n", + " self.total_iterations = 0 # Global iteration counter\n", + " \n", + " def __call__(self) -> None:\n", + " \"\"\"\n", + " Invoked at each registration iteration.\n", + " \"\"\"\n", + " try:\n", + " # Get current optimizer parameters\n", + " current_parameters = self.registration_method.GetOptimizerPosition()\n", + " except AttributeError:\n", + " logging.error(\"Unable to retrieve optimizer position.\")\n", + " return\n", + "\n", + " # Increment global iteration counter\n", + " self.total_iterations += 1\n", + "\n", + " if self.total_iterations % self.save_every != 0:\n", + " # Skip saving for this iteration\n", + " return\n", + "\n", + " # Create a new transform instance based on the initial transform's type\n", + " transform_type = type(self.initial_transform)\n", + " current_transform = transform_type()\n", + "\n", + " # Set fixed parameters (e.g., center of rotation)\n", + " current_transform.SetFixedParameters(self.initial_transform.GetFixedParameters())\n", + "\n", + " # Set moving parameters (e.g., rotation angle, translations)\n", + " current_transform.SetParameters(tuple(current_parameters))\n", + "\n", + " # Resample the moving image with the updated transform\n", + " moving_resampled = sitk.Resample(\n", + " self.moving,\n", + " self.fixed,\n", + " current_transform,\n", + " sitk.sitkLinear,\n", + " 0.0,\n", + " self.moving.GetPixelID()\n", + " )\n", + "\n", + " # Convert images to NumPy arrays\n", + " fixed_array = sitk.GetArrayFromImage(self.fixed)\n", + " moving_resampled_array = sitk.GetArrayFromImage(moving_resampled)\n", + "\n", + " # Compute mutual information and get MI image\n", + " mutual_info, mi_image = compute_mutual_information(fixed_array, moving_resampled_array, iteration=self.total_iterations)\n", + "\n", + " # Combine fixed, moving, and MI images into one visualization\n", + " combined_img = combine_visualizations(fixed_array, moving_resampled_array, mi_image)\n", + "\n", + " # Append the combined image to the list\n", + " self.combined_images.append(combined_img)\n", + "\n", + " # Log iteration details with global count\n", + " metric_value = self.registration_method.GetMetricValue()\n", + " logging.info(f\"Global Iteration: {self.total_iterations}, \"\n", + " f\"Metric Value: {metric_value:.4f}, \"\n", + " f\"Mutual Information: {mutual_info:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c0eab67b-25a6-416f-9ae1-01c86534bf13", + "metadata": {}, + "outputs": [], + "source": [ + "def perform_registration(\n", + " fixed_image_path: str,\n", + " moving_image_path: str,\n", + " output_tiff_path: str,\n", + " num_iterations: int = 200,\n", + " bins: int = 50,\n", + " save_every: int = 1\n", + ") -> sitk.Transform:\n", + "\n", + " # Read images\n", + " fixed_image = sitk.ReadImage(fixed_image_path, sitk.sitkFloat32)\n", + " moving_image = sitk.ReadImage(moving_image_path, sitk.sitkFloat32)\n", + "\n", + " # Initial display of the images\n", + " fixed_array = sitk.GetArrayFromImage(fixed_image)\n", + " moving_array = sitk.GetArrayFromImage(moving_image)\n", + " show_images(fixed_array, moving_array, title=\"Before Registration\")\n", + "\n", + " # Set up the registration framework\n", + " registration_method = sitk.ImageRegistrationMethod()\n", + "\n", + " # Similarity metric: Mattes Mutual Information\n", + " registration_method.SetMetricAsMattesMutualInformation(numberOfHistogramBins=bins)\n", + "\n", + " # Optimizer settings\n", + " registration_method.SetOptimizerAsGradientDescent(\n", + " learningRate=1.0,\n", + " numberOfIterations=num_iterations,\n", + " convergenceMinimumValue=1e-6,\n", + " convergenceWindowSize=10\n", + " )\n", + " registration_method.SetOptimizerScalesFromPhysicalShift()\n", + "\n", + " # Set the interpolator\n", + " registration_method.SetInterpolator(sitk.sitkLinear)\n", + "\n", + " # Set up the initial transform (Euler 2D)\n", + " initial_transform = sitk.CenteredTransformInitializer(\n", + " fixed_image,\n", + " moving_image,\n", + " sitk.Euler2DTransform(),\n", + " sitk.CenteredTransformInitializerFilter.GEOMETRY\n", + " )\n", + "\n", + " registration_method.SetInitialTransform(initial_transform, inPlace=False)\n", + "\n", + " # Multi-resolution framework\n", + " registration_method.SetShrinkFactorsPerLevel(shrinkFactors=[4, 2, 1])\n", + " registration_method.SetSmoothingSigmasPerLevel(smoothingSigmas=[2, 1, 0])\n", + " registration_method.SmoothingSigmasAreSpecifiedInPhysicalUnitsOn()\n", + "\n", + " # Initialize and add the callback\n", + " callback = RegistrationIterationCallback(\n", + " fixed_image,\n", + " moving_image,\n", + " initial_transform,\n", + " registration_method,\n", + " save_every=save_every\n", + " )\n", + " registration_method.AddCommand(sitk.sitkIterationEvent, callback)\n", + "\n", + " # Execute the registration\n", + " try:\n", + " final_transform = registration_method.Execute(\n", + " sitk.Cast(fixed_image, sitk.sitkFloat32),\n", + " sitk.Cast(moving_image, sitk.sitkFloat32)\n", + " )\n", + " except RuntimeError as e:\n", + " logging.error(f\"Registration failed: {e}\")\n", + " raise e\n", + "\n", + " # Apply the final transform to the moving image\n", + " moving_resampled = sitk.Resample(\n", + " moving_image,\n", + " fixed_image,\n", + " final_transform,\n", + " sitk.sitkLinear,\n", + " 0.0,\n", + " moving_image.GetPixelID()\n", + " )\n", + "\n", + " # Convert resampled image to NumPy array for display\n", + " moving_resampled_array = sitk.GetArrayFromImage(moving_resampled)\n", + " show_images(fixed_array, moving_resampled_array, title=\"After Registration\")\n", + "\n", + " # Print the final transform parameters\n", + " logging.info(f\"Final transform parameters: {final_transform}\")\n", + "\n", + " # Save the combined images as a TIFF stack using tifffile\n", + " if callback.combined_images:\n", + " # Stack images along the first axis (pages)\n", + " combined_stack = np.stack(callback.combined_images, axis=0)\n", + " # Save as multi-page TIFF with RGB photometric interpretation\n", + " tifffile.imwrite(output_tiff_path, combined_stack, photometric='rgb')\n", + " logging.info(f\"Combined visualizations saved as {output_tiff_path}\")\n", + " else:\n", + " logging.warning(\"No combined images were captured during registration.\")\n", + "\n", + " return final_transform" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "960da4c5-607e-4645-ba13-e5c5681a7c49", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-22 20:27:16,691 - INFO - Global Iteration: 1, Metric Value: -0.5017, Mutual Information: 0.5193\n", + "2024-09-22 20:27:17,174 - INFO - Global Iteration: 2, Metric Value: -0.5035, Mutual Information: 0.5212\n", + "2024-09-22 20:27:17,634 - INFO - Global Iteration: 3, Metric Value: -0.5046, Mutual Information: 0.5225\n", + "2024-09-22 20:27:18,105 - INFO - Global Iteration: 4, Metric Value: -0.5058, Mutual Information: 0.5249\n", + "2024-09-22 20:27:18,555 - INFO - Global Iteration: 5, Metric Value: -0.5073, Mutual Information: 0.5260\n", + "2024-09-22 20:27:19,122 - INFO - Global Iteration: 6, Metric Value: -0.5085, Mutual Information: 0.5275\n", + "2024-09-22 20:27:19,578 - INFO - Global Iteration: 7, Metric Value: -0.5097, Mutual Information: 0.5288\n", + "2024-09-22 20:27:20,070 - INFO - Global Iteration: 8, Metric Value: -0.5107, Mutual Information: 0.5297\n", + "2024-09-22 20:27:20,546 - INFO - Global Iteration: 9, Metric Value: -0.5118, Mutual Information: 0.5309\n", + "2024-09-22 20:27:21,019 - INFO - Global Iteration: 10, Metric Value: -0.5124, Mutual Information: 0.5319\n", + "2024-09-22 20:27:21,502 - INFO - Global Iteration: 11, Metric Value: -0.5136, Mutual Information: 0.5330\n", + "2024-09-22 20:27:21,982 - INFO - Global Iteration: 12, Metric Value: -0.5147, Mutual Information: 0.5340\n", + "2024-09-22 20:27:22,468 - INFO - Global Iteration: 13, Metric Value: -0.5160, Mutual Information: 0.5353\n", + "2024-09-22 20:27:22,939 - INFO - Global Iteration: 14, Metric Value: -0.5167, Mutual Information: 0.5365\n", + "2024-09-22 20:27:23,440 - INFO - Global Iteration: 15, Metric Value: -0.5171, Mutual Information: 0.5372\n", + "2024-09-22 20:27:23,889 - INFO - Global Iteration: 16, Metric Value: -0.5184, Mutual Information: 0.5380\n", + "2024-09-22 20:27:24,357 - INFO - Global Iteration: 17, Metric Value: -0.5190, Mutual Information: 0.5390\n", + "2024-09-22 20:27:24,934 - INFO - Global Iteration: 18, Metric Value: -0.5198, Mutual Information: 0.5398\n", + "2024-09-22 20:27:25,442 - INFO - Global Iteration: 19, Metric Value: -0.5209, Mutual Information: 0.5410\n", + "2024-09-22 20:27:25,928 - INFO - Global Iteration: 20, Metric Value: -0.5218, Mutual Information: 0.5420\n", + "2024-09-22 20:27:26,406 - INFO - Global Iteration: 21, Metric Value: -0.5234, Mutual Information: 0.5438\n", + "2024-09-22 20:27:26,870 - INFO - Global Iteration: 22, Metric Value: -0.5243, Mutual Information: 0.5454\n", + "2024-09-22 20:27:27,362 - INFO - Global Iteration: 23, Metric Value: -0.5256, Mutual Information: 0.5466\n", + "2024-09-22 20:27:27,833 - INFO - Global Iteration: 24, Metric Value: -0.5265, Mutual Information: 0.5487\n", + "2024-09-22 20:27:28,311 - INFO - Global Iteration: 25, Metric Value: -0.5276, Mutual Information: 0.5496\n", + "2024-09-22 20:27:28,798 - INFO - Global Iteration: 26, Metric Value: -0.5287, Mutual Information: 0.5512\n", + "2024-09-22 20:27:29,274 - INFO - Global Iteration: 27, Metric Value: -0.5295, Mutual Information: 0.5526\n", + "2024-09-22 20:27:29,786 - INFO - Global Iteration: 28, Metric Value: -0.5304, Mutual Information: 0.5547\n", + "2024-09-22 20:27:30,294 - INFO - Global Iteration: 29, Metric Value: -0.5316, Mutual Information: 0.5563\n", + "2024-09-22 20:27:30,876 - INFO - Global Iteration: 30, Metric Value: -0.5327, Mutual Information: 0.5579\n", + "2024-09-22 20:27:31,404 - INFO - Global Iteration: 31, Metric Value: -0.5338, Mutual Information: 0.5600\n", + "2024-09-22 20:27:31,905 - INFO - Global Iteration: 32, Metric Value: -0.5355, Mutual Information: 0.5618\n", + "2024-09-22 20:27:32,418 - INFO - Global Iteration: 33, Metric Value: -0.5367, Mutual Information: 0.5629\n", + "2024-09-22 20:27:32,905 - INFO - Global Iteration: 34, Metric Value: -0.5374, Mutual Information: 0.5636\n", + "2024-09-22 20:27:33,401 - INFO - Global Iteration: 35, Metric Value: -0.5383, Mutual Information: 0.5650\n", + "2024-09-22 20:27:33,870 - INFO - Global Iteration: 36, Metric Value: -0.5394, Mutual Information: 0.5664\n", + "2024-09-22 20:27:34,339 - INFO - Global Iteration: 37, Metric Value: -0.5402, Mutual Information: 0.5675\n", + "2024-09-22 20:27:34,847 - INFO - Global Iteration: 38, Metric Value: -0.5413, Mutual Information: 0.5695\n", + "2024-09-22 20:27:35,316 - INFO - Global Iteration: 39, Metric Value: -0.5431, Mutual Information: 0.5710\n", + "2024-09-22 20:27:35,830 - INFO - Global Iteration: 40, Metric Value: -0.5445, Mutual Information: 0.5722\n", + "2024-09-22 20:27:36,335 - INFO - Global Iteration: 41, Metric Value: -0.5454, Mutual Information: 0.5744\n", + "2024-09-22 20:27:36,823 - INFO - Global Iteration: 42, Metric Value: -0.5471, Mutual Information: 0.5751\n", + "2024-09-22 20:27:37,291 - INFO - Global Iteration: 43, Metric Value: -0.5476, Mutual Information: 0.5766\n", + "2024-09-22 20:27:37,891 - INFO - Global Iteration: 44, Metric Value: -0.5501, Mutual Information: 0.5800\n", + "2024-09-22 20:27:38,399 - INFO - Global Iteration: 45, Metric Value: -0.5527, Mutual Information: 0.5835\n", + "2024-09-22 20:27:38,868 - INFO - Global Iteration: 46, Metric Value: -0.5555, Mutual Information: 0.5866\n", + "2024-09-22 20:27:39,332 - INFO - Global Iteration: 47, Metric Value: -0.5582, Mutual Information: 0.5880\n", + "2024-09-22 20:27:39,845 - INFO - Global Iteration: 48, Metric Value: -0.5587, Mutual Information: 0.5889\n", + "2024-09-22 20:27:40,359 - INFO - Global Iteration: 49, Metric Value: -0.5620, Mutual Information: 0.5910\n", + "2024-09-22 20:27:40,857 - INFO - Global Iteration: 50, Metric Value: -0.5644, Mutual Information: 0.5931\n", + "2024-09-22 20:27:41,334 - INFO - Global Iteration: 51, Metric Value: -0.5664, Mutual Information: 0.5942\n", + "2024-09-22 20:27:41,814 - INFO - Global Iteration: 52, Metric Value: -0.5671, Mutual Information: 0.5943\n", + "2024-09-22 20:27:42,322 - INFO - Global Iteration: 53, Metric Value: -0.5690, Mutual Information: 0.5970\n", + "2024-09-22 20:27:42,783 - INFO - Global Iteration: 54, Metric Value: -0.5714, Mutual Information: 0.5988\n", + "2024-09-22 20:27:43,289 - INFO - Global Iteration: 55, Metric Value: -0.5733, Mutual Information: 0.6003\n", + "2024-09-22 20:27:43,777 - INFO - Global Iteration: 56, Metric Value: -0.5753, Mutual Information: 0.6011\n", + "2024-09-22 20:27:44,254 - INFO - Global Iteration: 57, Metric Value: -0.5771, Mutual Information: 0.6027\n", + "2024-09-22 20:27:44,749 - INFO - Global Iteration: 58, Metric Value: -0.5783, Mutual Information: 0.6038\n", + "2024-09-22 20:27:45,263 - INFO - Global Iteration: 59, Metric Value: -0.5813, Mutual Information: 0.6063\n", + "2024-09-22 20:27:45,758 - INFO - Global Iteration: 60, Metric Value: -0.5833, Mutual Information: 0.6069\n", + "2024-09-22 20:27:46,264 - INFO - Global Iteration: 61, Metric Value: -0.5856, Mutual Information: 0.6105\n", + "2024-09-22 20:27:46,800 - INFO - Global Iteration: 62, Metric Value: -0.5890, Mutual Information: 0.6132\n", + "2024-09-22 20:27:47,504 - INFO - Global Iteration: 63, Metric Value: -0.5921, Mutual Information: 0.6155\n", + "2024-09-22 20:27:47,987 - INFO - Global Iteration: 64, Metric Value: -0.5951, Mutual Information: 0.6192\n", + "2024-09-22 20:27:48,509 - INFO - Global Iteration: 65, Metric Value: -0.5988, Mutual Information: 0.6211\n", + "2024-09-22 20:27:49,032 - INFO - Global Iteration: 66, Metric Value: -0.6026, Mutual Information: 0.6258\n", + "2024-09-22 20:27:49,563 - INFO - Global Iteration: 67, Metric Value: -0.6076, Mutual Information: 0.6297\n", + "2024-09-22 20:27:50,081 - INFO - Global Iteration: 68, Metric Value: -0.6117, Mutual Information: 0.6339\n", + "2024-09-22 20:27:50,591 - INFO - Global Iteration: 69, Metric Value: -0.6179, Mutual Information: 0.6394\n", + "2024-09-22 20:27:51,107 - INFO - Global Iteration: 70, Metric Value: -0.6232, Mutual Information: 0.6438\n", + "2024-09-22 20:27:51,615 - INFO - Global Iteration: 71, Metric Value: -0.6289, Mutual Information: 0.6491\n", + "2024-09-22 20:27:52,140 - INFO - Global Iteration: 72, Metric Value: -0.6352, Mutual Information: 0.6545\n", + "2024-09-22 20:27:52,641 - INFO - Global Iteration: 73, Metric Value: -0.6423, Mutual Information: 0.6606\n", + "2024-09-22 20:27:53,166 - INFO - Global Iteration: 74, Metric Value: -0.6482, Mutual Information: 0.6654\n", + "2024-09-22 20:27:53,671 - INFO - Global Iteration: 75, Metric Value: -0.6559, Mutual Information: 0.6719\n", + "2024-09-22 20:27:54,168 - INFO - Global Iteration: 76, Metric Value: -0.6633, Mutual Information: 0.6787\n", + "2024-09-22 20:27:54,653 - INFO - Global Iteration: 77, Metric Value: -0.6709, Mutual Information: 0.6854\n", + "2024-09-22 20:27:55,111 - INFO - Global Iteration: 78, Metric Value: -0.6780, Mutual Information: 0.6927\n", + "2024-09-22 20:27:55,631 - INFO - Global Iteration: 79, Metric Value: -0.6868, Mutual Information: 0.7005\n", + "2024-09-22 20:27:56,154 - INFO - Global Iteration: 80, Metric Value: -0.6962, Mutual Information: 0.7099\n", + "2024-09-22 20:27:56,682 - INFO - Global Iteration: 81, Metric Value: -0.7059, Mutual Information: 0.7182\n", + "2024-09-22 20:27:57,204 - INFO - Global Iteration: 82, Metric Value: -0.7173, Mutual Information: 0.7292\n", + "2024-09-22 20:27:57,713 - INFO - Global Iteration: 83, Metric Value: -0.7303, Mutual Information: 0.7404\n", + "2024-09-22 20:27:58,234 - INFO - Global Iteration: 84, Metric Value: -0.7424, Mutual Information: 0.7505\n", + "2024-09-22 20:27:58,746 - INFO - Global Iteration: 85, Metric Value: -0.7551, Mutual Information: 0.7652\n", + "2024-09-22 20:27:59,512 - INFO - Global Iteration: 86, Metric Value: -0.7710, Mutual Information: 0.7843\n", + "2024-09-22 20:28:00,045 - INFO - Global Iteration: 87, Metric Value: -0.7930, Mutual Information: 0.8020\n", + "2024-09-22 20:28:00,557 - INFO - Global Iteration: 88, Metric Value: -0.8120, Mutual Information: 0.8235\n", + "2024-09-22 20:28:01,066 - INFO - Global Iteration: 89, Metric Value: -0.8365, Mutual Information: 0.8514\n", + "2024-09-22 20:28:01,587 - INFO - Global Iteration: 90, Metric Value: -0.8678, Mutual Information: 0.8857\n", + "2024-09-22 20:28:02,094 - INFO - Global Iteration: 91, Metric Value: -0.9065, Mutual Information: 0.9320\n", + "2024-09-22 20:28:02,578 - INFO - Global Iteration: 92, Metric Value: -0.9572, Mutual Information: 0.9938\n", + "2024-09-22 20:28:03,105 - INFO - Global Iteration: 93, Metric Value: -1.0295, Mutual Information: 1.0862\n", + "2024-09-22 20:28:03,595 - INFO - Global Iteration: 94, Metric Value: -1.1328, Mutual Information: 1.2028\n", + "2024-09-22 20:28:04,098 - INFO - Global Iteration: 95, Metric Value: -1.2609, Mutual Information: 0.8035\n", + "2024-09-22 20:28:04,593 - INFO - Global Iteration: 96, Metric Value: -0.8155, Mutual Information: 1.2153\n", + "2024-09-22 20:28:05,096 - INFO - Global Iteration: 97, Metric Value: -1.2849, Mutual Information: 0.5255\n", + "2024-09-22 20:28:05,658 - INFO - Global Iteration: 98, Metric Value: -0.4851, Mutual Information: 0.5564\n", + "2024-09-22 20:28:06,556 - INFO - Global Iteration: 99, Metric Value: -0.5190, Mutual Information: 0.5670\n", + "2024-09-22 20:28:07,128 - INFO - Global Iteration: 100, Metric Value: -0.5313, Mutual Information: 0.5785\n", + "2024-09-22 20:28:07,706 - INFO - Global Iteration: 101, Metric Value: -0.5449, Mutual Information: 0.5896\n", + "2024-09-22 20:28:08,265 - INFO - Global Iteration: 102, Metric Value: -0.5579, Mutual Information: 0.6026\n", + "2024-09-22 20:28:08,824 - INFO - Global Iteration: 103, Metric Value: -0.5726, Mutual Information: 0.6181\n", + "2024-09-22 20:28:09,376 - INFO - Global Iteration: 104, Metric Value: -0.5907, Mutual Information: 0.6362\n", + "2024-09-22 20:28:09,926 - INFO - Global Iteration: 105, Metric Value: -0.6109, Mutual Information: 0.6590\n", + "2024-09-22 20:28:10,481 - INFO - Global Iteration: 106, Metric Value: -0.6371, Mutual Information: 0.6898\n", + "2024-09-22 20:28:11,048 - INFO - Global Iteration: 107, Metric Value: -0.6728, Mutual Information: 0.7336\n", + "2024-09-22 20:28:11,609 - INFO - Global Iteration: 108, Metric Value: -0.7227, Mutual Information: 0.8004\n", + "2024-09-22 20:28:12,184 - INFO - Global Iteration: 109, Metric Value: -0.7991, Mutual Information: 0.9048\n", + "2024-09-22 20:28:12,762 - INFO - Global Iteration: 110, Metric Value: -0.9178, Mutual Information: 1.1218\n", + "2024-09-22 20:28:13,312 - INFO - Global Iteration: 111, Metric Value: -1.1590, Mutual Information: 1.6347\n", + "2024-09-22 20:28:13,854 - INFO - Global Iteration: 112, Metric Value: -1.7144, Mutual Information: 0.9162\n", + "2024-09-22 20:28:14,395 - INFO - Global Iteration: 113, Metric Value: -0.9385, Mutual Information: 1.1325\n", + "2024-09-22 20:28:14,907 - INFO - Global Iteration: 114, Metric Value: -1.1794, Mutual Information: 1.5433\n", + "2024-09-22 20:28:15,474 - INFO - Global Iteration: 115, Metric Value: -1.6221, Mutual Information: 1.0262\n", + "2024-09-22 20:28:16,337 - INFO - Global Iteration: 116, Metric Value: -1.0550, Mutual Information: 1.4383\n", + "2024-09-22 20:28:16,906 - INFO - Global Iteration: 117, Metric Value: -1.5030, Mutual Information: 1.0801\n", + "2024-09-22 20:28:17,470 - INFO - Global Iteration: 118, Metric Value: -1.1301, Mutual Information: 1.9433\n", + "2024-09-22 20:28:18,018 - INFO - Global Iteration: 119, Metric Value: -2.0355, Mutual Information: 0.7286\n", + "2024-09-22 20:28:18,545 - INFO - Global Iteration: 120, Metric Value: -0.7086, Mutual Information: 0.7752\n", + "2024-09-22 20:28:19,495 - INFO - Global Iteration: 121, Metric Value: -0.7528, Mutual Information: 0.7994\n", + "2024-09-22 20:28:20,236 - INFO - Global Iteration: 122, Metric Value: -0.7803, Mutual Information: 0.8262\n", + "2024-09-22 20:28:20,972 - INFO - Global Iteration: 123, Metric Value: -0.8112, Mutual Information: 0.8547\n", + "2024-09-22 20:28:21,689 - INFO - Global Iteration: 124, Metric Value: -0.8441, Mutual Information: 0.8860\n", + "2024-09-22 20:28:22,403 - INFO - Global Iteration: 125, Metric Value: -0.8803, Mutual Information: 0.9182\n", + "2024-09-22 20:28:23,113 - INFO - Global Iteration: 126, Metric Value: -0.9167, Mutual Information: 0.9543\n", + "2024-09-22 20:28:23,791 - INFO - Global Iteration: 127, Metric Value: -0.9579, Mutual Information: 0.9933\n", + "2024-09-22 20:28:24,481 - INFO - Global Iteration: 128, Metric Value: -1.0018, Mutual Information: 1.0379\n", + "2024-09-22 20:28:25,193 - INFO - Global Iteration: 129, Metric Value: -1.0513, Mutual Information: 1.0983\n", + "2024-09-22 20:28:25,924 - INFO - Global Iteration: 130, Metric Value: -1.1170, Mutual Information: 1.1865\n", + "2024-09-22 20:28:26,638 - INFO - Global Iteration: 131, Metric Value: -1.2116, Mutual Information: 1.3377\n", + "2024-09-22 20:28:27,309 - INFO - Global Iteration: 132, Metric Value: -1.3690, Mutual Information: 1.6700\n", + "2024-09-22 20:28:28,001 - INFO - Global Iteration: 133, Metric Value: -1.7031, Mutual Information: 1.6189\n", + "2024-09-22 20:28:28,657 - INFO - Global Iteration: 134, Metric Value: -1.6575, Mutual Information: 1.5052\n", + "2024-09-22 20:28:29,364 - INFO - Global Iteration: 135, Metric Value: -1.5368, Mutual Information: 1.5083\n", + "2024-09-22 20:28:30,099 - INFO - Global Iteration: 136, Metric Value: -1.5458, Mutual Information: 1.4682\n", + "2024-09-22 20:28:30,761 - INFO - Global Iteration: 137, Metric Value: -1.5009, Mutual Information: 1.5604\n", + "2024-09-22 20:28:31,408 - INFO - Global Iteration: 138, Metric Value: -1.5976, Mutual Information: 1.3553\n", + "2024-09-22 20:28:32,084 - INFO - Global Iteration: 139, Metric Value: -1.3860, Mutual Information: 2.0175\n", + "2024-09-22 20:28:32,791 - INFO - Global Iteration: 140, Metric Value: -2.0182, Mutual Information: 0.7661\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-09-22 20:28:33,789 - INFO - Final transform parameters: itk::simple::CompositeTransform\n", + " CompositeTransform (0x55e39c0a7220)\n", + " RTTI typeinfo: itk::CompositeTransform\n", + " Reference Count: 1\n", + " Modified Time: 28136\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " TransformQueue: \n", + " >>>>>>>>>\n", + " Euler2DTransform (0x55e3968135e0)\n", + " RTTI typeinfo: itk::Euler2DTransform\n", + " Reference Count: 1\n", + " Modified Time: 27929\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Matrix: \n", + " 0.939612 -0.342241 \n", + " 0.342241 0.939612 \n", + " Offset: [411.814, -261.629]\n", + " Center: [869.5, 1171.5]\n", + " Translation: [-41.6284, -34.7949]\n", + " Inverse: \n", + " 0.939612 0.342241 \n", + " -0.342241 0.939612 \n", + " Singular: 0\n", + " Angle: 0.349301\n", + " TransformsToOptimizeFlags: \n", + " 1 \n", + " TransformsToOptimizeQueue: \n", + " PreviousTransformsToOptimizeUpdateTime: 0\n", + "\n", + "2024-09-22 20:28:33,924 - INFO - Combined visualizations saved as ../static/img/joint_histogram_iterations.tif\n" + ] + } + ], + "source": [ + "# Define image paths (replace with your actual paths)\n", + "fixed_image_path = \"kevin.jpg\"\n", + "moving_image_path = \"kevin-rotated-20.jpg\"\n", + "\n", + "# Define output path for the TIFF stack\n", + "output_tiff_path = os.path.expanduser(\"../static/img/joint_histogram_iterations.tif\")\n", + "\n", + "# Perform registration\n", + "final_transform = perform_registration(\n", + " fixed_image_path=fixed_image_path,\n", + " moving_image_path=moving_image_path,\n", + " output_tiff_path=output_tiff_path,\n", + " num_iterations=200,\n", + " bins=50,\n", + " save_every=1 # Change to >1 to save combined images less frequently\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8bce1c0f-cd88-447f-a5d8-55fc8b65a138", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/static/img/joint_histogram_iterations.tif b/static/img/joint_histogram_iterations.tif new file mode 100644 index 0000000..5c85dff Binary files /dev/null and b/static/img/joint_histogram_iterations.tif differ diff --git a/static/img/joint_histogram_iterative.gif b/static/img/joint_histogram_iterative.gif new file mode 100644 index 0000000..9992cfa Binary files /dev/null and b/static/img/joint_histogram_iterative.gif differ diff --git a/static/img/voltron.png b/static/img/voltron.png new file mode 100644 index 0000000..9ca52e3 Binary files /dev/null and b/static/img/voltron.png differ