allow user to pick any of the 28 radiomics features

filter_data_app.py

@@ -14,7 +14,7 @@ st.set_page_config(layout="wide")
 LOCAL_PARQUET_FILE = 'qual-checks-and-quant-values.parquet'
 
 @st.cache_data
-def load_data():
+def load_data(radiomics_feature='Volume from Voxel Summation'):
     cols = [
         'PatientID',
         'StudyInstanceUID',
@@ -25,7 +25,7 @@ def load_data():
         'laterality_check',
         'series_with_vertabra_on_every_slice',
         'connected_volumes',
-        'Volume from Voxel Summation'
+        radiomics_feature  # Include the selected radiomics feature column
     ]
     df = pl.read_parquet(LOCAL_PARQUET_FILE, columns=cols)
     df = df.with_columns([
@@ -39,11 +39,15 @@ def load_data():
 # Function to filter data based on user input
 def filter_data(df, filters):
     for col, value in filters.items():
-        if value is not None:
+        if value is not None and col != 'radiomics_feature':  # Exclude radiomics_feature from filtering
             if col == 'connected_volumes' and value:
                 df = df.filter((pl.col(col) <= value) & (pl.col(col).is_not_null()))
             else:
                 df = df.filter(pl.col(col) == value)
+    # Filter based on radiomics feature
+    radiomics_feature = filters.get('radiomics_feature')
+    if radiomics_feature:
+        df = df.filter(pl.col(radiomics_feature) is not None)  # Filter where the radiomics feature is not None
     return df
 
 # Function to create an UpSet plot for failed checks
@@ -75,10 +79,10 @@ def create_upset_plot_passes(df):
     st.pyplot(fig)
 
 # Function to calculate standard deviation of volumes within a patient
-def calculate_std_dev(df):
+def calculate_std_dev(df,radiomics_feature):
     df=df.to_pandas()
     # Group by 'PatientID' and calculate the standard deviation of 'Volume from Voxel Summation'
-    std_dev_df = df.groupby(['PatientID','bodyPart'])['Volume from Voxel Summation'].std()
+    std_dev_df = df.groupby(['PatientID','bodyPart'])[radiomics_feature].std()
     return std_dev_df
 
 # Main function to run the Streamlit app
@@ -90,7 +94,7 @@ def main():
     page = st.sidebar.selectbox("Choose a page", ["Summary", "UpSet Plots"])
 
     # Load the data
-    df = load_data()
+    #df = load_data()
 
     if page == "UpSet Plots":
         with st.sidebar:
@@ -104,7 +108,8 @@ def main():
                     'laterality_check': None,
                     'series_with_vertabra_on_every_slice': None,
                     'connected_volumes': None,
-                    'laterality': None
+                    'laterality': None,
+                    'radiomics_feature': 'Volume from Voxel Summation'  # Default radiomics feature
                 }
 
             filters = st.session_state.filters
@@ -116,7 +121,8 @@ def main():
                     'laterality_check': None,
                     'series_with_vertabra_on_every_slice': None,
                     'connected_volumes': None,
-                    'laterality': None
+                    'laterality': None,
+                    'radiomics_feature': 'Volume from Voxel Summation' 
                 })
                 st.session_state.filters = filters
 
@@ -124,6 +130,49 @@ def main():
                 filters[filter_name] = value
                 st.session_state.filters = filters
 
+            
+            # Radiomics feature selection
+            radiomics_feature_options = [
+                'Volume from Voxel Summation',  # Default option
+                '10th percentile',
+                '90th percentile',
+                'Elongation',
+                'Energy',
+                'Flatness',
+                'Intensity Histogram Entropy',
+                'Intensity histogram uniformity',
+                'Interquartile range',
+                'Kurtosis',
+                'Least Axis in 3D Length',
+                'Major Axis in 3D Length',
+                'Maximum 3D Diameter of a Mesh',
+                'Maximum grey level',
+                'Mean',
+                'Mean absolute deviation',
+                'Median',
+                'Minimum grey level',
+                'Minor Axis in 3D Length',
+                'Range',
+                'Robust mean absolute deviation',
+                'Root mean square',
+                'Skewness',
+                'Sphericity',
+                'Surface Area of Mesh',
+                'Surface to Volume Ratio',
+                'Variance',
+                'Volume from Voxel Summation',
+                'Volume of Mesh'
+            ]
+            radiomics_feature = st.selectbox(
+                "Radiomics Feature",
+                options=radiomics_feature_options,
+                index=radiomics_feature_options.index(filters['radiomics_feature']) if filters['radiomics_feature'] else 0,
+                key='radiomics_feature',
+                on_change=lambda: apply_filter('radiomics_feature', st.session_state.radiomics_feature)
+            )
+            df = load_data(radiomics_feature=radiomics_feature)
+            filters['radiomics_feature'] = radiomics_feature
+
             # Body part filter
             body_part_options = sorted(df['bodyPart'].unique().to_list())
             body_part = st.selectbox("Body Part", options=body_part_options, key='bodyPart', on_change=reset_filters)
@@ -173,13 +222,6 @@ def main():
                 on_change=lambda: apply_filter('series_with_vertabra_on_every_slice', st.session_state.series_with_vertabra_on_every_slice)
             )
 
-            # connected_volumes = st.selectbox(
-            #     "Connected Volumes (<= value)",
-            #     options=connected_volumes_options,
-            #     index=connected_volumes_options.index(filters['connected_volumes']) if filters['connected_volumes'] else 0,
-            #     key='connected_volumes',
-            #     on_change=lambda: apply_filter('connected_volumes', st.session_state.connected_volumes)
-            # )
             connected_volumes = st.selectbox(
                 "Connected Volumes (<= value)",
                 options=[None] + connected_volumes_options,
@@ -258,14 +300,14 @@ def main():
         import pandas as pd
 
         # Assuming calculate_std_dev returns a Series
-        std_dev_before_filtering = calculate_std_dev(body_part_df)
-        std_dev_after_filtering = calculate_std_dev(filtered_df)
+        std_dev_before_filtering = calculate_std_dev(body_part_df, radiomics_feature)
+        std_dev_after_filtering = calculate_std_dev(filtered_df, radiomics_feature)
 
         # Convert Series to DataFrame and add 'Filtering' column
-        std_dev_before_filtering = std_dev_before_filtering.reset_index().rename(columns={0: 'Volume from Voxel Summation'})
+        std_dev_before_filtering = std_dev_before_filtering.reset_index().rename(columns={0: radiomics_feature})
         std_dev_before_filtering['Filtering'] = 'Before Filtering'
 
-        std_dev_after_filtering = std_dev_after_filtering.reset_index().rename(columns={0: 'Volume from Voxel Summation'})
+        std_dev_after_filtering = std_dev_after_filtering.reset_index().rename(columns={0: radiomics_feature})
         std_dev_after_filtering['Filtering'] = 'After Filtering'
 
         # Combine the dataframes for easier plotting
@@ -278,9 +320,11 @@ def main():
         st.header("Violin Plots for Standard Deviation of Volumes")
         st.write("This plot shows the distribution of standard deviation of volumes within a patient.")
         fig2, ax = plt.subplots()
-        sns.violinplot(x='Filtering', y='Volume from Voxel Summation', data=combined_df, ax=ax)
+        sns.violinplot(x='Filtering', y=radiomics_feature, data=combined_df, ax=ax)
         ax.set_ylabel("Standard Deviation of Volumes")
         st.pyplot(fig2)
+        body_part_df
+        filtered_df
         
 
     # Define the pages