Transforming an image based on a registered image

[iidas]

Hi!

I have been using VALIS for a while now and it has been working great. However now I'm facing an issue with largely negative stains from mIHC images, causing the images to be so dim that VALIS has trouble registering them. I was wondering if it's possible to register the brightest images (the DAPI images) from each staining set together, and then use the M transformation matrix on the dim images to achieve the same transformation and registering result as with the brighter image. I know that there is similar option to do this for a smaller spot/ROI, but I would like to do this for the whole image.

Would this be possible in VALIS? Thanks in advance!

[cdgatenbee]

Hi @iidas,
So happy to hear you've been finding valis useful! Regarding your question, yes, you should be able to register the images using the DAPI channels, and then apply those transformations to the associated dim images. If the dim channels are in the same image as the one with the DAPI channel this would be done automatically, but it's a little more involved if they're in separate files. In that case, you could use the following function to apply the transformations found using src_f (the DAPI channel image) to assoc_img_f (the dim image), saving the warped dim image as dst_f:

import numpy as np
from valis import registration, slide_io

def warp_associated_img(registrar, src_f, assoc_img_f, dst_f, 
                        level=0, non_rigid=True,
                        crop=True,
                        channel_names=None,
                        colormap=None,
                        interp_method="bicubic",
                        tile_wh=None, compression="lzw"):

    """Warp one image using another image's transforms

    Slides will be saved in the ome.tiff format.

    Parameters
    ----------
    
    registrar : valis.registration.Valis
        Valis object that has registered a group of images

    src_f : str
        Filname of the image that is associated with the transformations
    
    assoc_img_f : str
        Filname of the image that will be warped using the transformations 
        found using `src_f`

    dst_f : str
        Path to where the warped slide will be saved.

    level : int
        Pyramid level to be warped

    non_rigid : bool, optional
        Whether or not to conduct non-rigid warping. If False,
        then only a rigid transformation will be applied. Default is True

    crop: bool, str
        How to crop the registered images. If `True`, then the same crop used
        when initializing the `Valis` object will be used. If `False`, the
        image will not be cropped. If "overlap", the warped slide will be
        cropped to include only areas where all images overlapped.
        "reference" crops to the area that overlaps with the reference image,
        defined by `reference_img_f` when initialzing the `Valis object`.

    channel_names : list, optional
        List of channel names. If None, then Slide.reader
        will attempt to find the channel names associated with `src_f`.

    colormap : dict, optional
        Dictionary of channel colors, where the key is the channel name, and the value the color as rgb255.
        If None (default), the channel colors from `current_ome_xml_str` will be used, if available.
        If None, and there are no channel colors in the `current_ome_xml_str`, then no colors will be added

    interp_method : str
        Interpolation method used when warping slide. Default is "bicubic"

    tile_wh : int, optional
        Tile width and height used to save image

    compression : str
        Compression method used to save ome.tiff . Default is lzw, but can also
        be jpeg or jp2k. See pyips for more details.

    """

    src_slide = registrar.get_slide(src_f) 
    assoc_slide_reader_cls = slide_io.get_slide_reader(assoc_img_f)
    assoc_slide = assoc_slide_reader_cls(assoc_img_f)
    slide_meta = assoc_slide.metadata
    
    assert np.all(src_slide.slide_dimensions_wh[level] == slide_meta.slide_dimensions[level]), print("the src and associated images need to have the same shape")
    # Use src image to warp associated image
    warped_assoc = src_slide.warp_slide(level=level, non_rigid=non_rigid, crop=crop, 
                                        src_f=assoc_img_f, interp_method=interp_method)
    
    if slide_meta.pixel_physical_size_xyu[2] == slide_io.PIXEL_UNIT:
        px_phys_size = None
    else:
        px_phys_size = assoc_slide.scale_physical_size(level)

    if channel_names is None:
        channel_names = slide_meta.channel_names

    bf_dtype = slide_io.vips2bf_dtype(warped_assoc.format)
    out_xyczt = slide_io.get_shape_xyzct((warped_assoc.width, warped_assoc.height), warped_assoc.bands)
    ome_xml_obj = slide_io.update_xml_for_new_img(current_ome_xml_str=slide_meta.original_xml,
                                                new_xyzct=out_xyczt,
                                                bf_dtype=bf_dtype,
                                                is_rgb=slide_meta.is_rgb,
                                                series=assoc_slide.series,
                                                pixel_physical_size_xyu=px_phys_size,
                                                channel_names=channel_names,
                                                colormap=colormap
                                                )
    ome_xml = ome_xml_obj.to_xml()
    if tile_wh is None:
        tile_wh = slide_meta.optimal_tile_wh
        if level != 0:
            down_sampling = np.mean(slide_meta.slide_dimensions[level]/slide_meta.slide_dimensions[0])
            tile_wh = int(np.round(tile_wh*down_sampling))
            tile_wh = tile_wh - (tile_wh % 16)  # Tile shape must be multiple of 16
            if tile_wh < 16:
                tile_wh = 16
            if np.any(np.array(out_xyczt[0:2]) < tile_wh):
                tile_wh = min(out_xyczt[0:2])

    slide_io.save_ome_tiff(warped_assoc, dst_f=dst_f, ome_xml=ome_xml,
                           tile_wh=tile_wh, compression=compression)

Give the above function a shot and let me know how it goes.

Best,
-Chandler

[iidas]

Hi and thank you!
My case indeed is that I have all the images as separate files, and thus they don't automatically apply the changes. This function worked very well, however I got this error message:

File "/path/to/code/transformation.py", line 99, in warp_associated_img is_rgb=assoc_slide.is_rgb, AttributeError: 'VipsSlideReader' object has no attribute 'is_rgb'

I solved this by manually changing the is_rgb value to True in update_xml_for_new_img and the script works now, but I was wondering wheter it's my images or something else that causes the issue?

[cdgatenbee]

Hi @iidas,
Glad the function (mostly) worked out! This error is my fault. Looks like in the update_xml_for_new_img function is_rgb=assoc_slide.is_rgb should actually be is_rgb= slide_meta.is_rgb. I've updated the post with the correction. Hopefully it will run without error with that change, but please let me know if you run into any more issues.

Best,
-Chandler