dicom stl png pipeline

README.md

@@ -14,6 +14,7 @@ This repository contains:
 - `AbdCTBench_dataset/`: split CSVs + image data archive + 3D stl meshes
 - `code/`: training and evaluation pipeline
 - `models/`: released pretrained checkpoints (`.safetensors`) with configs
+- `code/dicom_stl_png_pipeline/`: DICOM -> STL -> PNG conversion scripts
 
 ## Quick Start
 

code/README.md

@@ -69,6 +69,45 @@ Each released model folder contains:
 - `config.json`
 - `biomarker_config.json`
 
+## DICOM to PNG Pipeline
+
+The DICOM -> STL -> PNG conversion scripts are in:
+
+- `dicom_stl_png_pipeline/`
+
+Key files:
+
+- `dicom2stl.py`: converts a DICOM series (folder/zip) to STL
+- `stl2png_centered.py`: renders STL to a centered PNG
+- `parseargs.py` and `utils/`: argument parsing and volume/mesh helper utilities
+- `requirements.txt` in this folder: extra dependencies for this conversion pipeline
+
+Install pipeline dependencies:
+
+```bash
+pip install -r dicom_stl_png_pipeline/requirements.txt
+```
+
+Minimal usage:
+
+```bash
+python dicom_stl_png_pipeline/dicom2stl.py \
+  --type skin \
+  --output ./sample.stl \
+  /path/to/dicom_series_folder
+```
+
+```bash
+python dicom_stl_png_pipeline/stl2png_centered.py \
+  ./sample.stl \
+  ./sample.png
+```
+
+Notes:
+
+- This conversion pipeline is optional and separate from model train/test.
+- `train.py` and `test.py` consume PNG + CSV data and do not run DICOM conversion internally.
+
 ## Biomarker Config Templates
 
 - `config/biomarker_config_single_task_example.yaml`

code/dicom_stl_png_pipeline/dicom2stl.py

@@ -0,0 +1,447 @@
+#! /usr/bin/env python
+
+"""
+Script to take a Dicom series and generate an STL surface mesh.
+
+Written by David T. Chen from the National Institute of Allergy
+and Infectious Diseases, dchen@mail.nih.gov.
+It is covered by the Apache License, Version 2.0:
+http://www.apache.org/licenses/LICENSE-2.0
+
+Note: if you run this script with the individual Dicom slices provided on the
+command line, they might not be ordered in the correct order.  You are better
+off providing a zip file or a directory.  Dicom slices are not necessarily
+ordered the same alphabetically as they are physically.
+"""
+
+from __future__ import print_function
+
+import gc
+import math
+import os
+import sys
+import tempfile
+import shutil
+import time
+import zipfile
+import vtk
+import re
+import SimpleITK as sitk
+
+from SimpleITK.utilities.vtk import sitk2vtk
+
+import parseargs
+
+from glob import glob
+
+from utils import dicomutils
+from utils import vtkutils
+
+
+def roundThousand(x):
+    y = int(1000.0 * x + 0.5)
+    return str(float(y) * 0.001)
+
+
+def elapsedTime(start_time):
+    dt = time.perf_counter() - start_time
+    print("    %4.3f seconds" % dt)
+
+
+def loadVolume(fname, tempDir=None, verbose=False):
+    modality = None
+    zipFlag = False
+    dirFlag = False
+
+    # Parse wildcards
+    # sum() flatten nested list
+    fname = sum([glob(f) for f in fname], [])
+
+    if len(fname) == 0:
+        print("Error: no valid input given.")
+        sys.exit(4)
+
+    if zipfile.is_zipfile(fname[0]):
+        zipFlag = True
+
+    if os.path.isdir(fname[0]):
+        dirFlag = True
+    else:
+        if len(fname) > 1:
+            print(
+                "File names: ",
+                fname[0],
+                fname[1],
+                "...",
+                fname[len(fname) - 1],
+                "\n",
+            )
+        else:
+            print("File names: ", fname, "\n")
+
+    img = sitk.Image(100, 100, 100, sitk.sitkUInt8)
+
+    #  Load our Dicom data
+    #
+    if zipFlag:
+        # Case for a zip file of images
+        if args.verbose:
+            print("zip")
+        if not tempDir:
+            with tempfile.TemporaryDirectory() as defaultTempDir:
+                img, modality = dicomutils.loadZipDicom(fname[0], defaultTempDir)
+        else:
+            img, modality = dicomutils.loadZipDicom(fname[0], tempDir)
+
+    else:
+        if dirFlag:
+            if verbose:
+                print("directory")
+            img, modality = dicomutils.loadLargestSeries(fname[0])
+
+        else:
+            # Case for a single volume image
+            if len(fname) == 1:
+                if verbose:
+                    print("Reading volume: ", fname[0])
+                img = sitk.ReadImage(fname[0])
+                modality = dicomutils.getModality(img)
+
+            else:
+                # Case for a series of image files
+                # For files named like IM1, IM2, .. IM10
+                # They would be ordered by default as IM1, IM10, IM2, ...
+                # sort the fname list in correct serial number order
+                RE_NUMBERS = re.compile(r"\d+")
+
+                def extract_int(file_path):
+                    file_name = os.path.basename(file_path)
+                    return int(RE_NUMBERS.findall(file_name)[0])
+
+                fname = sorted(fname, key=extract_int)
+
+                if args.verbose:
+                    if args.verbose > 1:
+                        print("Reading images: ", fname)
+                    else:
+                        print(
+                            "Reading images: ",
+                            fname[0],
+                            fname[1],
+                            "...",
+                            fname[len(fname) - 1],
+                        )
+                isr = sitk.ImageSeriesReader()
+                isr.SetFileNames(fname)
+                img = isr.Execute()
+                firstslice = sitk.ReadImage(fname[0])
+                modality = dicomutils.getModality(firstslice)
+
+    return img, modality
+
+
+def writeMetadataFile(img, metaName):
+    FP = open(metaName, "w")
+    size = img.GetSize()
+    spacing = img.GetSpacing()
+    FP.write("xdimension " + str(size[0]) + "\n")
+    FP.write("ydimension " + str(size[1]) + "\n")
+    FP.write("zdimension " + str(size[2]) + "\n")
+    FP.write("xspacing " + roundThousand(spacing[0]) + "\n")
+    FP.write("yspacing " + roundThousand(spacing[1]) + "\n")
+    FP.write("zspacing " + roundThousand(spacing[2]) + "\n")
+    FP.close()
+
+
+def volumeProcessingPipeline(
+    img, shrinkFlag=True, anisotropicSmoothing=True, thresholds=[], medianFilter=False
+):
+    #
+    # shrink the volume to 256 cubed
+    if shrinkFlag:
+        sfactor = []
+        size = img.GetSize()
+        total = 0
+        for s in size:
+            x = int(math.ceil(s / 256))
+            sfactor.append(x)
+            total = total + x
+
+        if total > 3:
+            # if total==3, no shrink happens
+            t = time.perf_counter()
+            print("Shrink factors: ", sfactor)
+            img = sitk.Shrink(img, sfactor)
+            newsize = img.GetSize()
+            print(size, "->", newsize)
+            elapsedTime(t)
+
+    gc.collect()
+
+    # Apply anisotropic smoothing to the volume image.  That's a smoothing filter
+    # that preserves edges.
+    #
+    if anisotropicSmoothing:
+        print("Anisotropic Smoothing")
+        t = time.perf_counter()
+        pixelType = img.GetPixelID()
+        img = sitk.Cast(img, sitk.sitkFloat32)
+        img = sitk.CurvatureAnisotropicDiffusion(img, 0.03)
+        img = sitk.Cast(img, pixelType)
+        elapsedTime(t)
+        gc.collect()
+
+    # Apply the double threshold filter to the volume
+    #
+    if len(thresholds) == 4:
+        print("Double Threshold: ", thresholds)
+        t = time.perf_counter()
+        img = sitk.DoubleThreshold(
+            img, thresholds[0], thresholds[1], thresholds[2], thresholds[3], 255, 0
+        )
+        elapsedTime(t)
+        gc.collect()
+
+    # Apply a 3x3x1 median filter.  I only use 1 in the Z direction so it's not so
+    # slow.
+    #
+    if medianFilter:
+        print("Median filter")
+        t = time.perf_counter()
+        img = sitk.Median(img, [3, 3, 1])
+        elapsedTime(t)
+        gc.collect()
+
+    #
+    # Get the minimum image intensity for padding the image
+    #
+    stats = sitk.StatisticsImageFilter()
+    stats.Execute(img)
+    minVal = stats.GetMinimum()
+
+    # Pad black to the boundaries of the image
+    #
+    pad = [5, 5, 5]
+    img = sitk.ConstantPad(img, pad, pad, minVal)
+    gc.collect()
+
+    return img
+
+
+def meshProcessingPipeline(
+    mesh,
+    connectivityFilter=False,
+    smallFactor=0.05,
+    smoothN=5000,
+    reduceFactor=0.9,
+    rotation=["X", 0.0],
+    debug=False,
+    subdivisionIterations=2,  # Add this parameter for subdivision iterations
+):
+
+
+    if debug:
+        print("Cleaning mesh")
+    mesh2 = vtkutils.cleanMesh(mesh, connectivityFilter)
+    mesh = None
+    gc.collect()
+    
+        # Apply subdivision
+    if subdivisionIterations > 0:
+    	print(f"Applying subdivision filter with {subdivisionIterations} iterations")
+    subdivisionFilter = vtk.vtkLoopSubdivisionFilter()
+    subdivisionFilter.SetNumberOfSubdivisions(subdivisionIterations)
+    subdivisionFilter.SetInputData(mesh2)
+    subdivisionFilter.Update()
+    mesh2 = subdivisionFilter.GetOutput()
+    gc.collect()
+
+
+    if debug:
+        print(f"Cleaning small parts ratio{smallFactor}")
+    mesh_cleaned_parts = vtkutils.removeSmallObjects(mesh2, smallFactor)
+    mesh2 = None
+    gc.collect()
+
+    if debug:
+        print("Smoothing mesh", smoothN, "iterations")
+    mesh3 = vtkutils.smoothMesh(mesh_cleaned_parts, smoothN)
+    mesh_cleaned_parts = None
+    gc.collect()
+
+    if debug:
+        print("Simplifying mesh")
+    mesh4 = vtkutils.reduceMesh(mesh3, reduceFactor)
+    mesh3 = None
+    gc.collect()
+    
+
+    print(rotation)
+    axis_map = {"X": 0, "Y": 1, "Z": 2}
+    try:
+        rotAxis = axis_map[rotation[0]]
+        if rotation[1] != 0.0:
+            mesh5 = vtkutils.rotateMesh(mesh4, rotAxis, rotation[1])
+        else:
+            mesh5 = mesh4
+    except BaseException:
+        mesh5 = mesh4
+    mesh4 = None
+    gc.collect()
+
+    return mesh5
+
+
+def getTissueThresholds(tissueType):
+    thresholds = []
+    medianFilter = False
+
+    # Convert tissue type name to threshold values
+    print("Tissue type: ", tissueType)
+    if tissueType.find("bone") > -1:
+        thresholds = [200.0, 800.0, 1300.0, 1500.0]
+    elif tissueType.find("skin") > -1:
+        thresholds = [-200.0, 0.0, 500.0, 1500.0]
+    elif tissueType.find("soft") > -1:
+        thresholds = [-15.0, 30.0, 58.0, 100.0]
+        medianFilter = True
+    elif tissueType.find("fat") > -1:
+        thresholds = [-122.0, -112.0, -96.0, -70.0]
+        medianFilter = True
+
+    return thresholds, medianFilter
+
+
+def dicom2stl(args):
+    # Global variables
+    #
+    thresholds = []
+    shrinkFlag = True
+    connectivityFilter = True
+    anisotropicSmoothing = True
+    medianFilter = False
+    rotFlag = True
+
+    # Handle enable/disable filters
+
+    if args.filters:
+        for x in args.filters:
+            val = True
+            y = x
+            if x[:2] == "no":
+                val = False
+                y = x[2:]
+            if y.startswith("shrink"):
+                shrinkFlag = val
+            if y.startswith("aniso"):
+                anisotropicSmoothing = val
+            if y.startswith("median"):
+                medianFilter = val
+            if y.startswith("large"):
+                connectivityFilter = val
+            if y.startswith("rotat"):
+                rotFlag = val
+
+    print("")
+    if args.temp == None:
+        args.temp = tempfile.mkdtemp()
+    print("Temp dir: ", args.temp)
+
+    if args.tissue:
+        thresholds, medianFilter = getTissueThresholds(args.tissue)
+
+    if args.double_threshold:
+        words = args.double_threshold.split(";")
+        thresholds = []
+        for x in words:
+            thresholds.append(float(x))
+        # check that there are 4 threshold values.
+        print("Thresholds: ", thresholds)
+        if len(thresholds) != 4:
+            print("Error: Thresholds is not of len 4.", thresholds)
+            sys.exit(3)
+    else:
+        print("Isovalue = ", args.isovalue)
+
+    if args.debug:
+        print("SimpleITK version: ", sitk.Version.VersionString())
+        print("SimpleITK: ", sitk, "\n")
+
+    #
+    # Load the volume image
+    img, modality = loadVolume(args.filenames, args.temp, args.verbose)
+
+    if args.ctonly:
+        if modality.find("CT") == -1:
+            print("Imaging modality is not CT.  Exiting.")
+            sys.exit(1)
+
+    # Write out the metadata text file
+    if args.meta:
+        writeMetadataFile(img, args.meta)
+
+    #
+    # Filter the volume image
+    img = volumeProcessingPipeline(
+        img, shrinkFlag, anisotropicSmoothing, thresholds, medianFilter
+    )
+
+    if len(thresholds) == 4:
+        args.isovalue = 64.0
+
+    if args.verbose:
+        print("\nImage for isocontouring")
+        print(img.GetSize())
+        print(img.GetPixelIDTypeAsString())
+        print(img.GetSpacing())
+        print(img.GetOrigin())
+        if args.verbose > 1:
+            print(img)
+        print("")
+
+    # Convert the SimpleITK image to a VTK image
+    vtkimg = sitk2vtk(img)
+
+    # Delete the SimpleITK image, free its memory
+    img = None
+    gc.collect()
+
+    if args.debug:
+        print("\nVTK version: ", vtk.vtkVersion.GetVTKVersion())
+        print("VTK: ", vtk, "\n")
+
+    # Extract the iso-surface
+    if args.debug:
+        print("Extracting surface")
+    mesh = vtkutils.extractSurface(vtkimg, args.isovalue)
+
+    # Delete the VTK image, free its memory
+    vtkimg = None
+    gc.collect()
+
+    # Filter the output mesh
+    mesh = meshProcessingPipeline(
+        mesh,
+        connectivityFilter,
+        args.small,
+        args.smooth,
+        args.reduce,
+        [args.rotaxis, args.rotangle],
+        args.debug,
+    )
+
+    # We done!  Write out the results
+    vtkutils.writeMesh(mesh, args.output)
+
+    # remove the temp directory
+    if args.clean:
+        # shutil.rmtree(args.temp)
+        # with context manager the temp dir would be deleted any way
+        pass
+
+    print("")
+
+
+if __name__ == "__main__":
+    args = parseargs.parseargs()
+    dicom2stl(args)

code/dicom_stl_png_pipeline/parseargs.py

@@ -0,0 +1,223 @@
+#! /usr/bin/env python
+
+import argparse
+
+
+class disableFilter(argparse.Action):
+    def __call__(self, parser, args, values, option_string=None):
+        # print("action, baby!", self.dest, values)
+        # print(args, type(args))
+        noval = "no" + values
+        if isinstance(args.filters, type(None)):
+            args.filters = [noval]
+        else:
+            args.filters.append(noval)
+
+
+class enableAnisotropic(argparse.Action):
+    def __init__(self, nargs=0, **kw):
+        super().__init__(nargs=nargs, **kw)
+
+    def __call__(self, parser, args, values, option_string=None):
+        # x = getattr(args, 'filters')
+        if isinstance(args.filters, type(None)):
+            args.filters = ["anisotropic"]
+        # args.filters.append('anisotropic')
+
+
+class enableLargest(argparse.Action):
+    def __init__(self, nargs=0, **kw):
+        super().__init__(nargs=nargs, **kw)
+
+    def __call__(self, parser, args, values, option_string=None):
+        x = getattr(args, "filters")
+        x.append("largest")
+
+
+def createParser():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("filenames", nargs="*")
+
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        default=False,
+        dest="verbose",
+        help="Enable verbose messages",
+    )
+
+    parser.add_argument(
+        "--debug",
+        "-D",
+        action="store_true",
+        default=False,
+        dest="debug",
+        help="""Enable debugging messages
+                        """,
+    )
+
+    parser.add_argument(
+        "--output",
+        "-o",
+        action="store",
+        dest="output",
+        default="result.stl",
+        help="Output file name (default=result.stl)",
+    )
+
+    parser.add_argument(
+        "--meta",
+        "-m",
+        action="store",
+        dest="meta",
+        help="Output metadata file",
+    )
+
+    parser.add_argument(
+        "--ct",
+        action="store_true",
+        default=False,
+        dest="ctonly",
+        help="Only allow CT Dicom as input",
+    )
+
+    parser.add_argument(
+        "--clean",
+        "-c",
+        action="store_true",
+        default=False,
+        dest="clean",
+        help="Clean up temp files",
+    )
+
+    parser.add_argument(
+        "--temp", "-T", action="store", dest="temp", help="Temporary directory"
+    )
+
+    parser.add_argument(
+        "--search",
+        "-s",
+        action="store",
+        dest="search",
+        help="Dicom series search string",
+    )
+
+    # Options that apply to the volumetric portion of the pipeline
+    vol_group = parser.add_argument_group("Volume options")
+
+    vol_group.add_argument(
+        "--type",
+        "-t",
+        action="store",
+        dest="tissue",
+        choices=["skin", "bone", "soft_tissue", "fat"],
+        help="CT tissue type",
+    )
+
+    vol_group.add_argument(
+        "--anisotropic",
+        "-a",
+        action=enableAnisotropic,
+        help="Apply anisotropic smoothing to the volume",
+    )
+
+    vol_group.add_argument(
+        "--isovalue",
+        "-i",
+        action="store",
+        dest="isovalue",
+        type=float,
+        default=0.0,
+        help="Iso-surface value",
+    )
+
+    vol_group.add_argument(
+        "--double",
+        "-d",
+        action="store",
+        dest="double_threshold",
+        help="""Double threshold with 4 semicolon separated floats
+                                """,
+    )
+
+    # Options that apply to the mesh processing portion of the pipeline
+    mesh_group = parser.add_argument_group("Mesh options")
+    mesh_group.add_argument(
+        "--largest",
+        "-l",
+        action=enableLargest,
+        help="Only keep the largest connected sub-mesh",
+    )
+
+    mesh_group.add_argument(
+        "--rotaxis",
+        action="store",
+        dest="rotaxis",
+        default="Y",
+        choices=["X", "Y", "Z"],
+        help="Rotation axis (default=Y)",
+    )
+
+    mesh_group.add_argument(
+        "--rotangle",
+        action="store",
+        dest="rotangle",
+        type=float,
+        default=0.0,
+        help="Rotation angle in degrees (default=180)",
+    )
+
+    mesh_group.add_argument(
+        "--smooth",
+        action="store",
+        dest="smooth",
+        type=int,
+        default=25,
+        help="Mesh smoothing iterations (default=25)",
+    )
+
+    mesh_group.add_argument(
+        "--reduce",
+        action="store",
+        dest="reduce",
+        type=float,
+        default=0.9,
+        help="Mesh reduction factor (default=.9)",
+    )
+
+    mesh_group.add_argument(
+        "--clean-small",
+        "-x",
+        action="store",
+        dest="small",
+        type=float,
+        default=0.05,
+        help="Clean small parts factor (default=.05)",
+    )
+
+    # Filtering options
+    filter_group = parser.add_argument_group("Filtering options")
+    filter_group.add_argument(
+        "--enable",
+        action="append",
+        dest="filters",
+        choices=["anisotropic", "shrink", "median", "largest", "rotation"],
+        help="Enable filtering options",
+    )
+    filter_group.add_argument(
+        "--disable",
+        action=disableFilter,
+        dest="filters",
+        choices=["anisotropic", "shrink", "median", "largest", "rotation"],
+        help="Disable filtering options",
+    )
+
+    return parser
+
+
+def parseargs():
+    parser = createParser()
+    args = parser.parse_args()
+    return args

code/dicom_stl_png_pipeline/requirements.txt

@@ -0,0 +1,5 @@
+numpy>=1.24.0
+SimpleITK>=2.2
+vtk>=9.2.0
+pydicom>=2.3
+simpleitkutilities>=0.2.2

code/dicom_stl_png_pipeline/stl2png_centered.py

@@ -0,0 +1,70 @@
+import argparse
+import pyvista as pv
+import numpy as np
+#import cv2
+
+def blur_image(image_path, output_path, kernel_size=(5, 5)):
+    # Read the image
+    image = cv2.imread(image_path)
+
+    # Blur the image
+    blurred_image = cv2.GaussianBlur(image, kernel_size, 0)
+
+    # Write the blurred image back to a file
+    cv2.imwrite(output_path, blurred_image)
+
+def generate_png_from_stl(stl_filename, png_filename, background_color=(1, 1, 1), camera_angles=(0, 0, 0)):
+    # Load the STL file
+    mesh = pv.read(stl_filename)
+    mesh = mesh.smooth(n_iter=5000)  # Increase n_iter for more smoothing
+    
+    # Center the mesh at the origin
+    bounds = mesh.bounds
+    center = [(bounds[i] + bounds[i+1]) / 2 for i in range(0, 6, 2)]
+    mesh.translate([-c for c in center])
+    
+    # Create a plotter with window size set to 384x384
+    plotter = pv.Plotter(window_size=(384, 384), off_screen=True)
+    
+    # Set up the camera position
+    distance_factor = 3  # Adjust this value to move the camera closer or further
+    cam_pos = [center[0], center[1] - (bounds[3] - bounds[2]) * distance_factor, center[2]]
+    focal_point = center
+    view_up = [0, 0, 1]
+    
+    plotter.camera_position = [cam_pos, focal_point, view_up]
+
+    # Adjust the zoom (values < 1 will zoom out)
+    plotter.camera.zoom(0.8)  # Adjust this value as needed
+    
+    # Add the mesh without edges (lines) and with the desired color
+    plotter.add_mesh(mesh, color='white', show_edges=False)
+
+    # Set the background color
+    plotter.set_background(background_color)
+
+    # Take a screenshot and save as PNG
+    plotter.show(screenshot=png_filename)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a PNG image from an STL file.")
+    parser.add_argument("stl_file", help="Path to the STL file.")
+    parser.add_argument("png_file", help="Output PNG file name.")
+    parser.add_argument("--background", nargs=3, type=float, default=[0, 0, 0],
+                        help="Background color as RGB values (between 0 and 1). Default is black.")
+    parser.add_argument("--camera", nargs=3, type=float, default=[0, 0, 0],
+                        help="Camera view angles for azimuth (horizontal rotation), elevation (vertical rotation), and roll (rotation about view direction) in degrees. Default is (0, 0, 0).")
+
+    args = parser.parse_args()
+    stl_file = args.stl_file
+    png_file = args.png_file
+    background_color = tuple(args.background)
+    camera_angles = tuple(args.camera)
+    generate_png_from_stl(stl_file, png_file, background_color, camera_angles)
+
+    # Blur the resulting image
+    #blur_image(png_file, 'blured'+png_file, kernel_size=(5, 5))
+
+if __name__ == "__main__":
+    main()

code/dicom_stl_png_pipeline/utils/__init__.py

@@ -0,0 +1 @@
+# Birdie putt

code/dicom_stl_png_pipeline/utils/dicomutils.py

@@ -0,0 +1,162 @@
+#! /usr/bin/env python
+
+"""
+Function to load the largest Dicom series in a directory.
+
+It scans the directory recursively search for files with the ".dcm"
+suffix.  Note that DICOM fails don't always have that suffix.  In
+that case this function will fail.
+
+Written by David T. Chen from the National Institute of Allergy
+and Infectious Diseases, dchen@mail.nih.gov.
+It is covered by the Apache License, Version 2.0:
+http://www.apache.org/licenses/LICENSE-2.0
+"""
+
+
+from __future__ import print_function
+import sys
+import os
+import fnmatch
+import zipfile
+import SimpleITK as sitk
+
+from pydicom.filereader import read_file_meta_info
+from pydicom.errors import InvalidDicomError
+
+
+def testDicomFile(file_path):
+    """Test if given file is in DICOM format."""
+    try:
+        read_file_meta_info(file_path)
+        return True
+    except InvalidDicomError:
+        return False
+
+
+def scanDirForDicom(dicomdir):
+    matches = []
+    dirs = []
+    try:
+        for root, dirnames, filenames in os.walk(dicomdir):
+            for filename in fnmatch.filter(filenames, "*.dcm"):
+                matches.append(os.path.join(root, filename))
+                if root not in dirs:
+                    dirs.append(root)
+    except BaseException as e:
+        print("Error in scanDirForDicom: ", e)
+        print("dicomdir = ", dicomdir)
+
+    return (matches, dirs)
+
+
+def getAllSeries(dirs):
+    """Get all the Dicom series in a set of directories."""
+    isr = sitk.ImageSeriesReader()
+    seriessets = []
+    for d in dirs:
+        series = isr.GetGDCMSeriesIDs(d)
+        for s in series:
+            files = isr.GetGDCMSeriesFileNames(d, s)
+            print(s, d, len(files))
+            seriessets.append([s, d, files])
+    return seriessets
+
+
+def getModality(img):
+    """Get an image's modality, as stored in the Dicom meta data."""
+    modality = ""
+    if (sitk.Version.MinorVersion() > 8) or (sitk.Version.MajorVersion() > 0):
+        try:
+            modality = img.GetMetaData("0008|0060")
+        except BaseException:
+            modality = ""
+    return modality
+
+
+def loadLargestSeries(dicomdir):
+    """
+    Load the largest Dicom series it finds in a recursive scan of
+    a directory.
+
+    Largest means has the most slices.  It also returns the modality
+    of the series.
+    """
+
+    files, dirs = scanDirForDicom(dicomdir)
+
+    if (len(files) == 0) or (len(dirs) == 0):
+        print("Error in loadLargestSeries.  No files found.")
+        print("dicomdir = ", dicomdir)
+        return None
+    seriessets = getAllSeries(dirs)
+    maxsize = 0
+    maxindex = -1
+
+    count = 0
+    for ss in seriessets:
+        size = len(ss[2])
+        if size > maxsize:
+            maxsize = size
+            maxindex = count
+        count = count + 1
+    if maxindex < 0:
+        print("Error:  no series found")
+        return None
+    isr = sitk.ImageSeriesReader()
+    ss = seriessets[maxindex]
+    files = ss[2]
+    isr.SetFileNames(files)
+    print("\nLoading series", ss[0], "in directory", ss[1])
+    img = isr.Execute()
+
+    firstslice = sitk.ReadImage(files[0])
+    modality = getModality(firstslice)
+
+    return img, modality
+
+
+def loadZipDicom(name, tempDir):
+    """Unzip a zipfile of dicom images into a temp directory, then
+    load the series that has the most slices.
+    """
+
+    print("Reading Dicom zip file:", name)
+    print("tempDir = ", tempDir)
+    myzip = zipfile.ZipFile(name, "r")
+
+    try:
+        myzip.extractall(tempDir)
+    except BaseException:
+        print("Zip extract failed")
+
+    return loadLargestSeries(tempDir)
+
+
+#
+#   Main (test code)
+#
+
+if __name__ == "__main__":
+    print("")
+    print("dicomutils.py")
+    print(sys.argv[1])
+
+    #    img = loadLargestSeries(sys.argv[1])
+    #    print (img)
+    #    sys.exit(0)
+
+    files, dirs = scanDirForDicom(sys.argv[1])
+    print("")
+    print("files")
+    print(files)
+    print("")
+    print("dirs")
+    print(dirs)
+
+    print("series")
+    seriessets = getAllSeries(dirs)
+    for ss in seriessets:
+        print(ss[0], " ", ss[1])
+        print(len(ss[2]))
+        print("")

code/dicom_stl_png_pipeline/utils/sitk2vtk.py

@@ -0,0 +1,87 @@
+#! /usr/bin/env python
+
+"""
+Function to convert a SimpleITK image to a VTK image.
+
+Written by David T. Chen from the National Institute of Allergy
+and Infectious Diseases, dchen@mail.nih.gov.
+It is covered by the Apache License, Version 2.0:
+http://www.apache.org/licenses/LICENSE-2.0
+"""
+
+import SimpleITK as sitk
+import vtk
+from vtk.util import numpy_support
+
+
+def sitk2vtk(img, debugOn=False):
+    """Convert a SimpleITK image to a VTK image, via numpy."""
+
+    size = list(img.GetSize())
+    origin = list(img.GetOrigin())
+    spacing = list(img.GetSpacing())
+    ncomp = img.GetNumberOfComponentsPerPixel()
+    direction = img.GetDirection()
+
+    # there doesn't seem to be a way to specify the image orientation in VTK
+
+    # convert the SimpleITK image to a numpy array
+    i2 = sitk.GetArrayFromImage(img)
+    if debugOn:
+        i2_string = i2.tostring()
+        print("data string address inside sitk2vtk", hex(id(i2_string)))
+
+    vtk_image = vtk.vtkImageData()
+
+    # VTK expects 3-dimensional parameters
+    if len(size) == 2:
+        size.append(1)
+
+    if len(origin) == 2:
+        origin.append(0.0)
+
+    if len(spacing) == 2:
+        spacing.append(spacing[0])
+
+    if len(direction) == 4:
+        direction = [
+            direction[0],
+            direction[1],
+            0.0,
+            direction[2],
+            direction[3],
+            0.0,
+            0.0,
+            0.0,
+            1.0,
+        ]
+
+    vtk_image.SetDimensions(size)
+    vtk_image.SetSpacing(spacing)
+    vtk_image.SetOrigin(origin)
+    vtk_image.SetExtent(0, size[0] - 1, 0, size[1] - 1, 0, size[2] - 1)
+
+    if vtk.vtkVersion.GetVTKMajorVersion() < 9:
+        print("Warning: VTK version <9.  No direction matrix.")
+    else:
+        vtk_image.SetDirectionMatrix(direction)
+
+    # depth_array = numpy_support.numpy_to_vtk(i2.ravel(), deep=True,
+    #                                          array_type = vtktype)
+    depth_array = numpy_support.numpy_to_vtk(i2.ravel())
+    depth_array.SetNumberOfComponents(ncomp)
+    vtk_image.GetPointData().SetScalars(depth_array)
+
+    vtk_image.Modified()
+    #
+    if debugOn:
+        print("Volume object inside sitk2vtk")
+        print(vtk_image)
+        #        print("type = ", vtktype)
+        print("num components = ", ncomp)
+        print(size)
+        print(origin)
+        print(spacing)
+        print(vtk_image.GetScalarComponentAsFloat(0, 0, 0, 0))
+
+    return vtk_image

code/dicom_stl_png_pipeline/utils/vtk2sitk.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+import SimpleITK as sitk
+import vtk
+import vtk.util.numpy_support as vtknp
+
+
+def vtk2sitk(vtkimg, debug=False):
+    """Takes a VTK image, returns a SimpleITK image."""
+    sd = vtkimg.GetPointData().GetScalars()
+    npdata = vtknp.vtk_to_numpy(sd)
+
+    dims = list(vtkimg.GetDimensions())
+    origin = vtkimg.GetOrigin()
+    spacing = vtkimg.GetSpacing()
+
+    if debug:
+        print("dims:", dims)
+        print("origin:", origin)
+        print("spacing:", spacing)
+
+        print("numpy type:", npdata.dtype)
+        print("numpy shape:", npdata.shape)
+
+    dims.reverse()
+    npdata.shape = tuple(dims)
+    if debug:
+        print("new shape:", npdata.shape)
+    sitkimg = sitk.GetImageFromArray(npdata)
+    sitkimg.SetSpacing(spacing)
+    sitkimg.SetOrigin(origin)
+
+    if vtk.vtkVersion.GetVTKMajorVersion() >= 9:
+        direction = vtkimg.GetDirectionMatrix()
+        d = []
+        for y in range(3):
+            for x in range(3):
+                d.append(direction.GetElement(y, x))
+        sitkimg.SetDirection(d)
+    return sitkimg

code/dicom_stl_png_pipeline/utils/vtkutils.py

@@ -0,0 +1,506 @@
+#! /usr/bin/env python
+
+
+"""
+A collection of VTK functions for processing surfaces and volume.
+
+Written by David T. Chen from the National Institute of Allergy and
+Infectious Diseases, dchen@mail.nih.gov.
+It is covered by the Apache License, Version 2.0:
+http://www.apache.org/licenses/LICENSE-2.0
+"""
+
+from __future__ import print_function
+
+# import gc
+import sys
+import time
+import traceback
+
+import vtk
+
+
+def elapsedTime(start_time):
+    dt = time.perf_counter() - start_time
+    print("    %4.3f seconds" % dt)
+
+
+#
+#  Isosurface extraction
+#
+def extractSurface(vol, isovalue=0.0):
+    """Extract an isosurface from a volume."""
+    try:
+        t = time.perf_counter()
+        iso = vtk.vtkContourFilter()
+        if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+            iso.SetInputData(vol)
+        else:
+            iso.SetInput(vol)
+        iso.SetValue(0, isovalue)
+        iso.Update()
+        print("Surface extracted")
+        mesh = iso.GetOutput()
+        print("    ", mesh.GetNumberOfPolys(), "polygons")
+        elapsedTime(t)
+        iso = None
+        return mesh
+    except BaseException:
+        print("Iso-surface extraction failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+#
+#  Mesh filtering
+#
+def cleanMesh(mesh, connectivityFilter=False):
+    """Clean a mesh using VTK's CleanPolyData filter."""
+    try:
+        t = time.perf_counter()
+        connect = vtk.vtkPolyDataConnectivityFilter()
+        clean = vtk.vtkCleanPolyData()
+
+        if connectivityFilter:
+            if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+                connect.SetInputData(mesh)
+            else:
+                connect.SetInput(mesh)
+            connect.SetExtractionModeToLargestRegion()
+            clean.SetInputConnection(connect.GetOutputPort())
+        else:
+            if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+                clean.SetInputData(mesh)
+            else:
+                clean.SetInput(mesh)
+
+        clean.Update()
+        print("Surface cleaned")
+        m2 = clean.GetOutput()
+        print("    ", m2.GetNumberOfPolys(), "polygons")
+        elapsedTime(t)
+        clean = None
+        connect = None
+        return m2
+    except BaseException:
+        print("Surface cleaning failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def smoothMesh(mesh, nIterations=10):
+    """Smooth a mesh using VTK's WindowedSincPolyData filter."""
+    try:
+        t = time.perf_counter()
+        smooth = vtk.vtkWindowedSincPolyDataFilter()
+        smooth.SetNumberOfIterations(nIterations)
+        if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+            smooth.SetInputData(mesh)
+        else:
+            smooth.SetInput(mesh)
+        smooth.Update()
+        print("Surface smoothed")
+        m2 = smooth.GetOutput()
+        print("    ", m2.GetNumberOfPolys(), "polygons")
+        elapsedTime(t)
+        smooth = None
+        return m2
+    except BaseException:
+        print("Surface smoothing failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def rotateMesh(mesh, axis=1, angle=0):
+    """Rotate a mesh about an arbitrary axis.  Angle is in degrees."""
+    try:
+        print("Rotating surface: axis=", axis, "angle=", angle)
+        matrix = vtk.vtkTransform()
+        if axis == 0:
+            matrix.RotateX(angle)
+        if axis == 1:
+            matrix.RotateY(angle)
+        if axis == 2:
+            matrix.RotateZ(angle)
+        tfilter = vtk.vtkTransformPolyDataFilter()
+        tfilter.SetTransform(matrix)
+        if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+            tfilter.SetInputData(mesh)
+        else:
+            tfilter.SetInput(mesh)
+        tfilter.Update()
+        mesh2 = tfilter.GetOutput()
+        return mesh2
+    except BaseException:
+        print("Surface rotating failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+# @profile
+
+
+def reduceMesh(mymesh, reductionFactor):
+    """Reduce the number of triangles in a mesh using VTK's vtkDecimatePro
+    filter."""
+    try:
+        t = time.perf_counter()
+        # deci = vtk.vtkQuadricDecimation()
+        deci = vtk.vtkDecimatePro()
+        deci.SetTargetReduction(reductionFactor)
+        if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+            deci.SetInputData(mymesh)
+        else:
+            deci.SetInput(mymesh)
+        deci.Update()
+        print("Surface reduced")
+        m2 = deci.GetOutput()
+        del deci
+        #        deci = None
+        print("    ", m2.GetNumberOfPolys(), "polygons")
+        elapsedTime(t)
+        return m2
+    except BaseException:
+        print("Surface reduction failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+# from https://github.com/AOT-AG/DicomToMesh/blob/master/lib/src/meshRoutines.cpp#L109
+# MIT License
+def removeSmallObjects(mesh, ratio):
+    """
+    Remove small parts which are not of interest
+    @param ratio A floating-point value between 0.0 and 1.0, the higher the stronger effect
+    """
+
+    # do nothing if ratio is 0
+    if ratio == 0:
+        return mesh
+
+    try:
+        t = time.perf_counter()
+        conn_filter = vtk.vtkPolyDataConnectivityFilter()
+        conn_filter.SetInputData(mesh)
+        conn_filter.SetExtractionModeToAllRegions()
+        conn_filter.Update()
+
+        # remove objects consisting of less than ratio vertexes of the biggest object
+        region_sizes = conn_filter.GetRegionSizes()
+
+        # find object with most vertices
+        max_size = 0
+        for i in range(conn_filter.GetNumberOfExtractedRegions()):
+            if region_sizes.GetValue(i) > max_size:
+                max_size = region_sizes.GetValue(i)
+
+        # append regions of sizes over the threshold
+        conn_filter.SetExtractionModeToSpecifiedRegions()
+        for i in range(conn_filter.GetNumberOfExtractedRegions()):
+            if region_sizes.GetValue(i) > max_size * ratio:
+                conn_filter.AddSpecifiedRegion(i)
+
+        conn_filter.Update()
+        processed_mesh = conn_filter.GetOutput()
+        print("Small parts cleaned")
+        print("    ", processed_mesh.GetNumberOfPolys(), "polygons")
+        elapsedTime(t)
+        return processed_mesh
+
+    except BaseException:
+        print("Remove small objects failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+
+
+#
+#   Mesh I/O
+#
+
+
+def readMesh(name):
+    """Read a mesh. Uses suffix to determine specific file type reader."""
+    if name.endswith(".vtk"):
+        return readVTKMesh(name)
+    if name.endswith(".ply"):
+        return readPLY(name)
+    if name.endswith(".stl"):
+        return readSTL(name)
+    print("Unknown file type: ", name)
+    return None
+
+
+def readVTKMesh(name):
+    """Read a VTK mesh file."""
+    try:
+        reader = vtk.vtkPolyDataReader()
+        reader.SetFileName(name)
+        reader.Update()
+        print("Input mesh:", name)
+        mesh = reader.GetOutput()
+        del reader
+        #        reader = None
+        return mesh
+    except BaseException:
+        print("VTK mesh reader failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def readSTL(name):
+    """Read an STL mesh file."""
+    try:
+        reader = vtk.vtkSTLReader()
+        reader.SetFileName(name)
+        reader.Update()
+        print("Input mesh:", name)
+        mesh = reader.GetOutput()
+        del reader
+        #        reader = None
+        return mesh
+    except BaseException:
+        print("STL Mesh reader failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def readPLY(name):
+    """Read a PLY mesh file."""
+    try:
+        reader = vtk.vtkPLYReader()
+        reader.SetFileName(name)
+        reader.Update()
+        print("Input mesh:", name)
+        mesh = reader.GetOutput()
+        del reader
+        #        reader = None
+        return mesh
+    except BaseException:
+        print("PLY Mesh reader failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def writeMesh(mesh, name):
+    """Write a mesh. Uses suffix to determine specific file type writer."""
+    print("Writing", mesh.GetNumberOfPolys(), "polygons to", name)
+    if name.endswith(".vtk"):
+        writeVTKMesh(mesh, name)
+        return
+    if name.endswith(".ply"):
+        writePLY(mesh, name)
+        return
+    if name.endswith(".stl"):
+        writeSTL(mesh, name)
+        return
+    print("Unknown file type: ", name)
+
+
+def writeVTKMesh(mesh, name):
+    """Write a VTK mesh file."""
+    try:
+        writer = vtk.vtkPolyDataWriter()
+        if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+            writer.SetInputData(mesh)
+        else:
+            writer.SetInput(mesh)
+        writer.SetFileTypeToBinary()
+        writer.SetFileName(name)
+        writer.Write()
+        print("Output mesh:", name)
+        writer = None
+    except BaseException:
+        print("VTK mesh writer failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def writeSTL(mesh, name):
+    """Write an STL mesh file."""
+    try:
+        writer = vtk.vtkSTLWriter()
+        if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+            print("writeSTL 1")
+            writer.SetInputData(mesh)
+        else:
+            print("writeSTL 2")
+            writer.SetInput(mesh)
+        writer.SetFileTypeToBinary()
+        writer.SetFileName(name)
+        writer.Write()
+        print("Output mesh:", name)
+        writer = None
+    except BaseException:
+        print("STL mesh writer failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def writePLY(mesh, name):
+    """Read a PLY mesh file."""
+    try:
+        writer = vtk.vtkPLYWriter()
+        if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
+            writer.SetInputData(mesh)
+        else:
+            writer.SetInput(mesh)
+        writer.SetFileTypeToBinary()
+        writer.SetFileName(name)
+        writer.Write()
+        print("Output mesh:", name)
+        writer = None
+    except BaseException:
+        print("PLY mesh writer failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+#
+#  Volume I/O
+#
+
+
+def readVTKVolume(name):
+    """Read a VTK volume image file. Returns a vtkStructuredPoints object."""
+    try:
+        reader = vtk.vtkStructuredPointsReader()
+        reader.SetFileName(name)
+        reader.Update()
+        print("Input volume:", name)
+        vol = reader.GetOutput()
+        reader = None
+        return vol
+    except BaseException:
+        print("VTK volume reader failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def writeVTKVolume(vtkimg, name):
+    """Write the old VTK Image file format"""
+    try:
+        writer = vtk.vtkStructuredPointsWriter()
+        writer.SetFileName(name)
+        writer.SetInputData(vtkimg)
+        writer.SetFileTypeToBinary()
+        writer.Update()
+    except BaseException:
+        print("VTK volume writer failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+
+
+def readVTIVolume(name):
+    """Read a VTK XML volume image file. Returns a vtkStructuredPoints object."""
+    try:
+        reader = vtk.vtkXMLImageDataReader()
+        reader.SetFileName(name)
+        reader.Update()
+        print("Input volume:", name)
+        vol = reader.GetOutput()
+        reader = None
+        return vol
+    except BaseException:
+        print("VTK XML volume reader failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+    return None
+
+
+def writeVTIVolume(vtkimg, name):
+    """Write the new XML VTK Image file format"""
+    try:
+        writer = vtk.vtkXMLImageDataWriter()
+        writer.SetFileName(name)
+        writer.SetInputData(vtkimg)
+        writer.Update()
+    except BaseException:
+        print("VTK volume writer failed")
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        traceback.print_exception(
+            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout
+        )
+
+
+# @profile
+
+
+def memquery1():
+    print("Hiya 1")
+
+
+# @profile
+
+
+def memquery2():
+    print("Hiya 2")
+
+
+# @profile
+
+
+def memquery3():
+    print("Hiya 3")
+
+
+#
+#  Main (test code)
+#
+if __name__ == "__main__":
+    print("vtkutils.py")
+
+    print("VTK version:", vtk.vtkVersion.GetVTKVersion())
+    print("VTK:", vtk)
+
+    try:
+        mesh = readMesh(sys.argv[1])
+        #       mesh = readMesh("models/soft.stl")
+        #       mesh = cleanMesh(mesh, False)
+        #       mesh = smoothMesh(mesh)
+        mesh2 = reduceMesh(mesh, 0.50)
+        #        writeMesh(mesh2, "soft.ply")
+        writeMesh(mesh2, sys.argv[2])
+    except BaseException:
+        print("Usage: vtkutils.py input_mesh output_mesh")