add some more weights

Author: muntasir-islam

app.py

@@ -4,15 +4,16 @@
 import pandas as pd
 import plotly.express as px
 from backend import ModalXSystem
-from emotion_engine import EmotionAnalyzer
 
+# --- PAGE CONFIG ---
 st.set_page_config(
     page_title="DIU Presentation Grader",
     page_icon="🎓",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
+# --- CSS STYLING ---
 st.markdown("""
     <style>
     .stApp { background-color: #0E1117; color: #FAFAFA; }
@@ -49,11 +50,6 @@
         color: white;
         border: 1px solid #444;
     }
-    [data-testid="stSidebar"] {
-        background-color: #12151e;
-        border-right: 1px solid #333;
-    }
-
     div.stDownloadButton > button {
         background: linear-gradient(90deg, #198754, #20c997);
         color: white !important;
@@ -63,27 +59,13 @@
         font-size: 16px;
         font-weight: bold;
         border-radius: 8px;
-        box-shadow: 0 4px 12px rgba(32, 201, 151, 0.4);
-        transition: transform 0.2s;
-    }
-    div.stDownloadButton > button:hover {
-        transform: scale(1.02);
-    }
-    
-    .stStatusWidget {
-        background-color: #1E2130;
-        border: 1px solid #444;
-        border-radius: 10px;
     }
     </style>
 """, unsafe_allow_html=True)
 
 st.markdown('<div class="main-header"><h1>🎓 DIU Smart Faculty Grader</h1><p>AI-Powered Multi-Modal Presentation Assessment</p></div>', unsafe_allow_html=True)
 
-@st.cache_resource
-def load_emotion_engine():
-    return EmotionAnalyzer()
-
+# --- SIDEBAR ---
 with st.sidebar:
     st.header("📋 Student Details")
     s_name = st.text_input("Student Name", placeholder="e.g. Muntasir Islam")
@@ -115,22 +97,18 @@ def load_emotion_engine():
 
     st.markdown("---")
     analyze_btn = st.button("🚀 Start Analysis", type="primary", use_container_width=True)
-    st.caption("Powered by ModalX Engine v2.1")
+    st.caption("Powered by ModalX Engine v3.0")
 
+# --- MAIN LOGIC ---
 if analyze_btn:
     if not video_path or not s_name:
         st.error("⚠️ Please enter Student Name and Provide a Video first.")
     else:
+        # Initialize Backend
         if 'modalx' not in st.session_state:
             with st.spinner("⚡ Booting AI Engine..."):
                 st.session_state.modalx = ModalXSystem()
 
-        try:
-            emotion_engine = load_emotion_engine()
-        except Exception as e:
-            st.error(f"Could not load Emotion Model: {e}")
-            st.stop()
-
         proc_col1, proc_col2 = st.columns([1, 1])
 
         with proc_col1:
@@ -142,46 +120,34 @@ def load_emotion_engine():
                 st.video(video_path)
 
         results = None
-        emotion_results = None
 
         with proc_col2:
             with st.status("🚀 ModalX Engine Running...", expanded=True) as status:
                 st.write("🔄 Initializing Neural Networks...")
                 time.sleep(1)
 
-                st.write("🧠 Running General Assessment (Whisper + CV)...")
+                st.write("🧠 Extracting Audio & Transcribing (Whisper)...")
+                st.write("👁️ Scanning Facial Landmarks (MediaPipe)...")
+                st.write("🎭 Analyzing Micro-Expressions & Tone (CNN)...")
+                st.write("📝 Evaluating Content Impact & Vocabulary...")
+                
                 try:
+                    # The backend now handles EVERYTHING (Audio, Visual, Emotion, Content)
                     results = st.session_state.modalx.analyze(video_path, s_name, s_id, is_url)
-                except Exception as e:
-                    st.error(f"General Engine Error: {e}")
-                
-                if video_path and os.path.exists(video_path) and not is_url:
-                    st.write("🎭 Analyzing Emotional Tones (CNN-1D)...")
-                    try:
-                        e_times, e_emotions, e_summary = emotion_engine.predict(video_path)
-                        emotion_results = {
-                            "times": e_times, 
-                            "emotions": e_emotions, 
-                            "summary": e_summary
-                        }
-                    except Exception as e:
-                        st.warning(f"Emotion Analysis skipped: {e}")
-                elif is_url:
-                    st.warning("⚠️ Emotion Graph unavailable for external URLs (Download required)")
-                
-                if results:
                     status.update(label="✅ Analysis Complete!", state="complete", expanded=False)
-                else:
+                except Exception as e:
+                    st.error(f"Engine Error: {e}")
                     status.update(label="❌ Analysis Failed", state="error")
 
+        # --- RESULTS DASHBOARD ---
         if results:
             st.divider()
             st.balloons()
 
             score = results['score']
 
-            grade = "F"
-            grade_bg = "#dc3545"
+            # Grade Logic
+            grade = "F"; grade_bg = "#dc3545"
             if score >= 80: grade, grade_bg = "A+", "#198754"
             elif score >= 75: grade, grade_bg = "A", "#20c997"
             elif score >= 70: grade, grade_bg = "A-", "#0dcaf0"
@@ -192,7 +158,7 @@ def load_emotion_engine():
             c1, c2, c3 = st.columns([1.5, 1.5, 3])
 
             with c1:
-                st.metric("Final Score", f"{score}/100", delta=f"{score-70} vs Avg")
+                st.metric("Final Weighted Score", f"{score}/100", delta=f"{score-70} vs Avg")
 
             with c2:
                 st.markdown(f"""
@@ -205,115 +171,104 @@ def load_emotion_engine():
             with c3:
                 st.markdown(f"### 👤 {s_name}")
                 st.caption(f"Student ID: {s_id}")
-                st.info("Grading Logic: Weighted average of Speech Clarity (60%) and Visual Engagement (40%).")
+                st.info("Grading Logic: Audio (30%), Visual (30%), Emotion (20%), Content (20%)")
 
             st.divider()
 
-            tab1, tab2, tab3 = st.tabs(["📊 Performance Metrics", "🎭 Emotional Intelligence", "📝 Transcript & Feedback"])
+            # --- TABS ---
+            tab1, tab2, tab3 = st.tabs(["📊 Performance Metrics", "🎭 Emotional Intelligence", "📝 Content & Report"])
 
+            # TAB 1: CORE METRICS
             with tab1:
                 col_a, col_b = st.columns(2)
 
                 with col_a:
                     st.subheader("🗣️ Audio Intelligence")
                     audio = results['metrics']['audio']
-                    
                     st.write(f"**Speaking Pace** ({audio['wpm']} WPM)")
                     st.progress(float(min(audio['wpm']/160, 1.0)))
-                    
-                    st.write(f"**Tonal Variation** (Score: {audio['physics']['pitch_variation']})")
+                    st.write(f"**Pitch Variation** ({audio['physics']['pitch_variation']})")
                     st.progress(float(min(audio['physics']['pitch_variation']/50, 1.0)))
-                    
-                    st.write(f"**Confidence (Volume)** (Score: {audio['physics']['volume_score']})")
-                    st.progress(float(min(audio['physics']['volume_score']/100, 1.0)))
-                    
-                    if audio['filler_count'] > 3:
-                        st.warning(f"⚠️ High Filler Words Detected: {audio['filler_count']}")
-                    else:
-                        st.success(f"✅ Low Filler Words: {audio['filler_count']}")
+                    st.metric("Pause Ratio", f"{audio['physics']['pause_ratio']}%")
 
                 with col_b:
                     visual = results['metrics']['visual']
-                    
                     if visual.get('is_slide_mode', False):
                         st.subheader("🖼️ Slide Design AI")
-                        st.info("Scanner Mode: Slide Presentation")
+                        st.info("Mode: Slide Presentation")
                         slides = results['metrics']['slides']
-                        
                         st.metric("Word Density", f"{slides['avg_words_per_slide']} words/slide")
-                        st.write("**Readability Score**")
-                        st.progress(float(min(slides['readability_score']/100, 1.0)))
-                        st.write(f"**Slide Transitions Detected:** {slides['slide_changes']}")
+                        st.metric("Slide Readability", f"{int(slides['readability_score'])}/100")
                     else:
                         st.subheader("👁️ Behavioral AI")
-                        st.info("Scanner Mode: Presenter Face")
-                        
-                        st.write(f"**Eye Contact Consistency** ({visual['eye_contact_score']}%)")
+                        st.info("Mode: Face Presentation")
+                        st.write(f"**Eye Contact** ({visual['eye_contact_score']}%)")
                         st.progress(float(visual['eye_contact_score']/100))
-                        
                         st.write(f"**Posture Stability** ({visual['posture_score']}%)")
                         st.progress(float(visual['posture_score']/100))
 
+            # TAB 2: EMOTION ANALYZER
             with tab2:
-                if emotion_results and emotion_results['times']:
+                emo_data = results.get('emotion_data', {})
+                if emo_data and emo_data.get('times'):
                     st.subheader("📈 Emotional Flow Over Time")
 
-                    e_times = emotion_results['times']
-                    e_emotions = emotion_results['emotions']
-                    e_summary = emotion_results['summary']
+                    e_times = emo_data['times']
+                    e_emotions = emo_data['emotions']
+                    e_summary = emo_data['summary']
 
+                    # Timeline Graph
                     df = pd.DataFrame({"Time (s)": e_times, "Emotion": e_emotions})
                     emotion_order = sorted(list(set(e_emotions)))
 
                     fig = px.scatter(
                         df, x="Time (s)", y="Emotion", color="Emotion",
                         size=[15]*len(df), template="plotly_dark",
-                        category_orders={"Emotion": emotion_order},
-                        title="Speaker Emotion Timeline"
+                        category_orders={"Emotion": emotion_order}
                     )
                     fig.update_traces(mode='lines+markers', line=dict(width=1, color='gray'))
-                    fig.update_layout(height=400, paper_bgcolor="#0E1117", plot_bgcolor="#0E1117")
+                    fig.update_layout(height=350, paper_bgcolor="#0E1117", plot_bgcolor="#0E1117")
                     st.plotly_chart(fig, use_container_width=True)
 
-                    c_pie, c_dom = st.columns([1, 1])
+                    # Summary
+                    c_pie, c_stat = st.columns([1, 1])
                     with c_pie:
                         st.markdown("##### Emotion Distribution")
-                        fig_pie = px.pie(
-                            names=list(e_summary.keys()), 
-                            values=list(e_summary.values()),
-                            hole=0.4, template="plotly_dark"
-                        )
+                        fig_pie = px.pie(names=list(e_summary.keys()), values=list(e_summary.values()), hole=0.4, template="plotly_dark")
                         fig_pie.update_layout(paper_bgcolor="#0E1117")
                         st.plotly_chart(fig_pie, use_container_width=True)
-                    
-                    with c_dom:
+                    with c_stat:
                         dom_emotion = max(e_summary, key=e_summary.get)
-                        st.markdown("##### Analysis")
                         st.metric("Dominant Tone", dom_emotion.upper())
-                        
-                        if dom_emotion in ['happy', 'neutral', 'surprise', 'surprised']:
-                            st.success("The speaker maintains a **Positive/Confident** tone.")
-                        elif dom_emotion in ['fear', 'sad']:
-                            st.warning("The speaker seems **Nervous or Low Energy**. Needs more enthusiasm.")
-                        elif dom_emotion in ['angry', 'disgust', 'anger']:
-                            st.error("The speaker sounds **Aggressive/Frustrated**. Needs a softer tone.")
+                        if dom_emotion in ['happy', 'neutral', 'surprise']:
+                            st.success("Positive tone detected. Good confidence.")
+                        else:
+                            st.warning("Negative/Nervous tone detected.")
                 else:
-                    st.info("Emotion analysis is not available for this file type or URL.")
+                    st.info("Emotion analysis unavailable for this file.")
 
+            # TAB 3: CONTENT & REPORT
             with tab3:
-                fb_col1, fb_col2 = st.columns([2, 1])
+                c_col1, c_col2 = st.columns([2, 1])
 
-                with fb_col1:
+                with c_col1:
+                    st.subheader("🧠 Content Intelligence")
+                    audio = results['metrics']['audio']
+                    
+                    col_i1, col_i2 = st.columns(2)
+                    col_i1.metric("Content Score", f"{int(audio.get('content_score', 0))}/100")
+                    col_i2.metric("Power Words Used", audio.get('impact_words', 0))
+                    
                     st.markdown("### 🤖 AI Recommendations")
                     for item in results['feedback']:
                         st.warning(f"👉 {item}")
-                    
-                    st.markdown("### 📄 Speech Transcript")
-                    st.text_area("Full Transcript", results['metrics']['audio']['transcript'], height=150)
+                        
+                    with st.expander("View Full Transcript"):
+                        st.text(audio['transcript'])
 
-                with fb_col2:
+                with c_col2:
                     st.markdown("### 📥 Official Report")
-                    st.write("Download the verified PDF report for faculty submission.")
+                    st.write("Download the verified PDF report containing all graphs and scores.")
 
                     if results['report']:
                         st.download_button(
@@ -323,5 +278,6 @@ def load_emotion_engine():
                             mime="application/pdf"
                         )
 
+            # Cleanup
             if video_path and os.path.exists(video_path) and not is_url:
                 os.remove(video_path)