Update app.py

app.py

@@ -17,156 +17,151 @@ import uuid
 import pandas as pd
 
 # ======================
-# 模型加载函数（缓存）
+# Model Loading Functions
 # ======================
 
 @st.cache_resource
 def load_smoke_pipeline():
-    """初始化并缓存吸烟图片分类 pipeline。"""
+    """Initialize and cache the smoking image classification pipeline."""
     return pipeline("image-classification", model="ccclllwww/smoker_cls_base_V9", use_fast=True)
 
 @st.cache_resource
 def load_gender_pipeline():
-    """初始化并缓存性别图片分类 pipeline。"""
+    """Initialize and cache the gender image classification pipeline."""
     return pipeline("image-classification", model="rizvandwiki/gender-classification-2", use_fast=True)
 
 @st.cache_resource
 def load_age_pipeline():
-    """初始化并缓存年龄图片分类 pipeline。"""
+    """Initialize and cache the age image classification pipeline."""
     return pipeline("image-classification", model="akashmaggon/vit-base-age-classification", use_fast=True)
 
-# 预先加载所有模型
+# Preload all models
 smoke_pipeline = load_smoke_pipeline()
 gender_pipeline = load_gender_pipeline()
 age_pipeline = load_age_pipeline()
 
 # ======================
-# remote settings
+# Twilio Configuration
 # ======================
-# Find your Account SID and Auth Token at twilio.com/console
-# and set the environment variables. See http://twil.io/secure
 
-account_sid = os.environ['TWILIO_ACCOUNT_SID']
-auth_token = os.environ['TWILIO_AUTH_TOKEN']
-client = Client(account_sid, auth_token)
+def initialize_twilio_client():
+    """Initialize Twilio client using environment variables."""
+    account_sid = os.environ.get('TWILIO_ACCOUNT_SID')
+    auth_token = os.environ.get('TWILIO_AUTH_TOKEN')
+    if not account_sid or not auth_token:
+        st.error("Twilio credentials not found in environment variables.")
+        st.stop()
+    client = Client(account_sid, auth_token)
+    return client.tokens.create()
 
-token = client.tokens.create()
+token = initialize_twilio_client()
 
 # ======================
-# 音频加载函数（缓存）
+# Audio Loading Function
 # ======================
 
 @st.cache_resource
-def load_all_audios():
-    """加载 audio 目录中的所有 .wav 文件，并返回一个字典，
-    键为文件名（不带扩展名），值为音频字节数据。"""
+def load_audio_files():
+    """Load all .wav files from the audio directory into a dictionary."""
     audio_dir = "audio"
+    if not os.path.exists(audio_dir):
+        st.error(f"Audio directory '{audio_dir}' not found.")
+        st.stop()
     audio_files = [f for f in os.listdir(audio_dir) if f.endswith(".wav")]
     audio_dict = {}
     for audio_file in audio_files:
-        file_path = os.path.join(audio_dir, audio_file)
-        with open(file_path, "rb") as af:
-            audio_bytes = af.read()
-        # 去掉扩展名作为键
-        key = os.path.splitext(audio_file)[0]
-        audio_dict[key] = audio_bytes
+        with open(os.path.join(audio_dir, audio_file), "rb") as file:
+            audio_dict[os.path.splitext(audio_file)[0]] = file.read()
     return audio_dict
 
-# 应用启动时加载所有音频
-audio_data = load_all_audios()
+# Load audio files at startup
+audio_data = load_audio_files()
 
 # ======================
-# 照片檢測处理函数
+# Image Processing Functions
 # ======================
 
-def smoking_detection(image: Image.Image) -> str:
+def detect_smoking(image: Image.Image) -> str:
+    """Classify an image for smoking activity."""
     try:
         output = smoke_pipeline(image)
-        status = output[0]["label"]
-        return status
+        return output[0]["label"]
     except Exception as e:
-        st.error(f"🔍 图像处理错误: {str(e)}")
+        st.error(f"Image processing error: {str(e)}")
         st.stop()
-        
-def gender_detection(image: Image.Image) -> str:
+
+def detect_gender(image: Image.Image) -> str:
+    """Classify an image for gender."""
     try:
         output = gender_pipeline(image)
-        status = output[0]["label"]
-        return status
+        return output[0]["label"]
     except Exception as e:
-        st.error(f"🔍 图像处理错误: {str(e)}")
+        st.error(f"Image processing error: {str(e)}")
         st.stop()
-        
-def age_detection(image: Image.Image) -> str:
+
+def detect_age(image: Image.Image) -> str:
+    """Classify an image for age range."""
     try:
         output = age_pipeline(image)
-        status = output[0]["label"]
-        return status
+        return output[0]["label"]
     except Exception as e:
-        st.error(f"🔍 图像处理错误: {str(e)}")
+        st.error(f"Image processing error: {str(e)}")
         st.stop()
-        
+
 # ======================
-# 實時檢測核心处理函数
+# Real-Time Classification Functions
 # ======================
 
 @st.cache_data(show_spinner=False, max_entries=3)
-def smoking_classification(image: Image.Image) -> str:
-    """接受 PIL 图片并利用吸烟分类 pipeline 进行判定，返回标签（如 "smoking"）。"""
+def classify_smoking(image: Image.Image) -> str:
+    """Classify an image for smoking and return the label with highest confidence."""
     try:
         output = smoke_pipeline(image)
-        status = max(output, key=lambda x: x["score"])['label']
-        return status
+        return max(output, key=lambda x: x["score"])["label"]
     except Exception as e:
-        st.error(f"🔍 图像处理错误: {str(e)}")
+        st.error(f"Image processing error: {str(e)}")
         st.stop()
 
 @st.cache_data(show_spinner=False, max_entries=3)
-def gender_classification(image: Image.Image) -> str:
-    """进行性别分类，返回模型输出的性别（依模型输出）。"""
+def classify_gender(image: Image.Image) -> str:
+    """Classify an image for gender and return the label with highest confidence."""
     try:
         output = gender_pipeline(image)
-        status = max(output, key=lambda x: x["score"])['label']
-        return status
+        return max(output, key=lambda x: x["score"])["label"]
     except Exception as e:
-        st.error(f"🔍 图像处理错误: {str(e)}")
+        st.error(f"Image processing error: {str(e)}")
         st.stop()
 
 @st.cache_data(show_spinner=False, max_entries=3)
-def age_classification(image: Image.Image) -> str:
-    """进行年龄分类，返回年龄范围，例如 "10-19" 等。"""
+def classify_age(image: Image.Image) -> str:
+    """Classify an image for age range and return the label with highest confidence."""
     try:
         output = age_pipeline(image)
-        age_range = max(output, key=lambda x: x["score"])['label']
-        return age_range
+        return max(output, key=lambda x: x["score"])["label"]
     except Exception as e:
-        st.error(f"🔍 图像处理错误: {str(e)}")
+        st.error(f"Image processing error: {str(e)}")
         st.stop()
 
 # ======================
-# 自定义JS播放音频函数
+# Audio Playback Function
 # ======================
 
-@st.cache_resource
-def play_audio_via_js(audio_bytes):
-    """
-    利用自定义 HTML 和 JavaScript 播放音频。
-    将二进制音频数据转换为 Base64 后嵌入 audio 标签，
-    并用 JS 在页面加载后模拟点击进行播放。
-    """
+def play_audio(audio_bytes: bytes):
+    """Play audio using HTML and JavaScript with Base64-encoded audio data."""
     audio_base64 = base64.b64encode(audio_bytes).decode("utf-8")
+    audio_id = f"audio_player_{uuid.uuid4()}"
     html_content = f"""
-    <audio id="audio_player_{uuid.uuid4()}" controls style="width: 100%;">
+    <audio id="{audio_id}" controls style="width: 100%;">
         <source src="data:audio/wav;base64,{audio_base64}" type="audio/wav">
         Your browser does not support the audio element.
     </audio>
     <script type="text/javascript">
         window.addEventListener('DOMContentLoaded', function() {{
             setTimeout(function() {{
-                var audioElement = document.getElementById("audio_player_{uuid.uuid4()}");
+                var audioElement = document.getElementById("{audio_id}");
                 if (audioElement) {{
                     audioElement.play().catch(function(e) {{
-                        console.log("播放被浏览器阻止:", e);
+                        console.log("Playback prevented by browser:", e);
                     }});
                 }}
             }}, 1000);
@@ -176,213 +171,187 @@ def play_audio_via_js(audio_bytes):
     st.components.v1.html(html_content, height=150)
 
 # ======================
-# VideoTransformer 定义：处理摄像头帧与快照捕获
+# Video Transformer Class
 # ======================
 
 class VideoTransformer(VideoTransformerBase):
     def __init__(self):
-        self.snapshots = []  # 存储捕获的快照
-        self.last_capture_time = time.time()  # 上次捕获时间
-        self.capture_interval = 1  # 每0.5秒捕获一张快照
+        self.snapshots = []
+        self.last_capture_time = time.time()
+        self.capture_interval = 1  # Capture every 1 second
+        self.max_snapshots = 5
 
     def transform(self, frame):
-        """从摄像头流捕获单帧图像，并转换为 PIL Image。"""
+        """Process video frame and capture snapshots."""
         img = frame.to_ndarray(format="bgr24")
         current_time = time.time()
-        # 每隔 capture_interval 秒捕获一张快照，直到捕获5张
-        if current_time - self.last_capture_time >= self.capture_interval and len(self.snapshots) < 5:
+        if (current_time - self.last_capture_time >= self.capture_interval and 
+            len(self.snapshots) < self.max_snapshots):
             img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
             self.snapshots.append(Image.fromarray(img_rgb))
             self.last_capture_time = current_time
-            st.write(f"已捕获快照 {len(self.snapshots)}/20")
-        return img  # 返回原始帧以供前端显示
+            st.write(f"Captured snapshot {len(self.snapshots)}/{self.max_snapshots}")
+        return img
 
 # ======================
 # Cover Page
 # ======================
 
 def cover_page():
-    """Display the cover page with project overview and usage instructions."""
-    st.title("Smoking Detection System")
-    
-    st.header("Project Overview")
-    st.write("""
-    The Smoking Detection System is a Streamlit-based web application designed to detect smoking behavior
-    in images or real-time video streams. It leverages advanced machine learning models to classify images
-    for smoking activity, gender, and age range. The system is structured to provide both static image analysis
-    and real-time video processing, with audio feedback for detected smoking incidents.
+    """Display an enhanced cover page with project overview and instructions."""
+    st.title("Smoking Detection System", anchor=False)
     
-    **Purpose**: The primary goal is to identify smoking behavior in public or controlled environments,
-    providing insights into the demographics (gender and age) of individuals engaged in smoking. This can
-    be used for monitoring compliance with no-smoking policies or conducting behavioral studies.
-    
-    **Significance**: The application promotes public health by enabling automated monitoring of smoking
-    activities, potentially aiding in the enforcement of smoking regulations and raising awareness about
-    smoking prevalence across different demographics.
+    st.markdown("### Welcome to the Smoking Detection System")
+    st.markdown("""
+    This Streamlit-based application harnesses cutting-edge machine learning to detect smoking behavior in images and real-time video streams. By analyzing smoking activity, gender, and age demographics, it provides valuable insights for public health monitoring and policy enforcement.
+    """)
     
-    **Structure**:
-    - **Cover Page**: Provides an overview and usage instructions.
-    - **Photo Detection**: Analyzes a single uploaded or captured image for smoking, gender, and age.
-    - **Real-Time Video Detection**: Processes video streams, capturing snapshots to detect smoking and
-      analyze demographics if smoking is detected.
+    st.markdown("#### Project Overview")
+    st.markdown("""
+    - **Purpose**: Automatically identify smoking behavior in public or controlled environments to support compliance with no-smoking policies and facilitate behavioral studies.
+    - **Significance**: Enhances public health initiatives by enabling real-time monitoring and demographic analysis of smoking activities.
+    - **Features**:
+      - **Photo Detection**: Analyze a single image (uploaded or captured) for smoking, gender, and age.
+      - **Real-Time Video Detection**: Process webcam streams, capturing snapshots to detect smoking and demographics.
+      - **Audio Feedback**: Play alerts based on detected gender and age when smoking is confirmed.
     """)
     
-    st.header("Usage Instructions")
-    st.write("""
-    1. **Navigation**: Use the sidebar to select a page:
-       - **Cover Page**: View this project overview.
-       - **Photo Detection**: Upload an image or use the camera to capture a photo for analysis.
-       - **Real-Time Video Detection**: Enable the webcam for continuous monitoring.
+    st.markdown("#### How to Use")
+    st.markdown("""
+    1. **Navigate**: Use the sidebar to select a page:
+       - **Cover Page**: View this overview.
+       - **Photo Detection**: Upload or capture an image for analysis.
+       - **Real-Time Video Detection**: Monitor live webcam feed.
     2. **Photo Detection**:
-       - Choose to upload an image or capture one using the camera.
-       - The system will classify the image for smoking. If smoking is detected, it will further analyze
-         gender and age, and play an audio alert based on the results.
+       - Upload an image or capture one via webcam.
+       - The system detects smoking; if detected, it analyzes gender and age, playing a corresponding audio alert.
     3. **Real-Time Video Detection**:
-       - Start the webcam to capture 20 snapshots over one minute.
-       - The system analyzes each snapshot for smoking. If smoking is detected in more than two snapshots,
-         it performs gender and age classification and displays the results.
-       - An audio alert is played if smoking is confirmed, based on the most common gender and age range.
-    4. **Requirements**:
-       - Ensure the 'audio' directory contains .wav files named in the format '<age_range> <gender>.wav'
-         (e.g., '10-19 male.wav') for audio feedback.
-       - Set up Twilio environment variables (TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN) for WebRTC.
+       - Captures 5 snapshots over one minute.
+       - If smoking is detected in more than 2 snapshots, it analyzes gender and age, displays results in a table, and plays an audio alert.
+    4. **Setup Requirements**:
+       - Ensure the 'audio' directory contains .wav files named as '<age_range> <gender>.wav' (e.g., '10-19 male.wav').
+       - Configure Twilio environment variables (`TWILIO_ACCOUNT_SID` and `TWILIO_AUTH_TOKEN`) for WebRTC functionality.
     """)
+    
+    st.markdown("#### Get Started")
+    st.markdown("Select a page from the sidebar to begin analyzing images or video streams.")
 
 # ======================
-# 照片检测页面
+# Photo Detection Page
 # ======================
 
 def photo_detection_page():
+    """Handle photo detection page for smoking, gender, and age classification."""
     audio_placeholder = st.empty()
-    st.title("照片检测")
-    st.write("上传一张图片或使用摄像头拍摄，检测是否吸烟，若检测到吸烟则进一步分析性别和年龄。")
-
-    # 提供上传和摄像头选项
-    option = st.radio("选择输入方式", ["上传图片", "使用摄像头拍摄"])
+    st.title("Photo Detection", anchor=False)
+    st.markdown("Upload an image or capture a photo to detect smoking behavior. If smoking is detected, gender and age will be analyzed.")
 
+    # Image input selection
+    option = st.radio("Choose input method", ["Upload Image", "Capture with Camera"], horizontal=True)
     image = None
-    if option == "上传图片":
-        uploaded_file = st.file_uploader("选择一张图片", type=["jpg", "jpeg", "png"])
-        if uploaded_file is not None:
+
+    if option == "Upload Image":
+        uploaded_file = st.file_uploader("Select an image", type=["jpg", "jpeg", "png"])
+        if uploaded_file:
             image = Image.open(uploaded_file)
-            st.image(image, caption="上传的图片", use_container_width=True)
+            st.image(image, caption="Uploaded Image", use_container_width=True)
     else:
-        # 摄像头拍摄
-        enable = st.checkbox("启用摄像头")
-        camera_file = st.camera_input("拍摄照片", disabled=not enable)
-        if camera_file is not None:
+        enable = st.checkbox("Enable Camera")
+        camera_file = st.camera_input("Capture Photo", disabled=not enable)
+        if camera_file:
             image = Image.open(camera_file)
-            st.image(image, caption="拍攝的圖片", use_container_width=True)
-
-    if image is not None:
-        # 吸烟分类
-        with st.spinner("Wait for smoking detection"):
-            smoke_result = smoking_detection(image)
-            st.success("The smoke result is:")
-        st.write(smoke_result)
-        
+            st.image(image, caption="Captured Photo", use_container_width=True)
+
+    if image:
+        with st.spinner("Detecting smoking..."):
+            smoke_result = detect_smoking(image)
+        st.success(f"Smoking Status: {smoke_result}")
+
         if smoke_result.lower() == "smoking":
-            # 性别分类
-            with st.spinner("Wait for gender detection"):
-                gender_result = gender_detection(image)
-                st.success("The gender result is:")
-            st.write(gender_result)
-
-            # 年龄分类
-            with st.spinner("Wait for age detection"):
-                age_result = age_detection(image)
-                st.success("The age result is:")
-            st.write(age_result)
-            
+            with st.spinner("Detecting gender..."):
+                gender_result = detect_gender(image)
+            st.success(f"Gender: {gender_result}")
+
+            with st.spinner("Detecting age..."):
+                age_result = detect_age(image)
+            st.success(f"Age Range: {age_result}")
+
             audio_placeholder.empty()
             audio_key = f"{age_result} {gender_result.lower()}"
             if audio_key in audio_data:
-                audio_bytes = audio_data[audio_key]
-                play_audio_via_js(audio_bytes)
+                play_audio(audio_data[audio_key])
             else:
-                st.error(f"音频文件不存在: {audio_key}.wav")
+                st.error(f"Audio file not found: {audio_key}.wav")
 
 # ======================
-# 实时检测页面
+# Real-Time Detection Page
 # ======================
 
 def real_time_detection_page():
-    st.title("实时视频检测")
-    st.write("程序在一分钟内捕获5张快照进行图片分类，首先判定是否吸烟。若检测到吸烟的快照超过2次，则将结果添加到表格中，包含快照、性别和年龄。")
+    """Handle real-time video detection with snapshot capture and analysis."""
+    st.title("Real-Time Video Detection", anchor=False)
+    st.markdown("Captures 5 snapshots over one minute to detect smoking. If smoking is detected in more than 2 snapshots, results include gender, age, and a snapshot in a table.")
 
-    # 初始化 session state 用于存储检测结果
+    # Initialize session state for detection results
     if 'detection_results' not in st.session_state:
         st.session_state.detection_results = []
 
-    # 创建用于显示进度文字和进度条的占位容器
-    capture_text_placeholder = st.empty()
-    capture_progress_placeholder = st.empty()
-    classification_text_placeholder = st.empty()
-    classification_progress_placeholder = st.empty()
-    detection_info_placeholder = st.empty()
-
-    # 显示检测结果表格
-    table_placeholder = st.empty()
-
-    # 启���实时视频流
-    ctx = webrtc_streamer(key="unique_example", video_transformer_factory=VideoTransformer,
-                          rtc_configuration={"iceServers": token.ice_servers})
-    image_placeholder = st.empty()
-    audio_placeholder = st.empty()
+    # Placeholders for UI elements
+    capture_text = st.empty()
+    capture_progress = st.empty()
+    classification_text = st.empty()
+    classification_progress = st.empty()
+    detection_info = st.empty()
+    table = st.empty()
+    image_display = st.empty()
+    audio = st.empty()
+
+    # Start video stream
+    ctx = webrtc_streamer(
+        key="unique_example",
+        video_transformer_factory=VideoTransformer,
+        rtc_configuration={"iceServers": token.ice_servers}
+    )
 
     capture_target = 5
 
-    if ctx.video_transformer is not None:
-        classification_result_placeholder = st.empty()
-        detection_info_placeholder.info("开始侦测")
+    if ctx.video_transformer:
+        detection_info.info("Starting detection...")
 
         while True:
             snapshots = ctx.video_transformer.snapshots
 
             if len(snapshots) < capture_target:
-                capture_text_placeholder.text(f"捕获进度: {len(snapshots)}/{capture_target} 张快照")
-                progress_value = int(len(snapshots) / capture_target * 100)
-                capture_progress_placeholder.progress(progress_value)
+                capture_text.text(f"Capture Progress: {len(snapshots)}/{capture_target} snapshots")
+                capture_progress.progress(int(len(snapshots) / capture_target * 100))
             else:
-                capture_text_placeholder.text("捕获进度: 捕获完成！")
-                capture_progress_placeholder.empty()
-                detection_info_placeholder.empty()
+                capture_text.text("Capture Progress: Completed!")
+                capture_progress.empty()
+                detection_info.empty()
 
-                total = len(snapshots)
-                classification_text_placeholder.text("分类进度: 正在分类...")
-                classification_progress = classification_progress_placeholder.progress(0)
+                classification_text.text("Classification Progress: Analyzing...")
+                classification = classification_progress.progress(0)
 
-                smoke_results = []
-                for idx, img in enumerate(snapshots):
-                    smoke_results.append(smoking_classification(img))
+                # Classify snapshots
+                smoke_results = [classify_smoking(img) for img in snapshots]
                 smoking_count = sum(1 for result in smoke_results if result.lower() == "smoking")
-                classification_progress.progress(33)
+                classification.progress(33)
 
                 if smoking_count > 2:
-                    gender_results = []
-                    for idx, img in enumerate(snapshots):
-                        gender_results.append(gender_classification(img))
-                    classification_progress.progress(66)
-
-                    age_results = []
-                    for idx, img in enumerate(snapshots):
-                        age_results.append(age_classification(img))
-                    classification_progress.progress(100)
-                    classification_text_placeholder.text("分类进度: 分类完成！")
+                    gender_results = [classify_gender(img) for img in snapshots]
+                    classification.progress(66)
+                    age_results = [classify_age(img) for img in snapshots]
+                    classification.progress(100)
+                    classification_text.text("Classification Progress: Completed!")
 
+                    # Determine most common gender and age
                     most_common_gender = Counter(gender_results).most_common(1)[0][0]
                     most_common_age = Counter(age_results).most_common(1)[0][0]
 
-                    # 找到第一张吸烟快照
-                    smoking_image = None
-                    for idx, label in enumerate(smoke_results):
-                        if label.lower() == "smoking":
-                            smoking_image = snapshots[idx]
-                            break
-                    if smoking_image is None:
-                        smoking_image = snapshots[0]
+                    # Select first smoking snapshot
+                    smoking_image = next((snapshots[i] for i, label in enumerate(smoke_results) if label.lower() == "smoking"), snapshots[0])
 
-                    # 添加结果到 session state
+                    # Store results
                     st.session_state.detection_results.append({
                         "Timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
                         "Snapshot": smoking_image,
@@ -391,7 +360,7 @@ def real_time_detection_page():
                         "Smoking Count": smoking_count
                     })
 
-                    # 更新表格显示
+                    # Update table
                     df = pd.DataFrame([
                         {
                             "Timestamp": result["Timestamp"],
@@ -400,28 +369,26 @@ def real_time_detection_page():
                             "Smoking Count": result["Smoking Count"]
                         } for result in st.session_state.detection_results
                     ])
-                    table_placeholder.dataframe(df, use_container_width=True)
+                    table.dataframe(df, use_container_width=True)
 
-                    # 显示示例快照
-                    image_placeholder.image(smoking_image, caption="捕获的吸烟快照", use_container_width=True)
+                    # Display snapshot
+                    image_display.image(smoking_image, caption="Detected Smoking Snapshot", use_container_width=True)
 
-                    # 播放音频
-                    audio_placeholder.empty()
+                    # Play audio
+                    audio.empty()
                     audio_key = f"{most_common_age} {most_common_gender.lower()}"
                     if audio_key in audio_data:
-                        audio_bytes = audio_data[audio_key]
-                        play_audio_via_js(audio_bytes)
+                        play_audio(audio_data[audio_key])
                     else:
-                        st.error(f"音频文件不存在: {audio_key}.wav")
+                        st.error(f"Audio file not found: {audio_key}.wav")
                 else:
-                    result_text = "**吸烟状态：** Not Smoking"
-                    classification_result_placeholder.markdown(result_text)
-                    image_placeholder.empty()
-                    audio_placeholder.empty()
-                    classification_text_placeholder.text("分类进度: 分类完成！")
+                    st.markdown("**Smoking Status:** Not Smoking")
+                    image_display.empty()
+                    audio.empty()
+                    classification_text.text("Classification Progress: Completed!")
                     classification_progress.progress(100)
 
-                # 更新表格显示，即使没有吸烟检测到
+                # Update table if results exist
                 if st.session_state.detection_results:
                     df = pd.DataFrame([
                         {
@@ -431,31 +398,33 @@ def real_time_detection_page():
                             "Smoking Count": result["Smoking Count"]
                         } for result in st.session_state.detection_results
                     ])
-                    table_placeholder.dataframe(df, use_container_width=True)
+                    table.dataframe(df, use_container_width=True)
 
+                # Reset for next cycle
                 time.sleep(5)
-                classification_progress_placeholder.empty()
-                classification_text_placeholder.empty()
-                capture_text_placeholder.empty()
-
-                detection_info_placeholder.info("开始侦测")
+                classification_progress.empty()
+                classification_text.empty()
+                capture_text.empty()
+                detection_info.info("Starting detection...")
                 ctx.video_transformer.snapshots = []
                 ctx.video_transformer.last_capture_time = time.time()
+
             time.sleep(0.1)
 
 # ======================
-# 主函数：多页面导航
+# Main Application
 # ======================
 
 def main():
-    st.sidebar.title("导航")
-    page = st.sidebar.selectbox("选择页面", ["coverpage", "照片检测", "实时视频检测"])
+    """Main function to handle page navigation."""
+    st.sidebar.title("Navigation")
+    page = st.sidebar.selectbox("Select Page", ["Cover Page", "Photo Detection", "Real-Time Video Detection"])
 
-    if page == "coverpage":
+    if page == "Cover Page":
         cover_page()
-    if page == "照片检测":
+    elif page == "Photo Detection":
         photo_detection_page()
-    if page == "实时视频检测":
+    elif page == "Real-Time Video Detection":
         real_time_detection_page()
 
 if __name__ == "__main__":