Develop

.gitignore

@@ -16,3 +16,4 @@ tests/data/
 work/
 .github/CODEOWNERS-tmp
 *.un~
+*.nf-test*

modules/sanger/bioinfotongli/cellpose/main.nf

@@ -1,21 +1,14 @@
-container_version = "0.1.0"
-params.debug = false
-params.cellpose_model_dir = "./"
-
 process BIOINFOTONGLI_CELLPOSE {
     tag "${meta.id}"
-    debug params.debug
-    cache true
 
-    label "gpu"
     label "medium_mem"
 
     container "${ workflow.containerEngine == 'singularity' && !task.ext.singularity_pull_docker_container ?
-        "quay.io/bioinfotongli/tiled_cellpose:${container_version}":
-        "quay.io/bioinfotongli/tiled_cellpose:${container_version}"}"
+        "quay.io/cellgeni/tiled_cellpose:0.1.3":
+        "quay.io/cellgeni/tiled_cellpose:0.1.3"}"
     containerOptions = {
-            workflow.containerEngine == "singularity" ? "--cleanenv --nv -B ${params.cellpose_model_dir}:/tmp/cellpose_models -B ${params.NUMBA_CACHE_DIR}:/tmp/numba_cache":
-            ( workflow.containerEngine == "docker" ? "--gpus all -v ${params.cellpose_model_dir}:/tmp/cellpose_models": null )
+            workflow.containerEngine == "singularity" ? "--cleanenv --nv":
+            ( workflow.containerEngine == "docker" ? "--gpus all": null )
     }
 
     publishDir params.out_dir + "/naive_cellpose_segmentation"
@@ -24,30 +17,42 @@ process BIOINFOTONGLI_CELLPOSE {
     tuple val(meta), val(x_min), val(y_min), val(x_max), val(y_max), path(image), val(cell_diameter)
 
     output:
-    tuple val(meta), val(cell_diameter), path("${stem}/${stem}_cp_outlines.txt"), emit: outlines, optional: true
-    tuple val(meta), val(cell_diameter), path("${stem}/${stem}_cp_outlines.wkt"), emit: wkts
-    tuple val(meta), val(cell_diameter), path("${stem}/${stem}*png"), emit: cp_plots, optional: true
+    tuple val(meta), path("${prefix}/${prefix}_cp_outlines.txt"), emit: outlines, optional: true
+    tuple val(meta), path("${prefix}/${prefix}_cp_outlines.wkt"), emit: wkts
+    tuple val(meta), path("${prefix}/${prefix}*png"), emit: cp_plots, optional: true
     path "versions.yml"           , emit: versions
 
     script:
-    stem = "${meta.id}-${x_min}_${y_min}_${x_max}_${y_max}-diam_${cell_diameter}"
+    prefix = "${meta.id}-${x_min}_${y_min}_${x_max}_${y_max}-diam_${cell_diameter}"
     def args = task.ext.args ?: ''  
     """
-    export CELLPOSE_LOCAL_MODELS_PATH=/tmp/cellpose_models
-    export NUMBA_CACHE_DIR=/tmp/numba_cache
-    /opt/conda/bin/python /scripts/cellpose_seg.py run \
+    cellpose_seg.py run \
         --image ${image} \
         --x_min ${x_min} \
         --y_min ${y_min} \
         --x_max ${x_max} \
         --y_max ${y_max} \
         --cell_diameter ${cell_diameter} \
-        --out_dir "${stem}" \
+        --out_dir "${prefix}" \
         ${args}
 
     cat <<-END_VERSIONS > versions.yml
     "${task.process}":
-        : \$(echo \$(/scripts/cellpose_seg.py version 2>&1) | sed 's/^.*cellpose_seg.py //; s/Using.*\$//' ))
+        : \$(echo \$(cellpose_seg.py version))
+    END_VERSIONS
+    """
+
+
+    stub:
+    def args = task.ext.args ?: ''
+    prefix = task.ext.prefix ?: "${meta.id}-${x_min}_${y_min}_${x_max}_${y_max}-diam_${cell_diameter}"
+    """
+    mkdir "${prefix}"
+    touch "${prefix}/${prefix}_cp_outlines.wkt"
+
+    cat <<-END_VERSIONS > versions.yml
+    "${task.process}":
+        bioinfotongli: \$(cellpose_seg.py version)
     END_VERSIONS
     """
 }

modules/sanger/bioinfotongli/cellpose/meta.yml

@@ -14,38 +14,65 @@ tools:
       documentation: "https://cellpose.readthedocs.io/en/latest/"
       tool_dev_url: "https://github.com/MouseLand/cellpose"
       doi: "https://doi.org/10.1038/s41592-020-01018-x"
-      licence: ""
+      licence: ["BSD-3-Clause license"]
 
 input:
-  # Only when we have meta
   - meta:
       type: map
       description: |
         Groovy Map containing sample information
-        e.g. `[ id:'test', use_gpu:true, channels:[1,2] ]`
+        e.g. `[ id:'test' ]`
 
+  - x_min:
+      type: integer
+      description: x_min of the region of interest
+
+  - x_max:
+      type: integer
+      description: x_max of the region of interest
+
+  - y_min:
+      type: integer
+      description: y_min of the region of interest
+
+  - y_max:
+      type: integer
+      description: y_max of the region of interest
+
   - imgs:
       type: file
       description: raw images for segmentation
-      pattern: "*.{tif,ome.tif,ome.tiff,png}"
+      pattern: "*.{tif,ome.tif,ome.tiff}"
 
+  - cell_diameter:
+      type: integer
+      description: expected cell diameter in pixels
+
 output:
-  #Only when we have meta
   - meta:
       type: map
-      description: |
+      description:
         Groovy Map containing sample information
-        e.g. `[ id:'test', use_gpu:true, channels:[0,1] ]`
+        e.g. `[ id:'test' ]`
 
   - versions:
       type: file
       description: File containing software versions
       pattern: "versions.yml"
 
-  - segmentation:
+  - "${stem}/${stem}_cp_outlines.txt":
       type: file
-      description: folder contains segmentation information
-      pattern: "*"
+      description: 
+      pattern: "*.txt"
 
+  - "${stem}/${stem}_cp_outlines.wkt":
+      type: file
+      description: 
+      pattern: "*.wkt"
+
+  - "${stem}/${stem}*png":
+      type: file
+      description: 
+      pattern: "*.png"
 authors:
   - "@BioinfoTongLI"

modules/sanger/bioinfotongli/cellpose/resources/usr/bin/cellpose_seg.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024 Wellcome Sanger Institute
+
+"""
+This script will slice the image in XY dimension and save the slices coordinates in json files
+"""
+import fire
+import os
+from cellpose import core, io, models
+import numpy as np
+from shapely import Polygon, wkt, MultiPolygon
+from glob import glob
+from imagetileprocessor import slice_and_crop_image
+
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+VERSION="0.1.3"
+
+
+def main(
+        image:str,
+        x_min:int, x_max:int, y_min:int, y_max:int,
+        out_dir:str,
+        cell_diameter:int=30,
+        cellpose_model:str="cyto3",
+        zs:list=[0],
+        channels:list=[0, 0],
+        resolution_level:int=0,
+        **cp_params
+    ):
+
+    crop = slice_and_crop_image(
+        image, x_min, x_max, y_min, y_max, zs, np.array(channels), resolution_level
+    )
+    # if z is missing, add it
+    if len(crop.shape) == 3:
+        crop = np.expand_dims(crop, axis=0)
+
+    logging.info(f"Loading Cellpose model: {cellpose_model} (GPU: {core.use_gpu()})")
+    model = models.Cellpose(gpu=core.use_gpu(), model_type=cellpose_model)
+    # model = denoise.CellposeDenoiseModel(
+    #     gpu=core.use_gpu(),
+    #     model_type=cellpose_model,
+    #     restore_type="denoise_cyto3",
+    #     chan2_restore=False
+    # )
+
+    masks, flows, _, _ = model.eval(
+        crop,
+        channels=channels,
+        diameter=cell_diameter,
+        channel_axis=1,
+        z_axis=0,
+        **cp_params,
+    )
+    os.mkdir(out_dir)
+    io.save_masks(
+        np.squeeze(crop),
+        masks,
+        flows,
+        file_names=out_dir,
+        save_txt=True,
+        png=True,
+        tif=False,
+        save_flows=False,
+        save_outlines=True,
+        savedir=out_dir,
+    )
+    # convert cellpose outlines to WTK
+    logging.info(f"Converting outlines to WKT format")
+    # prefix_list = out_dir.split(".")
+    # if len(prefix_list) > 1:
+    #     prefix = ".".join(prefix_list[:-1])
+    # else:
+    #     prefix = prefix_list[0]
+    # outlines_file = os.path.join(out_dir, f"{prefix}_cp_outlines.txt")
+    outline_file = glob(f"{out_dir}/*_cp_outlines.txt")
+
+    if len(outline_file) > 0:
+    # if os.path.exists(outlines_file):
+        wkts = []
+        with open(outline_file[0], "rt") as f:
+            for line in f.readlines():
+                # split by comma and make integer
+                try:
+                    outline = list(map(int, line.strip().split(",")))
+                except:
+                    continue
+                outline = np.array(list(zip(outline[::2], outline[1::2])))
+                # transport tile coordinats to original image coordinates
+                outline[:, 0] += x_min
+                outline[:, 1] += y_min
+                poly = Polygon(outline).buffer(0)
+                if isinstance(poly, MultiPolygon):
+                    poly = poly.geoms[0]
+                wkts.append(poly)
+
+        wkt_filename = os.path.join(out_dir, f"{out_dir}_cp_outlines.wkt")
+        with open(wkt_filename, "wt") as f:
+            f.write(wkt.dumps(MultiPolygon(wkts)))
+    else:
+        logging.info("No outlines file found")
+        with open(os.path.join(out_dir, f"{out_dir}_cp_outlines.wkt"), "wt") as f:
+            f.write("")
+
+
+if __name__ == "__main__":
+    options = {
+        "run": main,
+        "version": VERSION,
+    }
+    fire.Fire(options)

modules/sanger/bioinfotongli/cellpose/tests/main.nf.test

@@ -0,0 +1,109 @@
+nextflow_process {
+
+    name "Test Process BIOINFOTONGLI_CELLPOSE"
+    script "../main.nf"
+    config "./nextflow.config"
+    process "BIOINFOTONGLI_CELLPOSE"
+
+    tag "modules"
+    tag "modules_sanger"
+    tag "bioinfotongli"
+    tag "bioinfotongli/cellpose"
+
+    test("mouse_heart - tiff - 500") {
+
+        when {
+            process {
+                """
+                input[0] = [
+                    [ id:'test'],
+                    0, 0, 500, 500,
+                    file(params.modules_testdata_base_path + 'imaging/tiff/mindagap.mouse_heart.wga.tiff', checkIfExists: true),
+                    20,
+                ]
+                """
+            }
+        }
+
+        then {
+            assertAll(
+                { assert process.success },
+                { assert snapshot(process.out).match() }
+            )
+        }
+    }
+
+    test("mouse_heart - tiff - 200") {
+
+        when {
+            process {
+                """
+                input[0] = [
+                    [ id:'test'],
+                    0, 0, 200, 200,
+                    file(params.modules_testdata_base_path + 'imaging/tiff/mindagap.mouse_heart.wga.tiff', checkIfExists: true),
+                    20,
+                ]
+                """
+            }
+        }
+
+        then {
+            assertAll(
+                { assert process.success },
+                { assert snapshot(process.out).match() }
+            )
+        }
+    }
+
+
+    test("mouse_heart - tiff - 200 - large cell diameter") {
+
+        when {
+            process {
+                """
+                input[0] = [
+                    [ id:'test'],
+                    0, 0, 200, 200,
+                    file(params.modules_testdata_base_path + 'imaging/tiff/mindagap.mouse_heart.wga.tiff', checkIfExists: true),
+                    50,
+                ]
+                """
+            }
+        }
+
+        then {
+            assertAll(
+                { assert process.success },
+                { assert snapshot(process.out).match() }
+            )
+        }
+    }
+
+    test("mouse_heart - tiff - stub") {
+
+        options "-stub"
+
+        when {
+            process {
+                """
+                input[0] = [
+                    [ id:'test',],
+                    0, 0, 100, 100,
+                    file(params.modules_testdata_base_path + 'imaging/tiff/mindagap.mouse_heart.wga.tiff', checkIfExists: true),
+                    20,
+                ]
+                """
+            }
+        }
+
+        then {
+            assertAll(
+                { assert process.success },
+                { assert snapshot(process.out).match() }
+            )
+        }
+
+    }
+
+}