Resolve merge conflict: keep dvh_method and bound_type in DVH table

Author: sijiaww

.gitignore

@@ -56,3 +56,4 @@ docs/_build/
 /results/
 /metadata/
 /examples/hugging_face_data/
+.DS_Store

portpy/__init__.py

@@ -15,6 +15,6 @@
 # a separate commercial license.
 # ----------------------------------------------------------------------
 
-__version__ = "1.1.2"
+__version__ = "1.1.3"
 # Change version here manually to reflect it everywhere
 from portpy import photon

portpy/photon/clinical_criteria.py

@@ -140,34 +140,38 @@ def get_criteria(self, type: str = None) -> List[dict]:
         return all_criteria
 
     def check_criterion_exists(self, criterion, return_ind:bool = False):
-        criterion_exist = False
-        criterion_ind = None
-        for ind, crit in enumerate(self.clinical_criteria_dict['criteria']):
-            if (crit['type'] == criterion['type']) and crit['parameters'] == criterion['parameters']:
-                for constraint in crit['constraints']:
-                    if constraint == criterion['constraints']:
-                        criterion_exist = True
-                        criterion_ind = ind
-        if return_ind:
-            return criterion_exist,criterion_ind
-        else:
-            return criterion_exist
+            criterion_exist = False
+            criterion_ind = None
+            for ind, crit in enumerate(self.clinical_criteria_dict['criteria']):
+                if (crit['type'] == criterion['type']) and crit['parameters'] == criterion['parameters']:
+                    for constraint in crit['constraints']:
+                        for key, _ in criterion['constraints'].items():
+                            if constraint == key:
+                                criterion_exist = True
+                                criterion_ind = ind
+            if return_ind:
+                return criterion_exist,criterion_ind
+            else:
+                return criterion_exist
 
     def modify_criterion(self, criterion):
         """
-        Modify the criterion the clinical criteria
-
-
+        Update constraints for an existing criterion.
+        Only updates keys that already exist in the original constraint dict.
         """
-        criterion_found = False
         for ind, crit in enumerate(self.clinical_criteria_dict['criteria']):
-            if (crit['type'] == criterion['type']) and crit['parameters'] == criterion['parameters']:
-                for constraint in crit['constraints']:
-                    if constraint == criterion['constraints']:
-                        self.clinical_criteria_dict['criteria'][ind]['constraints'][constraint] = criterion['constraints']
-                        criterion_found = True
-        if not criterion_found:
-            raise Warning('No criteria  for {}'.format(criterion))
+
+            if crit['type'] == criterion['type'] and crit['parameters'] == criterion['parameters']:
+                existing_keys = crit['constraints']
+                updated = False
+                for key, value in criterion.get('constraints', {}).items():
+                    if key in existing_keys:
+                        existing_keys[key] = value
+                        updated = True
+                if updated:
+                    return
+
+        raise Warning(f"No criteria found for {criterion}")
 
 
     def get_num(self, string: Union[str, float]):
@@ -279,6 +283,7 @@ def get_dvh_table(self, my_plan: Plan, constraint_list: list = None, opt_params:
                     df.at[count, 'volume_perc'] = dvh_updated_list[i]['constraints'][limit_key]
                     df.at[count, 'dvh_type'] = 'constraint'
                     df.at[count, 'dvh_method'] = dvh_method
+                    df.at[count, 'bound_type'] = dvh_updated_list[i]['constraints'].get('bound_type', 'upper')
                     count = count + 1
                 goal_key = self.matching_keys(dvh_updated_list[i]['constraints'], 'goal')
                 if goal_key in dvh_updated_list[i]['constraints']:
@@ -288,6 +293,7 @@ def get_dvh_table(self, my_plan: Plan, constraint_list: list = None, opt_params:
                     df.at[count, 'dvh_type'] = 'goal'
                     df.at[count, 'dvh_method'] = dvh_method
                     df.at[count, 'weight'] = dvh_updated_list[i]['parameters']['weight']
+                    df.at[count, 'bound_type'] = dvh_updated_list[i]['constraints'].get('bound_type', 'upper')
                     count = count + 1
             if 'dose_volume_D' in dvh_updated_list[i]['type']:
                 limit_key = self.matching_keys(dvh_updated_list[i]['constraints'], 'limit')
@@ -297,6 +303,7 @@ def get_dvh_table(self, my_plan: Plan, constraint_list: list = None, opt_params:
                     df.at[count, 'dose_gy'] = self.dose_to_gy(limit_key, dvh_updated_list[i]['constraints'][limit_key])
                     df.at[count, 'dvh_method'] = dvh_method
                     df.at[count, 'dvh_type'] = 'constraint'
+                    df.at[count, 'bound_type'] = dvh_updated_list[i]['constraints'].get('bound_type', 'upper')
                     count = count + 1
                 goal_key = self.matching_keys(dvh_updated_list[i]['constraints'], 'goal')
                 if goal_key in dvh_updated_list[i]['constraints']:
@@ -306,14 +313,15 @@ def get_dvh_table(self, my_plan: Plan, constraint_list: list = None, opt_params:
                     df.at[count, 'dvh_method'] = dvh_method
                     df.at[count, 'dvh_type'] = 'goal'
                     df.at[count, 'weight'] = dvh_updated_list[i]['parameters']['weight']
+                    df.at[count, 'bound_type'] = dvh_updated_list[i]['constraints'].get('bound_type', 'upper')
                     count = count + 1
         self.dvh_table = df
         self.get_max_tol(constraints_list=constraint_list)
         self.filter_dvh(my_plan=my_plan)
         return self.dvh_table
 
 
-    def get_low_dose_vox_ind(self, my_plan: Plan, dose: np.ndarray, inf_matrix: InfluenceMatrix):
+    def get_low_dose_vox_ind(self, my_plan: Plan, dose: np.ndarray, inf_matrix: InfluenceMatrix = None):
         """
         Identifies and stores the indices of low-dose voxels for each DVH constraint or goal.
 
@@ -342,15 +350,25 @@ def get_low_dose_vox_ind(self, my_plan: Plan, dose: np.ndarray, inf_matrix: Infl
             volume percentage.
         """
         dvh_table = self.dvh_table
-        inf_matrix = my_plan.inf_matrix
+        if inf_matrix is None:
+            inf_matrix = my_plan.inf_matrix
         for ind in dvh_table.index:
             structure_name, dose_gy, vol_perc = dvh_table['structure_name'][ind], dvh_table['dose_gy'][ind], \
             dvh_table['volume_perc'][ind]
             dvh_type = dvh_table['dvh_type'][ind]
+            bound_type = dvh_table.at[ind, 'bound_type'] if 'bound_type' in dvh_table.columns else 'upper'
             vol_perc = vol_perc / inf_matrix.get_fraction_of_vol_in_calc_box(structure_name)
             struct_vox = inf_matrix.get_opt_voxels_idx(structure_name)
             n_struct_vox = len(struct_vox)
-            sort_ind = np.argsort(dose[struct_vox])
+            # sort_ind = np.argsort(dose[struct_vox])
+            if bound_type == 'lower':
+                # For lower bound (e.g., PTV coverage), pick HIGHEST-dose voxels up to p%
+                sort_ind = np.argsort(-dose[struct_vox])  # descending
+                target_perc = vol_perc  # accumulate to p%
+            else:
+                # Original behavior (upper bound): pick LOWEST-dose voxels up to (100 - p)%
+                sort_ind = np.argsort(dose[struct_vox])  # ascending
+                target_perc = 100 - vol_perc  # accumulate to (100 - p)%
             voxel_sort = struct_vox[sort_ind]
             weights = inf_matrix.get_opt_voxels_volume_cc(structure_name)
             weights_sort = weights[sort_ind]
@@ -360,7 +378,7 @@ def get_low_dose_vox_ind(self, my_plan: Plan, dose: np.ndarray, inf_matrix: Infl
                 for w_ind in range(n_struct_vox):
                     w_sum = w_sum + weights_sort[w_ind]
                     w_ratio = w_sum / weight_all_sum
-                    if w_ratio * 100 >= (100 - vol_perc):
+                    if w_ratio * 100 >= target_perc:
                         break
                 low_dose_voxels = voxel_sort[:w_ind+1]
                 if ind == 0:

portpy/photon/data_explorer.py

@@ -593,8 +593,8 @@ def _load_structure_metadata(self, patient_id: str, temp_download_dir: Optional[
                 repo_id=self.hf_repo_id,
                 repo_type="dataset",
                 filename=hf_path,
-                local_dir=temp_download_dir,
-                use_auth_token=self.hf_token
+                local_dir=temp_download_dir
+                # use_auth_token=self.hf_token
             )
             with open(local_file) as f:
                 return json.load(f)
@@ -634,8 +634,8 @@ def _load_beam_metadata(self, patient_id: str, temp_download_dir: Optional[str]
                     self.hf_repo_id,
                     repo_type="dataset",
                     filename=path,
-                    local_dir=temp_download_dir,
-                    use_auth_token=self.hf_token
+                    local_dir=temp_download_dir
+                    # use_auth_token=self.hf_token
                 )
                 with open(local_file) as f:
                     beam_meta.append(json.load(f))
@@ -666,8 +666,8 @@ def _load_planner_beams(self, patient_id: str, temp_download_dir: Optional[str]
                 self.hf_repo_id,
                 repo_type="dataset",
                 filename=hf_path,
-                local_dir=temp_download_dir,
-                use_auth_token=self.hf_token
+                local_dir=temp_download_dir
+                # use_auth_token=self.hf_token
             )
             with open(local_file) as f:
                 return json.load(f).get("IDs", [])

portpy/photon/vmat_scp/vmat_scp_optimization.py

@@ -1178,7 +1178,7 @@ def create_cvxpy_intermediate_problem_prediction(self, pred_dose_1d, final_dose_
             + cp.multiply(bound_v_r, card_bound_inds_r)]
         # generic constraints for relation between interior and boundary beamlets
         constraints += [leaf_pos_mu_r - leaf_pos_mu_l >= int_v[map_int_v]]
-        constraints += [int_v >= self.vmat_params['mu_min']]
+        constraints += [int_v*100 >= self.vmat_params['mu_min']] # multiply it by 100 to match eclipse mu
         constraints += [bound_v_l <= int_v[map_int_v]]
         constraints += [bound_v_r <= int_v[map_int_v]]
         if 'minimum_dynamic_leaf_gap_mm' in self.vmat_params: