6 |
7 |
8 |
9 | 
10 |
74 |
75 |
95 | @article{pettersen2022codefree,
96 | title={{Code-Free Development and Deployment of Deep Segmentation Models for Digital Pathology}},
97 | author={Pettersen, Henrik Sahlin and Belevich, Ilya and Røyset, Elin Synnøve and Smistad, Erik and Simpson, Melanie Rae and Jokitalo, Eija and Reinertsen, Ingerid and Bakke, Ingunn and Pedersen, André},
98 | journal={Frontiers in Medicine},
99 | volume={8},
100 | year={2022},
101 | url={https://www.frontiersin.org/article/10.3389/fmed.2021.816281},
102 | doi={10.3389/fmed.2021.816281},
103 | issn={2296-858X}
104 | }
105 |
106 |
107 | In addition, if you used the data set in your work, please, cite the following:
108 |
109 | @data{pettersen2021ibdcolepi,
110 | title = {{140 HE and 111 CD3-stained colon biopsies of active and inactivate inflammatory bowel disease with epithelium annotated: the IBDColEpi dataset}},
111 | author = {Pettersen, Henrik Sahlin and Belevich, Ilya and Røyset, Elin Synnøve and Smistad, Erik and Jokitalo, Eija and Reinertsen, Ingerid and Bakke, Ingunn and Pedersen, André},
112 | publisher = {DataverseNO},
113 | year = {2021},
114 | version = {V2},
115 | doi = {10.18710/TLA01U},
116 | url = {https://doi.org/10.18710/TLA01U}
117 | }
118 |
119 |
120 | ## [Acknowledgements](https://github.com/andreped/NoCodeSeg#acknowledgements)
121 | We wish to give our praise to [Peter Bankhead](https://www.ed.ac.uk/pathology/people/staff-students/peter-bankhead) and the [QuPath](https://github.com/qupath/qupath) team for their continuous support and assistance with QuPath and for assisting us in developing the scripts related to this study.
122 |
--------------------------------------------------------------------------------
/assets/generate_badge.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import pandas as pd
3 | import imgkit
4 |
5 |
6 | options = {
7 | 'format': 'png',
8 | 'crop-h': '20',
9 | 'crop-w': '176',
10 | 'crop-x': '8',
11 | 'crop-y': '8',
12 | 'encoding': "UTF-8",
13 | 'custom-header' : [
14 | ('Accept-Encoding', 'gzip')
15 | ]
16 | }
17 |
18 | path = "filedownloads?parentAlias=ntnu"
19 | data = np.asarray(pd.read_csv(path, delimiter=None))
20 | pid2find = "10.18710/TLA01U"
21 |
22 | res = []
23 | total = 0
24 | for i in range(data.shape[0]):
25 | id_, pid_, count_ = data[i]
26 | if pid2find in pid_:
27 | total += count_
28 |
29 | ret = ' + \
33 | '-orange){kind=icon}
'
34 |
35 | print("generated html line: ", ret)
36 |
37 | imgkit.from_string(ret, "badge.png", options=options)
38 |
39 | imgkit.from_string(ret, "badge.svg")
40 |
41 |
42 |
--------------------------------------------------------------------------------
/figures/deepmib-demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andreped/NoCodeSeg/ca8dfa805ec4763954b8098c027205dabe950d45/figures/deepmib-demo.gif
--------------------------------------------------------------------------------
/figures/inference-demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andreped/NoCodeSeg/ca8dfa805ec4763954b8098c027205dabe950d45/figures/inference-demo.gif
--------------------------------------------------------------------------------
/figures/merged-demos.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andreped/NoCodeSeg/ca8dfa805ec4763954b8098c027205dabe950d45/figures/merged-demos.gif
--------------------------------------------------------------------------------
/figures/qupath-demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andreped/NoCodeSeg/ca8dfa805ec4763954b8098c027205dabe950d45/figures/qupath-demo.gif
--------------------------------------------------------------------------------
/figures/youtube-thumbnail.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/andreped/NoCodeSeg/ca8dfa805ec4763954b8098c027205dabe950d45/figures/youtube-thumbnail.jpg
--------------------------------------------------------------------------------
/source/exportTiles.groovy:
--------------------------------------------------------------------------------
1 | /**
2 | * Script to export annotations as labeled tiles for QuPath > 0.2*.
3 | *
4 | * All patches will be exported to the same directory called 'tiles' inside the Project directory
5 | * The patches will be filtered based on tissue content, and finally moved to respective the
6 | * subdirectories: Images and Labels within the 'tiles' folder
7 | *
8 | * Each patch's filename contains the original WSI ID, and images are saved as PNG (by default)
9 | * and ground truth as TIF
10 | *
11 | * The downsampling level can be set by the user, default value is 4.
12 | *
13 | * Code is inspired by the script from the QuPath documentations, written by Pete Bankhead:
14 | * https://qupath.readthedocs.io/en/stable/docs/advanced/exporting_images.html#tile-exporter
15 | *
16 | * @author André Pedersen
17 | */
18 |
19 |
20 | import qupath.lib.images.servers.LabeledImageServer
21 | import java.awt.image.Raster
22 | import javax.imageio.ImageIO;
23 |
24 |
25 | // ----- SET THESE PARAMETERS -----
26 | def classNames = ["Benign", "Malign"] // names of classes of interest (simply add more values to list to add more classes)
27 | double downsample = 4 // which downsampling level to use -> how much to downsample the patches
28 | double glassThreshold = 50 // which threshold to use for tissue detection (lower value => more tissue included in mask)
29 | double percentageThreshold = 0.25 // if a patch contains less than X amount of tissue, it should be neglected (range [0.0, 1.0])
30 | int patchSize = 512 // generated patch size
31 | int pixelOverlap = 128 // stride for which patches are generated
32 | def imageExtension = ".tif"
33 | int nb_channels = 3;
34 | def multiChannel = false;
35 | // --------------------------------
36 |
37 |
38 | def imageData = getCurrentImageData()
39 |
40 | // Define output path (relative to project)
41 | def name = GeneralTools.getNameWithoutExtension(imageData.getServer().getMetadata().getName())
42 | def pathOutput = buildFilePath(PROJECT_BASE_DIR, 'tiles')
43 | mkdirs(pathOutput)
44 |
45 | // Create an ImageServer where the pixels are derived from annotations
46 | def tempServer = new LabeledImageServer.Builder(imageData)
47 | .backgroundLabel(0, ColorTools.WHITE) // Specify background label (usually 0 or 255)
48 | .downsample(downsample) // Choose server resolution; this should match the resolution at which tiles are exported
49 | .multichannelOutput(multiChannel) // If true, each label is a different channel (required for multiclass probability)
50 |
51 | // assign each class to the server (need to iterate across list array due to multi-class)
52 | def counter = 1
53 | classNames.each { currClassName ->
54 | tempServer.addLabel(currClassName, counter) // Choose output labels (the order matters!)
55 | counter++;
56 | }
57 |
58 | // finally, build server
59 | def labelServer = tempServer.build()
60 |
61 | // Create an exporter that requests corresponding tiles from the original & labeled image servers
62 | new TileExporter(imageData)
63 | .downsample(downsample) // Define export resolution
64 | .imageExtension(imageExtension) // Define file extension for original pixels (often .tif, .jpg, '.png' or '.ome.tif')
65 | .tileSize(patchSize) // Define size of each tile, in pixels
66 | .labeledServer(labelServer) // Define the labeled image server to use (i.e. the one we just built)
67 | .annotatedTilesOnly(true) // If true, only export tiles if there is a (labeled) annotation present
68 | .overlap(pixelOverlap) // Define overlap, in pixel units at the export resolution
69 | .writeTiles(pathOutput) // Write tiles to the specified directory
70 |
71 | // create new folder (IMAGES AND LABELS), but only if they do not exist!
72 | def dir1 = new File(pathOutput + "/Images");
73 | if (!dir1.isDirectory())
74 | dir1.mkdir()
75 |
76 | def dir2 = new File(pathOutput + "/Labels");
77 | if (!dir2.isDirectory())
78 | dir2.mkdir()
79 |
80 | // attempt to delete unwanted patches, both some formats as well as patches containing mostly glass
81 | // Iterate through all your tiles
82 | File folder = new File(pathOutput)
83 | File[] listOfFiles = folder.listFiles()
84 |
85 | // for each patch
86 | listOfFiles.each { tile ->
87 | // skip directories within masks folder, and skip all ground truth patches
88 | if (tile.isDirectory())
89 | return;
90 | def currPath = tile.getPath()
91 | if (!currPath.endsWith(imageExtension))
92 | return;
93 |
94 | // load TIFF images back again, estimate patch glass density, and remove patches with lots
95 | // of glass based on user-defined threshold
96 | def image = ImageIO.read(new File(currPath))
97 | Raster raster = image.getRaster();
98 |
99 | // estimate amount of tissue in patch
100 | def tissue = 0;
101 | for (int y = 0; y < image.getHeight(); ++y) {
102 | for (int x = 0; x < image.getWidth(); ++x) {
103 | double currDist = 0
104 | for (int z = 0; z < nb_channels; ++z) {
105 | currDist += raster.getSample(x, y, z)
106 | }
107 | currDist = ((currDist / 3) > (255 - glassThreshold)) ? 0 : 1;
108 | if (currDist > 0) {
109 | ++tissue
110 | }
111 | }
112 | }
113 |
114 | // remove patches containing less tissue, dependent on user-defined threshold, and move accepted patches to respective folders
115 | def amountTissue = tissue / (image.getWidth() * image.getHeight());
116 | def currLabelPatch = new File(pathOutput + "/" + tile.getName().split(imageExtension)[0] + ".png")
117 | if (amountTissue < percentageThreshold) {
118 | tile.delete()
119 | currLabelPatch.delete()
120 | } else {
121 | tile.renameTo(pathOutput + "/Images/" + tile.getName())
122 | currLabelPatch.renameTo(new File(pathOutput + "/Labels/" + tile.getName().split(imageExtension)[0] + ".png"))
123 | }
124 | }
125 |
126 | print "Done!"
127 |
128 | // reclaim memory - relevant for running this within a RunForProject
129 | Thread.sleep(100);
130 | javafx.application.Platform.runLater {
131 | getCurrentViewer().getImageRegionStore().cache.clear();
132 | System.gc();
133 | }
134 | Thread.sleep(100);
--------------------------------------------------------------------------------
/source/fastpathology-model-example/example-model-config.txt:
--------------------------------------------------------------------------------
1 | model_name:Epithelium_HE_512
2 | name:Epithelium_HE_512
3 | task:Epithelium_HE_512
4 | problem:segmentation
5 | resolution:high
6 | magnification_level:10
7 | mask_threshold:0.02
8 | tissue_threshold:70
9 | patch_overlap:0.05
10 | batch_size:1
11 | input_img_size_x:512
12 | input_img_size_y:512
13 | nb_channels:3
14 | nb_classes:2
15 | input_node:ImageInputLayer
16 | output_node:Softmax_Layer_Transpose2
17 | class_colors:0,0,255;0,255,0
18 | class_names:Exterior;Epithelium
19 | interpolation:0
20 | pipeline:import;tissue_segmentation;batchgen;neural_network;stitch;render
21 | batch_process:2
22 | scale_factor:1.0f/1.0f
23 | cpu:0
24 | IE:OpenVINO
--------------------------------------------------------------------------------
/source/fastpathology-model-example/example-pipeline.fpl:
--------------------------------------------------------------------------------
1 | PipelineName "Neural network high-res WSI segmentation"
2 | PipelineDescription "asd"
3 |
4 | PipelineOutputData heatmap stitcher 0
5 |
6 | ### Processing chain
7 | ProcessObject importer WholeSlideImageImporter
8 | Attribute filename @@filename@@
9 |
10 | ProcessObject tissueSeg TissueSegmentation
11 | Attribute threshold 85
12 | Input 0 importer 0
13 |
14 | ProcessObject patch PatchGenerator
15 | Attribute patch-size 256 256
16 | Attribute patch-level 2
17 | Attribute patch-overlap 0.0
18 | Attribute mask-threshold 0.05
19 | Input 0 importer 0
20 | Input 1 tissueSeg 0
21 |
22 | ProcessObject network SegmentationNetwork
23 | Attribute scale-factor 1.0
24 | #Attribute inference-engine TensorRT
25 | Attribute inference-engine OpenVINO
26 | Attribute model "C:/path/to/some/model.onnx"
27 | Input 0 patch 0
28 |
29 | ProcessObject stitcher PatchStitcher
30 | Input 0 network 0
31 |
32 | ProcessObject exporter TIFFImagePyramidExporter
33 | Attribute filename @@exportPath@@
34 | Attribute execute-on-last-frame-only true
35 | Input 0 stitcher 0
36 |
37 |
38 | ### Renderers
39 | Renderer segRenderer SegmentationRenderer
40 | Attribute opacity 1.0
41 | Attribute border-opacity 0.0
42 | Attribute label-colors "1" "green" "2" "red"
43 | Input 0 stitcher 0
--------------------------------------------------------------------------------
/source/getWorstPerformingPatches.ps1:
--------------------------------------------------------------------------------
1 | Get-Content "C:/path-to-list-of-worst-performing-patches.txt"
2 | | ForEach {Move-Item -LiteralPath .\$_ -Destination "C:/path-to-directory-of-removed-patches"
3 | }
--------------------------------------------------------------------------------
/source/html/generate-badge.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | 
'
50 | );
51 | }
52 |
--------------------------------------------------------------------------------
/source/html/generate-badge.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import pandas as pd
3 |
4 |
5 | url = "https://dataverse.no/api/info/metrics/filedownloads?parentAlias=ntnu"
6 |
7 |
--------------------------------------------------------------------------------
/source/importPyramidalTIFF.groovy:
--------------------------------------------------------------------------------
1 | /**
2 | * Script to import uint8 pyramidal TIFF images from FastPathology as annotations for QuPath >= v0.3*
3 | *
4 | * It is assumed that the TIFF lies in the project directory structure generated by FastPathology.
5 | *
6 | * Furthermore, we assume that the image is uint8, where each uint correspond to a different class.
7 | *
8 | * Currently, it is assumed that the classes are labelled {1, 2, 3, ..., k}, with no space between, and where 0 is background.
9 | *
10 | * Code is slightly modified from Peter Bankhead's script to support RunForProject:
11 | * https://gist.github.com/petebankhead/27c1f8cd950583452c756f3a2ea41fc0
12 | *
13 | * which was written for https://forum.image.sc/t/rendering-wsi-as-overlay-on-top-of-another-wsi/52629/25?u=andreped
14 | *
15 | * All credit to Peter Bankhead and the QuPath team for their tremendous support in implementing this script!
16 | *
17 | * @author André Pedersen
18 | */
19 |
20 |
21 | // --- SET THESE PARAMETERS ---
22 | def masksPath = "C:/Users/username/fastpathology/projects/2022-09-09-173804/results/" // path to where TIFFs are stored (FastPathology project)
23 | def downsample = 2 // which scaling factor to use, if the segmentation is produced at a lower magnification level
24 | def level = 0 // which level to extract segmentation from (choosing 0 may be slow)
25 | def extension = ".tiff" // pyramidal TIFF
26 | def classNames = ["Benign", "Malign"] // names of classes of interest (in this case two classes, excluding the background class)
27 | def taskName = "Tissue segmentation" // name of task, which correspond to which task that was run in FastPathology to get this result
28 | int channel = 0 // 0-based index for the channel to threshold
29 | def fromFP = true // whether result is from FastPathology or not, if no, we assume that the TIFF lie directly in the maskPath directory with the same name.
30 | // ----------------------------
31 |
32 | // In case the image has bounds, we need to shift annotations
33 | def imageServer = getCurrentServer();
34 | def shiftX = -imageServer.boundsX;
35 | def shiftY = -imageServer.boundsY;
36 |
37 | // Get a list of image files, stopping early if none can be found
38 | def dirOutput = new File(masksPath);
39 | if (!dirOutput.isDirectory()) {
40 | print dirOutput + ' is not a valid directory!';
41 | return;
42 | }
43 |
44 | // get current WSI, update paths to file
45 | def currWSIName = GeneralTools.getNameWithoutExtension(getProjectEntry().getImageName())
46 | def path = ""
47 |
48 | if (fromFP) {
49 | path = masksPath + "/" + currWSIName + "/" + taskName + "/Segmentation/Segmentation" + extension
50 | } else {
51 | path = masksPath + "/" + currWSIName + extension
52 | }
53 |
54 | // check if file exists, if no return
55 | File file = new File(path)
56 | if (!file.exists()) {
57 | print path + ' does not exist!';
58 | return;
59 | }
60 |
61 | // Create a single-resolution server at the desired level, if required
62 | def server = buildServer(path)
63 | if (level != 0) {
64 | server = qupath.lib.images.servers.ImageServers.pyramidalize(server, server.getDownsampleForResolution(level))
65 | }
66 |
67 | def belowClass = getPathClass('Ignore*') // Class for pixels below the threshold
68 | def current_thresh = 0.5;
69 |
70 | classNames.each { currClassName ->
71 | def aboveClass = getPathClass(currClassName) // Class for pixels above the threshold
72 |
73 | // Create a thresholded image
74 | def thresholdServer = PixelClassifierTools.createThresholdServer(server, channel, current_thresh, belowClass, getPathClass(currClassName))
75 |
76 | // Create annotations and add to the current object hierarchy
77 | def hierarchy = getCurrentHierarchy()
78 | PixelClassifierTools.createAnnotationsFromPixelClassifier(hierarchy, thresholdServer, -1, -1)
79 |
80 | // Select current annotations
81 | selectObjectsByClassification(currClassName);
82 |
83 | // Get current annotations, rescale and shift
84 | def oldObjects = getAnnotationObjects().findAll{it.getPathClass() == getPathClass(currClassName)}
85 | def transform = java.awt.geom.AffineTransform.getTranslateInstance(shiftX, shiftY)
86 | transform.concatenate(java.awt.geom.AffineTransform.getScaleInstance(downsample, downsample))
87 | def newObjects = oldObjects.collect {p -> PathObjectTools.transformObject(p, transform, false)}
88 |
89 | // Delete old annotations
90 | clearSelectedObjects(false);
91 |
92 | // add resulting annotation object (and update current threshold)
93 | addObjects(newObjects)
94 | current_thresh++;
95 | }
96 |
97 |
98 | // finally, correct all annotations, by iteratively subtracting adjacent annotations to assign one uint to one class
99 | for(int i = 0; i < classNames.size() - 1; i++) {
100 | def className1 = classNames[i]
101 | def className2 = classNames[i + 1]
102 |
103 | def class1 = getAnnotationObjects().find {it.getPathClass() == getPathClass(className1)}
104 | def class2 = getAnnotationObjects().find {it.getPathClass() == getPathClass(className2)}
105 | def plane = class1.getROI().getImagePlane()
106 | if (plane != class2.getROI().getImagePlane()) {
107 | println 'Annotations are on different planes!'
108 | return
109 | }
110 | // Convert to geometries & compute distance
111 | // Note: see https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#distance-org.locationtech.jts.geom.Geometry-
112 | def g1 = class1.getROI().getGeometry()
113 | def g2 = class2.getROI().getGeometry()
114 |
115 | def difference = g1.difference(g2)
116 | if (difference.isEmpty())
117 | println "No intersection between areas"
118 | else {
119 | def roi = GeometryTools.geometryToROI(difference, plane)
120 | def annotation = PathObjects.createAnnotationObject(roi, getPathClass('Difference'))
121 | addObject(annotation)
122 | selectObjects(annotation)
123 | }
124 | //remove original object
125 | removeObject(class1, true)
126 |
127 | // rename annotation
128 | getAnnotationObjects().each { annotation ->
129 | if (annotation.getPathClass().equals(getPathClass("Difference")))
130 | annotation.setPathClass(getPathClass(className1))
131 | }
132 | }
133 |
134 | print "Done!"
135 |
136 | // reclaim memory - relevant for running this within a RunForProject
137 | Thread.sleep(100);
138 | javafx.application.Platform.runLater {
139 | getCurrentViewer().getImageRegionStore().cache.clear();
140 | System.gc();
141 | }
142 | Thread.sleep(100);
143 |
--------------------------------------------------------------------------------
/source/importStitchedTIFfromMIB.groovy:
--------------------------------------------------------------------------------
1 | /**
2 | * Script to import uint8 stitched TIF images as annotations for QuPath >= v0.3*
3 | *
4 | * It is assumed that the TIF lies in a user-defined directory with the same name but with the extension '.tif'
5 | *
6 | * However, the name of the stitched images (assumed .tif) can be set in the "extensions" variable
7 | *
8 | * Furthermore, we assume that the image is uint8, where each uint correspond to a different class
9 | *
10 | * Script supports multi-class stitched images, but it is assumed that each class is set in a strided manner
11 | * where uint 0 is assumed to be background
12 | *
13 | * Code is inspired by Pete Bankhead's script from the ImageJ forum:
14 | * https://forum.image.sc/t/rendering-wsi-as-overlay-on-top-of-another-wsi/52629/9?u=andreped
15 | *
16 | * @author André Pedersen
17 | */
18 |
19 |
20 | import qupath.lib.images.servers.ImageServerProvider
21 | import qupath.lib.regions.RegionRequest
22 | import java.awt.image.BufferedImage
23 | import qupath.lib.analysis.images.ContourTracing;
24 | import static qupath.lib.gui.scripting.QPEx.*
25 |
26 |
27 | // --- SET THESE PARAMETERS ---
28 | def masksPath = "E:/path/to/some/ResultsModels_WSI/"
29 | def downsample = 2.0;
30 | def extension = ".tif"
31 | def classNames = ["Benign", "Malign"] // example class names, for single class use ["Benign"]
32 | boolean fromFP = false // if predictions are stored in a FP-like manner (two-level folder structure = true)
33 | boolean fromMIB = true // if predictions are from MIB, they will need to be renamed adding "labels_"
34 | // ----------------------------
35 |
36 |
37 | // Get a list of image files, stopping early if none can be found
38 | def dirOutput = new File(masksPath);
39 | if (!dirOutput.isDirectory()) {
40 | print dirOutput + ' is not a valid directory!';
41 | return;
42 | }
43 |
44 | // get current WSI, update paths to file
45 | def currWSIName = GeneralTools.getNameWithoutExtension(getProjectEntry().getImageName())
46 | if (fromFP) {
47 | masksPath += currWSIName
48 | }
49 |
50 | def path = ""
51 | if (fromMIB) {
52 | path = masksPath + "/labels_" + currWSIName + extension
53 | } else {
54 | path = masksPath + "/" + currWSIName + extension
55 | }
56 |
57 | // check if file exists, if no return
58 | File file = new File(path)
59 | if (!file.exists()) {
60 | print path + ' does not exist!';
61 | return;
62 | }
63 |
64 | // Ideally you'd use ImageIO.read(File)... but if it doesn't work we need this
65 | def server = ImageServerProvider.buildServer(path, BufferedImage)
66 | def region = RegionRequest.createInstance(server)
67 | def img = server.readBufferedImage(region)
68 | def band = ContourTracing.extractBand(img.getRaster(), 0)
69 | def request = RegionRequest.createInstance(getCurrentServer(), downsample)
70 |
71 | // for each class, iterate and create annotations for each
72 | int counter = 1
73 | classNames.each { currClassName ->
74 | def annotations = ContourTracing.createAnnotations(band, request, counter, counter)
75 |
76 | addObjects(annotations)
77 | replaceClassification(null, currClassName);
78 |
79 | counter++
80 | }
81 |
82 | print "Done!"
83 |
84 | // reclaim memory - relevant for running this within a RunForProject
85 | Thread.sleep(100);
86 | javafx.application.Platform.runLater {
87 | getCurrentViewer().getImageRegionStore().cache.clear();
88 | System.gc();
89 | }
90 | Thread.sleep(100);
--------------------------------------------------------------------------------
/source/importTiles.groovy:
--------------------------------------------------------------------------------
1 | /**
2 | * Script to import binary masks & create annotations, adding them to the current object hierarchy for QuPath >= v0.3.*
3 | *
4 | * It is assumed that each mask is stored in a TIFF file in a project subdirectory called 'masks'.
5 | * Each file name should be of the form:
6 | * "Labels_{Short original image name} [{x},{y}, {width},{height}].tif"
7 | *
8 | * Note: It's assumed that the classification is a simple name without underscores, i.e. not a 'derived' classification
9 | * (so 'Tumor' is ok, but 'Tumor: Positive' is not)
10 | *
11 | * It is also assumed that the background is assigned value 0 and class of interest is assigned value 1.
12 | *
13 | * The x, y, width & height values should be in terms of coordinates for the full-resolution image.
14 | *
15 | * By default, the image name stored in the mask filename has to match that of the current image - but this check can be turned off.
16 | *
17 | * Code is inspired by scripts and ideas from these threads of the ImageJ forum:
18 | * https://forum.image.sc/t/importing-binary-masks-in-qupath/25713/24
19 | * https://forum.image.sc/t/importing-binary-masks-in-qupath/25713/2
20 | * https://forum.image.sc/t/transferring-segmentation-predictions-from-custom-masks-to-qupath/43408/24
21 | *
22 | * The code of these threads were mainly contributed by Pete Bankhead, Benjamin Pavie, and Raymond301.
23 | *
24 | * @author André Pedersen
25 | */
26 |
27 |
28 | import ij.plugin.filter.ThresholdToSelection
29 | import ij.process.ImageProcessor
30 | import qupath.lib.objects.PathObjects
31 | import qupath.lib.regions.ImagePlane
32 | import qupath.imagej.processing.RoiLabeling
33 | import ij.IJ
34 | import static qupath.lib.gui.scripting.QPEx.*
35 |
36 |
37 | // --- SET THESE PARAMETERS ---
38 | def className = "Epithelium";
39 | def pathOutput = "C:/path-to-exported-labels-dir"
40 | def patchFormat = "tif" // set to "png" or "tif"
41 | // ----------------------------
42 |
43 |
44 | // Get the main QuPath data structures
45 | def imageData = getCurrentImageData();
46 | def hierarchy = imageData.getHierarchy();
47 | def server = imageData.getServer();
48 | def plane = getCurrentViewer().getImagePlane();
49 |
50 | def name = GeneralTools.getNameWithoutExtension(imageData.getServer().getMetadata().getName())
51 | print pathOutput
52 | print name
53 |
54 | // Get a list of image files, stopping early if none can be found
55 | def dirOutput = new File(pathOutput);
56 | print dirOutput
57 | if (!dirOutput.isDirectory()) {
58 | print pathOutput + ' is not a valid directory!';
59 | return;
60 | }
61 |
62 | def files = dirOutput.listFiles({f -> f.isFile() } as FileFilter) as List;
63 | if (files.isEmpty()) {
64 | print 'No mask files found in ' + dirOutput;
65 | return;
66 | }
67 |
68 | // loading bar
69 | int spaces = 40;
70 | float progress = 100.0;
71 | int counter = 0;
72 | int nbPatches = files.size;
73 |
74 | // Create annotations for all the files
75 | def annotations = [];
76 | files.each {
77 | String hash = "#" * Math.ceil((counter * spaces) / nbPatches);
78 | println String.format("[%-" + spaces + "s] %d%s%d\r", hash, counter, '/', nbPatches);
79 | counter ++;
80 | def currentName = GeneralTools.getNameWithoutExtension(getProjectEntry().getImageName())
81 | def filename = it.getName();
82 | if (!filename.contains(currentName) || !filename.endsWith("]." + patchFormat))
83 | return;
84 | try {
85 | annotations << parseAnnotation(it, plane);
86 | } catch (Exception e) {
87 | print 'Unable to parse annotation from ' + it.getName() + ': ' + e.getLocalizedMessage();
88 | }
89 | }
90 |
91 | /**
92 | * Create a new annotation from a binary image, parsing the classification & region from the file name.
93 | *
94 | * @param file File containing the TIFF image mask. The image name must be formatted as above.
95 | * @return The PathAnnotationObject created based on the mask & file name contents.
96 | */
97 | def parseAnnotation(File file, ImagePlane plane) {
98 |
99 | def filename = file.getName();
100 | def imp = IJ.openImage(file.getPath());
101 |
102 | def parts = filename.split(' ');
103 | def regionParts = parts[-1].split(",") as List;
104 |
105 | // Handle scenario where there was not done any downsampling (d=1 skipped!)
106 | if (regionParts.size() == 4) {
107 | regionParts[0] = regionParts[0][1..-1]
108 | regionParts.add(0, "[d=1")
109 | }
110 |
111 | def downsample = regionParts[0].replace("[d=", "") as float;
112 |
113 | // Parse the x, y coordinates of the region
114 | int x = regionParts[1].replace("x=", "") as int;
115 | int y = regionParts[2].replace("y=", "") as int;
116 |
117 | // To create the ROI, travel into ImageJ
118 | def bp = imp.getProcessor();
119 | int n = bp.getStatistics().max as int;
120 | def rois = RoiLabeling.labelsToConnectedROIs(bp, n);
121 |
122 | def pathObjects = rois.collect {
123 | if (it == null)
124 | return;
125 | def roiQ = IJTools.convertToROI(it, -x/downsample, -y/downsample, downsample, plane);
126 | return PathObjects.createAnnotationObject(roiQ);
127 | }
128 | // this is slow, but it works... Better to add objects AFTER, as it seems like it draws every single time, maybe?
129 | addObjects(pathObjects);
130 | }
131 |
132 | resolveHierarchy();
133 |
134 | // finally, rename to class of interest
135 | replaceClassification(null, className);
136 |
137 | // merge all annotations
138 | print "Merging (might take some time...)"
139 | selectObjects {
140 | return it.isAnnotation() && it.getPathClass() == getPathClass(className)
141 | }
142 | mergeSelectedAnnotations();
143 |
144 | print "Done!"
145 |
146 | // reclaim memory - relevant for running this within a RunForProject
147 | Thread.sleep(100);
148 | javafx.application.Platform.runLater {
149 | getCurrentViewer().getImageRegionStore().cache.clear();
150 | System.gc();
151 | }
152 | Thread.sleep(100);
--------------------------------------------------------------------------------
/source/qupath_export_tiles_annotation_multiclass.groovy:
--------------------------------------------------------------------------------
1 | import qupath.lib.images.servers.LabeledImageServer
2 |
3 | def imageData = getCurrentImageData()
4 |
5 | // Define output path (relative to project)
6 | def name = GeneralTools.getNameWithoutExtension(imageData.getServer().getMetadata().getName())
7 |
8 | //create directory called tiles in qupath project directory
9 | //adding more strings will create more subfolders
10 | def pathOutput = buildFilePath(PROJECT_BASE_DIR, 'tiles')
11 | mkdirs(pathOutput)
12 |
13 |
14 | // Define output resolution
15 | double requestedPixelSize = 1 // default 10.0, change based on image size
16 |
17 | // Convert to downsample
18 | double downsample = requestedPixelSize / imageData.getServer().getPixelCalibration().getAveragedPixelSize()
19 |
20 | // Create an ImageServer where the pixels are derived from annotations
21 | def labelServer = new LabeledImageServer.Builder(imageData)
22 | .backgroundLabel(0, ColorTools.WHITE) // Specify background label (usually 0 or 255)
23 | .downsample(downsample) // Choose server resolution; this should match the resolution at which tiles are exported
24 | .addLabel('Epithelia', 1) // Choose output labels (the order matters! and so does the threshold value)
25 | .addLabel('Crypt', 2)
26 | .multichannelOutput(true) // If true, each label is a different channel (required for multiclass probability)
27 | .build()
28 |
29 | // Create an exporter that requests corresponding tiles from the original & labeled image servers
30 | new TileExporter(imageData)
31 | .downsample(downsample) // Define export resolution
32 | .imageExtension('.tif') // Define file extension for original pixels (often .tif, .jpg, '.png' or '.ome.tif')
33 | .tileSize(512) // Define size of each tile, in pixels
34 | .labeledServer(labelServer) // Define the labeled image server to use (i.e. the one we just built)
35 | .annotatedTilesOnly(false) // If true, only export tiles if there is a (labeled) annotation present
36 | .overlap(64) // Define overlap, in pixel units at the export resolution
37 | .imageSubDir("images")//save images in a subfolder called images
38 | .labeledImageSubDir("masks")//save masks in a subfolder called masks
39 | .writeTiles(pathOutput) // Write tiles to the specified directory:
40 | //by default you can omit imageSubDir and labeledImageSubDir and use just writeTiles.
41 | //This will save all images together
42 | print 'Done!'
--------------------------------------------------------------------------------
/source/runtime-experiments/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required(VERSION 3.12)
2 | project(pipelineRuntime)
3 |
4 | set(CMAKE_CXX_STANDARD 17)
5 |
6 | include_directories(.)
7 | find_package(FAST REQUIRED)
8 | include(${FAST_USE_FILE})
9 |
10 | add_executable(pipelineRuntime pipelineRuntime.cpp)
11 | add_dependencies(pipelineRuntime fast_copy)
12 | target_link_libraries(pipelineRuntime ${FAST_LIBRARIES})
13 |
14 | set_target_properties(pipelineRuntime PROPERTIES
15 | CXX_STANDARD 17
16 | CXX_EXTENSIONS OFF
17 | )
--------------------------------------------------------------------------------
/source/runtime-experiments/pipelineRuntime.cpp:
--------------------------------------------------------------------------------
1 | #include