Automation of functionality in Slicer

[lukasvdstricht]

Hi everyone

I am using MONAILabel together with Slicer to train models to automatically segment certain body parts on MRI/CT images.
The training went well and I have a decent model. I am interested in volumetric properties of the segmentation I have made with Automatic segmentation.
With the help of some existing blog posts and such, I have already succeeded in writing a Python script to generate a table with the SegmentStatistics module and save it locally as a .csv file. I would however want to automate this process even further and include in my script the step where I press Run for the automatic segmentation in MONAILabel. I am looking for how I can translate this step to Python code, similar to this.

I found the source code for this module, and I suspect that the function I’m looking for is onClickSegmentation on line 1446. The only problem is that I don’t know how to invoke this function in a Python script.

Thanks in advance!

Lukas

[SachidanandAlle]

@tangy5 can you look into this question

[diazandr3s]

Hi @lukasvdstricht,

Do you want to use the exact code in Slicer? If you're running the MONAI Label server on the same PC, you could create a post-transform on the server side that preprocess the predicted label and store the output CSV file.

Here is the post transforms for the segmentation model that processed the model prediction: https://github.com/Project-MONAI/MONAILabel/blob/main/sample-apps/radiology/lib/infers/segmentation.py#L69-L79

You may want to add a custom transform after the AsDiscreted transform.

This is another idea. I'm sure @tangy5 can also help here :)

[tangy5]

HI @lukasvdstricht , thank you for raising the request and question. I think @diazandr3s mentioned above is a better choice, instead of changing the MONAI Label Plugin module source code, which required recompile afterward, or reinstall local MONAI Label package. The better option is to create your function/ script in the Sample-App directory here: https://github.com/Project-MONAI/MONAILabel/tree/main/sample-apps/radiology/lib, for example:

if you would like an automated metric calculation after inference/training, you could add function to the post-processing in /radiology/lib/infer/.py or in /trainer, etc...

Also, it would be convenient and easy to add customize code to config for defining different models, inferer/trainer in the config folder such as spleen segmentation: https://github.com/Project-MONAI/MONAILabel/blob/main/sample-apps/radiology/lib/configs/segmentation_spleen.py

Thank you, hope this helps.

[lukasvdstricht]

Hi @tangy5

I don't think I'm trying to change the model source code. I just have some local Python files that I invoke in Slicer's Python Interactor to do certain things automatically.
For example, this is the code that I have for saving the table on the node called 'Table' to a .csv file:

def saveTable():
	tablenode = getNode('Table')
	slicer.util.saveNode(tablenode,"tableTest.csv")

saveTable()

The method offered by @diazandr3s above may work for this particular task (creating and saving the table of volumetric properties) but in the future we may broaden our desire for automation to other tasks. So my question essentially is how you use Slicer's MONAILabel module from a Python file.

I hope this makes it more clear.

Thank you very much for your answer!

Lukas
`

[pieper]

If you really need to, in Slicer's python interactor you can use code like thisslicer.modules.MONAILabelWidget.onClickSegmentation() once the module widget has been constructed (use slicer.util.selectModule("MONAILabel") if you need to force this.

However we try to avoid using the GUI methods for this kind of thing and instead try to use an API that doesn't mix GUI and Logic operations. I haven't looked closely at the implementation, but ideally there would be a set of methods in MONAILabelLogic that mix Slicer functionality with MONAI functionality independent of the GUI, and that logic layer would leverage MONAI-specific functionality in the MONAILabelClient.

[lassoan]

Fully agree with @pieper. All the MONAILabel features that someone would want to run in a batch mode should be exposed in the logic class. This allows changing the GUI without worrying that it messes up things for people who use the module via Python scripting.

I've checked and there are already a number of methods in the logic class, which might be sufficient for you:

MONAILabel/plugins/slicer/MONAILabel/MONAILabel.py

Lines 2068 to 2167 in 5a7cbd8

	class MONAILabelLogic(ScriptedLoadableModuleLogic):
	def __init__(self, tmpdir=None, server_url=None, progress_callback=None, client_id=None):
	ScriptedLoadableModuleLogic.__init__(self)
	self.server_url = server_url
	self.tmpdir = slicer.util.tempDirectory("slicer-monai-label") if tmpdir is None else tmpdir
	self.client_id = client_id
	self.volumeToSessions = dict()
	self.progress_callback = progress_callback
	def setDefaultParameters(self, parameterNode):
	if not parameterNode.GetParameter("SegmentationModel"):
	parameterNode.SetParameter("SegmentationModel", "")
	if not parameterNode.GetParameter("DeepgrowModel"):
	parameterNode.SetParameter("DeepgrowModel", "")
	if not parameterNode.GetParameter("ScribblesMethod"):
	parameterNode.SetParameter("ScribblesMethod", "")
	def __del__(self):
	shutil.rmtree(self.tmpdir, ignore_errors=True)
	def setServer(self, server_url=None):
	self.server_url = server_url if server_url else "http://127.0.0.1:8000"
	def setClientId(self, client_id):
	self.client_id = client_id if client_id else "user-xyz"
	def setProgressCallback(self, progress_callback=None):
	self.progress_callback = progress_callback
	def reportProgress(self, progress):
	if self.progress_callback:
	self.progress_callback(progress)
	def get_segment_editor_node(self):
	# Use the Segment Editor module's parameter node for the embedded segment editor widget.
	# This ensures that if the user switches to the Segment Editor then the selected
	# segmentation node, volume node, etc. are the same.
	segmentEditorSingletonTag = "SegmentEditor"
	segmentEditorNode = slicer.mrmlScene.GetSingletonNode(segmentEditorSingletonTag, "vtkMRMLSegmentEditorNode")
	if segmentEditorNode is None:
	segmentEditorNode = slicer.mrmlScene.CreateNodeByClass("vtkMRMLSegmentEditorNode")
	segmentEditorNode.UnRegister(None)
	segmentEditorNode.SetSingletonTag(segmentEditorSingletonTag)
	segmentEditorNode = slicer.mrmlScene.AddNode(segmentEditorNode)
	return segmentEditorNode
	def info(self):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).info()
	def datastore(self):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).datastore()
	def download_label(self, label_id, tag):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).download_label(label_id, tag)
	def next_sample(self, strategy, params={}):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).next_sample(strategy, params)
	def create_session(self, image_in):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).create_session(image_in)
	def get_session(self, session_id):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).get_session(session_id)
	def remove_session(self, session_id):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).remove_session(session_id)
	def upload_image(self, image_in, image_id=None):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).upload_image(image_in, image_id)
	def save_label(self, image_in, label_in, params):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).save_label(
	image_in, label_in, params=params
	)
	def infer(self, model, image_in, params={}, label_in=None, file=None, session_id=None):
	logging.debug("Preparing input data for segmentation")
	self.reportProgress(0)
	client = MONAILabelClient(self.server_url, self.tmpdir, self.client_id)
	params["result_extension"] = ".nrrd" # expect .nrrd
	params["result_dtype"] = "uint8"
	result_file, params = client.infer(model, image_in, params, label_in, file, session_id)
	logging.debug(f"Image Response: {result_file}")
	logging.debug(f"JSON Response: {params}")
	self.reportProgress(100)
	return result_file, params
	def train_start(self, model=None, params={}):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).train_start(model, params)
	def train_status(self, check_if_running):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).train_status(check_if_running)
	def train_stop(self):
	return MONAILabelClient(self.server_url, self.tmpdir, self.client_id).train_stop()

You can use it like this:

logic = slicer.util.getModuleLogic('MONAILabel')
...
result_file, params = logic.infer(...)