QuPath Measurement Maps Image Export Script

[ahouston (Avery Houston)]

Hey QuPath community,

I am using the measurement maps to visualize the circularity of the nucleus in my region of interest. I’d like to export this using scripting but can’t figure out how to call the measurement maps command up to create this. I can do this manually using the export images - Rendered RGB (with overlays).

Is there a way to call this specific measurement map, visualize it on the ROI, and then export this?
I am also still having trouble exporting images with scripting in general but I am still looking into it and wont give up.

Any and all help is greatly appreciated! Thanks!

[Research_Associate (MicroscopyRA)]

I think most exporting with the RGB overlay is most easily accomplished with an image open so that the script “knows” what you want to do as far as the color maps. Then, you need to use the correct server, much like the labeled image server.
The official documentation gives an example of writing out a rendered image using:
https://qupath.readthedocs.io/en/latest/docs/advanced/exporting_images.html#images-regions
This is probably the best way to handle what you are doing at the moment.
Here is a version that was edited for specific ROIs - in this case a TMA.

Export TMA cores with Positive Cell Detection Overlay

That ended up being more difficult for me than I thought, but the solution was a variant of the function on the Readthedocs page. // Write the full image, displaying objects according to how they are currently shown in the viewer double downsample = 10.0 def server = getCurrentServer() def name = getProjectEntry().getImageName() def viewer = getCurrentViewer() getCurrentHierarchy().getTMAGrid().getTMACoreList().each{ mkdirs(buildFilePath(PROJECT_BASE_DIR,'export')) def path = buildFile…

Alternatively:
Digging through my list here, I found:

Script for 'Send Region to ImageJ'

I’m not 100% sure I understand or know which script you’re referring to, but it sounds like you need a variation of the one I posted in the third post. Here is an adapted version that writes the TIFF rather than showing it: import ij.IJ import qupath.imagej.gui.IJExtension double downsample = 4.0 def server = getCurrentServer() def request = RegionRequest.createInstance(server, downsample) boolean setROI = false def imp = IJExtension.extractROIWithOverlay( getCurrentServer(), null,…

[petebankhead (Pete)]

@ahouston Something like this should be close:

import qupath.lib.gui.tools.MeasurementMapper
import qupath.lib.gui.images.servers.RenderedImageServer

// Define the color map name
String colorMapName = 'Magma'

// Load a color mapper
def colorMapper = MeasurementMapper.loadColorMappers().find {it.name == colorMapName}
println colorMapper

// Define measurement & display range
def name = "Nucleus: Circularity" // Set to null to reset
double minValue = 0.0
double maxValue = 1.0

// Request current viewer & objects
def viewer = getCurrentViewer()
def options = viewer.getOverlayOptions()
def detections = getDetectionObjects()

// Update the display
if (name) {
    print String.format('Setting measurement map: %s (%.2f - %.2f)', name, minValue, maxValue)
    def mapper = new MeasurementMapper(colorMapper, name, detections)
    mapper.setDisplayMinValue(minValue)
    mapper.setDisplayMaxValue(maxValue)
    options.setMeasurementMapper(mapper)
} else {
    print 'Resetting measurement map'
    options.setMeasurementMapper(null)
}

// Now export the rendered image
import qupath.imagej.tools.IJTools
import qupath.lib.gui.images.servers.RenderedImageServer
import qupath.lib.gui.viewer.overlays.HierarchyOverlay
import qupath.lib.regions.RegionRequest

// It is important to define the downsample!
// This is required to determine annotation line thicknesses
double downsample = 10

// Add the output file path here
String path = buildFilePath(PROJECT_BASE_DIR, 'rendered')
mkdirs(path)

// Request the current viewer for settings, and current image (which may be used in batch processing)
def imageData = getCurrentImageData()

// Create a rendered server that includes a hierarchy overlay using the current display settings
def server = new RenderedImageServer.Builder(imageData)
    .downsamples(downsample)
    .layers(new HierarchyOverlay(null, options, imageData))
    .build()
    
// Write or display the rendered image
int count = 0
for (annotation in getAnnotationObjects()) {
    count++
    def imageName = getProjectEntry().getImageName() + count + '.png'
    def path2 = buildFilePath(path, imageName)
    def region = RegionRequest.createInstance(server.getPath(), downsample, annotation.getROI())
    writeImageRegion(server, region, path2)
}

It’s a bit ugly, since it’s really two scripts glued together and tweaked a little bit. The originals are

• Set a MeasurementMapper in QuPath v0.1.2 to control detection object display in a script · GitHub
• Script to export a rendered (RGB) image in QuPath v0.2.0 · GitHub

Be sure to look out for the name, colorMapName and downsample values, which probably will need to be changed.

This works using Run for project, but you might be able to drop the whole first half of the script if you set the measurement mapper in the viewer manually.

[ahouston (Avery Houston)]

@petebankhead Here is the original post I was referencing

[ahouston (Avery Houston)]

A million thanks Pete!!! Works perfectly!