Update app.py

app.py

@@ -172,135 +172,135 @@ MRI_WINDOW_CENTER = st.sidebar.number_input("MRI Window Center", min_value=WINDO
 MRI_WINDOW_WIDTH = st.sidebar.number_input("MRI Window Width", min_value=WINDOW_WIDTH_MIN, max_value=WINDOW_WIDTH_MAX, value=DEFAULT_MRI_WINDOW_WIDTH, step=1)
 
 uploaded_ct_file = st.file_uploader("Upload a candidate CT DICOM", type=["dcm"])
-if uploaded_ct_file is not None:
-    # Save the uploaded file to a temporary location
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".dcm") as temp_file:
-        temp_file.write(uploaded_ct_file.getvalue())
-
-        # Apply evaluation transforms to the DICOM image for model prediction
-        image_tensor = eval_transforms(temp_file.name).unsqueeze(0).to(device)
-
-        # Predict
-        with torch.no_grad():
-            outputs = ct_model(image_tensor).sigmoid().to("cpu").numpy()
-            prob = outputs[0][0]
-            CLOTS_CLASSIFICATION = False
-            if(prob >= CT_INFERENCE_THRESHOLD):
-                CLOTS_CLASSIFICATION=True
-
-        st.header("CT Classification")
-        st.subheader(f"Ischaemic Stroke : {CLOTS_CLASSIFICATION}")
-        st.subheader(f"Confidence : {prob * 100:.1f}%")
-
-        # Load the original DICOM image for download
-        download_image_tensor = original_transforms(temp_file.name).unsqueeze(0).to(device)
-        download_image = download_image_tensor.squeeze()
-
-        # Transform the download image and apply windowing
-        transformed_download_image = DICOM_Utils.transform_image_for_display(download_image)
-        windowed_download_image = DICOM_Utils.apply_windowing(transformed_download_image, CT_WINDOW_CENTER, CT_WINDOW_WIDTH)
-
-        # Streamlit button to trigger image download
-        image_data = image_to_bytes(Image.fromarray(windowed_download_image))
-        st.download_button(
-            label="Download CT Image",
-            data=image_data,
-            file_name="downloaded_ct_image.png",
-            mime="image/png"
-        )
-
-        # Load the original DICOM image for display
-        display_image_tensor = cam_transforms(temp_file.name).unsqueeze(0).to(device)
-        display_image = display_image_tensor.squeeze()
-
-        # Transform the image and apply windowing
-        transformed_image = DICOM_Utils.transform_image_for_display(display_image)
-        windowed_image = DICOM_Utils.apply_windowing(transformed_image, CT_WINDOW_CENTER, CT_WINDOW_WIDTH)
-        st.image(Image.fromarray(windowed_image), caption="Original CT Visualization", use_column_width=True)
-
-        # Expand to three channels
-        windowed_image = np.expand_dims(windowed_image, axis=2)
-        windowed_image = np.tile(windowed_image, [1, 1, 3])
-
-        # Ensure both are of float32 type
-        windowed_image = windowed_image.astype(np.float32)
-
-        # Normalize to [0, 1] range
-        windowed_image = np.float32(windowed_image) / 255
-
-        # Build the CAM (Class Activation Map)
-        target_layers = [ct_model.model.norm]
-        cam = GradCAM(model=ct_model, target_layers=target_layers, reshape_transform=reshape_transform, use_cuda=True)
-        grayscale_cam = cam(input_tensor=image_tensor, targets=[ClassifierOutputTarget(CAM_CLASS_ID)])
-        grayscale_cam = grayscale_cam[0, :]
-
-        # Now you can safely call the show_cam_on_image function
-        visualization = show_cam_on_image(windowed_image, grayscale_cam, use_rgb=True)
-        st.image(Image.fromarray(visualization), caption="CAM CT Visualization", use_column_width=True)
-
-uploaded_mri_file = st.file_uploader("Upload a candidate MRI DICOM", type=["dcm"])
-if uploaded_mri_file is not None:
-    # Save the uploaded file to a temporary location
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".dcm") as temp_file:
-        temp_file.write(uploaded_mri_file.getvalue())
-
-        # Apply evaluation transforms to the DICOM image for model prediction
-        image_tensor = eval_transforms(temp_file.name).unsqueeze(0).to(device)
-
-        # Predict
-        with torch.no_grad():
-            outputs = mri_model(image_tensor).sigmoid().to("cpu").numpy()
-            prob = outputs[0][0]
-            CLOTS_CLASSIFICATION = False
-            if(prob >= MRI_INFERENCE_THRESHOLD):
-                CLOTS_CLASSIFICATION=True
-
-        st.header("MRI Classification")
-        st.subheader(f"Ischaemic Stroke : {CLOTS_CLASSIFICATION}")
-        st.subheader(f"Confidence : {prob * 100:.1f}%")
-
-        # Load the original DICOM image for download
-        download_image_tensor = original_transforms(temp_file.name).unsqueeze(0).to(device)
-        download_image = download_image_tensor.squeeze()
-
-        # Transform the download image and apply windowing
-        transformed_download_image = DICOM_Utils.transform_image_for_display(download_image)
-        windowed_download_image = DICOM_Utils.apply_windowing(transformed_download_image, MRI_WINDOW_CENTER, MRI_WINDOW_WIDTH)
-
-        # Streamlit button to trigger image download
-        image_data = image_to_bytes(Image.fromarray(windowed_download_image))
-        st.download_button(
-            label="Download MRI Image",
-            data=image_data,
-            file_name="downloaded_mri_image.png",
-            mime="image/png"
-        )
-
-        # Load the original DICOM image for display
-        display_image_tensor = cam_transforms(temp_file.name).unsqueeze(0).to(device)
-        display_image = display_image_tensor.squeeze()
-
-        # Transform the image and apply windowing
-        transformed_image = DICOM_Utils.transform_image_for_display(display_image)
-        windowed_image = DICOM_Utils.apply_windowing(transformed_image, MRI_WINDOW_CENTER, MRI_WINDOW_WIDTH)
-        st.image(Image.fromarray(windowed_image), caption="Original MRI Visualization", use_column_width=True)
-
-        # Expand to three channels
-        windowed_image = np.expand_dims(windowed_image, axis=2)
-        windowed_image = np.tile(windowed_image, [1, 1, 3])
-
-        # Ensure both are of float32 type
-        windowed_image = windowed_image.astype(np.float32)
-
-        # Normalize to [0, 1] range
-        windowed_image = np.float32(windowed_image) / 255
-
-        # Build the CAM (Class Activation Map)
-        target_layers = [mri_model.model.norm]
-        cam = GradCAM(model=mri_model, target_layers=target_layers, reshape_transform=reshape_transform, use_cuda=True)
-        grayscale_cam = cam(input_tensor=image_tensor, targets=[ClassifierOutputTarget(CAM_CLASS_ID)])
-        grayscale_cam = grayscale_cam[0, :]
-
-        # Now you can safely call the show_cam_on_image function
-        visualization = show_cam_on_image(windowed_image, grayscale_cam, use_rgb=True)
-        st.image(Image.fromarray(visualization), caption="CAM MRI Visualization", use_column_width=True)
+# if uploaded_ct_file is not None:
+#     # Save the uploaded file to a temporary location
+#     with tempfile.NamedTemporaryFile(delete=False, suffix=".dcm") as temp_file:
+#         temp_file.write(uploaded_ct_file.getvalue())
+
+#         # Apply evaluation transforms to the DICOM image for model prediction
+#         image_tensor = eval_transforms(temp_file.name).unsqueeze(0).to(device)
+
+#         # Predict
+#         with torch.no_grad():
+#             outputs = ct_model(image_tensor).sigmoid().to("cpu").numpy()
+#             prob = outputs[0][0]
+#             CLOTS_CLASSIFICATION = False
+#             if(prob >= CT_INFERENCE_THRESHOLD):
+#                 CLOTS_CLASSIFICATION=True
+
+#         st.header("CT Classification")
+#         st.subheader(f"Ischaemic Stroke : {CLOTS_CLASSIFICATION}")
+#         st.subheader(f"Confidence : {prob * 100:.1f}%")
+
+#         # Load the original DICOM image for download
+#         download_image_tensor = original_transforms(temp_file.name).unsqueeze(0).to(device)
+#         download_image = download_image_tensor.squeeze()
+
+#         # Transform the download image and apply windowing
+#         transformed_download_image = DICOM_Utils.transform_image_for_display(download_image)
+#         windowed_download_image = DICOM_Utils.apply_windowing(transformed_download_image, CT_WINDOW_CENTER, CT_WINDOW_WIDTH)
+
+#         # Streamlit button to trigger image download
+#         image_data = image_to_bytes(Image.fromarray(windowed_download_image))
+#         st.download_button(
+#             label="Download CT Image",
+#             data=image_data,
+#             file_name="downloaded_ct_image.png",
+#             mime="image/png"
+#         )
+
+#         # Load the original DICOM image for display
+#         display_image_tensor = cam_transforms(temp_file.name).unsqueeze(0).to(device)
+#         display_image = display_image_tensor.squeeze()
+
+#         # Transform the image and apply windowing
+#         transformed_image = DICOM_Utils.transform_image_for_display(display_image)
+#         windowed_image = DICOM_Utils.apply_windowing(transformed_image, CT_WINDOW_CENTER, CT_WINDOW_WIDTH)
+#         st.image(Image.fromarray(windowed_image), caption="Original CT Visualization", use_column_width=True)
+
+#         # Expand to three channels
+#         windowed_image = np.expand_dims(windowed_image, axis=2)
+#         windowed_image = np.tile(windowed_image, [1, 1, 3])
+
+#         # Ensure both are of float32 type
+#         windowed_image = windowed_image.astype(np.float32)
+
+#         # Normalize to [0, 1] range
+#         windowed_image = np.float32(windowed_image) / 255
+
+#         # Build the CAM (Class Activation Map)
+#         target_layers = [ct_model.model.norm]
+#         cam = GradCAM(model=ct_model, target_layers=target_layers, reshape_transform=reshape_transform, use_cuda=True)
+#         grayscale_cam = cam(input_tensor=image_tensor, targets=[ClassifierOutputTarget(CAM_CLASS_ID)])
+#         grayscale_cam = grayscale_cam[0, :]
+
+#         # Now you can safely call the show_cam_on_image function
+#         visualization = show_cam_on_image(windowed_image, grayscale_cam, use_rgb=True)
+#         st.image(Image.fromarray(visualization), caption="CAM CT Visualization", use_column_width=True)
+
+# uploaded_mri_file = st.file_uploader("Upload a candidate MRI DICOM", type=["dcm"])
+# if uploaded_mri_file is not None:
+#     # Save the uploaded file to a temporary location
+#     with tempfile.NamedTemporaryFile(delete=False, suffix=".dcm") as temp_file:
+#         temp_file.write(uploaded_mri_file.getvalue())
+
+#         # Apply evaluation transforms to the DICOM image for model prediction
+#         image_tensor = eval_transforms(temp_file.name).unsqueeze(0).to(device)
+
+#         # Predict
+#         with torch.no_grad():
+#             outputs = mri_model(image_tensor).sigmoid().to("cpu").numpy()
+#             prob = outputs[0][0]
+#             CLOTS_CLASSIFICATION = False
+#             if(prob >= MRI_INFERENCE_THRESHOLD):
+#                 CLOTS_CLASSIFICATION=True
+
+#         st.header("MRI Classification")
+#         st.subheader(f"Ischaemic Stroke : {CLOTS_CLASSIFICATION}")
+#         st.subheader(f"Confidence : {prob * 100:.1f}%")
+
+#         # Load the original DICOM image for download
+#         download_image_tensor = original_transforms(temp_file.name).unsqueeze(0).to(device)
+#         download_image = download_image_tensor.squeeze()
+
+#         # Transform the download image and apply windowing
+#         transformed_download_image = DICOM_Utils.transform_image_for_display(download_image)
+#         windowed_download_image = DICOM_Utils.apply_windowing(transformed_download_image, MRI_WINDOW_CENTER, MRI_WINDOW_WIDTH)
+
+#         # Streamlit button to trigger image download
+#         image_data = image_to_bytes(Image.fromarray(windowed_download_image))
+#         st.download_button(
+#             label="Download MRI Image",
+#             data=image_data,
+#             file_name="downloaded_mri_image.png",
+#             mime="image/png"
+#         )
+
+#         # Load the original DICOM image for display
+#         display_image_tensor = cam_transforms(temp_file.name).unsqueeze(0).to(device)
+#         display_image = display_image_tensor.squeeze()
+
+#         # Transform the image and apply windowing
+#         transformed_image = DICOM_Utils.transform_image_for_display(display_image)
+#         windowed_image = DICOM_Utils.apply_windowing(transformed_image, MRI_WINDOW_CENTER, MRI_WINDOW_WIDTH)
+#         st.image(Image.fromarray(windowed_image), caption="Original MRI Visualization", use_column_width=True)
+
+#         # Expand to three channels
+#         windowed_image = np.expand_dims(windowed_image, axis=2)
+#         windowed_image = np.tile(windowed_image, [1, 1, 3])
+
+#         # Ensure both are of float32 type
+#         windowed_image = windowed_image.astype(np.float32)
+
+#         # Normalize to [0, 1] range
+#         windowed_image = np.float32(windowed_image) / 255
+
+#         # Build the CAM (Class Activation Map)
+#         target_layers = [mri_model.model.norm]
+#         cam = GradCAM(model=mri_model, target_layers=target_layers, reshape_transform=reshape_transform, use_cuda=True)
+#         grayscale_cam = cam(input_tensor=image_tensor, targets=[ClassifierOutputTarget(CAM_CLASS_ID)])
+#         grayscale_cam = grayscale_cam[0, :]
+
+#         # Now you can safely call the show_cam_on_image function
+#         visualization = show_cam_on_image(windowed_image, grayscale_cam, use_rgb=True)
+#         st.image(Image.fromarray(visualization), caption="CAM MRI Visualization", use_column_width=True)