quick0306 / portpy

Opensource radiation treatment planning system in Python [AAPM'23]

What is PortPy?

Note: The package is at its early stages of development (version 0.1.0) and we are now collecting feedback from researchers to further refine the data structure and the main functionality. We are expecting to have a stable version 1.xx by the end of September 2023. We would love to hear your feedback.

PortPy, short for Planning and Optimization for Radiation Therapy, represents a collective effort to establish an open-source Python library dedicated to advancing the development and clinical implementation of cancer radiotherapy treatment planning algorithms. This initiative encompasses planning methodologies for Intensity Modulated Radiation Therapy (IMRT), Volumetric Modulated Arc Therapy (VMAT), along with other emerging modalities. PortPy provides clinical-grade data and coding resources that foster benchmarking, reproducibility, and community development.

Contents

• What can you do with PortPy?
• Quick Start
• How to contribute?
• The limitations of current version
• Data
• Installation
• Team

What can you do with PortPy?

PortPy facilitates the design, testing, and clinical validation of your treatment planning algorithms. This includes both cutting-edge AI-based models and traditional optimization techniques. PortPy provides:

1. Benchmark Dataset

   • Access to data required for optimization, extracted directly from the FDA-approved Eclipse treatment planning system via its API
   • A current set of data from 10 lung patients, which will be expanded to 100 lung patients by the end of September 2023
   • A benchmark IMRT plan for each patient, created using our in-house automated planning system (Edelman Award Finalist YouTube Video, Paper)

2. Benchmark Algorithms: Offering globally optimal solutions for:

   • Dose Volume Histogram (DVH) constraints (see dvh_constraint_optimization.ipynb)
   • IMRT Beam Orientation Optimization (BOO) (see beam_orientation_optimization.ipynb)
   • Volumetric Modulated Arc Therapy (VMAT) (see vmat_optimization.ipynb)

3. Visualization

   • Basic built-in visualization tools (e.g., DVH, dose distribution) are integrated into PortPy (see (see basic_tutorial.ipynb))
   • Enhanced visualizations are available through the integration with the popular open-source 3DSlicer package (see 3d_slicer_integration.ipynb)

4. Evaluation

   • PortPy IMRT plans can be imported into Eclipse for final clinical evaluations (see eclipse_integration.ipynb)
   • Plans can also be evaluated within PortPy using well-established clinical protocols (e.g., Lung 2Gyx30, see basic_tutorial.ipynb)
   • Future updates will include more standardized RTOG metrics and outcome models (TCP/NTCP)

5. Optimization

   • PortPy provides high-level optimization problem formulation and access to both free and commercial optimization engines through the integration with a popular open-source CVXPy package (see basic_tutorial.ipynb)
   • Commercial engines (e.g., MOSEK, CPLEX, GUROBI) are also free for academic and research use

6. AI-Based Planning

   • The PortPy.AI module provides a framework for exploring AI-driven treatment planning (see dose_prediction_pipeline.ipynb)
   • The newly added PortPy.AI module includes a tutorial on predicting a 3D-dose distribution and converting the prediction into a deliverable plan

Quick Start

1. To grasp the primary features of PortPy, we highly recommend exploring the basic_tutorial.ipynb notebook
2. To understand how to import a PortPy plan into Eclipse for final evaluations, browse through the eclipse_integration.ipynb notebook
3. To learn about enhanced visualization techniques using the 3D-Slicer package, refer to the 3d_slicer_integration.ipynb notebook
4. For algorithm benchmarking, the global optimal solutions are provided for non-convex optimization problems resulting from beam angle optimization beam_orientation_optimization.ipynb, incorporating DVH constraints dvh_constraint_optimization.ipynb, and VMAT optimization vmat_optimization.ipynb using the mixed-integer programming on down-sampled data.
5. If you encounter computational challenges with large-scale optimization problems, you can opt for down-sampling the voxels/beamlets, as illustrated in the down_sampling notebook, or further sparsify the influence matrix, as demonstrated in the inf_matrix_sparsification notebook.

How to contribute?

To maintain the lightweight nature and user-friendliness of PortPy modules, our aim is to include only fundamental functionalities, along with benchmark data and algorithms. We will establish separate repositories within the PortPy-Project orgainization for projects developed by our team using PortPy as a platform. This is similar to what we've done for projects like LowDimRT and VMAT.

If you're interested in contributing to existing PortPy modules or wish to create a new module, we encourage you to contact us first. This will help ensure that our objectives and priorities are aligned. If you use PortPy to build your own package, you're welcome to host your package within the PortPy-Project orgainization. Alternatively, you can host your package on your own GitHub page. In this case, please inform us so that we can fork it and feature it under the PortPy-Project organization.

The limitations of current version of PortPy

Current version of PortPy has the following limitations which would be addressed in the future updates:

1. You can only work with the benchmark dataset provided in this PortPy repo and cannot use your own dataset for now.
2. PortPy.Photon and PortPy.AI are the only modules available. You cannot do proton research with the current version.
3. You can only import the optimal fluence of PortPy-IMRT plans into Eclipse. Support for importing control points, VMAT plans, and other commercial systems will be added in the future updates.

Data

PortPy equips researchers with a robust benchmark patient dataset, sourced from the FDA-approved Eclipse commercial treatment planning system through its API. This dataset embodies all necessary elements for optimizing various machine configurations such as beam angles, aperture shapes, and leaf movements. It includes

1. Dose Influence Matrix: The dose contribution of each beamlet to each voxel,
2. Beamlets/Voxels Details: Detailed information about the position and size of beamlets/voxels,
3. Expert-Selected Benchmark Beams: An expert clinical physicist has carefully selected benchmark beams, providing reference beams for comparison and benchmarking,
4. Benchmark IMRT Plan: A benchmark IMRT plan generated using our in-house automated treatment planning system called ECHO (Edelman Award Finalist YouTube Video, Paper). This plan serves as a benchmark for evaluating new treatment planning algorithms.

To access these resources, users are advised to download the latest version of the dataset, which can be found here. Subsequently, create a directory titled './data' in the current project directory and transfer the downloaded file into it. For example, ./data/Lung_Phantom_Patient_1.

Note: Initially, we will utilize a lung dataset from TCIA. The original DICOM CT images and structure sets are not included in the PortPy dataset and need to be directly downloaded from the TCIA. Users can fetch the TCIA collection ID and the TCIA subject ID for each PortPy patient using the get_tcia_metadata() method in PortPy and subsequently download the data from TCIA (see eclipse_integration.ipynb)

Installation

1. Install using pip:

   • Run the command 'pip install portpy'

2. Install using conda:

   • Run the command 'conda install -c conda-forge portpy'

3. Install from source:

   • Clone this repository using 'git clone https://github.com/PortPy-Project/PortPy.git'

   • Navigate to the repository with 'cd portpy'

   • Install the dependencies within a Python virtual environment or Anaconda environment. To set up in a Python virtual environment, install all the dependencies specified in requirements.txt as follows:

     • Create the virtual environment with 'python3 -m venv venv'
     • Activate the environment with 'source venv/bin/activate'
     • Install the requirements using '(venv) pip install -r requirements.txt'

Team

PortPy is a community project initiated at Memorial Sloan Kettering Cancer Center. It is currently developed and maintained by:

Name	Expertise	Institution
Masoud Zarepisheh	Treatment Planning and Optimization	MSK
Saad Nadeem	Computer Vision and AI in Medical Imaging	MSK
Gourav Jhanwar	Algorithm Design and Development	MSK
Mojtaba Tefagh	Mathematical Modeling and Reinforcement Learning	SUT
Vicki Taasti	Physics and Planning of Proton Therapy	MAASTRO
Sadegh Alam	Adaptive Treatment Planning and Imaging	Cornell
Seppo Tuomaala	Eclispe API Scripting	VARIAN

License

PortPy code is distributed under Apache 2.0 with Commons Clause license, and is available for non-commercial academic purposes.

Reference

If you find our work useful in your research or if you use parts of this code please cite our AAPM'23 abstract :

@article{jhanwar2023portpy,
  title={Portpy: An Open-Source Python Package for Planning and Optimization in Radiation Therapy Including Benchmark Data and Algorithms},
  author={Jhanwar, Gourav and Tefagh, Mojtaba and Taasti, Vicki T and Alam, Sadegh R and Tuomaala, Seppo and Nadeem, Saad and Zarepisheh, Masoud},
  journal={AAPM 65th Annual Meeting & Exhibition},
  year={2023}
}