added models

app.py

@@ -1,31 +1,12 @@
 import streamlit as st
 
 st.set_page_config(
-    page_title="U-Net Architecture Prototype",
-    page_icon="👋",
+    page_title="One-Class SVM Prototype",
 )
 
-st.title("Enhancing the Performance of SVM and CNN Models in Detection and Classification of Cervical Cells in Pap Smear Images Using U-Net Architecture for Image Segmentation")
-st.write("A prototype for our U-Net Architecture for Image Segmentation of Cervical Cancer Cells, and SVM and CNN for Classification of Cervical Cancer Cells")
-st.write("Thesis Project by Group DJY of Mapua University")
-st.image("pages/Cervical-Cancer-Cells.jpg", caption='', width=700)
+st.title("Implementing Unsupervised SVM for Crowd Panic Detection in Video-Surveillance Scenes using Fused Pose- and Motion-Based Features")
+st.write("A One-Class SVM Prototype for Crowd Panic Detection")
+st.write("Thesis Proof of Concept by Group DGO of Mapua University")
 
 
-st.header("How does this app work? ⚙")
-st.write("""
-Once you upload an image of cervical cancer cells using any of our models,
-they analyze the cell structure and classify the type of cancer present.
-The system will then predict the type of cancer cells based on the analysis.  
-""")
-
-st.subheader("How to use this app? 🤔")
-st.markdown("""
-1. Select U-Net-Model to segment your Cervical Cells image into predicted Cytoplasm and Nuclei Mask.
-2. Download predicted Cytoplasm and Nuclei Mask image from U-Net-Model.
-3. Head to either CNN or SVM Model to classify Cervical Cells image. 
-4. Upload Cervical Cells image, Predicted Cytoplasm image, and Predicted Nuclei image in the model choosen.
-5. Wait for the model to analyze and classify the type of cancer present.
-6. The model will output predicted Cervical Cancer cell type based on the analysis with images of the uploaded images and plotted image of concatenated image of predicted Cytoplasm and Nuclei Mask. 
-""")
-
 st.sidebar.info("Please select a model from above 👆")

pages/Motion-Based_Model.py

@@ -0,0 +1,141 @@
+import streamlit as st
+import joblib
+import numpy as np
+import cv2
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import OneClassSVM
+
+# Streamlit app header
+st.title("Motion-Based One-Class SVM Model")
+
+#==========================IMPORTING MODELS==========================
+
+motion_scaler = joblib.load('pages/motion_scaler.pkl')
+ocsvm_motion = joblib.load('pages/ocsvm_motion.pkl')
+
+#====================================================================
+
+#==========================FUNCTIONS==========================
+
+# Function to extract and calculate motion features from BytesIO object
+def calculate_optical_flow_and_motion_energy(video_bytes):
+    motion_features = []
+
+    # Convert BytesIO to a NumPy array (in-memory video stream)
+    video_bytes.seek(0)
+    video_data = np.asarray(bytearray(video_bytes.read()), dtype=np.uint8)
+
+    # Use cv2.VideoCapture to read from the video data (byte stream)
+    cap = cv2.VideoCapture(cv2.imdecode(video_data, cv2.IMREAD_COLOR))
+
+    # Check if the video opened successfully
+    if not cap.isOpened():
+        raise ValueError("Error opening video file from uploaded bytes.")
+
+    # Read the first frame
+    ret, prev_frame = cap.read()
+    if not ret:
+        raise ValueError("Cannot read the first frame from the video.")
+
+    # Convert the first frame to grayscale
+    prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
+
+    while True:
+        # Read the next frame
+        ret, frame = cap.read()
+        if not ret:
+            break  # Exit if there are no more frames
+
+        # Convert the current frame to grayscale
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+        # Calculate optical flow
+        flow = cv2.calcOpticalFlowFarneback(prev_gray, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+
+        # Calculate magnitude and angle
+        mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
+
+        # Calculate average magnitude, angle, and motion energy
+        avg_mag = np.mean(mag)  # Average magnitude
+        avg_ang = np.mean(ang)  # Average angle
+        motion_energy = np.sum(mag)  # Motion energy
+
+        # Motion Intensity Changes (Velocity and Acceleration)
+        if len(motion_features) >= 2:
+            velocity = avg_mag - motion_features[-1][0]
+            acceleration = velocity - (motion_features[-1][0] - motion_features[-2][0])
+        elif len(motion_features) == 1:
+            velocity = avg_mag - motion_features[0][0]
+            acceleration = 0
+        else:
+            velocity = 0
+            acceleration = 0
+
+        # Flow Coherence
+        flow_coherence = np.mean(np.cos(ang))
+
+        # Store features
+        features = np.array([velocity, avg_mag, flow_coherence])
+        motion_features.append(features)
+
+        # Update previous frame
+        prev_gray = gray
+
+    # Release the video capture object
+    cap.release()
+
+    return np.array(motion_features)
+
+# Function to predict panic from uploaded video and display label
+def predict_uploaded_video(video_uploaded):
+    # Calculate motion features from the uploaded BytesIO object
+    motion_features = calculate_optical_flow_and_motion_energy(video_uploaded)
+    
+    # Scale the features
+    motion_features = motion_scaler.transform(motion_features)
+    
+    # Create a list to store predictions
+    predictions = []
+    
+    # Predict on each set of features
+    for feature in motion_features:
+        prediction = ocsvm_motion.predict([feature])
+        predictions.append(prediction)
+    
+    # Open the video again for display with labels
+    video_uploaded.seek(0)
+    video_data = np.asarray(bytearray(video_uploaded.read()), dtype=np.uint8)
+    cap = cv2.VideoCapture(cv2.imdecode(video_data, cv2.IMREAD_COLOR))
+
+    stframe = st.empty()
+    frame_index = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break  # No more frames
+
+        # Overlay "Panic" label if the prediction is 1 for the current frame
+        if predictions[frame_index] == 1:
+            label = "Panic"
+            cv2.putText(frame, label, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+
+        # Convert the frame from BGR to RGB for display in Streamlit
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+        # Display the frame with the label
+        stframe.image(frame_rgb)
+
+        frame_index += 1
+
+    cap.release()
+
+#====================================================================
+
+#==========================PREDICTING UPLOADED VIDEO==========================
+
+video_mp4_file = st.file_uploader("Upload Video File", type=['mp4'])
+
+if video_mp4_file is not None:
+    predict_uploaded_video(video_mp4_file)
+
+#==============================================================================

pages/motion_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c55b77bbd5def51e02dbe0fcd860160007fa784ad0750df6fc085b93e1d3db9
+size 671

pages/ocsvm_motion.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e09ffc19450daff44e93c70dd934e8e30b42e67d72f7836b524f94c4e334338
+size 3583

pages/svm_prototype.py

@@ -1,6 +0,0 @@
-import streamlit as st
-
-# Streamlit app header
-st.title("Cervical Cancer Cell Classification - SVM Model")
-
-st.sidebar.info("Feel free to select other models from the pages above 🙂")