Fresh deployment with Git LFS

.gitattributes

@@ -0,0 +1 @@
+models/*.pth.tar filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,62 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Output files
+output/
+*.mp4
+*.avi
+*.mov
+
+# Temporary files
+*.tmp
+temp/
+tmp/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Data files (if large)
+data/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Whitelist for Demo
+!demo/
+!demo/*.mp4
+!demo/*.json

Dockerfile

@@ -0,0 +1,28 @@
+# Sử dụng Python 3.10 slim để dung lượng nhẹ hơn
+FROM python:3.10-slim
+
+# Cài đặt các thư viện hệ thống cần thiết cho OpenCV và MediaPipe
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Tạo người dùng không có quyền root (Yêu cầu của Hugging Face Spaces)
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copy các dependencies trước để tối ưu hóa Docker cache
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy toàn bộ code vào container
+COPY --chown=user . .
+
+# Hugging Face Spaces lắng nghe trên cổng 7860 mặc định
+CMD ["uvicorn", "api_server:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,32 @@
+---
+title: Golf Tech Analysis
+emoji: 🏌️
+colorFrom: green
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+# Golf Tech Analysis AI
+
+Hệ thống phân tích kỹ thuật Golf sử dụng AI (SwingNet & MediaPipe).
+
+## Tính năng
+
+- Phân tích 8 giai đoạn của cú Swing.
+- Trích xuất dữ liệu khung xương (Skeleton) dưới dạng JSON.
+- Phân tích tư thế và đưa ra nhận xét chuyên môn.
+- Toàn bộ dữ liệu được xóa ngay sau khi xử lý (Stateless).
+
+## Cách sử dụng
+
+1. Tải video cú đánh của bạn lên qua giao diện Web.
+2. Chờ hệ thống AI phân tích.
+3. Tải về file `master_data.json` để sử dụng cho các công cụ phân tích hoặc render video.
+
+## Deploy local
+
+```bash
+pip install -r requirements.txt
+python api_server.py
+```

analyze.py

@@ -0,0 +1,224 @@
+import sys
+sys.stdout.reconfigure(encoding="utf-8")
+import cv2
+import mediapipe as mp
+import numpy as np
+import os
+import json
+
+class GolfDiagnosticEngine:
+    """
+    Hệ thống chẩn đoán kỹ thuật Golf dựa trên tư thế (Pose Estimation).
+    Sử dụng MediaPipe để trích xuất điểm mốc và heuristics hình học để chấm điểm.
+    """
+    def __init__(self):
+        self.mp_pose = mp.solutions.pose
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.pose = self.mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.5)
+        self.labels = ['1_Address', '2_Toe-up', '3_Mid-Backswing', '4_Top', 
+                       '5_Mid-Downswing', '6_Impact', '7_Mid-Follow-Through', '8_Finish']
+
+    def detect_view_angle(self, landmarks):
+        """
+        Xác định góc quay (Face-on hay Down-the-line) dựa trên độ rộng vai ở Address.
+        Face-on: Hai vai cách xa nhau theo trục X.
+        DTL: Hai vai gần nhau (che khuất).
+        """
+        if not landmarks: return "Unknown"
+        
+        l_shoulder = landmarks[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value]
+        r_shoulder = landmarks[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value]
+        l_hip = landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value]
+        r_hip = landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value]
+
+        shoulder_width = abs(l_shoulder.x - r_shoulder.x)
+        
+        # Tính chiều cao thân người (Torso Height) để chuẩn hóa
+        mid_shoulder_y = (l_shoulder.y + r_shoulder.y) / 2
+        mid_hip_y = (l_hip.y + r_hip.y) / 2
+        torso_height = abs(mid_shoulder_y - mid_hip_y)
+        
+        if torso_height == 0: return "Unknown"
+        
+        # Tỷ lệ chiều rộng vai / chiều cao thân
+        ratio = shoulder_width / torso_height
+        
+        # Heuristic: Nếu tỷ lệ > 0.5 (vai rộng bằng nửa lưng) -> Face-on
+        if ratio > 0.4: # Hạ threshold xuống chút cho an toàn
+            return "Face-on (Trực diện)"
+        else:
+            return "Down-the-Line (Dọc)"
+
+
+    def calculate_angle(self, a, b, c):
+        """Tính góc (độ) giữa 3 điểm a, b, c (b là đỉnh)"""
+        a = np.array(a)
+        b = np.array(b)
+        c = np.array(c)
+        
+        radians = np.arctan2(c[1]-b[1], c[0]-b[0]) - np.arctan2(a[1]-b[1], a[0]-b[0])
+        angle = np.abs(radians*180.0/np.pi)
+        
+        if angle > 180.0:
+            angle = 360-angle
+            
+        return angle
+
+    def get_landmarks(self, image):
+        results = self.pose.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        if not results.pose_landmarks:
+            return None, None
+        return results.pose_landmarks.landmark, results.pose_landmarks
+
+    def draw_annotations(self, image, landmarks_proto, phase_name, analysis):
+        """Vẽ landmarks tinh tế và chuyên nghiệp hơn"""
+        annotated_image = image.copy()
+        
+        # Cấu hình phong cách vẽ tinh tế (mỏng hơn, nhỏ hơn)
+        landmark_style = self.mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=1, circle_radius=1) # Neon Green thon gọn
+        connection_style = self.mp_drawing.DrawingSpec(color=(255, 255, 255), thickness=1) # Đường nối trắng mỏng
+        
+        # Vẽ khung xương
+        self.mp_drawing.draw_landmarks(
+            annotated_image, landmarks_proto, self.mp_pose.POSE_CONNECTIONS,
+            landmark_style,
+            connection_style
+        )
+        
+        return annotated_image
+
+    def analyze_phase(self, phase_name, landmarks):
+        if not landmarks:
+            return {"score": 0, "comments": ["Không tìm thấy tư thế"], "data": {}}
+
+        analysis = {"score": 10.0, "comments": [], "data": {}, "raw_landmarks": []}
+        
+        # Trích xuất tọa độ thô của toàn bộ khớp xương để kỹ sư khác sử dụng
+        for i, lm in enumerate(landmarks):
+            analysis["raw_landmarks"].append({
+                "id": i,
+                "name": self.mp_pose.PoseLandmark(i).name,
+                "x": round(lm.x, 4),
+                "y": round(lm.y, 4),
+                "z": round(lm.z, 4),
+                "visibility": round(lm.visibility, 4)
+            })
+
+        # Lấy các điểm mốc quan trọng để tính toán logic nội bộ
+        l_shoulder = [landmarks[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
+        r_shoulder = [landmarks[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x, landmarks[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y]
+        l_elbow = [landmarks[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].y]
+        r_elbow = [landmarks[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].x, landmarks[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].y]
+        l_wrist = [landmarks[self.mp_pose.PoseLandmark.LEFT_WRIST.value].x, landmarks[self.mp_pose.PoseLandmark.LEFT_WRIST.value].y]
+        r_wrist = [landmarks[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].x, landmarks[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].y]
+        l_hip = [landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[self.mp_pose.PoseLandmark.LEFT_HIP.value].y]
+        r_hip = [landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value].x, landmarks[self.mp_pose.PoseLandmark.RIGHT_HIP.value].y]
+        l_ankle = [landmarks[self.mp_pose.PoseLandmark.LEFT_ANKLE.value].x, landmarks[self.mp_pose.PoseLandmark.LEFT_ANKLE.value].y]
+        r_ankle = [landmarks[self.mp_pose.PoseLandmark.RIGHT_ANKLE.value].x, landmarks[self.mp_pose.PoseLandmark.RIGHT_ANKLE.value].y]
+
+        # Phân tích cụ thể từng pha (Thang điểm 10)
+        # Sử dụng endswith để khớp với tên có hoặc không có số thứ tự
+        if phase_name.endswith('Address'):
+            # 1. Độ rộng chân (so với vai)
+            shoulder_width = np.abs(l_shoulder[0] - r_shoulder[0])
+            stance_width = np.abs(l_ankle[0] - r_ankle[0])
+            ratio = stance_width / shoulder_width if shoulder_width > 0 else 0
+            analysis["data"]["stance_ratio"] = ratio
+            if ratio < 0.8:
+                analysis["score"] -= 1.0
+                analysis["comments"].append("Tư thế đứng quá hẹp")
+            elif ratio > 1.4:
+                analysis["score"] -= 1.0
+                analysis["comments"].append("Tư thế đứng quá rộng")
+
+        elif phase_name.endswith('Top'):
+            # 2. Độ thẳng tay trái (Lead arm - giả sử golfer thuận tay phải)
+            lead_arm_angle = self.calculate_angle(l_shoulder, l_elbow, l_wrist)
+            analysis["data"]["lead_arm_angle"] = lead_arm_angle
+            if lead_arm_angle < 150:
+                analysis["score"] -= 2.0
+                analysis["comments"].append("Tay trái bị cong quá nhiều (Chicken Wing)")
+            
+            # 3. Góc xoay vai (đơn giản hóa)
+            shoulder_tilt = np.abs(l_shoulder[1] - r_shoulder[1])
+            analysis["data"]["shoulder_tilt"] = shoulder_tilt
+
+        elif phase_name.endswith('Impact'):
+            # 4. Độ thẳng tay trái lúc Impact
+            impact_arm_angle = self.calculate_angle(l_shoulder, l_elbow, l_wrist)
+            if impact_arm_angle < 160:
+                analysis["score"] -= 2.5
+                analysis["comments"].append("Tay trái không thẳng, mất lực")
+            
+            # 5. Hip rotation (Lead hip vs Back hip)
+            hip_openness = l_hip[0] - r_hip[0]
+            analysis["data"]["hip_openness"] = hip_openness
+            
+        elif phase_name.endswith('Finish'):
+            # 6. Thăng bằng (Trọng tâm dồn về chân trái)
+            # Kiểm tra thăng bằng đơn giản bằng vị trí hông so với chân lead
+            if l_hip[0] > l_ankle[0] + 0.1 or l_hip[0] < l_ankle[0] - 0.1:
+                analysis["score"] -= 1.5
+                analysis["comments"].append("Kết thúc thiếu thăng bằng")
+
+        if not analysis["comments"]:
+            analysis["comments"].append("Đạt chuẩn")
+
+        analysis["score"] = round(max(0, analysis["score"]), 1)
+        return analysis
+
+    def process_video_results(self, output_dir):
+        # Lấy video_id từ tên thư mục output
+        video_id = os.path.basename(output_dir)
+        extraction_dir = os.path.join(output_dir, 'phases')
+        
+        report = {"video_id": video_id, "phases": {}, "overall_score": 0, "view_angle": "Unknown"}
+        
+        total_score = 0
+        valid_phases = 0
+
+        # Mảng lưu landmarks Address để detect view
+        address_landmarks = None
+
+        for label in self.labels:
+            img_path = os.path.join(extraction_dir, label, f"{video_id}.jpg")
+            if not os.path.exists(img_path):
+                continue
+                
+            image = cv2.imread(img_path)
+            landmarks_list, _ = self.get_landmarks(image)
+            
+            # Lưu landmarks của Address
+            if label == '1_Address' and landmarks_list:
+                address_landmarks = landmarks_list
+
+            phase_analysis = self.analyze_phase(label, landmarks_list)
+
+            report["phases"][label] = phase_analysis
+            total_score += phase_analysis["score"]
+            valid_phases += 1
+
+        if valid_phases > 0:
+            report["overall_score"] = round(total_score / valid_phases, 1)
+
+        # Detect View Angle một lần duy nhất
+        if address_landmarks:
+            report["view_angle"] = self.detect_view_angle(address_landmarks)
+        
+        # Lưu báo cáo vào thư mục output của video
+        report_path = os.path.join(output_dir, 'report.json')
+        with open(report_path, 'w', encoding='utf-8') as f:
+            json.dump(report, f, indent=4, ensure_ascii=False)
+            
+        return report
+
+if __name__ == "__main__":
+    import sys
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('output_dir', help='Thư mục output của video (ví dụ: output/video_01)')
+    args = parser.parse_args()
+    
+    engine = GolfDiagnosticEngine()
+    result = engine.process_video_results(args.output_dir)
+    print(json.dumps(result, indent=4, ensure_ascii=False))

api_server.py

@@ -0,0 +1,86 @@
+import os
+import shutil
+import uuid
+import json
+from fastapi import FastAPI, UploadFile, File, HTTPException, Request
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.templating import Jinja2Templates
+import subprocess
+import sys
+
+app = FastAPI(title="Golf Tech Analysis API - Stateless")
+
+UPLOAD_DIR = "uploads"
+OUTPUT_DIR = "output"
+TEMPLATES_DIR = "templates"
+
+# Đảm bảo các thư mục tồn tại (chúng sẽ chỉ chứa file tạm thời cực ngắn)
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(TEMPLATES_DIR, exist_ok=True)
+
+templates = Jinja2Templates(directory=TEMPLATES_DIR)
+
+@app.post("/")
+async def analyze_video(file: UploadFile = File(...)):
+    # 1. Tạo job tạm thời
+    job_id = str(uuid.uuid4())
+    video_ext = os.path.splitext(file.filename)[1]
+    video_path = os.path.join(UPLOAD_DIR, f"{job_id}{video_ext}")
+
+    try:
+        # 2. Lưu video tạm thời
+        with open(video_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # 3. Chạy Pipeline phân tích
+        base_path = os.path.dirname(os.path.abspath(__file__))
+        main_py_path = os.path.join(base_path, "main.py")
+        video_abs_path = os.path.abspath(video_path)
+        
+        process = subprocess.run(
+            [sys.executable, main_py_path, video_abs_path],
+            capture_output=True,
+            text=True,
+            encoding="utf-8"
+        )
+        
+        if process.returncode != 0:
+            raise HTTPException(status_code=500, detail=f"Pipeline Error: {process.stderr}")
+
+        # 4. Đọc kết quả Master JSON
+        video_id = os.path.splitext(os.path.basename(video_path))[0]
+        job_output_dir = os.path.join(OUTPUT_DIR, video_id)
+        master_json_path = os.path.join(job_output_dir, "master_data.json")
+        
+        if not os.path.exists(master_json_path):
+            raise HTTPException(status_code=500, detail="Không tìm thấy master_data.json.")
+
+        with open(master_json_path, 'r', encoding='utf-8') as f:
+            master_report = json.load(f)
+
+        # 5. DỌN DẸP TUYỆT ĐỐI NGAY LẬP TỨC (Không lưu lại bất cứ gì)
+        shutil.rmtree(job_output_dir, ignore_errors=True)
+        if os.path.exists(video_path): os.remove(video_path)
+        
+        # Xóa các file rác khác trong uploads nếu có
+        # (Chỉ xóa file của chính job này để đảm bảo concurrency)
+        
+        # Trả về JSON Data trực tiếp (Browser sẽ nhận được text/json)
+        return master_report
+
+    except Exception as e:
+        # Cleanup nếu có lỗi
+        if os.path.exists(video_path): os.remove(video_path)
+        video_id = os.path.splitext(os.path.basename(video_path))[0]
+        shutil.rmtree(os.path.join(OUTPUT_DIR, video_id), ignore_errors=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/")
+async def root(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+if __name__ == "__main__":
+    import uvicorn
+    # Hugging Face Spaces yêu cầu cổng 7860
+    uvicorn.run(app, host="0.0.0.0", port=7860)

coach.py

@@ -0,0 +1,109 @@
+import sys
+sys.stdout.reconfigure(encoding="utf-8")
+import json
+import os
+
+class GolfCoachEngine:
+    """
+    Công cụ Huấn luyện Golf: Chấm điểm và gợi ý bài tập.
+    - Áp dụng trọng số cho từng pha (Impact quan trọng nhất).
+    - So sánh lỗi với 'Drill Library' để đưa ra bài tập khắc phục.
+    """
+    def __init__(self):
+        # Trọng số cho từng pha (Impact là quan trọng nhất)
+        self.weights = {
+            '1_Address': 0.1,
+            '2_Toe-up': 0.05,
+            '3_Mid-Backswing': 0.05,
+            '4_Top': 0.2,
+            '5_Mid-Downswing': 0.1,
+            '6_Impact': 0.35,
+            '7_Mid-Follow-Through': 0.05,
+            '8_Finish': 0.1
+        }
+        
+        # Thư viện bài tập gợi ý
+        self.drill_library = {
+            "Tư thế đứng quá rộng": "Bài tập đứng trên hai đầu gối hoặc khép chân để cảm nhận sự xoay trục.",
+            "Tư thế đứng quá hẹp": "Bài tập bước rộng chân và xoay hông tại chỗ để tạo nền tảng vững chắc.",
+            "Tay trái bị cong quá nhiều ở đỉnh swing (Chicken Wing)": "Kẹp một chiếc khăn hoặc quả bóng tập giữa hai cánh tay ở nách để giữ sự kết nối.",
+            "Tay trái không thẳng lúc tiếp bóng, mất lực": "Bài tập Half-swing (swing nửa vòng) tập trung vào việc giữ tay lead thẳng và xoay hông.",
+            "Kết thúc không vững, trọng tâm chưa dồn hết về chân trái": "Bài tập Hold Finish - giữ nguyên tư thế kết thúc trong 3 giây cho đến khi thăng bằng hoàn toàn."
+        }
+
+    def generate_report(self, diagnostic_json_path):
+        with open(diagnostic_json_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        phases = data.get("phases", {})
+        weighted_score = 0
+        all_comments = []
+        drills = set()
+        
+        # Tính toán điểm có trọng số
+        for phase, analysis in phases.items():
+            score = analysis.get("score", 0)
+            weight = self.weights.get(phase, 0.1)
+            weighted_score += score * weight
+            
+            # Thu thập nhận xét và drills
+            for comment in analysis.get("comments", []):
+                all_comments.append(f"[{phase}] {comment}")
+                if comment in self.drill_library:
+                    drills.add(self.drill_library[comment])
+
+        # Phân loại trình độ dựa trên điểm (Thang điểm 10)
+        score = round(weighted_score, 1)
+        if score >= 9.0: level = "Professional / Low Handicap"
+        elif score >= 7.5: level = "Mid Handicap"
+        elif score >= 5.5: level = "High Handicap"
+        else: level = "Beginner"
+
+        final_report = {
+            "video_id": data.get("video_id"),
+            "final_score": score,
+            "skill_level": level,
+            "key_faults": all_comments,
+            "recommended_drills": list(drills),
+            "summary": self._generate_summary(score, all_comments)
+        }
+        
+        return final_report
+
+    def _generate_summary(self, score, faults):
+        if not faults or faults[0].endswith("Đạt chuẩn"):
+            return f"Cú swing của bạn đạt {score}/10. Kỹ thuật rất chuẩn, hãy tiếp tục duy trì!"
+        
+        summary = f"Điểm kỹ thuật của bạn đạt {score}/10. "
+        if score < 7.0:
+            summary += "Hệ thống phát hiện một số lỗi cần khắc phục để nâng cao hiệu suất. "
+        else:
+            summary += "Kỹ thuật của bạn khá tốt, chỉ cần tinh chỉnh một vài chi tiết nhỏ. "
+            
+        fault_text = faults[0].split('] ')[1] if faults else ""
+        if fault_text != "Đạt chuẩn":
+            summary += f"Lỗi ưu tiên cần sửa: {fault_text}."
+        return summary
+
+if __name__ == "__main__":
+    import sys
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('output_dir', help='Thư mục output của video')
+    args = parser.parse_args()
+    
+    coach = GolfCoachEngine()
+    
+    input_path = os.path.join(args.output_dir, 'report.json')
+    if os.path.exists(input_path):
+        final_result = coach.generate_report(input_path)
+        print(json.dumps(final_result, indent=4, ensure_ascii=False))
+        
+        # Lưu báo cáo cuối cùng vào thư mục output của video
+        output_path = os.path.join(args.output_dir, 'FINAL_report.json')
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(final_result, f, indent=4, ensure_ascii=False)
+        print(f"\nBáo cáo coaching cuối cùng đã lưu tại {output_path}")
+    else:
+        print(f"Lỗi: Không tìm thấy file: {input_path}")
+        sys.exit(1)

extract.py

@@ -0,0 +1,211 @@
+import os
+import sys
+sys.stdout.reconfigure(encoding="utf-8")
+import torch
+import cv2
+import numpy as np
+import torch.nn.functional as F
+from torchvision import transforms
+
+# Thêm đường dẫn src để import model
+sys.path.insert(0, os.path.abspath('src'))
+
+from model import EventDetector
+from eval import ToTensor, Normalize
+from tqdm import tqdm
+
+import argparse
+import json
+
+def smooth_probs(probs, window_size=5):
+    """Làm mượt xác suất bằng Moving Average"""
+    smoothed = np.zeros_like(probs)
+    for i in range(probs.shape[1]):
+        smoothed[:, i] = np.convolve(probs[:, i], np.ones(window_size)/window_size, mode='same')
+    # Chia lại để tổng xác suất mỗi frame = 1
+    return smoothed / smoothed.sum(axis=1, keepdims=True)
+
+def run_ai_extraction(video_path, slow_factor=1.0, output_dir=None):
+    if not os.path.exists(video_path):
+        print(f"Lỗi: Không tìm thấy file {video_path}")
+        return
+
+    video_name = os.path.basename(video_path)
+    video_prefix = os.path.splitext(video_name)[0]
+    
+    # Nếu không có output_dir, dùng mặc định
+    if output_dir is None:
+        output_dir = os.path.join('output', video_prefix)
+        
+    model_path = 'models/swingnet_1800.pth.tar'
+    phases_dir = os.path.join(output_dir, 'phases')
+    
+    # Thêm số thứ tự để đảm bảo sắp xếp đúng trong thư mục
+    labels = ['1_Address', '2_Toe-up', '3_Mid-Backswing', '4_Top', 
+              '5_Mid-Downswing', '6_Impact', '7_Mid-Follow-Through', '8_Finish']
+    for label in labels: 
+        os.makedirs(os.path.join(phases_dir, label), exist_ok=True)
+        
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model = EventDetector(pretrain=False, width_mult=1., lstm_layers=1, lstm_hidden=256, bidirectional=True, dropout=False)
+    
+    save_dict = torch.load(model_path, map_location=device)
+    model.load_state_dict(save_dict['model_state_dict'])
+    model.to(device).eval()
+    print(f"Mô hình đã sẵn sàng trên {device} (Slow factor: {slow_factor})")
+
+    transform = transforms.Compose([ToTensor(), Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
+    
+    print(f"Đang đọc video {video_path}...")
+    cap = cv2.VideoCapture(video_path)
+    raw_frames = []
+    while True:
+        ret, img = cap.read()
+        if not ret: break
+        raw_frames.append(img)
+    cap.release()
+
+    if not raw_frames:
+        print("Không tìm thấy frame nào.")
+        return
+
+    # Frame Interpolation (Nội suy tuyến tính)
+    if slow_factor < 1.0:
+        print(f"Đang nội suy frame (Slow-mo {slow_factor}x)...")
+        steps = int(1.0 / slow_factor)
+        interpolated_full_res = []
+        for i in range(len(raw_frames) - 1):
+            f1 = raw_frames[i]
+            f2 = raw_frames[i+1]
+            for s in range(steps):
+                alpha = s / steps
+                mixed = cv2.addWeighted(f1, 1-alpha, f2, alpha, 0)
+                interpolated_full_res.append(mixed)
+        interpolated_full_res.append(raw_frames[-1])
+        full_res_frames = interpolated_full_res
+        
+        # Lưu file video slow-motion vật lý
+        slow_video_path = os.path.join(output_dir, "slow_motion.mp4")
+        print(f"Đang ghi file slow motion: {slow_video_path}")
+        
+        # Lấy lại FPS gốc (hoặc mặc định 30)
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        cap.release()
+        if fps <= 0: fps = 30
+        
+        h, w = full_res_frames[0].shape[:2]
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(slow_video_path, fourcc, fps, (w, h))
+        
+        for frame in full_res_frames:
+            out.write(frame)
+        out.release()
+        print(f"Đã tạo video slow motion: {slow_video_path}")
+        
+    else:
+        full_res_frames = raw_frames
+
+    # Tiền xử lý cho AI
+    print("Đang tiền xử lý cho AI...")
+    images = []
+    input_size = 160
+    for img in tqdm(full_res_frames):
+        h, w = img.shape[:2]
+        ratio = input_size / max(h, w)
+        new_size = (int(w * ratio), int(h * ratio))
+        resized = cv2.resize(img, new_size)
+        delta_w, delta_h = input_size - new_size[0], input_size - new_size[1]
+        top, bottom, left, right = delta_h // 2, delta_h - (delta_h // 2), delta_w // 2, delta_w - (delta_w // 2)
+        b_img = cv2.copyMakeBorder(resized, top, bottom, left, right, cv2.BORDER_CONSTANT, value=[0.406*255, 0.456*255, 0.485*255])
+        images.append(cv2.cvtColor(b_img, cv2.COLOR_BGR2RGB))
+    
+    sample = transform({'images': np.asarray(images), 'labels': np.zeros(len(images))})
+    img_tensor = sample['images'].unsqueeze(0).to(device)
+    
+    print("Đang chạy AI Inference...")
+    with torch.no_grad():
+        seq_length, batch, all_logits = 48, 0, []
+        while batch * seq_length < img_tensor.shape[1]:
+            end_idx = min((batch + 1) * seq_length, img_tensor.shape[1])
+            all_logits.append(model(img_tensor[:, batch * seq_length:end_idx, :, :, :]).cpu().numpy())
+            batch += 1
+        
+        logits_concat = np.concatenate(all_logits, axis=0)
+        probs = F.softmax(torch.tensor(logits_concat), dim=1).numpy()
+        
+        # Làm mượt kết quả để giảm nhiễu (đặc biệt cho DTL)
+        probs = smooth_probs(probs, window_size=5)
+        
+        # Áp dụng thuật toán Anchor-based Bidirectional Search
+        # 1. Tìm sự kiện "Neo" (Anchor) đáng tin cậy nhất (thường là Impact hoặc Top)
+        # Chỉ xét 8 lớp sự kiện đầu tiên, bỏ qua lớp số 9 (No Event/Background)
+        probs_events = probs[:, :8]
+        max_probs = np.max(probs_events, axis=0) # Max prob của từng class sự kiện
+        anchor_class = np.argmax(max_probs) # Class có độ tự tin cao nhất trong 8 sự kiện
+        anchor_frame = np.argmax(probs_events[:, anchor_class])
+        
+        print(f"Detected Anchor: {labels[anchor_class]} at frame {anchor_frame} (conf: {max_probs[anchor_class]:.2f})")
+        
+        events = np.zeros(8, dtype=int)
+        events[anchor_class] = anchor_frame
+        
+        # 2. Đi lùi: Tìm các pha trước Anchor
+        current_limit = anchor_frame
+        for i in range(anchor_class - 1, -1, -1):
+            if current_limit > 0:
+                # Tìm max trong vùng cho phép [0, current_limit]
+                segment = probs[0:current_limit, i]
+                if len(segment) > 0:
+                    events[i] = np.argmax(segment)
+                else:
+                    events[i] = 0
+            else:
+                events[i] = 0
+            current_limit = events[i]
+            
+        # 3. Đi tiến: Tìm các pha sau Anchor
+        current_limit = anchor_frame
+        total_frames = probs.shape[0]
+        for i in range(anchor_class + 1, 8):
+            if current_limit < total_frames - 1:
+                # Tìm max trong vùng cho phép [current_limit + 1, end]
+                # Bắt buộc tiến ít nhất 1 frame
+                segment = probs[current_limit + 1:, i]
+                if len(segment) > 0:
+                    events[i] = (current_limit + 1) + np.argmax(segment)
+                else:
+                    events[i] = total_frames - 1
+            else:
+                events[i] = total_frames - 1
+            current_limit = events[i]
+            
+        print(f"Detected Events (Frames): {events}")
+
+        # Lưu thông tin frame index để visual_report sử dụng
+        event_metadata = {}
+        for i, frame_idx in enumerate(events):
+            if frame_idx < len(full_res_frames):
+                cv2.imwrite(os.path.join(phases_dir, labels[i], f"{video_prefix}.jpg"), full_res_frames[frame_idx])
+                event_metadata[labels[i]] = int(frame_idx)
+        
+        # Lấy FPS để đồng bộ phía frontend
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        cap.release()
+        if fps <= 0: fps = 30
+
+        metadata_path = os.path.join(output_dir, "metadata.json")
+        with open(metadata_path, 'w') as f:
+            json.dump({"event_frames": event_metadata, "slow_factor": slow_factor, "fps": fps}, f)
+    
+    print(f"Xong! Ảnh trích xuất lưu tại {phases_dir}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('video_path', nargs='?', default='data/output_video_-M5SITXMA2Y.mp4')
+    parser.add_argument('--slow', type=float, default=1.0, help='Tỉ lệ làm chậm video (0.5, 0.2, ...)')
+    parser.add_argument('--output_dir', type=str, default=None, help='Đường dẫn thư mục đầu ra')
+    args = parser.parse_args()
+    
+    run_ai_extraction(args.video_path, args.slow, args.output_dir)

main.py

@@ -0,0 +1,143 @@
+import os
+import sys
+sys.stdout.reconfigure(encoding="utf-8")
+import json
+import subprocess
+import argparse
+
+def run_step(command, step_desc):
+    """
+    Thực thi một lệnh shell và in kết quả gọn gàng.
+    """
+    print(f"{step_desc}...", end=" ", flush=True)
+    
+    # Force UTF-8 encoding for subprocess
+    env = os.environ.copy()
+    env["PYTHONIOENCODING"] = "utf-8"
+    
+    result = subprocess.run(command, capture_output=True, text=True, errors='replace', encoding='utf-8', env=env)
+    
+    if result.returncode != 0:
+        print("FAILED")
+        print(f"Lỗi chi tiết:\n{result.stderr}")
+        return False
+        
+    print("DONE")
+    return True
+
+def main():
+    # Cấu hình stdout để hỗ trợ tiếng Việt trên Windows terminal
+    if sys.stdout.encoding != 'utf-8':
+        try:
+            sys.stdout.reconfigure(encoding='utf-8')
+            sys.stderr.reconfigure(encoding='utf-8')
+        except AttributeError:
+            import io
+            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+            sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+
+    parser = argparse.ArgumentParser(description='Hệ thống Phân tích Golf thông minh (End-to-End)')
+    parser.add_argument('video_path', help='Đường dẫn đến file video .mp4')
+    parser.add_argument('--slow', type=float, default=1.0, help='Tỷ lệ làm chậm (0.5 hoặc 0.2 để tăng độ chính xác)')
+    args = parser.parse_args()
+
+    video_path = args.video_path
+    video_name = os.path.basename(video_path)
+    video_id = os.path.splitext(video_name)[0]
+    
+    # Tạo thư mục output riêng cho video này
+    output_dir = os.path.join('output', video_id)
+    os.makedirs(output_dir, exist_ok=True)
+
+    print("====================================================")
+    print(f"BẮT ĐẦU PHÂN TÍCH VIDEO: {video_name}")
+    print(f"Thư mục kết quả: {output_dir}")
+    print("====================================================")
+
+    # Bước 1: Trích xuất giai đoạn bằng AI
+    if not run_step([sys.executable, 'extract.py', video_path, '--slow', str(args.slow), '--output_dir', output_dir], 
+                    "[1/4] Nhận diện giai đoạn"):
+        sys.exit(1)
+
+    # Bước 2: Chẩn đoán tư thế (Landmark Analysis)
+    if not run_step([sys.executable, 'analyze.py', output_dir], 
+                    "[2/4] Phân tích tư thế"):
+        sys.exit(1)
+        
+    # Tự động dọn dẹp thư mục phases để tiết kiệm dung lượng
+    import shutil
+    phases_dir = os.path.join(output_dir, 'phases')
+    if os.path.exists(phases_dir):
+        try:
+            shutil.rmtree(phases_dir)
+        except Exception as e:
+            pass # Silent cleanup
+
+    # Bước 3: Đưa ra nhận xét và chấm điểm (Coaching Engine)
+    if not run_step([sys.executable, 'coach.py', output_dir], 
+                    "[3/4] Chấm điểm & Phân tích"):
+        sys.exit(1)
+
+    # Bước 4: Tạo video báo cáo trực quan (Timeline) - ĐÃ LOẠI BỎ ĐỂ CHUYỂN SANG OVERLAY PHÍA CLIENT
+    # slow_video_path = os.path.join(output_dir, "slow_motion.mp4")
+    # target_video_for_report = video_path
+    # if os.path.exists(slow_video_path):
+    #     target_video_for_report = slow_video_path
+    # if not run_step([sys.executable, 'report.py', target_video_for_report, output_dir], 
+    #                 "[4/4] Tạo báo cáo video"):
+    #     sys.exit(1)
+
+    # 4. TỔNG HỢP VÀ DỌN DẸP -> CHỈ GIỮ LẠI MASTER JSON
+    final_report_path = os.path.join(output_dir, "FINAL_report.json")
+    if os.path.exists(final_report_path):
+        try:
+            with open(final_report_path, 'r', encoding='utf-8') as f:
+                report_data = json.load(f)
+            
+            master_data = {
+                "status": "success",
+                "job_id": video_id,
+                "metadata": {},
+                "analysis": {},
+                "coaching": report_data
+            }
+            
+            # Đọc Metadata
+            metadata_path = os.path.join(output_dir, "metadata.json")
+            if os.path.exists(metadata_path):
+                with open(metadata_path, 'r', encoding='utf-8') as f:
+                    master_data["metadata"] = json.load(f)
+            
+            # Đọc Analysis chi tiết
+            report_detail_path = os.path.join(output_dir, "report.json")
+            if os.path.exists(report_detail_path):
+                with open(report_detail_path, 'r', encoding='utf-8') as f:
+                    master_data["analysis"] = json.load(f)
+            
+            # Lưu Master JSON
+            master_json_path = os.path.join(output_dir, "master_data.json")
+            with open(master_json_path, 'w', encoding='utf-8') as f:
+                json.dump(master_data, f, indent=4, ensure_ascii=False)
+            
+            # --- DỌN DẸP FILE TRUNG GIAN (CHỈ GIỮ MASTER JSON) ---
+            annotated_dir = os.path.join(output_dir, "annotated")
+            files_to_delete = [metadata_path, report_detail_path, final_report_path]
+            
+            # Xóa các file JSON trung gian
+            for f_path in files_to_delete:
+                if os.path.exists(f_path):
+                    os.remove(f_path)
+            
+            # Xóa thư mục annotated nếu tồn tại
+            if os.path.exists(annotated_dir):
+                shutil.rmtree(annotated_dir, ignore_errors=True)
+            
+            print(f"\n[MASTER_JSON_CREATED]: {master_json_path}")
+            
+        except Exception as e:
+            print(f"Lưu Master JSON hoặc Dọn dẹp thất bại: {e}")
+    else:
+        print(f"\n[ERROR]: Không tìm thấy FINAL_report.json để tạo Master JSON.")
+
+if __name__ == "__main__":
+    main()

models/mobilenet_v2.pth.tar

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

models/swingnet_1800.pth.tar

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

reengineer.py

@@ -0,0 +1,236 @@
+import cv2
+import json
+import os
+import sys
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import textwrap
+import argparse
+
+# Cấu hình encoding cho stdout để in tiếng Việt
+if sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except AttributeError:
+        import io
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
+POSE_CONNECTIONS = [
+    (11, 12), (11, 13), (13, 15), (12, 14), (14, 16), # Vai - Khuỷu - Cổ tay
+    (11, 23), (12, 24), (23, 24), # Vai - Hông - Hông
+    (23, 25), (24, 26), (25, 27), (26, 28), # Hông - Gối - Cổ chân
+]
+
+def draw_vietnamese_text(img_cv, text, position, font_size=24, color=(255, 255, 255), max_width=None):
+    """Vẽ tiếng Việt lên ảnh OpenCV sử dụng Pillow"""
+    img_pil = Image.fromarray(cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB))
+    draw = ImageDraw.Draw(img_pil)
+    
+    try:
+        # Sử dụng font Arial mặc định (Tìm trong thư mục dự án hoặc hệ thống)
+        base_dir = os.path.dirname(os.path.abspath(__file__))
+        font_path = os.path.join(base_dir, 'font', 'arial.ttf')
+        if not os.path.exists(font_path):
+            font_path = "C:\\Windows\\Fonts\\arial.ttf"
+        
+        font = ImageFont.truetype(font_path, font_size)
+    except:
+        font = ImageFont.load_default()
+    
+    if max_width:
+        avg_char_width = font_size * 0.5 
+        chars_per_line = int(max_width / avg_char_width)
+        wrapped_lines = textwrap.wrap(text, width=chars_per_line)
+        text = "\n".join(wrapped_lines)
+        
+    draw.text(position, text, font=font, fill=color, spacing=6)
+    return cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2BGR)
+
+def draw_glass_panel(img, pt1, pt2, color=(0, 0, 0), alpha=0.5):
+    """Vẽ bảng điều khiển bán trong suốt (Glassmorphism effect)"""
+    overlay = img.copy()
+    cv2.rectangle(overlay, pt1, pt2, color, -1)
+    return cv2.addWeighted(overlay, alpha, img, 1 - alpha, 0)
+
+def reengineer_video(json_path, video_path, output_path=None):
+    """
+    Áp dụng dữ liệu JSON lên video gốc (nguyên kích thước) với overlay cao cấp.
+    """
+    if not os.path.exists(json_path):
+        print(f"Lỗi: Không tìm thấy file JSON tại {json_path}")
+        return
+    if not os.path.exists(video_path):
+        print(f"Lỗi: Không tìm thấy file video tại {video_path}")
+        return
+
+    # 1. Đọc Master JSON
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    metadata = data.get("metadata", {})
+    analysis = data.get("analysis", {})
+    event_frames = metadata.get("event_frames", {})
+    fps_meta = metadata.get("fps", 30)
+
+    # 2. Mở video gốc
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print("Lỗi: Không thể mở video.")
+        return
+
+    vw = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    vh = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps_video = cap.get(cv2.CAP_PROP_FPS)
+    if fps_video <= 0: fps_video = fps_meta
+    
+    # Xử lý ghi đè (Overwrite logic)
+    is_overwrite = False
+    final_output_path = output_path
+    
+    if output_path is None:
+        # Mặc định ghi đè (overwrite) lên chính video gốc
+        final_output_path = video_path
+    
+    # Nếu đường dẫn output trùng với video gốc, cần dùng file tạm
+    if os.path.abspath(final_output_path) == os.path.abspath(video_path):
+        is_overwrite = True
+        temp_output_path = final_output_path + ".tmp.mp4"
+    else:
+        temp_output_path = final_output_path
+
+    print(f"--- Đang tạo video Premium: {os.path.basename(video_path)} ({vw}x{vh}) ---")
+
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(temp_output_path, fourcc, fps_video, (vw, vh))
+
+    idx_to_phase = {int(v): k for k, v in event_frames.items()}
+    current_phase = "1_Address"
+    
+    # Tính toán font size động (Tỉ lệ với chiều cao video)
+    base_font_size = max(18, int(vh / 25))
+    small_font_size = int(base_font_size * 0.7)
+    title_font_size = int(base_font_size * 1.2)
+    line_spacing = int(base_font_size * 1.5)
+    margin = int(vw * 0.05)
+
+    frame_idx = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret: break
+
+        # 3. KIỂM TRA EVENT ĐỂ TẠO CÚ KHỰNG (FREEZE-FRAME)
+        if frame_idx in idx_to_phase:
+            current_phase = idx_to_phase[frame_idx]
+
+            # Tạo frame đặc biệt có overlay cao cấp
+            pause_frame = frame.copy()
+            
+            # --- VẼ SKELETON (MỎNG & TINH TẾ) ---
+            phase_data = analysis.get("phases", {}).get(current_phase)
+            if phase_data and "raw_landmarks" in phase_data:
+                landmarks = phase_data["raw_landmarks"]
+                # Bones (Line thickness: 2)
+                for start_idx, end_idx in POSE_CONNECTIONS:
+                    if start_idx < len(landmarks) and end_idx < len(landmarks):
+                        l1 = landmarks[start_idx]
+                        l2 = landmarks[end_idx]
+                        if l1["visibility"] > 0.5 and l2["visibility"] > 0.5:
+                            p1 = (int(l1["x"] * vw), int(l1["y"] * vh))
+                            p2 = (int(l2["x"] * vw), int(l2["y"] * vh))
+                            cv2.line(pause_frame, p1, p2, (0, 255, 157), 2)
+                
+                # Joints (Ultra-sleek dots)
+                # 1. Xử lý khuôn mặt: 1 chấm mũi + 1 viền tròn đầu
+                nose = landmarks[0]
+                ear_l = landmarks[7]
+                ear_r = landmarks[8]
+                if nose["visibility"] > 0.5:
+                    p_nose = (int(nose["x"] * vw), int(nose["y"] * vh))
+                    # Vẽ chấm mũi
+                    cv2.circle(pause_frame, p_nose, 2, (255, 255, 255), -1)
+                    
+                    # Vẽ viền tròn đầu (Face outline)
+                    if ear_l["visibility"] > 0.5 and ear_r["visibility"] > 0.5:
+                        p_l = np.array([ear_l["x"] * vw, ear_l["y"] * vh])
+                        p_r = np.array([ear_r["x"] * vw, ear_r["y"] * vh])
+                        radius = int(np.linalg.norm(p_l - p_r) * 0.8)
+                        cv2.circle(pause_frame, p_nose, radius, (0, 255, 157), 1)
+
+                # 2. Xử lý các khớp còn lại (Body)
+                for i, lm in enumerate(landmarks):
+                    if lm["visibility"] > 0.5:
+                        # Bỏ qua các điểm mặt 0-10 vì đã xử lý riêng
+                        if i <= 10:
+                            continue
+                        
+                        p = (int(lm["x"] * vw), int(lm["y"] * vh))
+                        # Các khớp thân mình mỏng và nhỏ (Radius: 2)
+                        cv2.circle(pause_frame, p, 2, (255, 255, 255), -1)
+                        cv2.circle(pause_frame, p, 3, (0, 255, 157), 1)
+
+            # --- VẼ BẢNG THÔNG TIN (GLASS OVERLAY - TOP LEFT) ---
+            # Chuyển bảng thông tin lên góc trên bên trái
+            panel_w = int(vw * 0.45)
+            panel_h = int(vh * 0.35)
+            panel_margin = 10
+            
+            # Vẽ panel mờ ở góc trên trái
+            pause_frame = draw_glass_panel(pause_frame, (panel_margin, panel_margin), 
+                                         (panel_margin + panel_w, panel_margin + panel_h), alpha=0.6)
+
+            phase_display_parts = current_phase.split('_', 1)
+            phase_display_name = phase_display_parts[1].upper() if len(phase_display_parts) > 1 else current_phase.upper()
+            
+            # Text nội dung
+            text_x = panel_margin + 20
+            text_y = panel_margin + 40
+            
+            # Title
+            pause_frame = draw_vietnamese_text(pause_frame, f"GIAI ĐOẠN: {phase_display_name}", 
+                                            (text_x, text_y), title_font_size, (0, 255, 157))
+            
+            if phase_data:
+                score = phase_data.get("score", 0)
+                comments = " | ".join(phase_data.get("comments", []))
+                # Điểm số
+                pause_frame = draw_vietnamese_text(pause_frame, f"ĐIỂM: {score}/10", 
+                                                (text_x, text_y + line_spacing), base_font_size, (255, 255, 255))
+                # Nhận xét
+                pause_frame = draw_vietnamese_text(pause_frame, f"NHẬN XÉT: {comments}", 
+                                                (text_x, text_y + line_spacing * 2), small_font_size, (200, 200, 200), max_width=panel_w - 40)
+            # Freeze for 2 seconds
+            for _ in range(int(fps_video * 2.0)):
+                out.write(pause_frame)
+        
+        # 4. GHI FRAME VIDEO BÌNH THƯỜNG
+        display_frame = frame.copy()
+        phase_display_parts = current_phase.split('_', 1)
+        phase_display_name = phase_display_parts[1].upper() if len(phase_display_parts) > 1 else current_phase.upper()
+        
+        # Nhãn nhỏ góc trên
+        label_w = int(vw * 0.3)
+        display_frame = draw_glass_panel(display_frame, (20, 20), (20 + label_w, 20 + line_spacing), alpha=0.4)
+        display_frame = draw_vietnamese_text(display_frame, f"PHA: {phase_display_name}", 
+                                           (30, 25), small_font_size, (0, 255, 157))
+        
+        out.write(display_frame)
+        frame_idx += 1
+
+    cap.release()
+    out.release()
+
+    if is_overwrite:
+        if os.path.exists(video_path):
+            os.remove(video_path)
+        os.rename(temp_output_path, final_output_path)
+
+    print(f"--- HOÀN TẤT! Video lưu tại: {final_output_path} ---")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Golf Video Re-engineer Tool")
+    parser.add_argument("--json", required=True, help="Đường dẫn file master_data.json")
+    parser.add_argument("--video", required=True, help="Đường dẫn video gốc .mp4")
+    parser.add_argument("--output", help="Đường dẫn file đầu ra")
+    
+    args = parser.parse_args()
+    reengineer_video(args.json, args.video, args.output)

requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+uvicorn
+python-multipart
+torch
+torchvision
+opencv-python
+mediapipe==0.10.11
+numpy
+pillow
+tqdm
+jinja2

src/MobileNetV2.py

@@ -0,0 +1,129 @@
+import torch.nn as nn
+import math
+
+"""
+https://github.com/tonylins/pytorch-mobilenet-v2
+"""
+
+def conv_bn(inp, oup, stride):
+    return nn.Sequential(
+        nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
+        nn.BatchNorm2d(oup),
+        nn.ReLU6(inplace=True)
+    )
+
+
+def conv_1x1_bn(inp, oup):
+    return nn.Sequential(
+        nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
+        nn.BatchNorm2d(oup),
+        nn.ReLU6(inplace=True)
+    )
+
+
+class InvertedResidual(nn.Module):
+    def __init__(self, inp, oup, stride, expand_ratio):
+        super(InvertedResidual, self).__init__()
+        self.stride = stride
+        assert stride in [1, 2]
+
+        hidden_dim = round(inp * expand_ratio)
+        self.use_res_connect = self.stride == 1 and inp == oup
+
+        if expand_ratio == 1:
+            self.conv = nn.Sequential(
+                # dw
+                nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False),
+                nn.BatchNorm2d(hidden_dim),
+                nn.ReLU6(inplace=True),
+                # pw-linear
+                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
+                nn.BatchNorm2d(oup),
+            )
+        else:
+            self.conv = nn.Sequential(
+                # pw
+                nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
+                nn.BatchNorm2d(hidden_dim),
+                nn.ReLU6(inplace=True),
+                # dw
+                nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False),
+                nn.BatchNorm2d(hidden_dim),
+                nn.ReLU6(inplace=True),
+                # pw-linear
+                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
+                nn.BatchNorm2d(oup),
+            )
+
+    def forward(self, x):
+        if self.use_res_connect:
+            return x + self.conv(x)
+        else:
+            return self.conv(x)
+
+
+class MobileNetV2(nn.Module):
+    def __init__(self, n_class=1000, input_size=224, width_mult=1.):
+        super(MobileNetV2, self).__init__()
+        block = InvertedResidual
+        min_depth = 16
+        input_channel = 32
+        last_channel = 1280
+        interverted_residual_setting = [
+            # t, c, n, s
+            [1, 16, 1, 1],
+            [6, 24, 2, 2],
+            [6, 32, 3, 2],
+            [6, 64, 4, 2],
+            [6, 96, 3, 1],
+            [6, 160, 3, 2],
+            [6, 320, 1, 1],
+        ]
+
+        # building first layer
+        assert input_size % 32 == 0
+        input_channel = int(input_channel * width_mult) if width_mult >= 1.0 else input_channel
+        self.last_channel = int(last_channel * width_mult) if width_mult > 1.0 else last_channel
+        self.features = [conv_bn(3, input_channel, 2)]
+        # building inverted residual blocks
+        for t, c, n, s in interverted_residual_setting:
+            output_channel = max(int(c * width_mult), min_depth)
+            for i in range(n):
+                if i == 0:
+                    self.features.append(block(input_channel, output_channel, s, expand_ratio=t))
+                else:
+                    self.features.append(block(input_channel, output_channel, 1, expand_ratio=t))
+                input_channel = output_channel
+        # building last several layers
+        self.features.append(conv_1x1_bn(input_channel, self.last_channel))
+        # make it nn.Sequential
+        self.features = nn.Sequential(*self.features)
+
+        # building classifier
+        self.classifier = nn.Sequential(
+            nn.Dropout(0.2),
+            nn.Linear(self.last_channel, n_class),
+        )
+
+        self._initialize_weights()
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.mean(3).mean(2)
+        x = self.classifier(x)
+        return x
+
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+                if m.bias is not None:
+                    m.bias.data.zero_()
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+            elif isinstance(m, nn.Linear):
+                n = m.weight.size(1)
+                m.weight.data.normal_(0, 0.01)
+                m.bias.data.zero_()

src/dataloader.py

@@ -0,0 +1,113 @@
+import os.path as osp
+import cv2
+import pandas as pd
+import numpy as np
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+
+
+class GolfDB(Dataset):
+    def __init__(self, data_file, vid_dir, seq_length, transform=None, train=True):
+        self.df = pd.read_pickle(data_file)
+        self.vid_dir = vid_dir
+        self.seq_length = seq_length
+        self.transform = transform
+        self.train = train
+
+    def __len__(self):
+        return len(self.df)
+
+    def __getitem__(self, idx):
+        a = self.df.loc[idx, :]  # annotation info
+        events = a['events']
+        events -= events[0]  # now frame #s correspond to frames in preprocessed video clips
+
+        images, labels = [], []
+        cap = cv2.VideoCapture(osp.join(self.vid_dir, '{}.mp4'.format(a['id'])))
+
+        if self.train:
+            # random starting position, sample 'seq_length' frames
+            start_frame = np.random.randint(events[-1] + 1)
+            cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+            pos = start_frame
+            while len(images) < self.seq_length:
+                ret, img = cap.read()
+                if ret:
+                    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                    images.append(img)
+                    if pos in events[1:-1]:
+                        labels.append(np.where(events[1:-1] == pos)[0][0])
+                    else:
+                        labels.append(8)
+                    pos += 1
+                else:
+                    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                    pos = 0
+            cap.release()
+        else:
+            # full clip
+            for pos in range(int(cap.get(cv2.CAP_PROP_FRAME_COUNT))):
+                _, img = cap.read()
+                img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                images.append(img)
+                if pos in events[1:-1]:
+                    labels.append(np.where(events[1:-1] == pos)[0][0])
+                else:
+                    labels.append(8)
+            cap.release()
+
+        sample = {'images':np.asarray(images), 'labels':np.asarray(labels)}
+        if self.transform:
+            sample = self.transform(sample)
+        return sample
+
+
+class ToTensor(object):
+    """Convert ndarrays in sample to Tensors."""
+    def __call__(self, sample):
+        images, labels = sample['images'], sample['labels']
+        images = images.transpose((0, 3, 1, 2))
+        return {'images': torch.from_numpy(images).float().div(255.),
+                'labels': torch.from_numpy(labels).long()}
+
+
+class Normalize(object):
+    def __init__(self, mean, std):
+        self.mean = torch.tensor(mean, dtype=torch.float32)
+        self.std = torch.tensor(std, dtype=torch.float32)
+
+    def __call__(self, sample):
+        images, labels = sample['images'], sample['labels']
+        images.sub_(self.mean[None, :, None, None]).div_(self.std[None, :, None, None])
+        return {'images': images, 'labels': labels}
+
+
+if __name__ == '__main__':
+
+    norm = Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])  # ImageNet mean and std (RGB)
+
+    dataset = GolfDB(data_file='data/train_split_1.pkl',
+                     vid_dir='data/videos_160/',
+                     seq_length=64,
+                     transform=transforms.Compose([ToTensor(), norm]),
+                     train=False)
+
+    data_loader = DataLoader(dataset, batch_size=1, shuffle=False, num_workers=6, drop_last=False)
+
+    for i, sample in enumerate(data_loader):
+        images, labels = sample['images'], sample['labels']
+        events = np.where(labels.squeeze() < 8)[0]
+        print('{} events: {}'.format(len(events), events))
+
+
+
+
+    
+
+
+
+
+
+       
+

src/eval.py

@@ -0,0 +1,70 @@
+from model import EventDetector
+import torch
+from torch.utils.data import DataLoader
+from torchvision import transforms
+from dataloader import GolfDB, ToTensor, Normalize
+import torch.nn.functional as F
+import numpy as np
+from util import correct_preds
+
+
+def eval(model, split, seq_length, n_cpu, disp):
+    dataset = GolfDB(data_file='data/val_split_{}.pkl'.format(split),
+                     vid_dir='data/videos_160/',
+                     seq_length=seq_length,
+                     transform=transforms.Compose([ToTensor(),
+                                                   Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
+                     train=False)
+
+    data_loader = DataLoader(dataset,
+                             batch_size=1,
+                             shuffle=False,
+                             num_workers=n_cpu,
+                             drop_last=False)
+
+    correct = []
+
+    for i, sample in enumerate(data_loader):
+        images, labels = sample['images'], sample['labels']
+        # full samples do not fit into GPU memory so evaluate sample in 'seq_length' batches
+        batch = 0
+        while batch * seq_length < images.shape[1]:
+            if (batch + 1) * seq_length > images.shape[1]:
+                image_batch = images[:, batch * seq_length:, :, :, :]
+            else:
+                image_batch = images[:, batch * seq_length:(batch + 1) * seq_length, :, :, :]
+            logits = model(image_batch.cuda())
+            if batch == 0:
+                probs = F.softmax(logits.data, dim=1).cpu().numpy()
+            else:
+                probs = np.append(probs, F.softmax(logits.data, dim=1).cpu().numpy(), 0)
+            batch += 1
+        _, _, _, _, c = correct_preds(probs, labels.squeeze())
+        if disp:
+            print(i, c)
+        correct.append(c)
+    PCE = np.mean(correct)
+    return PCE
+
+
+if __name__ == '__main__':
+
+    split = 1
+    seq_length = 64
+    n_cpu = 6
+
+    model = EventDetector(pretrain=True,
+                          width_mult=1.,
+                          lstm_layers=1,
+                          lstm_hidden=256,
+                          bidirectional=True,
+                          dropout=False)
+
+    save_dict = torch.load('models/swingnet_1800.pth.tar')
+    model.load_state_dict(save_dict['model_state_dict'])
+    model.cuda()
+    model.eval()
+    PCE = eval(model, split, seq_length, n_cpu, True)
+    print('Average PCE: {}'.format(PCE))
+
+

src/model.py

@@ -0,0 +1,74 @@
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+from MobileNetV2 import MobileNetV2
+import os
+
+class EventDetector(nn.Module):
+    def __init__(self, pretrain, width_mult, lstm_layers, lstm_hidden, bidirectional=True, dropout=True):
+        super(EventDetector, self).__init__()
+        self.width_mult = width_mult
+        self.lstm_layers = lstm_layers
+        self.lstm_hidden = lstm_hidden
+        self.bidirectional = bidirectional
+        self.dropout = dropout
+
+        net = MobileNetV2(width_mult=width_mult)
+        
+        # Get the directory of the current script (src/)
+        current_script_directory = os.path.dirname(os.path.abspath(__file__))
+        # Path to models folder (outside src/)
+        relative_directory = '../models/mobilenet_v2.pth.tar'
+        
+        # Construct the absolute path
+        model_dir = os.path.normpath(os.path.join(current_script_directory, relative_directory))
+        
+        # Check cuda availability
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        
+        # Ensure loading model with GPU or CPU
+        state_dict_mobilenet = torch.load(model_dir,map_location=device)
+
+        if pretrain:
+            net.load_state_dict(state_dict_mobilenet)
+
+        self.cnn = nn.Sequential(*list(net.children())[0][:19])
+        self.rnn = nn.LSTM(int(1280*width_mult if width_mult > 1.0 else 1280),
+                           self.lstm_hidden, self.lstm_layers,
+                           batch_first=True, bidirectional=bidirectional)
+        if self.bidirectional:
+            self.lin = nn.Linear(2*self.lstm_hidden, 9)
+        else:
+            self.lin = nn.Linear(self.lstm_hidden, 9)
+        if self.dropout:
+            self.drop = nn.Dropout(0.5)
+
+    def init_hidden(self, batch_size, device):
+        if self.bidirectional:
+            return (Variable(torch.zeros(2*self.lstm_layers, batch_size, self.lstm_hidden).to(device), requires_grad=True),
+                    Variable(torch.zeros(2*self.lstm_layers, batch_size, self.lstm_hidden).to(device), requires_grad=True))
+        else:
+            return (Variable(torch.zeros(self.lstm_layers, batch_size, self.lstm_hidden).to(device), requires_grad=True),
+                    Variable(torch.zeros(self.lstm_layers, batch_size, self.lstm_hidden).to(device), requires_grad=True))
+
+    def forward(self, x, lengths=None):
+        batch_size, timesteps, C, H, W = x.size()
+        self.hidden = self.init_hidden(batch_size, x.device)
+
+        # CNN forward
+        c_in = x.view(batch_size * timesteps, C, H, W)
+        c_out = self.cnn(c_in)
+        c_out = c_out.mean(3).mean(2)
+        if self.dropout:
+            c_out = self.drop(c_out)
+
+        # LSTM forward
+        r_in = c_out.view(batch_size, timesteps, -1)
+        r_out, states = self.rnn(r_in, self.hidden)
+        out = self.lin(r_out)
+        out = out.view(batch_size*timesteps,9)
+
+        return out
+
+
+

src/util.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+
+def correct_preds(probs, labels, tol=-1):
+    """
+    Gets correct events in full-length sequence using tolerance based on number of frames from address to impact.
+    Used during validation only.
+    :param probs: (sequence_length, 9)
+    :param labels: (sequence_length,)
+    :return: array indicating correct events in predicted sequence (8,)
+    """
+
+    events = np.where(labels < 8)[0]
+    preds = np.zeros(len(events))
+    if tol == -1:
+        tol = int(max(np.round((events[5] - events[0])/30), 1))
+    for i in range(len(events)):
+        preds[i] = np.argsort(probs[:, i])[-1]
+    deltas = np.abs(events-preds)
+    correct = (deltas <= tol).astype(np.uint8)
+    return events, preds, deltas, tol, correct
+
+
+def freeze_layers(num_freeze, net):
+    # print("Freezing {:2d} layers".format(num_freeze))
+    i = 1
+    for child in net.children():
+        if i ==1:
+            j = 1
+            for child_child in child.children():
+                if j <= num_freeze:
+                    for param in child_child.parameters():
+                        param.requires_grad = False
+                j += 1
+        i += 1

templates/index.html

@@ -0,0 +1,303 @@
+<!DOCTYPE html>
+<html lang="vi">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Golf AI Analysis - Premium Experience</title>
+    <link
+      href="https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@300;400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
+    <style>
+      :root {
+        --primary: #00ff9d;
+        --primary-dark: #00cc7d;
+        --bg: #050505;
+        --glass: rgba(255, 255, 255, 0.05);
+        --glass-border: rgba(255, 255, 255, 0.1);
+      }
+
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+        font-family: "Plus Jakarta Sans", sans-serif;
+      }
+
+      body {
+        background: var(--bg);
+        color: #fff;
+        min-height: 100vh;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        overflow: hidden;
+      }
+
+      /* Abstract Background */
+      .bg-glow {
+        position: fixed;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        width: 800px;
+        height: 800px;
+        background: radial-gradient(
+          circle,
+          rgba(0, 255, 157, 0.1) 0%,
+          transparent 70%
+        );
+        z-index: -1;
+        filter: blur(100px);
+      }
+
+      .container {
+        width: 100%;
+        max-width: 500px;
+        padding: 2rem;
+        z-index: 1;
+      }
+
+      .card {
+        background: var(--glass);
+        backdrop-filter: blur(20px);
+        border: 1px solid var(--glass-border);
+        border-radius: 24px;
+        padding: 3rem 2rem;
+        text-align: center;
+        box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+      }
+
+      h1 {
+        font-size: 2rem;
+        font-weight: 700;
+        margin-bottom: 0.5rem;
+        background: linear-gradient(to right, #fff, var(--primary));
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+      }
+
+      p {
+        color: #888;
+        margin-bottom: 2.5rem;
+        font-size: 0.95rem;
+      }
+
+      .upload-area {
+        border: 2px dashed var(--glass-border);
+        border-radius: 20px;
+        padding: 3rem 1rem;
+        cursor: pointer;
+        transition: all 0.3s ease;
+        position: relative;
+      }
+
+      .upload-area:hover,
+      .upload-area.dragover {
+        border-color: var(--primary);
+        background: rgba(0, 255, 157, 0.02);
+        transform: translateY(-2px);
+      }
+
+      .upload-icon {
+        font-size: 3rem;
+        margin-bottom: 1rem;
+        display: block;
+      }
+
+      .upload-text {
+        font-weight: 500;
+        color: #ccc;
+      }
+
+      #file-input {
+        display: none;
+      }
+
+      .status-container {
+        display: none;
+        margin-top: 2rem;
+      }
+
+      .progress-bar-bg {
+        width: 100%;
+        height: 6px;
+        background: var(--glass-border);
+        border-radius: 10px;
+        overflow: hidden;
+        margin-bottom: 1rem;
+      }
+
+      .progress-bar-fill {
+        width: 0%;
+        height: 100%;
+        background: var(--primary);
+        box-shadow: 0 0 15px var(--primary);
+        transition: width 0.3s ease;
+      }
+
+      .status-text {
+        font-size: 0.85rem;
+        color: var(--primary);
+        font-weight: 600;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+      }
+
+      .result-btn {
+        display: none;
+        width: 100%;
+        padding: 1rem;
+        border-radius: 12px;
+        border: none;
+        background: var(--primary);
+        color: #000;
+        font-weight: 700;
+        cursor: pointer;
+        margin-top: 1.5rem;
+        transition: all 0.3s ease;
+      }
+
+      .result-btn:hover {
+        background: var(--primary-dark);
+        transform: translateY(-2px);
+        box-shadow: 0 10px 20px rgba(0, 255, 157, 0.2);
+      }
+
+      /* Animations */
+      @keyframes pulse {
+        0% {
+          opacity: 1;
+        }
+        50% {
+          opacity: 0.5;
+        }
+        100% {
+          opacity: 1;
+        }
+      }
+
+      .analyzing {
+        animation: pulse 1.5s infinite ease-in-out;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="bg-glow"></div>
+    <div class="container">
+      <div class="card">
+        <h1>Golf AI Analysis</h1>
+        <p>Tải video swing để nhận phản hồi chuyên sâu</p>
+
+        <div class="upload-area" id="drop-zone">
+          <span class="upload-icon">🚀</span>
+          <span class="upload-text">Kéo thả video hoặc nhấn để chọn</span>
+          <input
+            type="file"
+            id="file-input"
+            accept="video/mp4,video/quicktime"
+          />
+        </div>
+
+        <div class="status-container" id="status-container">
+          <div class="progress-bar-bg">
+            <div class="progress-bar-fill" id="progress-fill"></div>
+          </div>
+          <div class="status-text" id="status-text">Đang chuẩn bị...</div>
+        </div>
+
+        <!-- Simplified Success View -->
+        <div id="success-view" style="display: none; margin-top: 2rem; text-align: center;">
+          <div style="font-size: 4rem; margin-bottom: 1rem;">✅</div>
+          <h2 style="color: var(--primary); margin-bottom: 0.5rem;">PHÂN TÍCH HOÀN TẤT</h2>
+          <p style="margin-bottom: 1.5rem;">File <strong>master_data.json</strong> đã được tải xuống tự động.</p>
+          <button class="result-btn" onclick="location.reload()" style="display: block;">TẢI VIDEO MỚI</button>
+        </div>
+      </div>
+    </div>
+
+    <script>
+      const dropZone = document.getElementById("drop-zone");
+      const fileInput = document.getElementById("file-input");
+      const statusContainer = document.getElementById("status-container");
+      const progressFill = document.getElementById("progress-fill");
+      const statusText = document.getElementById("status-text");
+      const successView = document.getElementById("success-view");
+
+      dropZone.onclick = () => fileInput.click();
+
+      dropZone.ondragover = (e) => { e.preventDefault(); dropZone.classList.add("dragover"); };
+      dropZone.ondragleave = () => { dropZone.classList.remove("dragover"); };
+      dropZone.ondrop = (e) => {
+        e.preventDefault();
+        dropZone.classList.remove("dragover");
+        if (e.dataTransfer.files.length) handleUpload(e.dataTransfer.files[0]);
+      };
+
+      fileInput.onchange = () => {
+        if (fileInput.files.length) handleUpload(fileInput.files[0]);
+      };
+
+      async function handleUpload(file) {
+        dropZone.style.display = "none";
+        statusContainer.style.display = "block";
+        progressFill.style.width = "10%";
+        statusText.innerText = "Đang tải video lên...";
+
+        const formData = new FormData();
+        formData.append("file", file);
+
+        try {
+          let progress = 10;
+          const interval = setInterval(() => {
+            if (progress < 95) {
+              progress += 2;
+              progressFill.style.width = `${progress}%`;
+              if (progress > 30) statusText.innerText = "Đang chạy SwingNet AI...";
+              if (progress > 70) statusText.innerText = "Đang tổng hợp Master JSON...";
+            }
+          }, 500);
+
+          const response = await fetch("/", { method: "POST", body: formData });
+          clearInterval(interval);
+
+          if (!response.ok) throw new Error("Phân tích thất bại");
+
+          // Xử lý JSON Response trực tiếp từ server (Stateless)
+          const resultData = await response.json();
+          
+          // Trigger download file JSON từ dữ liệu trong bộ nhớ
+          const jsonString = JSON.stringify(resultData, null, 4);
+          const blob = new Blob([jsonString], { type: 'application/json' });
+          const url = window.URL.createObjectURL(blob);
+          const a = document.createElement('a');
+          a.style.display = 'none';
+          a.href = url;
+          a.download = 'master_data.json';
+          document.body.appendChild(a);
+          a.click();
+          window.URL.revokeObjectURL(url);
+          document.body.removeChild(a);
+
+          // Hiển thị giao diện thành công
+          showSuccess();
+
+        } catch (error) {
+          statusText.innerText = "LỖI: " + error.message;
+          statusText.style.color = "#ff4d4d";
+        }
+      }
+
+      function showSuccess() {
+        progressFill.style.width = '100%';
+        statusText.innerText = 'THÀNH CÔNG!';
+        statusText.style.color = '#00ff9d';
+        
+        setTimeout(() => {
+          statusContainer.style.display = "none";
+          successView.style.display = "block";
+        }, 800);
+      }
+    </script>
+  </body>
+</html>