3 |
2 |
3 |
65 | 
66 |
67 | 68 | **Figure Explanation:** The figure above compares the proposed RMR algorithm with four existing sparsification algorithms in terms of feasibility and optimality gaps. These gaps were calculated by solving both the original and surrogate optimization problems for 10 lung cancer patients, whose data is publicly available on PortPy. The results demonstrate that the RMR algorithm outperforms the existing methods. 69 | 70 |
71 | 
72 |
73 | 74 | **Figure Explanation:** The figure above illustrates the discrepancies in Dose Volume Histogram (DVH) plots between the actual dose ($A\mathbf{x}$, shown as a solid line) and the approximated dose ($𝑆\mathbf{x}$, shown as a dotted line), where 75 | $\mathbf{x}$ is the optimal solution of the surrogate optimization problem. A smaller gap between the dotted and solid lines indicates a more accurate dose approximation. **Left figure** demonstrates a significant dose discrepancy when the matrix 76 | $A$ is sparsified by simply zeroing out small elements—a technique commonly used in practice. **Right figure** shows a minimal dose discrepancy when the matrix $A$ is sparsified using the RMR algorithm. Importantly, in both cases, the sparsified matrix contained only 2% non-zero elements. 77 | 78 | 79 | **Implementation in PortPy:** 80 | 81 | If you are using PortPy for your radiotherapy research, you can apply RMR sparsification by simply adding the following lines of code. For more details, see [Sparse-Only Jupyter Notebook](https://github.com/PortPy-Project/CompressRTP/blob/main/examples/matrix_sparse_only.ipynb). 82 | 83 | ```python 84 | from compress_rtp.utils.get_sparse_only import get_sparse_only 85 | 86 | # Apply RMR sparsification to the matrix A 87 | S = get_sparse_only(A=A, threshold_perc=10, compression='rmr') 88 | 89 | # Replace the original matrix A with the sparsified matrix S 90 | inf_matrix.A = S 91 | ``` 92 | 93 | ## 1.2) Sparse-Plus-Low-Rank Matrix Compression 94 | The rows of matrix $𝐴$ correspond to the patient's voxels, and the similarity of doses delivered to neighboring voxels makes these rows highly correlated (the same argument applies to the columns). This high correlation means that matrix $𝐴$ 95 | is **low-rank** and therefore **compressible**. 96 | 97 |
98 | 
99 |
100 | 101 | **Figure Explanation:** The low-rank nature of matrix $𝐴$ can be verified by observing the exponential decay of its singular values, as shown by the blue line in the **left figure**. If we decompose matrix 102 | $A$ into $A=S+L$, where $𝑆$ is a sparse matrix containing large-magnitude elements (e.g., elements greater than 1% of the maximum value of $𝐴$), and $𝐿$ includes smaller elements mainly representing scattering doses, then the singular values of the scattering matrix $𝐿$ reveal an even sharper exponential decay (depicted by the red line). This suggests the use of “sparse-plus-low-rank” compression, $𝐴≈𝑆+𝐻𝑊$, as schematically shown in the **right figure**. 103 | 104 | 105 | The matrix $S$ is sparse, $H$ is a “tall skinny matrix” with only a few columns, and $W$ is a “wide short matrix” with only a few rows. Therefore, $A≈S+HW$ provides a compressed representation of the data. This allows us to solve the following surrogate problem instead of the original problem 106 | 107 | $Minimize \text{ } f(S\mathbf{x}+H\mathbf{y},\mathbf{x})$ 108 | 109 | Subject to $g(S\mathbf{x}+H\mathbf{y},\mathbf{x})\leq 0, \mathbf{y}=W\mathbf{x}, \mathbf{x}\geq 0$ 110 | 111 | Decomposing a matrix into the sum of a sparse matrix and a low-rank matrix has found numerous applications in fields such as computer vision, medical imaging, and statistics. Historically, this structure has been employed as a form of prior knowledge to recover objects of interest that manifest themselves in either the sparse or low-rank components. However, the application presented here represents a novel departure from conventional uses of sparse-plus-low-rank decomposition. Unlike traditional settings where specific components (sparse or low-rank) hold intrinsic importance, our primary goal is not to isolate or interpret these structures. Instead, we leverage them for computationally efficient matrix representation. In this case, the structure serves purely as a tool for optimizing computational efficiency while maintaining data integrity. 112 | 113 | **Note:** Both sparse-only and sparse-plus-low-rank compression techniques serve the same purpose. We are currently investigating the strengths and weaknesses of each technique and their potential combination. Stay tuned for more results. 114 | 115 | **Implementation in PortPy:** 116 | 117 | In PortPy, you can apply the sparse-plus-low-rank compression using the following lines of code. Unlike the sparse-only compression using RMR, which did not require any changes other than replacing $A\mathbf{x}$ with $S\mathbf{x}$ in your optimization formulation and code, this compression requires adding a linear constraint $y=W\mathbf{x}$ and replacing $Ax$ with $S\mathbf{x}+H\mathbf{y}$. These changes can be easily implemented using CVXPy (see the [Sparse-Plus-Low-Rank Jupyter Notebook](https://github.com/PortPy-Project/CompressRTP/blob/main/examples/matrix_sparse_plus_low_rank.ipynb) for details). 118 | 119 | ```python 120 | from compress_rtp.utils.get_sparse_plus_low_rank import get_sparse_plus_low_rank 121 | 122 | S, H, W = get_sparse_plus_low_rank(A=A, threshold_perc=1, rank=5) 123 | ``` 124 | 125 | 126 | ## 2) Fluence Compression to Enforce Smoothness on $x$ 127 | 128 | The fluence smoothness required for efficient and accurate plan delivery is typically achieved by adding an additional "regularization" term to the objective function. This term measures local variations in adjacent beamlets to discourage fluctuating beamlet intensities. However, a significant limitation of this method is its focus on **local complexity** within each beam—it assesses variations between adjacent beamlets but overlooks the **global complexity** of the entire plan. Another challenge is that achieving an optimal balance between plan complexity and dosimetric quality requires careful fine-tuning of the importance weight associated with the smoothness term in the objective function. 129 | 130 | To address these challenges, we treat the intensity map of each beam as a **2D image** and represent it using wavelets corresponding to **low-frequency changes**. The compressed representation of fluence using low-frequency wavelets induces built-in local and global smoothness that can be achieved **without any hyperparameter fine-tuning**. This approach can be easily incorporated into the optimization by adding a set of linear constraints in the form of $𝑥=𝑊𝑦$, where $W$ is the matrix including low-frequency wavelets. 131 | 132 | 133 |
134 | 
135 |
136 | 137 | **Figure Explanation:** As illustrated in the figure above, the treatment plan achieved using wavelet compression is not only more conformal to the tumor but also less complex. This is evidenced by a smaller duty cycle compared to the plan achieved by adding only a regularization term to the objective function. 138 | 139 | 140 | **Implementation in PortPy:** 141 | 142 | In **PortPy**, you can incorporate wavelet smoothness by adding the following lines of code. For detailed explanation, see [Wavelet Jupyter Notebook](https://github.com/PortPy-Project/CompressRTP/blob/main/examples/fluence_wavelets.ipynb). 143 | 144 | ```python 145 | from compress_rtp.utils.get_low_dim_basis import get_low_dim_basis 146 | 147 | # Generate the matrix W of low-frequency wavelets 148 | W = get_low_dim_basis(inf_matrix=inf_matrix, compression='wavelet') 149 | 150 | # Add the variable y 151 | y = cp.Variable(W.shape[1]) 152 | 153 | # Add the constraint Wy = x 154 | opt.constraints += [W @ y == opt.vars['x']] 155 | ``` 156 | 157 | # Team 158 | 159 | | Name | Institution | 160 | |------------------------------------------------------------------------------|----------------------------------------| 161 | | [Mojtaba Tefagh](https://www.ed.ac.uk/profile/mojtaba-tefagh) | University of Edinburgh, Scotland | 162 | | [Gourav Jhanwar](https://github.com/gourav3017) | Memorial Sloan Kettering Cancer Center | 163 | | [Masoud Zarepisheh](https://masoudzp.github.io/) | Memorial Sloan Kettering Cancer Center | 164 | 165 | 166 | ## License 167 | CompressRTP code is distributed under **Apache License 2.0 with Commons Clause**, and is available for non-commercial academic purposes. 168 | 169 | ## Reference 170 | 171 | ``` 172 | 173 | @article{Adeli2024Randomized, 174 | title={Randomized Sparse Matrix Compression for 175 | Large-Scale Constrained Optimization in Cancer 176 | Radiotherapy}, 177 | author={Adeli, Shima and Tefagh, Mojtaba and Jhanwar, Gourav and Zarepisheh, Masoud}, 178 | journal={accepted at NeurIPS}, 179 | year={2024} 180 | } 181 | 182 | @article{tefaghcompressed, 183 | title={Compressed radiotherapy treatment planning: A new paradigm for rapid and high-quality treatment planning optimization}, 184 | author={Tefagh, Mojtaba and Jhanwar, Gourav and Zarepisheh, Masoud}, 185 | journal={Medical Physics}, 186 | publisher={Wiley Online Library} 187 | } 188 | 189 | @article{tefagh2023built, 190 | title={Built-in wavelet-induced smoothness to reduce plan complexity in intensity modulated radiation therapy (IMRT)}, 191 | author={Tefagh, Mojtaba and Zarepisheh, Masoud}, 192 | journal={Physics in Medicine \& Biology}, 193 | volume={68}, 194 | number={6}, 195 | pages={065013}, 196 | year={2023}, 197 | publisher={IOP Publishing} 198 | } 199 | 200 | 201 | 202 | ``` 203 | 204 | -------------------------------------------------------------------------------- /compress_rtp/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/compress_rtp/__init__.py -------------------------------------------------------------------------------- /compress_rtp/compress_rtp_optimization.py: -------------------------------------------------------------------------------- 1 | from __future__ import annotations 2 | 3 | from portpy.photon import Optimization 4 | from typing import TYPE_CHECKING 5 | if TYPE_CHECKING: 6 | from portpy.photon.plan import Plan 7 | from portpy.photon.influence_matrix import InfluenceMatrix 8 | from portpy.photon.clinical_criteria import ClinicalCriteria 9 | import cvxpy as cp 10 | import numpy as np 11 | from copy import deepcopy 12 | 13 | 14 | class CompressRTPOptimization(Optimization): 15 | """ 16 | Class for Compressed RTP optimization. It is child class of PortPy.Photon Optimization class 17 | 18 | - **Attributes** :: 19 | :param my_plan: object of class Plan 20 | :param inf_matrix: object of class InfluenceMatrix 21 | :param clinical_criteria: object of class ClinicalCriteria 22 | :param opt_params: dictionary of vmat optimization parameters 23 | :param vars: dictionary of variables 24 | 25 | :Example: 26 | >>> opt = CompressRTPOptimization(my_plan=my_plan, inf_matrix=inf_matrix, clinical_criteria=clinical_criteria, opt_params=vmat_opt_params) 27 | >>> opt.create_cvxpy_problem_compressed(solver='MOSEK', verbose=True) 28 | 29 | - **Methods** :: 30 | :create_cvxpy_problem_compressed() 31 | Creates cvxpy problem for solving using compressed data 32 | """ 33 | def __init__(self, my_plan: Plan, inf_matrix: InfluenceMatrix = None, 34 | clinical_criteria: ClinicalCriteria = None, 35 | opt_params: dict = None, vars: dict = None): 36 | # Call the constructor of the base class (Optimization) using super() 37 | super().__init__(my_plan=my_plan, inf_matrix=inf_matrix, 38 | clinical_criteria=clinical_criteria, 39 | opt_params=opt_params, vars=vars) 40 | 41 | def create_cvxpy_problem_compressed(self, S=None, H=None, W=None): 42 | 43 | """ 44 | It runs optimization to create optimal plan based upon clinical criteria 45 | 46 | :param S: sparse influence matrix. Uses influence matrix in my_plan by default 47 | :param H: tall skinny matrix. It is obtained using SVD of L = A-S. UKV = svd(L, rank=k). H=U 48 | :param W: thin wide matrix. It is obtained using SVD of L = A-S. W=KV 49 | 50 | """ 51 | # unpack data 52 | my_plan = self.my_plan 53 | inf_matrix = self.inf_matrix 54 | opt_params = self.opt_params 55 | clinical_criteria = self.clinical_criteria 56 | x = self.vars['x'] 57 | obj = self.obj 58 | constraints = self.constraints 59 | 60 | # get opt params for optimization 61 | obj_funcs = opt_params['objective_functions'] if 'objective_functions' in opt_params else [] 62 | opt_params_constraints = opt_params['constraints'] if 'constraints' in opt_params else [] 63 | 64 | if S is None: 65 | S = inf_matrix.A 66 | num_fractions = clinical_criteria.get_num_of_fractions() 67 | st = inf_matrix 68 | if W is None and H is None: 69 | H = np.zeros((S.shape[0], 1)) 70 | W = np.zeros((1, S.shape[1])) 71 | 72 | # Construct optimization problem 73 | Wx = cp.Variable(H.shape[1]) # creating dummy variable for dose 74 | # Generating objective functions 75 | print('Objective Start') 76 | for i in range(len(obj_funcs)): 77 | if obj_funcs[i]['type'] == 'quadratic-overdose': 78 | if obj_funcs[i]['structure_name'] in my_plan.structures.get_structures(): 79 | struct = obj_funcs[i]['structure_name'] 80 | if len(st.get_opt_voxels_idx(struct)) == 0: # check if there are any opt voxels for the structure 81 | continue 82 | key = self.matching_keys(obj_funcs[i], 'dose') 83 | dose_gy = self.dose_to_gy(key, obj_funcs[i][key]) / num_fractions 84 | dO = cp.Variable(len(st.get_opt_voxels_idx(struct)), pos=True) 85 | obj += [(1 / len(st.get_opt_voxels_idx(struct))) * (obj_funcs[i]['weight'] * cp.sum_squares(dO))] 86 | constraints += [S[st.get_opt_voxels_idx(struct), :] @ x + H[st.get_opt_voxels_idx(struct), :] @ Wx <= dose_gy + dO] 87 | elif obj_funcs[i]['type'] == 'quadratic-underdose': 88 | if obj_funcs[i]['structure_name'] in my_plan.structures.get_structures(): 89 | struct = obj_funcs[i]['structure_name'] 90 | if len(st.get_opt_voxels_idx(struct)) == 0: 91 | continue 92 | key = self.matching_keys(obj_funcs[i], 'dose') 93 | dose_gy = self.dose_to_gy(key, obj_funcs[i][key]) / num_fractions 94 | dU = cp.Variable(len(st.get_opt_voxels_idx(struct)), pos=True) 95 | obj += [(1 / len(st.get_opt_voxels_idx(struct))) * (obj_funcs[i]['weight'] * cp.sum_squares(dU))] 96 | constraints += [S[st.get_opt_voxels_idx(struct), :] @ x + H[st.get_opt_voxels_idx(struct), :] @ Wx >= dose_gy - dU] 97 | elif obj_funcs[i]['type'] == 'quadratic': 98 | if obj_funcs[i]['structure_name'] in my_plan.structures.get_structures(): 99 | struct = obj_funcs[i]['structure_name'] 100 | if len(st.get_opt_voxels_idx(struct)) == 0: 101 | continue 102 | obj += [(1 / len(st.get_opt_voxels_idx(struct))) * ( 103 | obj_funcs[i]['weight'] * cp.sum_squares(S[st.get_opt_voxels_idx(struct), :] @ x + H[st.get_opt_voxels_idx(struct), :] @ Wx))] 104 | elif obj_funcs[i]['type'] == 'smoothness-quadratic': 105 | [Qx, Qy, num_rows, num_cols] = self.get_smoothness_matrix(inf_matrix.beamlets_dict) 106 | smoothness_X_weight = 0.6 107 | smoothness_Y_weight = 0.4 108 | obj += [obj_funcs[i]['weight'] * (smoothness_X_weight * (1 / num_cols) * cp.sum_squares(Qx @ x) + 109 | smoothness_Y_weight * (1 / num_rows) * cp.sum_squares(Qy @ x))] 110 | 111 | print('Objective done') 112 | 113 | print('Constraints Start') 114 | 115 | constraint_def = deepcopy( 116 | clinical_criteria.get_criteria()) # get all constraints definition using clinical criteria 117 | 118 | # add/modify constraints definition if present in opt params 119 | for opt_constraint in opt_params_constraints: 120 | # add constraint 121 | param = opt_constraint['parameters'] 122 | if param['structure_name'] in my_plan.structures.get_structures(): 123 | criterion_exist, criterion_ind = clinical_criteria.check_criterion_exists(opt_constraint, 124 | return_ind=True) 125 | if criterion_exist: 126 | constraint_def[criterion_ind] = opt_constraint 127 | else: 128 | constraint_def += [opt_constraint] 129 | 130 | # Adding max/mean constraints 131 | for i in range(len(constraint_def)): 132 | if constraint_def[i]['type'] == 'max_dose': 133 | limit_key = self.matching_keys(constraint_def[i]['constraints'], 'limit') 134 | if limit_key: 135 | limit = self.dose_to_gy(limit_key, constraint_def[i]['constraints'][limit_key]) 136 | org = constraint_def[i]['parameters']['structure_name'] 137 | if org != 'GTV' and org != 'CTV': 138 | if org in my_plan.structures.get_structures(): 139 | if len(st.get_opt_voxels_idx(org)) == 0: 140 | continue 141 | constraints += [S[st.get_opt_voxels_idx(org), :] @ x + H[st.get_opt_voxels_idx(org), :] @ Wx <= limit / num_fractions] 142 | elif constraint_def[i]['type'] == 'mean_dose': 143 | limit_key = self.matching_keys(constraint_def[i]['constraints'], 'limit') 144 | if limit_key: 145 | limit = self.dose_to_gy(limit_key, constraint_def[i]['constraints'][limit_key]) 146 | org = constraint_def[i]['parameters']['structure_name'] 147 | # mean constraints using voxel weights 148 | if org in my_plan.structures.get_structures(): 149 | if len(st.get_opt_voxels_idx(org)) == 0: 150 | continue 151 | fraction_of_vol_in_calc_box = my_plan.structures.get_fraction_of_vol_in_calc_box(org) 152 | limit = limit / fraction_of_vol_in_calc_box # modify limit due to fraction of volume receiving no dose 153 | constraints += [(1 / sum(st.get_opt_voxels_volume_cc(org))) * 154 | (cp.sum((cp.multiply(st.get_opt_voxels_volume_cc(org), 155 | S[st.get_opt_voxels_idx(org), :] @ x + H[st.get_opt_voxels_idx(org), :] @ Wx)))) 156 | <= limit / num_fractions] 157 | 158 | constraints += [Wx == (W @ x)] 159 | print('Constraints done') -------------------------------------------------------------------------------- /compress_rtp/utils/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/compress_rtp/utils/__init__.py -------------------------------------------------------------------------------- /compress_rtp/utils/get_low_dim_basis.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | from portpy.photon.influence_matrix import InfluenceMatrix 4 | import numpy as np 5 | import scipy 6 | try: 7 | import pywt 8 | except ImportError: 9 | pass 10 | 11 | 12 | def get_low_dim_basis(inf_matrix: InfluenceMatrix, compression: str = 'wavelet'): 13 | """ 14 | :param inf_matrix: an object of class InfluenceMatrix for the specified plan 15 | :param compression: the compression method 16 | :type compression: str 17 | :return: a list that contains the dimension reduction basis in the format of array(float) 18 | """ 19 | 20 | low_dim_basis = {} 21 | num_of_beams = len(inf_matrix.beamlets_dict) 22 | num_of_beamlets = inf_matrix.beamlets_dict[num_of_beams - 1]['end_beamlet_idx'] + 1 23 | beam_id = [inf_matrix.beamlets_dict[i]['beam_id'] for i in range(num_of_beams)] 24 | beamlets = inf_matrix.get_bev_2d_grid(beam_id=beam_id) 25 | index_position = list() 26 | for ind in range(num_of_beams): 27 | low_dim_basis[beam_id[ind]] = [] 28 | for i in range(inf_matrix.beamlets_dict[ind]['start_beamlet_idx'], 29 | inf_matrix.beamlets_dict[ind]['end_beamlet_idx'] + 1): 30 | index_position.append((np.where(beamlets[ind] == i)[0][0], np.where(beamlets[ind] == i)[1][0])) 31 | if compression == 'wavelet': 32 | max_dim_0 = np.max([beamlets[ind].shape[0] for ind in range(num_of_beams)]) 33 | max_dim_1 = np.max([beamlets[ind].shape[1] for ind in range(num_of_beams)]) 34 | beamlet_2d_grid = np.zeros((int(np.ceil(max_dim_0 / 2)), int(np.ceil(max_dim_1 / 2)))) 35 | for row in range(beamlet_2d_grid.shape[0]): 36 | for col in range(beamlet_2d_grid.shape[1]): 37 | beamlet_2d_grid[row][col] = 1 38 | approximation_coeffs = pywt.idwt2((beamlet_2d_grid, (None, None, None)), 'sym4', 39 | mode='periodization') 40 | horizontal_coeffs = pywt.idwt2((None, (beamlet_2d_grid, None, None)), 'sym4', mode='periodization') 41 | for b in range(num_of_beams): 42 | if ((2 * row + 1 < beamlets[b].shape[0] and 2 * col + 1 < beamlets[b].shape[1] and 43 | beamlets[b][2 * row + 1][2 * col + 1] != -1) or 44 | (2 * row + 1 < beamlets[b].shape[0] and 2 * col < beamlets[b].shape[1] and 45 | beamlets[b][2 * row + 1][2 * col] != -1) or 46 | (2 * row < beamlets[b].shape[0] and 2 * col + 1 < beamlets[b].shape[1] and 47 | beamlets[b][2 * row][2 * col + 1] != -1) or 48 | (2 * row < beamlets[b].shape[0] and 2 * col < beamlets[b].shape[1] and 49 | beamlets[b][2 * row][2 * col] != -1)): 50 | approximation = np.zeros(num_of_beamlets) 51 | horizontal = np.zeros(num_of_beamlets) 52 | for ind in range(inf_matrix.beamlets_dict[b]['start_beamlet_idx'], 53 | inf_matrix.beamlets_dict[b]['end_beamlet_idx'] + 1): 54 | approximation[ind] = approximation_coeffs[index_position[ind]] 55 | horizontal[ind] = horizontal_coeffs[index_position[ind]] 56 | low_dim_basis[beam_id[b]].append(np.transpose(np.stack([approximation, horizontal]))) 57 | beamlet_2d_grid[row][col] = 0 58 | for b in beam_id: 59 | low_dim_basis[b] = np.concatenate(low_dim_basis[b], axis=1) 60 | u, s, vh = scipy.sparse.linalg.svds(low_dim_basis[b], k=min(low_dim_basis[b].shape[0], low_dim_basis[b].shape[1]) - 1) 61 | ind = np.where(s > 0.0001) 62 | low_dim_basis[b] = u[:, ind[0]] 63 | return np.concatenate([low_dim_basis[b] for b in beam_id], axis=1) -------------------------------------------------------------------------------- /compress_rtp/utils/get_sparse_only.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import math 3 | import scipy 4 | 5 | 6 | def get_sparse_only(A: np.ndarray, threshold_perc: float = 1, compression: str = 'naive'): 7 | """ 8 | Get sparse matrix using threshold and different methods 9 | :param A: matrix to be sparsified 10 | :param threshold_perc: threshold for matrix sparsification 11 | :param compression: Method of Sparsification 12 | 13 | :return: Sparse influence matrix 14 | """ 15 | threshold = np.max(A) * threshold_perc * 0.01 16 | if compression == 'rmr': 17 | copy_matrix = A.copy() 18 | print('Generating sparse matrix using RMR...') 19 | np.apply_along_axis(row_operation, 1, copy_matrix, threshold) 20 | S = scipy.sparse.csr_matrix(copy_matrix) 21 | else: 22 | S = np.where(A >= threshold, A, 0) 23 | S = scipy.sparse.csr_matrix(S) 24 | return S 25 | 26 | 27 | def row_operation(copy_row, threshold): 28 | argzero = np.argwhere((np.abs(copy_row) <= threshold) * (copy_row != 0)) 29 | argzero = argzero.reshape(len(argzero), ) 30 | argzero_copy = copy_row[argzero] 31 | copy_row[argzero] = 0 32 | sum = np.sum(argzero_copy) 33 | if sum != 0: 34 | k = math.ceil(sum / threshold) 35 | 36 | indices = np.random.choice(argzero, k, p=argzero_copy / sum, replace=True) 37 | np.add.at(copy_row, indices, sum / k) 38 | 39 | -------------------------------------------------------------------------------- /compress_rtp/utils/get_sparse_plus_low_rank.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import scipy 3 | 4 | try: 5 | from sklearn.utils.extmath import randomized_svd 6 | except ImportError: 7 | pass 8 | 9 | 10 | def get_sparse_plus_low_rank(A: np.ndarray, threshold_perc: float = 1, rank: int = 5): 11 | """ 12 | :param A: dose influence matrix 13 | :param threshold_perc: thresold percentage. Default to 1% of max(A) 14 | :type rank: rank of L = A-S. 15 | :returns: S, H, W using randomized svd 16 | """ 17 | tol = np.max(A) * threshold_perc * 0.01 18 | S = np.where(A > tol, A, 0) 19 | if rank == 0: 20 | S = scipy.sparse.csr_matrix(S) 21 | return S 22 | else: 23 | print('Running svd..') 24 | [U, svd_S, V] = randomized_svd(A - S, n_components=rank + 1, random_state=0) 25 | print('svd done!') 26 | H = U[:, :rank] 27 | W = np.diag(svd_S[:rank]) @ V[:rank, :] 28 | S = scipy.sparse.csr_matrix(S) 29 | return S, H, W 30 | -------------------------------------------------------------------------------- /examples/fluence_wavelets.py: -------------------------------------------------------------------------------- 1 | """ 2 | 3 | This example shows creating and modification of wavelet bases for fluence map compression using portpy 4 | 5 | """ 6 | 7 | import portpy.photon as pp 8 | from compress_rtp.utils.get_low_dim_basis import get_low_dim_basis 9 | import cvxpy as cp 10 | import matplotlib.pyplot as plt 11 | 12 | 13 | def ex_wavelet(): 14 | 15 | """ 16 | 1) Accessing the portpy data (DataExplorer class) 17 | 18 | """ 19 | 20 | # Note: you first need to download the patient database from the link provided in the GitHub page. 21 | 22 | # specify the patient data location. 23 | data_dir = r'../../Data' 24 | 25 | # Use PortPy DataExplorer class to explore PortPy data and pick one of the patient 26 | data = pp.DataExplorer(data_dir=data_dir) 27 | patient_id = 'Lung_Patient_3' 28 | data.patient_id = patient_id 29 | 30 | # Load ct and structure set for the above patient using CT and Structures class 31 | ct = pp.CT(data) 32 | structs = pp.Structures(data) 33 | 34 | # If the list of beams are not provided, it uses the beams selected manually 35 | # by a human expert planner for the patient (manually selected beams are stored in portpy data). 36 | # Create beams for the planner beams by default 37 | # for the customized beams, you can pass the argument beam_ids 38 | # e.g. beams = pp.Beams(data, beam_ids=[0,10,20,30,40,50,60]) 39 | beams = pp.Beams(data) 40 | 41 | # create rinds based upon rind definition in optimization params 42 | protocol_name = 'Lung_2Gy_30Fx' 43 | opt_params = data.load_config_opt_params(protocol_name=protocol_name) 44 | structs.create_opt_structures(opt_params=opt_params) 45 | 46 | # load influence matrix based upon beams and structure set 47 | inf_matrix = pp.InfluenceMatrix(ct=ct, structs=structs, beams=beams) 48 | 49 | # load clinical criteria from the config files for which plan to be optimized 50 | clinical_criteria = pp.ClinicalCriteria(data, protocol_name=protocol_name) 51 | 52 | ''' 53 | 2) Optimizing the plan without quadratic smoothness (with and without wavelet constraint) 54 | 55 | ''' 56 | # - Without wavelet constraint 57 | 58 | # remove smoothness objective 59 | for i in range(len(opt_params['objective_functions'])): 60 | if opt_params['objective_functions'][i]['type'] == 'smoothness-quadratic': 61 | opt_params['objective_functions'][i]['weight'] = 0 62 | 63 | # create a plan using ct, structures, beams and influence matrix. Clinical criteria is optional 64 | my_plan = pp.Plan(ct=ct, structs=structs, beams=beams, inf_matrix=inf_matrix, clinical_criteria=clinical_criteria) 65 | 66 | # create cvxpy problem using the clinical criteria and optimization parameters 67 | opt = pp.Optimization(my_plan, opt_params=opt_params) 68 | opt.create_cvxpy_problem() 69 | sol_no_quad_no_wav = opt.solve(solver='MOSEK', verbose=False) 70 | 71 | # - With wavelet constraint 72 | 73 | # creating the wavelet incomplete basis representing a low dimensional subspace for dimension reduction 74 | wavelet_basis = get_low_dim_basis(inf_matrix=inf_matrix, compression='wavelet') 75 | # Smoothness Constraint 76 | y = cp.Variable(wavelet_basis.shape[1]) 77 | opt.constraints += [wavelet_basis @ y == opt.vars['x']] 78 | sol_no_quad_with_wav = opt.solve(solver='MOSEK', verbose=False) 79 | 80 | ''' 81 | 3) Optimizing the plan with quadratic smoothness 82 | 83 | ''' 84 | # - Without wavelet constraint 85 | 86 | for i in range(len(opt_params['objective_functions'])): 87 | if opt_params['objective_functions'][i]['type'] == 'smoothness-quadratic': 88 | opt_params['objective_functions'][i]['weight'] = 10 89 | 90 | # create cvxpy problem using the clinical criteria and optimization parameters 91 | opt = pp.Optimization(my_plan, opt_params=opt_params) 92 | opt.create_cvxpy_problem() 93 | 94 | sol_quad_no_wav = opt.solve(solver='MOSEK', verbose=False) 95 | 96 | # - With Wavelet constraint 97 | 98 | # Wavelet Smoothness Constraint 99 | y = cp.Variable(wavelet_basis.shape[1]) 100 | opt.constraints += [wavelet_basis @ y == opt.vars['x']] 101 | sol_quad_with_wav = opt.solve(solver='MOSEK', verbose=False) 102 | 103 | ''' 104 | 4) Saving and loading plans 105 | 106 | ''' 107 | 108 | pp.save_plan(my_plan, plan_name='my_plan.pkl', path=r'C:\temp') 109 | pp.save_optimal_sol(sol_no_quad_no_wav, sol_name='sol_no_quad_no_wav.pkl', path=r'C:\temp') 110 | pp.save_optimal_sol(sol_no_quad_with_wav, sol_name='sol_no_quad_with_wav.pkl', path=r'C:\temp') 111 | pp.save_optimal_sol(sol_quad_no_wav, sol_name='sol_quad_no_wav.pkl', path=r'C:\temp') 112 | pp.save_optimal_sol(sol_quad_with_wav, sol_name='sol_quad_with_wav.pkl', path=r'C:\temp') 113 | 114 | # my_plan = pp.load_plan(plan_name='my_plan', path=r'C:\temp') 115 | # sol_no_quad_no_wav = pp.load_optimal_sol(sol_name='sol_no_quad_no_wav', path=r'C:\temp') 116 | # sol_no_quad_with_wav = pp.load_optimal_sol(sol_name='sol_no_quad_with_wav', path=r'C:\temp') 117 | # sol_quad_no_wav = pp.load_optimal_sol(sol_name='sol_quad_no_wav', path=r'C:\temp') 118 | # sol_quad_with_wav = pp.load_optimal_sol(sol_name='sol_quad_with_wav', path=r'C:\temp') 119 | 120 | ''' 121 | 5) Visualization and compare the plans 122 | 123 | ''' 124 | # plot fluence 3D and 2D 125 | fig, ax = plt.subplots(1, 2, figsize=(18, 6), subplot_kw={'projection': '3d'}) 126 | fig.suptitle('Without Quadratic smoothness') 127 | pp.Visualization.plot_fluence_3d(sol=sol_no_quad_no_wav, beam_id=37, ax=ax[0], title='Without Wavelet') 128 | pp.Visualization.plot_fluence_3d(sol=sol_no_quad_with_wav, beam_id=37, ax=ax[1], title='With Wavelet') 129 | 130 | fig, ax = plt.subplots(1, 2, figsize=(18, 6), subplot_kw={'projection': '3d'}) 131 | fig.suptitle('With Quadratic smoothness') 132 | pp.Visualization.plot_fluence_3d(sol=sol_quad_no_wav, beam_id=37, ax=ax[0], title='Without Wavelet') 133 | pp.Visualization.plot_fluence_3d(sol=sol_quad_with_wav, beam_id=37, ax=ax[1], title='With Wavelet') 134 | plt.show() 135 | 136 | # plot DVH for the structures in the given list. Default dose_1d is in Gy and volume is in relative scale(%). 137 | structs = ['PTV', 'ESOPHAGUS', 'HEART', 'CORD', 'LUNG_L', 'LUNG_R'] 138 | fig, ax = plt.subplots(1, 2, figsize=(20, 8)) 139 | ax0 = pp.Visualization.plot_dvh(my_plan, sol=sol_no_quad_no_wav, structs=structs, style='solid', ax=ax[0]) 140 | ax0 = pp.Visualization.plot_dvh(my_plan, sol=sol_no_quad_with_wav, structs=structs, style='dashed', ax=ax0) 141 | fig.suptitle('DVH comparison') 142 | ax0.set_title('Without Quadratic smoothness \n solid: Without Wavelet, Dash: With Wavelet') 143 | # plt.show() 144 | # print('\n\n') 145 | 146 | # fig, ax = plt.subplots(figsize=(12, 8)) 147 | ax1 = pp.Visualization.plot_dvh(my_plan, sol=sol_quad_no_wav, structs=structs, style='solid', ax=ax[1]) 148 | ax1 = pp.Visualization.plot_dvh(my_plan, sol=sol_quad_with_wav, structs=structs, style='dashed', ax=ax1) 149 | ax1.set_title('With Quadratic smoothness \n solid: Without Wavelet, Dash: With Wavelet') 150 | plt.show() 151 | 152 | ''' 153 | 6) Evaluate the plan based upon clinical criteria 154 | 155 | ''' 156 | # visualize plan metrics based upon clinical criteria 157 | pp.Evaluation.display_clinical_criteria(my_plan, 158 | sol=[sol_no_quad_no_wav, sol_no_quad_with_wav, sol_quad_no_wav, sol_quad_with_wav], 159 | sol_names=['no_quad_no_wav', 'no_quad_with_wav', 'quad_no_wav', 'quad_with_wav']) 160 | 161 | 162 | if __name__ == "__main__": 163 | ex_wavelet() 164 | -------------------------------------------------------------------------------- /examples/matrix_spare_plus_low_rank.py: -------------------------------------------------------------------------------- 1 | """ 2 | 3 | This example demonstrates compressed planning based on a sparse-plus-low-rank matrix compression technique: 4 | 5 | """ 6 | import os 7 | import portpy.photon as pp 8 | from compress_rtp.compress_rtp_optimization import CompressRTPOptimization 9 | from compress_rtp.utils.get_sparse_plus_low_rank import get_sparse_plus_low_rank 10 | from compress_rtp.utils.get_sparse_only import get_sparse_only 11 | import matplotlib.pyplot as plt 12 | from copy import deepcopy 13 | 14 | 15 | def sparse_plus_low_rank(): 16 | """ 17 | 1) Accessing the portpy data (DataExplorer class) 18 | To start using this resource, users are required to download the latest version of the dataset, which can be found at (https://drive.google.com/drive/folders/1nA1oHEhlmh2Hk8an9e0Oi0ye6LRPREit). Then, the dataset can be accessed as demonstrated below. 19 | 20 | """ 21 | 22 | # specify the patient data location. 23 | data_dir = r'../../PortPy/data' 24 | # Use PortPy DataExplorer class to explore PortPy data 25 | data = pp.DataExplorer(data_dir=data_dir) 26 | 27 | # pick a patient from the existing patient list to get detailed info (e.g., beam angles, structures). 28 | data.patient_id = 'Lung_Patient_2' 29 | 30 | ct = pp.CT(data) 31 | structs = pp.Structures(data) 32 | 33 | # If the list of beams are not provided, it uses the beams selected manually 34 | # by a human expert planner for the patient (manually selected beams are stored in portpy data). 35 | # Create beams for the planner beams by default 36 | # for the customized beams, you can pass the argument beam_ids 37 | # e.g. beams = pp.Beams(data, beam_ids=[0,10,20,30,40,50,60]) 38 | beams = pp.Beams(data, load_inf_matrix_full=True) 39 | 40 | # In order to create an IMRT plan, we first need to specify a protocol which includes the disease site, 41 | # the prescribed dose for the PTV, the number of fractions, and the radiation dose thresholds for OARs. 42 | # These information are stored in .json files which can be found in a directory named "config_files". 43 | # An example of such a file is 'Lung_2Gy_30Fx.json'. Here's how you can load these files: 44 | protocol_name = 'Lung_2Gy_30Fx' 45 | # load clinical criteria from the config files for which plan to be optimized 46 | clinical_criteria = pp.ClinicalCriteria(data, protocol_name=protocol_name) 47 | 48 | # Optimization problem formulation 49 | protocol_name = 'Lung_2Gy_30Fx' 50 | # Loading hyper-parameter values for optimization problem 51 | opt_params = data.load_config_opt_params(protocol_name=protocol_name) 52 | # Creating optimization structures (i.e., Rinds) 53 | structs.create_opt_structures(opt_params=opt_params, clinical_criteria=clinical_criteria) 54 | # Loading influence matrix 55 | inf_matrix = pp.InfluenceMatrix(ct=ct, structs=structs, beams=beams, is_full=True) 56 | 57 | """ 58 | 59 | 2) creating a simple IMRT plan using CVXPy (Plan class, Optimization class) 60 | Note: you can call different opensource / commercial optimization engines from CVXPy. 61 | For commercial engines (e.g., Mosek, Gorubi, CPLEX), you first need to obtain an appropriate license. 62 | Most commercial optimization engines give free academic license. 63 | 64 | Create my_plan object which would store all the data needed for optimization 65 | (e.g., influence matrix, structures and their voxels, beams and their beamlets). 66 | 67 | """ 68 | # create a plan using ct, structures, beams and influence matrix. Clinical criteria is optional 69 | my_plan = pp.Plan(ct=ct, structs=structs, beams=beams, inf_matrix=inf_matrix, clinical_criteria=clinical_criteria) 70 | 71 | # run optimization with naive thresold of 1% of max(A) and no low rank 72 | # create cvxpy problem using the clinical criteria and optimization parameters 73 | A = deepcopy(inf_matrix.A) 74 | S = get_sparse_only(A=A, threshold_perc=1) 75 | # Users can also use below method to get sparse matrix using threshold. Rank=0 is equivalent to above method 76 | # S = get_sparse_plus_low_rank(A=A, thresold_perc=1, rank=0) 77 | inf_matrix.A = S 78 | opt = pp.Optimization(my_plan, inf_matrix=inf_matrix, opt_params=opt_params) 79 | opt.create_cvxpy_problem() 80 | sol_sparse = opt.solve(solver='MOSEK', verbose=True) 81 | 82 | # run optimization with thresold of 1% and rank 5 83 | # create cvxpy problem using the clinical criteria and optimization parameters 84 | S, H, W = get_sparse_plus_low_rank(A=A, threshold_perc=1, rank=5) 85 | opt = CompressRTPOptimization(my_plan, opt_params=opt_params) 86 | opt.create_cvxpy_problem_compressed(S=S, H=H, W=W) 87 | 88 | # run imrt fluence map optimization using cvxpy and one of the supported solvers and save the optimal solution in sol 89 | mosek_params = {'MSK_IPAR_PRESOLVE_ELIMINATOR_MAX_NUM_TRIES': 0, 90 | 'MSK_IPAR_INTPNT_SCALING': 'MSK_SCALING_NONE'} 91 | sol_slr = opt.solve(solver='MOSEK', verbose=True, mosek_params=mosek_params) 92 | 93 | """ 94 | 3) visualizing the dvh with and without compression (Visualization class) 95 | 96 | """ 97 | 98 | fig, ax = plt.subplots(1, 2, figsize=(20, 8)) 99 | struct_names = ['PTV', 'ESOPHAGUS', 'HEART', 'CORD', 'LUNGS_NOT_GTV'] 100 | dose_1d_sparse = (S @ sol_sparse['optimal_intensity']) * my_plan.get_num_of_fractions() 101 | dose_1d_full_sparse = (A @ sol_sparse['optimal_intensity']) * my_plan.get_num_of_fractions() 102 | ax0 = pp.Visualization.plot_dvh(my_plan, dose_1d=dose_1d_sparse, struct_names=struct_names, style='dotted', ax=ax[0], norm_flag=True) 103 | ax0 = pp.Visualization.plot_dvh(my_plan, dose_1d=dose_1d_full_sparse, struct_names=struct_names, style='solid', ax=ax0, norm_flag=True) 104 | ax0.set_title("sparse_vs_full") 105 | 106 | dose_1d_slr = (S @ sol_slr['optimal_intensity'] + H @ (W @ sol_slr['optimal_intensity'])) * my_plan.get_num_of_fractions() 107 | dose_1d_full_slr = (A @ sol_slr['optimal_intensity']) * my_plan.get_num_of_fractions() 108 | ax1 = pp.Visualization.plot_dvh(my_plan, dose_1d=dose_1d_slr, struct_names=struct_names, style='dashed', ax=ax[1], norm_flag=True) 109 | ax1 = pp.Visualization.plot_dvh(my_plan, dose_1d=dose_1d_full_slr, struct_names=struct_names, style='solid', ax=ax1, norm_flag=True) 110 | ax1.set_title("slr_vs_full") 111 | plt.show(block=False) 112 | 113 | """ 114 | 4) evaluating the plan (Evaluation class) 115 | The Evaluation class offers a set of methods for quantifying the optimized plan. 116 | If you need to compute individual dose volume metrics, you can use methods such as *get_dose* or *get_volume*. 117 | Furthermore, the class also facilitates the assessment of the plan based on a collection of metrics, 118 | such as mean, max, and dose-volume histogram (DVH), as specified in the clinical protocol. This capability is demonstrated below 119 | """ 120 | 121 | # visualize plan metrics based upon clinical criteria 122 | pp.Evaluation.display_clinical_criteria(my_plan, dose_1d=[dose_1d_full_sparse, dose_1d_full_slr], sol_names=['Without compression', 'With compression']) 123 | 124 | """ 125 | 5) saving and loading the plan for future use (utils) 126 | 127 | """ 128 | # Comment/Uncomment these lines to save and load the pickle file for plans and optimal solution from the directory 129 | pp.save_plan(my_plan, plan_name='my_plan.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 130 | pp.save_optimal_sol(sol_slr, sol_name='sol_sparse.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 131 | pp.save_optimal_sol(sol_slr, sol_name='sol_slr.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 132 | # my_plan = pp.load_plan(plan_name='my_plan.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 133 | # sol = pp.load_optimal_sol(sol_name='sol_sparse.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 134 | 135 | 136 | if __name__ == "__main__": 137 | sparse_plus_low_rank() 138 | -------------------------------------------------------------------------------- /examples/matrix_sparse_only.py: -------------------------------------------------------------------------------- 1 | """ 2 | 3 | This example demonstrates compressed planning based on a RMR matrix compression technique: 4 | 5 | """ 6 | import os 7 | import portpy.photon as pp 8 | from compress_rtp.utils.get_sparse_only import get_sparse_only 9 | import numpy as np 10 | import matplotlib.pyplot as plt 11 | from copy import deepcopy 12 | 13 | 14 | def matrix_sparse_only_rmr(): 15 | """ 16 | 1) Accessing the portpy data (DataExplorer class) 17 | To start using this resource, users are required to download the latest version of the dataset, which can be found at (https://drive.google.com/drive/folders/1nA1oHEhlmh2Hk8an9e0Oi0ye6LRPREit). Then, the dataset can be accessed as demonstrated below. 18 | 19 | """ 20 | 21 | # specify the patient data location. 22 | data_dir = r'../../PortPy/data' 23 | # Use PortPy DataExplorer class to explore PortPy data 24 | data = pp.DataExplorer(data_dir=data_dir) 25 | 26 | # pick a patient from the existing patient list to get detailed info (e.g., beam angles, structures). 27 | data.patient_id = 'Lung_Patient_6' 28 | ct = pp.CT(data) 29 | structs = pp.Structures(data) 30 | 31 | # If the list of beams are not provided, it uses the beams selected manually 32 | # by a human expert planner for the patient (manually selected beams are stored in portpy data). 33 | # Create beams for the planner beams by default 34 | # for the customized beams, you can pass the argument beam_ids 35 | # e.g. beams = pp.Beams(data, beam_ids=[0,10,20,30,40,50,60]) 36 | beams = pp.Beams(data, load_inf_matrix_full=True) 37 | 38 | # In order to create an IMRT plan, we first need to specify a protocol which includes the disease site, 39 | # the prescribed dose for the PTV, the number of fractions, and the radiation dose thresholds for OARs. 40 | # These information are stored in .json files which can be found in a directory named "config_files". 41 | # An example of such a file is 'Lung_2Gy_30Fx.json'. Here's how you can load these files: 42 | protocol_name = 'Lung_2Gy_30Fx' 43 | # load clinical criteria from the config files for which plan to be optimized 44 | clinical_criteria = pp.ClinicalCriteria(data, protocol_name=protocol_name) 45 | 46 | # Optimization problem formulation 47 | protocol_name = 'Lung_2Gy_30Fx' 48 | # Loading hyper-parameter values for optimization problem 49 | opt_params = data.load_config_opt_params(protocol_name=protocol_name) 50 | # Creating optimization structures (i.e., Rinds) 51 | structs.create_opt_structures(opt_params=opt_params, clinical_criteria=clinical_criteria) 52 | # Loading influence matrix 53 | inf_matrix = pp.InfluenceMatrix(ct=ct, structs=structs, beams=beams, is_full=True) 54 | 55 | """ 56 | 57 | 2) creating a simple IMRT plan using CVXPy (Plan class, Optimization class) 58 | Note: you can call different opensource / commercial optimization engines from CVXPy. 59 | For commercial engines (e.g., Mosek, Gorubi, CPLEX), you first need to obtain an appropriate license. 60 | Most commercial optimization engines give free academic license. 61 | 62 | Create my_plan object which would store all the data needed for optimization 63 | (e.g., influence matrix, structures and their voxels, beams and their beamlets). 64 | 65 | """ 66 | # create a plan using ct, structures, beams and influence matrix. Clinical criteria is optional 67 | my_plan = pp.Plan(ct=ct, structs=structs, beams=beams, inf_matrix=inf_matrix, clinical_criteria=clinical_criteria) 68 | 69 | # run optimization with naive thresold of 1% of max(A) and no low rank 70 | # create cvxpy problem using the clinical criteria and optimization parameters 71 | A = deepcopy(inf_matrix.A) 72 | S_sparse = get_sparse_only(A=A, threshold_perc=1) 73 | inf_matrix.A = S_sparse 74 | opt = pp.Optimization(my_plan, inf_matrix=inf_matrix, opt_params=opt_params) 75 | opt.create_cvxpy_problem() 76 | sol_sparse_naive = opt.solve(solver='MOSEK', verbose=True) 77 | 78 | # run optimization with thresold of 1% and sparsifying matrix using RMR method 79 | # create cvxpy problem using the clinical criteria and optimization parameters 80 | S_rmr = get_sparse_only(A=A, threshold_perc=10, compression='rmr') 81 | inf_matrix.A = S_rmr 82 | opt = pp.Optimization(my_plan, inf_matrix=inf_matrix, opt_params=opt_params) 83 | opt.create_cvxpy_problem() 84 | sol_sparse_rmr = opt.solve(solver='MOSEK', verbose=True) 85 | 86 | 87 | """ 88 | 3) visualizing the dvh with and without compression (Visualization class) 89 | 90 | """ 91 | 92 | fig, ax = plt.subplots(1, 2, figsize=(20, 8)) 93 | struct_names = ['PTV', 'ESOPHAGUS', 'HEART', 'CORD', 'LUNGS_NOT_GTV'] 94 | dose_1d_naive = (S_sparse @ sol_sparse_naive['optimal_intensity']) * my_plan.get_num_of_fractions() 95 | dose_1d_full_naive = (A @ sol_sparse_naive['optimal_intensity']) * my_plan.get_num_of_fractions() 96 | ax0 = pp.Visualization.plot_dvh(my_plan, dose_1d=dose_1d_naive, struct_names=struct_names, style='dotted', ax=ax[0], norm_flag=True) 97 | ax0 = pp.Visualization.plot_dvh(my_plan, dose_1d=dose_1d_full_naive, struct_names=struct_names, style='solid', ax=ax0, norm_flag=True) 98 | ax0.set_title("sparse_naive_vs_full") 99 | 100 | dose_1d_rmr = (S_rmr @ sol_sparse_rmr['optimal_intensity']) * my_plan.get_num_of_fractions() 101 | dose_1d_full_rmr = (A @ sol_sparse_rmr['optimal_intensity']) * my_plan.get_num_of_fractions() 102 | ax1 = pp.Visualization.plot_dvh(my_plan, dose_1d=dose_1d_rmr, struct_names=struct_names, style='dashed', ax=ax[1], norm_flag=True) 103 | ax1 = pp.Visualization.plot_dvh(my_plan, dose_1d=dose_1d_full_rmr, struct_names=struct_names, style='solid', ax=ax1, norm_flag=True) 104 | ax1.set_title("sparse_rmr_vs_full") 105 | plt.show(block=False) 106 | 107 | """ 108 | 4) evaluating the plan (Evaluation class) 109 | The Evaluation class offers a set of methods for quantifying the optimized plan. 110 | If you need to compute individual dose volume metrics, you can use methods such as *get_dose* or *get_volume*. 111 | Furthermore, the class also facilitates the assessment of the plan based on a collection of metrics, 112 | such as mean, max, and dose-volume histogram (DVH), as specified in the clinical protocol. This capability is demonstrated below 113 | """ 114 | 115 | # visualize plan metrics based upon clinical criteria 116 | pp.Evaluation.display_clinical_criteria(my_plan, dose_1d=[dose_1d_full_naive, dose_1d_full_rmr], sol_names=['Naive Sparsification', 'RMR Sparsification']) 117 | 118 | """ 119 | 5) saving and loading the plan for future use (utils) 120 | 121 | """ 122 | # Comment/Uncomment these lines to save and load the pickle file for plans and optimal solution from the directory 123 | pp.save_plan(my_plan, plan_name='my_plan.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 124 | pp.save_optimal_sol(sol_sparse_naive, sol_name='sol_sparse_naive.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 125 | pp.save_optimal_sol(sol_sparse_rmr, sol_name='sol_sparse_rmr.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 126 | # my_plan = pp.load_plan(plan_name='my_plan.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 127 | # sol = pp.load_optimal_sol(sol_name='sol_sparse.pkl', path=os.path.join(r'C:\temp', data.patient_id)) 128 | 129 | 130 | if __name__ == "__main__": 131 | matrix_sparse_only_rmr() -------------------------------------------------------------------------------- /images/Algorithm_RMR.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/Algorithm_RMR.png -------------------------------------------------------------------------------- /images/CompressRTPLogo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/CompressRTPLogo.png -------------------------------------------------------------------------------- /images/CompressRTPLogo2.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/CompressRTPLogo2.PNG -------------------------------------------------------------------------------- /images/FluenceCompress.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/FluenceCompress.PNG -------------------------------------------------------------------------------- /images/LowDimRT.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/LowDimRT.png -------------------------------------------------------------------------------- /images/RMR_NeurIPS_Paper.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/RMR_NeurIPS_Paper.pdf -------------------------------------------------------------------------------- /images/RMR_performance.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/RMR_performance.PNG -------------------------------------------------------------------------------- /images/RMR_vs_Naive.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/RMR_vs_Naive.PNG -------------------------------------------------------------------------------- /images/RMR_vs_Native.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/RMR_vs_Native.png -------------------------------------------------------------------------------- /images/RMR_vs_Others.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/RMR_vs_Others.png -------------------------------------------------------------------------------- /images/SLR.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/SLR.PNG -------------------------------------------------------------------------------- /images/SPlusL_Lung_Benefits.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/SPlusL_Lung_Benefits.png -------------------------------------------------------------------------------- /images/SPlusL_singular_values.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/SPlusL_singular_values.png -------------------------------------------------------------------------------- /images/Wavelet_Benefits.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PortPy-Project/CompressRTP/867ff1632026b9d25ae9ea84ca2a5612b2a076a9/images/Wavelet_Benefits.png -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | portpy>=1.0.3 2 | PyWavelets>=1.4.0 3 | scikit-learn>=1.5.2 4 | --------------------------------------------------------------------------------