registration/app.py

import gradio as gr
import nibabel as nib
import numpy as np
import os
from PIL import Image
import pandas as pd
import nrrd
import ants
from natsort import natsorted
from scipy.ndimage import zoom, rotate
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torchvision.models as models
import torchvision.transforms as transforms
from sklearn.metrics.pairwise import cosine_similarity
import cv2

def square_padd(original_data, square_size=(120,152, 184), order = 1):
    # e.g. square_size = 256 by default
    # takes a raw image as input
    # returns a square (padded) image as output

    # order = [int(x-1) for x in ss.rankdata(original_data.shape)]
    # # print(order)
    # data =  original_data.transpose(order)
    data= original_data
    # print(original_data.shape)
    # print(data.shape)
    if data.shape[1]>data.shape[0] and data.shape[1]>data.shape[2]: # width>height
      scale_percent = (square_size[1]/data.shape[1])*100
      # print("dim1")
    elif data.shape[2]>data.shape[0] and data.shape[2]>data.shape[1]: # width>height
      scale_percent = (square_size[2]/data.shape[2])*100
      # print("dim2")
    else: # width<height
      scale_percent = (square_size[0]/data.shape[0])*100
    scale_percent = int(scale_percent)
    # print(scale_percent)
    width = int(data.shape[0] * scale_percent / 100); height = int(data.shape[1] * scale_percent / 100); depth = int(data.shape[2] * scale_percent / 100);
    dim = (width, height, depth)
    # print(dim)
    zoomFactors = [square_size_axis/float(data_shape) for data_shape, square_size_axis in zip(data.shape, square_size)]
    sect_mask = zoom(data,zoom = zoomFactors, order = order, )
    # sect_mask = zoom(data,(scale_percent/100, scale_percent/100, scale_percent/100), order = order, )
    # sect_mask = cv2.resize(data, dim, interpolation = cv2.INTER_AREA)
    sect_padd = (np.ones(square_size))*data[0,0,0]
    sect_padd[int((square_size[0]-np.shape(sect_mask)[0])/2):int((square_size[0]-np.shape(sect_mask)[0])/2)+np.shape(sect_mask)[0],
              int((square_size[1]-np.shape(sect_mask)[1])/2):int((square_size[1]-np.shape(sect_mask)[1])/2)+np.shape(sect_mask)[1],
              int((square_size[2]-np.shape(sect_mask)[2])/2):int((square_size[2]-np.shape(sect_mask)[2])/2)+np.shape(sect_mask)[2]] = sect_mask
    return sect_padd

def square_padding_RGB(single_RGB,square_size=256):
    # e.g. square_size = 256 by default
    # takes a raw image as input
    # returns a square (padded) image as output
    # input:  2D image
    # output: 2D resized padded image
    # example: BNI images, HMS data
    if single_RGB.shape[1]>single_RGB.shape[0]: # width>height
      scale_percent = (square_size/single_RGB.shape[1])*100
    else: # width<height
      scale_percent = (square_size/single_RGB.shape[0])*100
    width = int(single_RGB.shape[1] * scale_percent / 100); height = int(single_RGB.shape[0] * scale_percent / 100); dim = (width, height)
    sect_mask = cv2.resize(single_RGB, dim, interpolation = cv2.INTER_AREA)
    sect_padd = (np.ones((square_size,square_size,3)))*np.mean(single_RGB[:10,:10])
    sect_padd[int((square_size-np.shape(sect_mask)[0])/2):int((square_size-np.shape(sect_mask)[0])/2)+np.shape(sect_mask)[0],
                int((square_size-np.shape(sect_mask)[1])/2):int((square_size-np.shape(sect_mask)[1])/2)+np.shape(sect_mask)[1],:] = sect_mask
    return sect_padd

def square_padding(single_gray,square_size=256):
    # e.g. square_size = 256 by default
    # takes a raw image as input
    # returns a square (padded) image as output
    # input:  2D image
    # output: 2D resized padded image
    # example: BNI images, HMS data
    if len(np.shape(single_gray))>2:
      return square_padding_RGB(single_gray[:,:,:3])
    else:
    #   print("Single gray shape:", np.shape(single_gray))
      if single_gray.shape[1]>single_gray.shape[0]: # width>height
        scale_percent = (square_size/single_gray.shape[1])*100
      else: # width<height
        scale_percent = (square_size/single_gray.shape[0])*100
      width = int(single_gray.shape[1] * scale_percent / 100); height = int(single_gray.shape[0] * scale_percent / 100); dim = (width, height)
    #   print("Dim::", dim)
      sect_mask = cv2.resize(single_gray, dim, interpolation = cv2.INTER_AREA)
      sect_padd = (np.zeros((square_size,square_size)))*single_gray[-20,-20]#find a better solution for single_gray[100,-100]
      sect_padd[int((square_size-np.shape(sect_mask)[0])/2):int((square_size-np.shape(sect_mask)[0])/2)+np.shape(sect_mask)[0],
                  int((square_size-np.shape(sect_mask)[1])/2):int((square_size-np.shape(sect_mask)[1])/2)+np.shape(sect_mask)[1]] = sect_mask
      return sect_padd


def affine_reg(fixed_image,moving_image,gauss_param=100):
    # this function takes fixed and moving images as input and return affine transformation matrix
    # fixed/moving images can be 2D/3D
    # todo: add an option as flag to save the transformation matrix and displacement fields at the desired location to be able to apply the transforms later
    mytx = ants.registration(fixed=fixed_image,
                         moving=moving_image,
                         type_of_transform='Affine',
                         reg_iterations = (gauss_param,gauss_param,gauss_param,gauss_param))
    print('affine registration completed')
    return mytx


def nonrigid_reg(fixed_image,mytx,type_of_transform='SyN',grad_step=0.25,reg_iterations=(50,50,50, ),flow_sigma=9,total_sigma=0.2):
    # this function takes fixed image and affined tx matrix as input and return non-rigid transformation matrix
    # fixed/moving images can be 2D/3D
    # type of transform selection: https://antspy.readthedocs.io/en/latest/registration.html
    # todo: scale the function to incorporate the extended parameters for type_of_transform
    # todo: scale the function to incorporate the affine+non-rigid simultaneously in case of SyNRA

    transform_type = {'SyN':{'grad_step':grad_step,'reg_iterations':reg_iterations,'flow_sigma':flow_sigma,'total_sigma':total_sigma},
                      'SyNRA':{'grad_step':grad_step,'reg_iterations':reg_iterations,'flow_sigma':flow_sigma,'total_sigma':total_sigma}}

    mytx_non_rigid = ants.registration(fixed = fixed_image,
                                   moving=mytx['warpedmovout'],
                                   type_of_transform=type_of_transform,
                                   grad_step=transform_type[type_of_transform]['grad_step'],
                                   reg_iterations=transform_type[type_of_transform]['reg_iterations'],
                                   flow_sigma=transform_type[type_of_transform]['flow_sigma'],
                                   total_sigma=transform_type[type_of_transform]['total_sigma'])

    print('non-rigid registration completed')
    return mytx_non_rigid

def affine_reg(fixed_image,moving_image,gauss_param=100):
    # this function takes fixed and moving images as input and return affine transformation matrix
    # fixed/moving images can be 2D/3D
    # todo: add an option as flag to save the transformation matrix and displacement fields at the desired location to be able to apply the transforms later
    mytx = ants.registration(fixed=fixed_image,
                         moving=moving_image,
                         type_of_transform='Affine',
                         reg_iterations = (gauss_param,gauss_param,gauss_param,gauss_param))
    print('affine registration completed')
    return mytx


def nonrigid_reg(fixed_image,mytx,type_of_transform='SyN',grad_step=0.25,reg_iterations=(50,50,50, ),flow_sigma=9,total_sigma=0.2):
    # this function takes fixed image and affined tx matrix as input and return non-rigid transformation matrix
    # fixed/moving images can be 2D/3D
    # type of transform selection: https://antspy.readthedocs.io/en/latest/registration.html
    # todo: scale the function to incorporate the extended parameters for type_of_transform
    # todo: scale the function to incorporate the affine+non-rigid simultaneously in case of SyNRA

    transform_type = {'SyN':{'grad_step':grad_step,'reg_iterations':reg_iterations,'flow_sigma':flow_sigma,'total_sigma':total_sigma},
                      'SyNRA':{'grad_step':grad_step,'reg_iterations':reg_iterations,'flow_sigma':flow_sigma,'total_sigma':total_sigma}}

    mytx_non_rigid = ants.registration(fixed = fixed_image,
                                   moving=mytx['warpedmovout'],
                                   type_of_transform=type_of_transform,
                                   grad_step=transform_type[type_of_transform]['grad_step'],
                                   reg_iterations=transform_type[type_of_transform]['reg_iterations'],
                                   flow_sigma=transform_type[type_of_transform]['flow_sigma'],
                                   total_sigma=transform_type[type_of_transform]['total_sigma'])

    print('non-rigid registration completed')
    return mytx_non_rigid



def run_3D_registration(user_section, ):
  global allen_atlas_ccf, allen_template_ccf
  template_atlas = allen_atlas_ccf
  template_section = allen_template_ccf
  template_atlas = np.uint16(template_atlas*255)
  user_section = square_padd(user_section,  (60, 76, 92))
  
  template_atlas = square_padd(template_atlas, user_section.shape)
  template_section = square_padd(template_section, user_section.shape)

  fixed_image = ants.from_numpy(user_section)
  moving_atlas_ants = ants.from_numpy(template_atlas)
  moving_image = ants.from_numpy(template_section)

  mytx = affine_reg(fixed_image,moving_image)
  mytx_non_rigid = nonrigid_reg(fixed_image,mytx)
  affined_fixed_atlas = ants.apply_transforms(fixed=fixed_image,
                                                moving=moving_image,
                                                transformlist=mytx['fwdtransforms'],
                                                interpolator='nearestNeighbor')
  nonrigid_fixed_atlas = ants.apply_transforms(fixed=fixed_image,
                                              moving=affined_fixed_atlas,
                                              transformlist=mytx_non_rigid['fwdtransforms'],
                                              interpolator='nearestNeighbor')
  gallery_images = load_gallery_images()
  transformed_images = []
  if not(os.path.exists("Overlaped_registered")):
    os.mkdir("Overlaped_registered")
  registered = nonrigid_fixed_atlas.numpy()/255
  for id in list(range((registered.shape[0]//2)-15, (registered.shape[0]//2)+15, 2)):
    print(id)
    plt.imsave(f'Overlaped_registered/{id}.png',registered[id, :, :], cmap = 'gray' )
    transformed_images.append(f'Overlaped_registered/{id}.png')

  return transformed_images


def run_2D_registration(user_section, slice_idx):
  global allen_atlas_ccf, allen_template_ccf, gallery_selected_data
  template_atlas = allen_atlas_ccf
  template_section = allen_template_ccf

  template_atlas = allen_atlas_ccf[slice_idx,:,:]
  template_section = allen_template_ccf[slice_idx,:,:]
  # colored_atlas = colored_atlas[slice_idx,:,:]
  print(np.shape(template_atlas), np.shape(template_section))
  user_section = square_padding(user_section)
  
  template_atlas = np.uint16(template_atlas*255)
  template_atlas = square_padding(template_atlas)
  template_section = square_padding(template_section)

  fixed_image = ants.from_numpy(user_section)
  moving_atlas_ants = ants.from_numpy(template_atlas)
  moving_image = ants.from_numpy(template_section)

  mytx = affine_reg(fixed_image,moving_image)
  mytx_non_rigid = nonrigid_reg(fixed_image,mytx)
  gallery_imgs = natsorted(load_gallery_images())
  moving_gallery_img = ants.from_numpy(square_padding(plt.imread(gallery_imgs[gallery_selected_data])))
  affined_fixed_atlas = ants.apply_transforms(fixed=fixed_image,
                                                moving=moving_image,
                                                transformlist=mytx['fwdtransforms'],
                                                interpolator='nearestNeighbor')
  nonrigid_fixed_atlas = ants.apply_transforms(fixed=fixed_image,
                                              moving=affined_fixed_atlas,
                                              transformlist=mytx_non_rigid['fwdtransforms'],
                                              interpolator='nearestNeighbor')
  gallery_images = load_gallery_images()
  transformed_images = []
  if not(os.path.exists("Overlaped_registered")):
    os.mkdir("Overlaped_registered")
  plt.imsave(f'Overlaped_registered/registered_slice.png',nonrigid_fixed_atlas.numpy()/255, cmap = 'gray')
  
  return ['Overlaped_registered/registered_slice.png']


def embeddings_classifier(user_section, atlas_embeddings,atlas_labels):
    class SliceEncoder(nn.Module):
        def __init__(self):
            super(SliceEncoder, self).__init__()
            base = models.resnet18(pretrained=True)
            self.backbone = nn.Sequential(*list(base.children())[:-1])  # Remove final FC layer

        def forward(self, x):
            x = self.backbone(x)  # Output shape: (B, 512, 1, 1)
            return x.view(x.size(0), -1)  # Flatten to (B, 512)

    # Transform
    transform = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                            std=[0.229, 0.224, 0.225]),
    ])

    # Feature extraction utility
    def extract_embedding(img_array, encoder, transform):
        img = Image.fromarray(((img_array) * 255).astype(np.uint8)).convert('RGB')
        img_tensor = transform(img).unsqueeze(0).to(device)
        with torch.no_grad():
            embedding = encoder(img_tensor)
        return embedding.cpu().numpy().flatten()

    # Prepare device and model
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    encoder = SliceEncoder().to(device).eval()

    # Precompute atlas embeddings
    

    query_emb = extract_embedding(user_section, encoder, transform).reshape(1, -1)
    sims = cosine_similarity(query_emb, atlas_embeddings)[0]

    pred_idx = np.argmax(sims)
    pred_gt = atlas_labels[pred_idx]

    return int(pred_gt)


def gray_scale(image):
  # input:  a 2D RGB image (x,y,z)
  # output: a grayscale image (x,y)
  # todo: fix the depth issue of pixels
  if len(np.shape(image))>2:
    return cv2.cvtColor(image[:,:,:3], cv2.COLOR_RGB2GRAY)
  else:
    return image

def atlas_slice_prediction(user_section, axis = 'coronal'):

  user_section = gray_scale(square_padding(gray_scale(user_section)))
  user_section = gray_scale(user_section)
  user_section = square_padding(user_section, 224)
  user_section = (user_section - np.min(user_section))/((np.max(user_section) - np.min(user_section)))
  print("Loading model")
  atlas_embeddings = np.load(f"registration/atlas_embeddings_{axis}.npy")
  atlas_labels = np.load(f"registration/atlas_labels_{axis}.npy")
  idx = embeddings_classifier(user_section, atlas_embeddings,atlas_labels)

  return idx






example_files = [
    ["./resampled_green_25.nii.gz", "CCF registered Sample", "3D"],
    ["./Brain_1.png", "Custom Sample", "2D"],
#     ["examples/sample3.nii.gz"]
]

# Global variables
coronal_slices = []
last_probabilities = []
prob_df = pd.DataFrame()
vol = None
slice_idx = None

# Target cell types
cell_types = [
    "ABC.NN", "Astro.TE.NN", "CLA.EPd.CTX.Car3.Glut", "Endo.NN", "L2.3.IT.CTX.Glut",
    "L4.5.IT.CTX.Glut", "L5.ET.CTX.Glut", "L5.IT.CTX.Glut", "L5.NP.CTX.Glut", "L6.CT.CTX.Glut",
    "L6.IT.CTX.Glut", "L6b.CTX.Glut", "Lamp5.Gaba", "Lamp5.Lhx6.Gaba", "Lymphoid.NN", "Microglia.NN",
    "OPC.NN", "Oligo.NN", "Peri.NN", "Pvalb.Gaba", "Pvalb.chandelier.Gaba", "SMC.NN", "Sncg.Gaba",
    "Sst.Chodl.Gaba", "Sst.Gaba", "VLMC.NN", "Vip.Gaba"
]

actual_ids = [30,52,71,91,104,109,118,126,131,137,141,164,178,182,197,208,218,226,232,242,244,248,256,262,270,282,293,297,308,323,339,344,350,355,364,372,379,389,395,401,410,415,418,424,429,434,440,444,469,479,487,509]
gallery_ids = [5,6,8,9,10,11,12,13,14,15,16,17,18,19,24,25,26,27,28,29,30,31,32,33,35,36,37,38,39,40,42,43,44,45,46,47,48,49,50,51,52,54,55,56,57,58,59,60,61,62,64,66,67]
# gallery_ids.reverse()

allen_atlas_ccf, header = nrrd.read('./registration/annotation_25.nrrd')
allen_template_ccf, _ = nrrd.read("./registration/average_template_25.nrrd")
# colored_atlas,_ =  nrrd.read('./registration/colored_atlas_turbo.nrrd')
gallery_selected_data = None
def load_nifti_or_png(file, sample_type, data_type):
    global coronal_slices, vol, slice_idx, gallery_selected_data
    if file.name.endswith(".nii") or file.name.endswith(".nii.gz"):
        img = nib.load(file.name)
        vol = img.get_fdata()
        coronal_slices = [vol[i, :, :] for i in range(vol.shape[0])]
        if data_type == "2D":
            mid_index = vol.shape[0] // 2
            slice_img = Image.fromarray((coronal_slices[mid_index] / np.max(coronal_slices[mid_index]) * 255).astype(np.uint8))
            gallery_images = load_gallery_images()
            return (
                slice_img,
                gr.update(visible=False),
                gallery_images,
                gr.update(visible=True),
                gr.update(visible=True),
                gr.update(visible=(sample_type == "Custom Sample"))
            )
        else:  # 3D with actual_ids only
            coronal_slices = [vol[i, :, :] for i in actual_ids]
            idx = len(actual_ids) // 2  # Mid of actual_ids
            slice_img = Image.fromarray((coronal_slices[idx] / np.max(coronal_slices[idx]) * 255).astype(np.uint8))
            gallery_images = load_gallery_images()
            gallery_images = natsorted(gallery_images)
            return (
                slice_img,
                gr.update(visible=True, minimum=0, maximum=len(coronal_slices)-1, value=idx),
                gallery_images,
                gr.update(visible=True),
                gr.update(visible=True),
                gr.update(visible=(sample_type == "Custom Sample"))
            )
            

    else:
        img = Image.open(file.name).convert("L")
        vol = np.array(img)
        coronal_slices = [np.array(img)]
        gallery_images = natsorted(load_gallery_images())
        idx = atlas_slice_prediction(np.array(img))
        slice_idx = idx
        closest_actual_idx = min(actual_ids, key=lambda x: abs(x - idx))
        gallery_index = actual_ids.index(closest_actual_idx)
        print(gallery_index, len(actual_ids) -(gallery_index))
        gallery_selected_data = len(actual_ids) -(gallery_index)

        return (
            img,
            gr.update(visible=False),
            gr.update(selected_index=len(actual_ids) -(gallery_index) if gallery_index < len(gallery_ids) else 0, visible = True),
            # gr.update(value=gallery_images, selected_index=len(actual_ids) -(gallery_index)),  # gallery
            gr.update(visible=True),
            gr.update(visible=True),
            gr.update(visible=(sample_type == "Custom Sample"))
        )

     


def update_slice(index):
    if not coronal_slices:
        return None, None, None
    slice_img = Image.fromarray((coronal_slices[index] / np.max(coronal_slices[index]) * 255).astype(np.uint8))
    gallery_selection = gr.update(selected_index=len(gallery_ids) - index if index < len(gallery_ids) else 0)
    
    if last_probabilities:
        noise = np.random.normal(0, 0.01, size=len(last_probabilities))
        new_probs = np.clip(np.array(last_probabilities) + noise, 0, None)
        new_probs /= new_probs.sum()
    else:
        new_probs = []
    return slice_img, plot_probabilities(new_probs), gallery_selection


def load_gallery_images():
    folder = "Overlapped_updated"
    images = []
    if os.path.exists(folder):
        for fname in sorted(os.listdir(folder)):
            if fname.lower().endswith(('.png', '.jpg', '.jpeg')):
                images.append(os.path.join(folder, fname))
    return images

def generate_random_probabilities():
    probs = np.random.rand(len(cell_types))
    low_indices = np.random.choice(len(probs), size=5, replace=False)
    for idx in low_indices:
        probs[idx] = np.random.rand() * 0.01
    probs /= probs.sum()
    return probs.tolist()

def plot_probabilities(probabilities):
    if len(probabilities) < 1:
        return None
    prob_df = pd.DataFrame({"labels": cell_types, "values": probabilities})
    prob_df.to_csv('Cell_types_predictions.csv', index=False)
    return prob_df

def run_mapping():
    global last_probabilities
    last_probabilities = generate_random_probabilities()
    return plot_probabilities(last_probabilities), gr.update(visible=True)

def run_registration(data_type, selected_idx):
    global vol, slice_idx
    print("Running registration logic here..., Vol shape::", vol.shape)
    if data_type == "3D":
      gallery_images = run_3D_registration(vol)
      
    else:
      gallery_images = run_2D_registration(vol, slice_idx)
    return gallery_images  




    return "Registration complete!"

def download_csv():
    return 'Cell_types_predictions.csv'


def handle_data_type_change(dt):
    if dt == "2D":
        return gr.update(visible=False)
    else:
        return gr.update(visible=True, minimum=0, maximum=len(actual_ids)-1, value=len(actual_ids)//2)

def on_select(evt: gr.SelectData):
  gallery_selected_data = evt.index

gallery_images = natsorted(load_gallery_images())
with gr.Blocks() as demo:
    gr.Markdown("# Map My Sections")

    gr.Markdown("### Step 1: Upload your sample and choose type")
    with gr.Row():
        nifti_file = gr.File(label="File Upload")
        with gr.Column():
          sample_type = gr.Dropdown(choices=["CCF registered Sample", "Custom Sample"], value="CCF registered Sample", label="Sample Type")
          data_type = gr.Radio(choices=["2D", "3D"], value="3D", label="Data Type")

    gr.Examples(examples=example_files, inputs=[nifti_file, sample_type, data_type], label="Try one of our example samples")

    with gr.Row(visible=False) as slice_row:
        with gr.Column(scale=1):
            gr.Markdown("### Step 2: Visualizing your uploaded sample")
            image_display = gr.Image(height=450)
            slice_slider = gr.Slider(minimum=0, maximum=0, value=0, step=1, label="Slices", visible=False)
        with gr.Column(scale=1):
            gr.Markdown("### Step 3: Visualizing Allen Brain Cell Types Atlas")
            gallery = gr.Gallery(label="ABC Atlas", value = gallery_images,)
            gr.Markdown("**Step 4: Run cell type mapping**")
            with gr.Row():
                run_button = gr.Button("Run Mapping")
                reg_button = gr.Button("Run Registration", visible=False)

    with gr.Column(visible=False) as plot_row:
        gr.Markdown("### Step 5: Quantitative results of the mapping model.")
        prob_plot = gr.BarPlot(prob_df, x="labels", y="values", title="Cell Type Probabilities", scroll_to_output=True, x_label_angle=-90, height=400)
        gr.Markdown("### Step 6: Download Results.")
        download_button = gr.DownloadButton(label="Download Results", value='Cell_types_predictions.csv')

    nifti_file.change(
    load_nifti_or_png,
    inputs=[nifti_file, sample_type, data_type],
    outputs=[image_display, slice_slider, gallery, slice_row, plot_row, reg_button]
    )

    sample_type.change(
        lambda s: (gr.update(visible=True), gr.update(visible=(s == "Custom Sample"))),
        inputs=sample_type,
        outputs=[slice_row, reg_button]
    )

    
    data_type.change(
          handle_data_type_change,
          inputs=data_type,
          outputs=slice_slider
      )
    
    gallery.select(on_select, None, None)

    slice_slider.change(update_slice, inputs=slice_slider, outputs=[image_display, prob_plot, gallery])
    run_button.click(run_mapping, outputs=[prob_plot, plot_row])
    reg_button.click(run_registration,inputs = [data_type], outputs=[gallery])

    demo.launch()