initial commit

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+output/images/Screenshot[[:space:]]2024-09-08[[:space:]]030742.png filter=lfs diff=lfs merge=lfs -text
+output/images/Screenshot[[:space:]]2024-09-08[[:space:]]030816.png filter=lfs diff=lfs merge=lfs -text
+output/images/Screenshot[[:space:]]2024-09-08[[:space:]]030836.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,42 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Create static folder structure (if needed by original UI, less critical for pure API)
+RUN mkdir -p static/images
+
+# Install system dependencies required by OpenCV and other libraries
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+# Ensure your requirements.txt is clean and includes gunicorn
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application's source code
+COPY app.py .
+COPY exercises ./exercises
+COPY pose_estimation ./pose_estimation
+COPY feedback ./feedback
+COPY utils ./utils
+COPY db ./db
+COPY static ./static
+COPY templates ./templates
+
+# Make port 8080 available to the world outside this container (Cloud Run default)
+EXPOSE 8080
+
+# Define environment variable for the port
+ENV PORT 8080
+ENV MPLCONFIGDIR /tmp/matplotlib_config_cache
+
+# Run app.py when the container launches using Gunicorn WSGI server
+CMD ["gunicorn", "--worker-class", "eventlet", "-w", "1", "--bind", "0.0.0.0:${PORT}", "--timeout", "0", "app:app"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Yakup Zengin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,255 @@
 ---
-title: FinalTrain
-emoji: 🌖
+title: Fitness Trainer Pose Estimation
+emoji: 💪
 colorFrom: blue
-colorTo: gray
+colorTo: green
 sdk: docker
+app_file: app.py
+health_check_path: /healthz
+app_port: 8080 # Or the port Gunicorn is set to in your Dockerfile CMD
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Fitness Trainer with Pose Estimation
+
+An AI-powered web application that tracks exercises using computer vision and provides real-time feedback. This version now includes **real-time feedback via WebSockets** for an enhanced live training experience.
+
+## Features
+
+- Real-time pose estimation using MediaPipe.
+- Multiple exercise types: Squats, Push-ups, and Hammer Curls.
+- Customizable sets and repetitions (via UI or API parameters).
+- Exercise form feedback.
+- Progress tracking (if database features are enabled).
+- Web interface for easy access, including a live test page using WebSockets.
+- HTTP API for single frame analysis and stateful exercise tracking.
+- **WebSocket API for low-latency, interactive exercise tracking.**
+
+## Installation
+
+1.  Clone the repository:
+    ```bash
+    git clone https://github.com/yourusername/fitness-trainer-pose-estimation.git # Replace with actual repo URL
+    cd fitness-trainer-pose-estimation
+    ```
+
+2.  Install dependencies:
+    ```bash
+    pip install -r requirements.txt
+    ```
+    This will install all necessary Python packages, including Flask, Flask-SocketIO, Gunicorn, eventlet, OpenCV, and MediaPipe.
+
+3.  Set up the static folder structure (if not already present):
+    ```bash
+    mkdir -p static/images
+    ```
+
+4.  Add exercise images to the `static/images` folder (if using the original UI templates):
+    - `squat.png`
+    - `push_up.png`
+    - `hammer_curl.png`
+
+## Usage
+
+### Running Locally (Development)
+
+1.  Start the Flask-SocketIO development server:
+    ```bash
+    python app.py
+    ```
+    This runs the app with Flask's built-in server, suitable for development. It will typically be available at `http://127.0.0.1:5000`.
+
+2.  Access the application:
+    *   **Main UI (if developed):** Open a web browser and navigate to `http://127.0.0.1:5000/`.
+    *   **Live WebSocket Test Page:**
+        1.  To use `live_test.html`, it's recommended to serve it via a Flask route. You can add a simple route to `app.py` like this:
+            ```python
+            @app.route('/live')
+            def live_test_page():
+                return render_template('live_test.html')
+            ```
+            And move `live_test.html` into the `templates` folder.
+            Then access it via `http://127.0.0.1:5000/live`.
+        2.  Alternatively, if you prefer to keep `live_test.html` in the root and test without modifying `app.py` for serving it, you might be able to open the `live_test.html` file directly in your browser. However, ensure the Flask server (`python app.py`) is running, as the JavaScript in `live_test.html` needs to connect to the WebSocket server at `ws://127.0.0.1:5000`. Relative paths to static assets like CSS or JS within the HTML might not work as expected if opened as a direct file, which is why serving it via Flask is more robust.
+
+3.  Using the Live Test Page (`live_test.html`):
+    *   Select an exercise type from the dropdown.
+    *   Click "Start Trainer".
+    *   Allow webcam access if prompted.
+    *   Position yourself in front of your camera so that your full body is visible.
+    *   Observe the real-time feedback (reps, stage, messages) updated via WebSockets.
+    *   Click "Stop Trainer" to end the session.
+
+## API Usage
+
+The application offers two primary ways to interact with its pose estimation capabilities: a traditional HTTP API and a real-time WebSocket API.
+
+### 1. HTTP API
+
+This API is suitable for scenarios where you want to send individual frames or manage exercise sessions via HTTP requests.
+
+#### a. Stateless Single-Frame Analysis (`/api/analyze_frame`)
+
+Analyzes a single image frame for pose landmarks without maintaining state.
+
+*   **URL:** `http://127.0.0.1:5000/api/analyze_frame`
+*   **Method:** `POST`
+*   **Payload (JSON):**
+    *   `image` (string): Base64 encoded image.
+    *   `exercise_type` (string, optional): "squat", "push_up", "hammer_curl". Defaults to "squat".
+*   **Success Response (JSON):** `{"success": true, "landmarks": [...]}`
+*   **Error Response (JSON):** `{"error": "Error message"}`
+
+#### b. Stateful HTTP Exercise Tracking (`/api/track_exercise_stream` and `/api/end_exercise_session`)
+
+These endpoints allow tracking an exercise over a series of frames, maintaining state on the server.
+
+*   **`/api/track_exercise_stream` (POST):**
+    *   **Payload (JSON):**
+        *   `session_id` (string): Unique ID for the session.
+        *   `exercise_type` (string): Exercise type.
+        *   `image` (string): Base64 encoded image of the current frame.
+        *   `frame_width` (int): Width of the video frame.
+        *   `frame_height` (int): Height of the video frame.
+    *   **Success Response (JSON):** Contains `success`, `landmarks_detected`, and exercise-specific `data`.
+*   **`/api/end_exercise_session` (POST):**
+    *   **Payload (JSON):** `session_id` (string).
+    *   **Success Response (JSON):** Confirmation message.
+
+(For detailed request/response structures of the HTTP API, refer to the previous README version or inspect the `app.py` code.)
+
+### 2. WebSocket API for Live Training
+
+This API provides a low-latency, bidirectional communication channel for real-time exercise tracking, as used by `live_test.html`.
+
+*   **Endpoint Connection:** The client connects to the server's root URL, e.g., `ws://127.0.0.1:5000/` (or `wss://your-deployed-app.com/`). Flask-SocketIO handles this on the default namespace.
+*   **Client-side Setup:**
+    1.  Include the Socket.IO client library in your HTML:
+        ```html
+        <script src="https://cdn.socket.io/4.7.2/socket.io.min.js"></script>
+        ```
+    2.  Connect to the server:
+        ```javascript
+        const socket = io(); // Or io.connect('http://your-server-address');
+        ```
+
+*   **Key WebSocket Events:**
+
+    *   **Client to Server:**
+        *   `socket.emit('start_exercise_session', { exercise_type: 'squat' });`
+            *   Call this to initiate a new exercise session.
+            *   `exercise_type` can be 'squat', 'push_up', or 'hammer_curl'.
+        *   `socket.emit('process_frame', { image: 'base64img_data', exercise_type: 'squat', frame_width: width, frame_height: height });`
+            *   Send a video frame for processing.
+            *   `image`: Base64 encoded string of the JPEG frame.
+            *   `exercise_type`: The current exercise.
+            *   `frame_width`, `frame_height`: Dimensions of the original video frame.
+
+    *   **Server to Client:**
+        *   `socket.on('session_started', (data) => { ... });`
+            *   Confirmation that the session has started.
+            *   `data` typically includes: `{ session_id: 'server_assigned_sid', exercise_type: 'squat' }`. The `request.sid` on the server is used as the session identifier for WebSocket communications.
+        *   `socket.on('exercise_update', (data) => { ... });`
+            *   Provides feedback for the processed frame.
+            *   `data` structure:
+                ```json
+                {
+                    "success": true,
+                    "landmarks_detected": true, // or false
+                    "data": {
+                        // Structure depends on the exercise_type (matches HTTP API's track_exercise_stream response data)
+                        // Example for 'squat':
+                        // "counter": 0, "stage": "down", "angle_left": 85.0, "feedback": "Good depth!"
+                        // Example for 'push_up':
+                        // "counter": 0, "stage": "up", "angle_body_left": 170.0, "feedback": "Keep body straight."
+                        // Example for 'hammer_curl':
+                        // "counter_left": 1, "stage_left": "up", "angle_left_curl": 45.0, "feedback_left": "Good curl!", ... (and right side)
+                    },
+                    "message": "Optional message, e.g., 'No landmarks detected.'" // if landmarks_detected is false
+                }
+                ```
+        *   `socket.on('session_error', (data) => { ... });`
+            *   Sent if there's an error starting a session (e.g., invalid exercise type, server busy).
+            *   `data`: `{ error: "Error message description" }`
+        *   `socket.on('frame_error', (data) => { ... });`
+            *   Sent if there's an error processing a specific frame (e.g., bad image data, unexpected server error).
+            *   `data`: `{ error: "Error message description" }`
+        *   `socket.on('disconnect', () => { ... });`
+            *   Standard Socket.IO event. The client is disconnected. Server-side, the `disconnect` handler in `app.py` cleans up the `active_exercise_sessions` entry for that client (`request.sid`).
+
+## Project Structure
+
+- `app.py` - Main Flask application with HTTP routes and SocketIO event handlers.
+- `templates/` - HTML templates (e.g., `index.html`, `live_test.html` if moved here).
+- `static/` - CSS, client-side JavaScript (e.g., `websocket_trainer.js`), and images.
+- `pose_estimation/` - Pose estimation modules.
+- `exercises/` - Exercise tracking classes.
+- `feedback/` - User feedback modules.
+- `utils/` - Helper functions and utilities.
+- `Dockerfile` - For building the application container.
+- `requirements.txt` - Python dependencies.
+- `live_test.html` - Client-side example for testing WebSocket functionality (currently in root, consider moving to `templates/` and serving via a route).
+
+## Technologies Used
+
+- Flask - Web framework.
+- Flask-SocketIO - For WebSocket communication.
+- Gunicorn + eventlet - For concurrent WSGI server suitable for WebSockets.
+- OpenCV - Computer vision tasks.
+- MediaPipe - Pose estimation.
+- HTML/CSS/JavaScript - Frontend.
+
+## Deployment
+
+Containerization with Docker is highly recommended for deployment.
+
+### Dockerfile
+
+The provided `Dockerfile` sets up the Python environment, installs dependencies, and configures Gunicorn to run the application.
+**Key change for WebSockets:** The Dockerfile now uses `eventlet` as the worker class for Gunicorn, which is essential for Flask-SocketIO:
+```dockerfile
+# ... (other Dockerfile instructions) ...
+
+# Run app.py when the container launches using Gunicorn WSGI server
+CMD ["gunicorn", "--worker-class", "eventlet", "-w", "1", "--bind", "0.0.0.0:${PORT}", "--timeout", "0", "app:app"]
+```
+*   `--worker-class eventlet`: Uses the asynchronous eventlet worker.
+*   `-w 1`: Starts 1 worker process. For eventlet, a single worker can handle many concurrent connections.
+*   `--timeout 0`: Disables worker timeouts, important for long-lived WebSocket connections.
+
+### Hosting Options
+
+#### 1. Hugging Face Spaces
+
+- **Setup:** Push your code (including the `Dockerfile` and `app.py`) to a Hugging Face Space repository. Select "Docker" as the Space SDK.
+- **WebSocket Support:** Hugging Face Spaces generally supports WebSockets. The application should be accessible.
+- **Port Configuration:** Ensure your `CMD` in the Dockerfile uses a port variable like `${PORT}` (which HF Spaces sets, often to 7860 or 8080) or a fixed port that HF Spaces can map. The `app_port: 8080` in the README metadata is a common choice.
+
+#### 2. Google Cloud Run
+
+- **Setup:** Build your Docker container and push it to Google Container Registry (GCR) or Artifact Registry. Deploy the image from there to Cloud Run.
+- **WebSocket Support & Session Affinity:**
+    - Cloud Run supports WebSockets.
+    - **Session Affinity:** For applications using Flask-SocketIO with its default in-memory session management (`active_exercise_sessions` in this app, keyed by `request.sid`), session affinity is crucial if you scale to more than one instance. Session affinity directs requests from a specific client to the same container instance. Enable it in your Cloud Run service settings.
+    - **Statelessness Consideration:** While session affinity helps, be aware that `active_exercise_sessions` are still tied to individual instances. If an instance restarts or you scale down and up, that specific instance's memory is lost. For more robust session management across multiple instances or instance restarts, an external store (like Redis via Memorystore) for `active_exercise_sessions` would be necessary. For the current implementation, session affinity is the primary mechanism to make WebSockets work with multiple instances.
+- **Gunicorn Command:** The `CMD` in the Dockerfile is already configured for Cloud Run (binds to `0.0.0.0:${PORT}`).
+
+#### 3. Other PaaS/VPS
+
+- Ensure the platform supports Python and Docker (or allows manual setup of Python, eventlet, Gunicorn).
+- Configure your reverse proxy (like Nginx) correctly to handle WebSocket connections (Upgrade and Connection headers) if you place one in front of Gunicorn.
+
+### Note on Session Management (General)
+
+The current application uses an in-memory Python dictionary (`active_exercise_sessions`) to store user session data, keyed by the WebSocket `request.sid`. This is simple but has limitations:
+*   **Scalability:** Data is not shared across multiple Gunicorn worker processes (if you were to increase `-w` beyond 1, though with `eventlet` one worker is standard) or multiple server instances (e.g., when load balancing or on platforms like Cloud Run with multiple instances).
+*   **Persistence:** Sessions are lost if the server or worker restarts.
+For production environments requiring high availability or scalability, consider implementing session management using an external store like Redis or Memcached.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. Ensure your contributions align with the project's structure and coding style. If adding new features, please update relevant documentation and consider adding tests.
+
+## License
+
+This project is licensed under the MIT License - see the `LICENSE` file for details (if one exists in the repository).

app.py

@@ -0,0 +1,632 @@
+from flask import Flask, render_template, Response, request, jsonify, session, redirect, url_for
+from flask_socketio import SocketIO
+import cv2
+import base64
+import io
+import numpy as np
+from PIL import Image
+import threading
+import time
+import uuid
+import sys
+import traceback
+import logging
+from flask_cors import CORS
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG, 
+                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                   handlers=[logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+# Import attempt with error handling
+try:
+    from pose_estimation.estimation import PoseEstimator
+    from exercises.squat import Squat
+    from exercises.hammer_curl import HammerCurl
+    from exercises.push_up import PushUp
+    from feedback.information import get_exercise_info
+    from feedback.layout import layout_indicators
+    from utils.draw_text_with_background import draw_text_with_background
+    logger.info("Successfully imported pose estimation modules")
+except ImportError as e:
+    logger.error(f"Failed to import required modules: {e}")
+    traceback.print_exc()
+    sys.exit(1)
+
+# Try to import WorkoutLogger with fallback
+try:
+    from db.workout_logger import WorkoutLogger
+    workout_logger = WorkoutLogger()
+    logger.info("Successfully initialized workout logger")
+except ImportError:
+    logger.warning("WorkoutLogger import failed, creating dummy class")
+    
+    class DummyWorkoutLogger:
+        def __init__(self):
+            pass
+        def log_workout(self, *args, **kwargs):
+            return {}
+        def get_recent_workouts(self, *args, **kwargs):
+            return []
+        def get_weekly_stats(self, *args, **kwargs):
+            return {}
+        def get_exercise_distribution(self, *args, **kwargs):
+            return {}
+        def get_user_stats(self, *args, **kwargs):
+            return {'total_workouts': 0, 'total_exercises': 0, 'streak_days': 0}
+    
+    workout_logger = DummyWorkoutLogger()
+
+logger.info("Setting up Flask application")
+app = Flask(__name__)
+app.secret_key = 'fitness_trainer_secret_key'  # Required for sessions
+CORS(app, origins="*", methods=["GET", "POST", "OPTIONS"], allow_headers=["Content-Type", "Authorization"])
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+pose_estimator_api = None
+active_exercise_sessions = {}
+# Max number of concurrent sessions to avoid memory issues
+MAX_SESSIONS = 100 
+
+def get_pose_estimator_api_instance():
+    global pose_estimator_api
+    if pose_estimator_api is None:
+        logger.info("Initializing PoseEstimator for API")
+        pose_estimator_api = PoseEstimator()
+    return pose_estimator_api
+
+# Global variables
+camera = None
+output_frame = None
+lock = threading.Lock()
+exercise_running = False
+current_exercise = None
+current_exercise_data = None
+exercise_counter = 0
+exercise_goal = 0
+sets_completed = 0
+sets_goal = 0
+workout_start_time = None
+
+def initialize_camera():
+    global camera
+    if camera is None:
+        camera = cv2.VideoCapture(0)
+    return camera
+
+def release_camera():
+    global camera
+    if camera is not None:
+        camera.release()
+        camera = None
+
+def generate_frames():
+    global output_frame, lock, exercise_running, current_exercise, current_exercise_data
+    global exercise_counter, exercise_goal, sets_completed, sets_goal
+    
+    pose_estimator = PoseEstimator()
+    
+    while True:
+        if camera is None:
+            continue
+            
+        success, frame = camera.read()
+        if not success:
+            continue
+        
+        # Only process frames if an exercise is running
+        if exercise_running and current_exercise:
+            # Process with pose estimation
+            results = pose_estimator.estimate_pose(frame, current_exercise_data['type'])
+            
+            if results.pose_landmarks:
+                # Track exercise based on type
+                if current_exercise_data['type'] == "squat":
+                    counter, angle, stage = current_exercise.track_squat(results.pose_landmarks.landmark, frame)
+                    layout_indicators(frame, current_exercise_data['type'], (counter, angle, stage))
+                    exercise_counter = counter
+                    
+                elif current_exercise_data['type'] == "push_up":
+                    counter, angle, stage = current_exercise.track_push_up(results.pose_landmarks.landmark, frame)
+                    layout_indicators(frame, current_exercise_data['type'], (counter, angle, stage))
+                    exercise_counter = counter
+                    
+                elif current_exercise_data['type'] == "hammer_curl":
+                    (counter_right, angle_right, counter_left, angle_left,
+                     warning_message_right, warning_message_left, progress_right, 
+                     progress_left, stage_right, stage_left) = current_exercise.track_hammer_curl(
+                        results.pose_landmarks.landmark, frame)
+                    layout_indicators(frame, current_exercise_data['type'], 
+                                     (counter_right, angle_right, counter_left, angle_left,
+                                      warning_message_right, warning_message_left, 
+                                      progress_right, progress_left, stage_right, stage_left))
+                    exercise_counter = max(counter_right, counter_left)
+                
+                # Display exercise information
+                exercise_info = get_exercise_info(current_exercise_data['type'])
+                draw_text_with_background(frame, f"Exercise: {exercise_info.get('name', 'N/A')}", (40, 50),
+                                         cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255), (118, 29, 14), 1)
+                draw_text_with_background(frame, f"Reps Goal: {exercise_goal}", (40, 80),
+                                         cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255), (118, 29, 14), 1)
+                draw_text_with_background(frame, f"Sets Goal: {sets_goal}", (40, 110),
+                                         cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255), (118, 29, 14), 1)
+                draw_text_with_background(frame, f"Current Set: {sets_completed + 1}", (40, 140),
+                                         cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255), (118, 29, 14), 1)
+                
+                # Check if rep goal is reached for current set
+                if exercise_counter >= exercise_goal:
+                    sets_completed += 1
+                    exercise_counter = 0
+                    # Reset exercise counter in the appropriate exercise object
+                    if current_exercise_data['type'] == "squat" or current_exercise_data['type'] == "push_up":
+                        current_exercise.counter = 0
+                    elif current_exercise_data['type'] == "hammer_curl":
+                        current_exercise.counter_right = 0
+                        current_exercise.counter_left = 0
+                    
+                    # Check if all sets are completed
+                    if sets_completed >= sets_goal:
+                        exercise_running = False
+                        draw_text_with_background(frame, "WORKOUT COMPLETE!", (frame.shape[1]//2 - 150, frame.shape[0]//2),
+                                                cv2.FONT_HERSHEY_DUPLEX, 1.2, (255, 255, 255), (0, 200, 0), 2)
+                    else:
+                        draw_text_with_background(frame, f"SET {sets_completed} COMPLETE! Rest for 30 sec", 
+                                                (frame.shape[1]//2 - 200, frame.shape[0]//2),
+                                                cv2.FONT_HERSHEY_DUPLEX, 1.0, (255, 255, 255), (0, 0, 200), 2)
+                        # We could add rest timer functionality here
+        else:
+            # Display welcome message if no exercise is running
+            cv2.putText(frame, "Select an exercise to begin", (frame.shape[1]//2 - 150, frame.shape[0]//2),
+                       cv2.FONT_HERSHEY_DUPLEX, 0.8, (255, 255, 255), 1)
+                
+        # Encode the frame in JPEG format
+        with lock:
+            output_frame = frame.copy()
+            
+        # Yield the frame in byte format
+        ret, buffer = cv2.imencode('.jpg', output_frame)
+        frame = buffer.tobytes()
+        yield (b'--frame\r\n'
+               b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
+
+@app.route('/')
+def index():
+    """Home page with exercise selection"""
+    logger.info("Rendering index page")
+    try:
+        return render_template('index.html')
+    except Exception as e:
+        logger.error(f"Error rendering index: {e}")
+        return f"Error rendering template: {str(e)}", 500
+
+@app.route('/dashboard')
+def dashboard():
+    """Dashboard page with workout statistics"""
+    logger.info("Rendering dashboard page")
+    try:
+        # Get data for the dashboard
+        recent_workouts = workout_logger.get_recent_workouts(5)
+        weekly_stats = workout_logger.get_weekly_stats()
+        exercise_distribution = workout_logger.get_exercise_distribution()
+        user_stats = workout_logger.get_user_stats()
+        
+        # Format workouts for display
+        formatted_workouts = []
+        for workout in recent_workouts:
+            formatted_workouts.append({
+                'date': workout['date'],
+                'exercise': workout['exercise_type'].replace('_', ' ').title(),
+                'sets': workout['sets'],
+                'reps': workout['reps'],
+                'duration': f"{workout['duration_seconds'] // 60}:{workout['duration_seconds'] % 60:02d}"
+            })
+        
+        # Calculate total workouts this week
+        weekly_workout_count = sum(day['workout_count'] for day in weekly_stats.values())
+        
+        return render_template('dashboard.html',
+                              recent_workouts=formatted_workouts,
+                              weekly_workouts=weekly_workout_count,
+                              total_workouts=user_stats['total_workouts'],
+                              total_exercises=user_stats['total_exercises'],
+                              streak_days=user_stats['streak_days'])
+    except Exception as e:
+        logger.error(f"Error in dashboard: {e}")
+        traceback.print_exc()
+        return f"Error loading dashboard: {str(e)}", 500
+
+@app.route('/video_feed')
+def video_feed():
+    """Video streaming route"""
+    return Response(generate_frames(),
+                   mimetype='multipart/x-mixed-replace; boundary=frame')
+
+@app.route('/start_exercise', methods=['POST'])
+def start_exercise():
+    """Start a new exercise based on user selection"""
+    global exercise_running, current_exercise, current_exercise_data
+    global exercise_counter, exercise_goal, sets_completed, sets_goal
+    global workout_start_time
+    
+    data = request.json
+    exercise_type = data.get('exercise_type')
+    sets_goal = int(data.get('sets', 3))
+    exercise_goal = int(data.get('reps', 10))
+    
+    # Initialize camera if not already done
+    initialize_camera()
+    
+    # Reset counters
+    exercise_counter = 0
+    sets_completed = 0
+    workout_start_time = time.time()
+    
+    # Initialize the appropriate exercise class
+    if exercise_type == "squat":
+        current_exercise = Squat()
+    elif exercise_type == "push_up":
+        current_exercise = PushUp()
+    elif exercise_type == "hammer_curl":
+        current_exercise = HammerCurl()
+    else:
+        return jsonify({'success': False, 'error': 'Invalid exercise type'})
+    
+    # Store exercise data
+    current_exercise_data = {
+        'type': exercise_type,
+        'sets': sets_goal,
+        'reps': exercise_goal
+    }
+    
+    # Start the exercise
+    exercise_running = True
+    
+    return jsonify({'success': True})
+
+@app.route('/stop_exercise', methods=['POST'])
+def stop_exercise():
+    """Stop the current exercise and log the workout"""
+    global exercise_running, current_exercise_data, workout_start_time
+    global exercise_counter, exercise_goal, sets_completed, sets_goal
+    
+    if exercise_running and current_exercise_data:
+        # Calculate duration
+        duration = int(time.time() - workout_start_time) if workout_start_time else 0
+        
+        # Log the workout
+        workout_logger.log_workout(
+            exercise_type=current_exercise_data['type'],
+            sets=sets_completed + (1 if exercise_counter > 0 else 0),  # Include partial set
+            reps=exercise_goal,
+            duration_seconds=duration
+        )
+    release_camera()
+    exercise_running = False
+    return jsonify({'success': True})
+
+@app.route('/get_status', methods=['GET'])
+def get_status():
+    """Return current exercise status"""
+    global exercise_counter, sets_completed, exercise_goal, sets_goal, exercise_running
+    
+    return jsonify({
+        'exercise_running': exercise_running,
+        'current_reps': exercise_counter,
+        'current_set': sets_completed + 1 if exercise_running else 0,
+        'total_sets': sets_goal,
+        'rep_goal': exercise_goal
+    })
+
+@app.route('/profile')
+def profile():
+    """User profile page - placeholder for future development"""
+    return "Profile page - Coming soon!"
+
+@app.route('/healthz')
+def health_check():
+    logger.info("Health check endpoint called successfully.")
+    return "OK", 200
+
+@app.route('/api/analyze_frame', methods=['POST'])
+def analyze_frame():
+    logger.info("API call to /api/analyze_frame")
+    try:
+        data = request.json
+        if not data or 'image' not in data:
+            logger.warning("API /api/analyze_frame: No image provided or invalid JSON.")
+            return jsonify({'error': 'No image provided in JSON payload (expected base64 string under "image" key)'}), 400
+        
+        # Use 'squat' as a default if not provided. This primarily affects server-side drawing, not the landmarks themselves.
+        exercise_type_for_api = data.get('exercise_type', 'squat')
+        if exercise_type_for_api not in ["squat", "push_up", "hammer_curl"]: # Validate against known types if necessary
+            logger.warning(f"API /api/analyze_frame: Invalid exercise_type '{exercise_type_for_api}'. Defaulting to 'squat'.")
+            exercise_type_for_api = "squat"
+
+        image_data = data['image']
+        
+        # Add padding if missing for base64 decoding
+        missing_padding = len(image_data) % 4
+        if missing_padding:
+            image_data += '=' * (4 - missing_padding)
+
+        try:
+            # Decode the base64 string
+            image_bytes = base64.b64decode(image_data)
+            pil_image = Image.open(io.BytesIO(image_bytes))
+            # Convert PIL image (RGB) to OpenCV frame (BGR)
+            frame = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+        except Exception as e:
+            logger.error(f"API /api/analyze_frame: Error decoding base64 image: {e}")
+            return jsonify({'error': f'Invalid base64 image data: {str(e)}'}), 400
+
+        estimator = get_pose_estimator_api_instance()
+        
+        # Process with pose estimation
+        results = estimator.estimate_pose(frame, exercise_type_for_api) 
+        
+        landmarks_list = []
+        if results.pose_landmarks:
+            for i, landmark in enumerate(results.pose_landmarks.landmark):
+                landmarks_list.append({
+                    'index': i,
+                    'x': landmark.x,
+                    'y': landmark.y,
+                    'z': landmark.z,
+                    'visibility': landmark.visibility if hasattr(landmark, 'visibility') else None
+                })
+            logger.info(f"API /api/analyze_frame: Successfully processed image, found {len(landmarks_list)} landmarks for exercise type '{exercise_type_for_api}'.")
+            return jsonify({'success': True, 'landmarks': landmarks_list})
+        else:
+            logger.info(f"API /api/analyze_frame: No landmarks detected in the provided image for exercise type '{exercise_type_for_api}'.")
+            return jsonify({'success': True, 'landmarks': []})
+
+    except Exception as e:
+        logger.error(f"API /api/analyze_frame: Error: {e}")
+        traceback.print_exc()
+        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
+
+@app.route('/api/track_exercise_stream', methods=['POST'])
+def track_exercise_stream():
+    logger.info("API call to /api/track_exercise_stream")
+    data = {} # Initialize data to ensure it's defined for logging in case of early errors
+    try:
+        data = request.json
+        if not data:
+            return jsonify({'error': 'No JSON data provided'}), 400
+
+        session_id = data.get('session_id')
+        exercise_type = data.get('exercise_type')
+        image_data_base64 = data.get('image')
+        frame_width = data.get('frame_width')
+        frame_height = data.get('frame_height')
+
+        if not all([session_id, exercise_type, image_data_base64, frame_width, frame_height]):
+            return jsonify({'error': 'Missing required fields: session_id, exercise_type, image, frame_width, frame_height'}), 400
+
+        if not isinstance(frame_width, int) or not isinstance(frame_height, int) or frame_width <= 0 or frame_height <= 0:
+            return jsonify({'error': 'Invalid frame_width or frame_height'}), 400
+        
+        # Manage session limit
+        if len(active_exercise_sessions) >= MAX_SESSIONS and session_id not in active_exercise_sessions:
+            logger.warning(f"Max sessions ({MAX_SESSIONS}) reached. Rejecting new session {session_id}.")
+            # Optional: could try to evict oldest session
+            return jsonify({'error': 'Server busy, max sessions reached. Please try again later.'}), 503
+
+
+        # Get or create exercise session object
+        if session_id not in active_exercise_sessions:
+            logger.info(f"Creating new session {session_id} for exercise {exercise_type}")
+            if exercise_type == 'squat':
+                active_exercise_sessions[session_id] = Squat()
+            elif exercise_type == 'push_up':
+                active_exercise_sessions[session_id] = PushUp()
+            elif exercise_type == 'hammer_curl':
+                active_exercise_sessions[session_id] = HammerCurl()
+            else:
+                logger.warning(f"Invalid exercise type: {exercise_type} for session {session_id}")
+                return jsonify({'error': 'Invalid exercise_type'}), 400
+        
+        exercise_session = active_exercise_sessions[session_id]
+
+        # Decode image (similar to /api/analyze_frame)
+        missing_padding = len(image_data_base64) % 4
+        if missing_padding:
+            image_data_base64 += '=' * (4 - missing_padding)
+        try:
+            image_bytes = base64.b64decode(image_data_base64)
+            pil_image = Image.open(io.BytesIO(image_bytes))
+            frame_for_estimation = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR) # For PoseEstimator
+        except Exception as e:
+            logger.error(f"Session {session_id}: Error decoding base64 image: {e}")
+            return jsonify({'error': f'Invalid base64 image data: {str(e)}'}), 400
+
+        # Get pose landmarks
+        pose_estimator = get_pose_estimator_api_instance() # Reusing the existing estimator instance getter
+        # The 'squat' here is just a default for PoseEstimator's internal drawing logic, which we don't use for API response.
+        # The actual exercise type for tracking is handled by `exercise_session` object.
+        results = pose_estimator.estimate_pose(frame_for_estimation, 'squat') 
+
+        if not results.pose_landmarks:
+            logger.info(f"Session {session_id}: No landmarks detected.")
+            # Return current state even if no new landmarks, or specific message
+            return jsonify({
+                'success': True, 
+                'landmarks_detected': False,
+                'message': 'No landmarks detected in this frame.',
+                # Optionally, could return last known state from exercise_session if needed
+            })
+        
+        exercise_data = None
+        if exercise_type == 'squat':
+            exercise_data = exercise_session.track_squat(results.pose_landmarks.landmark, frame_width, frame_height)
+        elif exercise_type == 'push_up':
+            exercise_data = exercise_session.track_push_up(results.pose_landmarks.landmark, frame_width, frame_height)
+        elif exercise_type == 'hammer_curl':
+            exercise_data = exercise_session.track_hammer_curl(results.pose_landmarks.landmark, frame_width, frame_height)
+        
+        if exercise_data:
+            logger.debug(f"Session {session_id}: Exercise data: {exercise_data}")
+            return jsonify({'success': True, 'landmarks_detected': True, 'data': exercise_data})
+        else:
+            # Should not happen if exercise_type is valid and session initialized
+            logger.error(f"Session {session_id}: Could not get exercise_data for {exercise_type}")
+            return jsonify({'error': 'Failed to process exercise frame.'}), 500
+
+    except Exception as e:
+        session_id_log = data.get('session_id', 'unknown_session') if isinstance(data, dict) else 'unknown_session'
+        logger.error(f"API /api/track_exercise_stream Error for session {session_id_log}: {e}")
+        traceback.print_exc()
+        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
+
+@app.route('/api/end_exercise_session', methods=['POST'])
+def end_exercise_session():
+    logger.info("API call to /api/end_exercise_session")
+    try:
+        data = request.json
+        if not data:
+            return jsonify({'error': 'No JSON data provided'}), 400
+        
+        session_id = data.get('session_id')
+        if not session_id:
+            return jsonify({'error': 'Missing session_id'}), 400
+
+        if session_id in active_exercise_sessions:
+            del active_exercise_sessions[session_id]
+            logger.info(f"Ended and removed session: {session_id}")
+            return jsonify({'success': True, 'message': f'Session {session_id} ended.'})
+        else:
+            logger.warning(f"Attempted to end non-existent session: {session_id}")
+            return jsonify({'success': False, 'message': f'Session {session_id} not found.'}), 404
+    except Exception as e:
+        logger.error(f"API /api/end_exercise_session Error: {e}")
+        traceback.print_exc()
+        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
+
+# SocketIO Event Handlers
+
+@socketio.on('connect')
+def handle_connect():
+    logger.info(f"Client connected: {request.sid}")
+    socketio.emit('connection_ack', {'message': 'Connected to server', 'sid': request.sid}, room=request.sid)
+
+@socketio.on('disconnect')
+def handle_disconnect():
+    logger.info(f"Client disconnected: {request.sid}")
+    if request.sid in active_exercise_sessions:
+        del active_exercise_sessions[request.sid]
+        logger.info(f"Cleaned up exercise session for disconnected client {request.sid}")
+
+@socketio.on('start_exercise_session')
+def handle_start_exercise_session(data):
+    exercise_type = data.get('exercise_type')
+    logger.info(f"Attempting to start exercise session for {request.sid} with type: {exercise_type}")
+
+    if not exercise_type:
+        logger.warning(f"Session start for {request.sid} failed: no exercise_type provided.")
+        socketio.emit('session_error', {'error': 'exercise_type is required.'}, room=request.sid)
+        return
+
+    if len(active_exercise_sessions) >= MAX_SESSIONS and request.sid not in active_exercise_sessions:
+        logger.warning(f"Max sessions ({MAX_SESSIONS}) reached. Rejecting new session for {request.sid}.")
+        socketio.emit('session_error', {'error': 'Server busy, max sessions reached.'}, room=request.sid)
+        return
+
+    if request.sid in active_exercise_sessions:
+        logger.info(f"Session for {request.sid} already exists. Re-initializing for new exercise: {exercise_type}")
+        # Optionally, could end the previous exercise type cleanly if needed
+        # For now, just overwrite with the new one or ensure client manages this flow.
+
+    if exercise_type == 'squat':
+        active_exercise_sessions[request.sid] = {'exercise': Squat(), 'type': exercise_type}
+    elif exercise_type == 'push_up':
+        active_exercise_sessions[request.sid] = {'exercise': PushUp(), 'type': exercise_type}
+    elif exercise_type == 'hammer_curl':
+        active_exercise_sessions[request.sid] = {'exercise': HammerCurl(), 'type': exercise_type}
+    else:
+        logger.warning(f"Invalid exercise type: {exercise_type} for session {request.sid}")
+        socketio.emit('session_error', {'error': 'Invalid exercise_type'}, room=request.sid)
+        return
+    
+    logger.info(f"Successfully created exercise session for {request.sid}, type: {exercise_type}")
+    socketio.emit('session_started', {'session_id': request.sid, 'exercise_type': exercise_type}, room=request.sid)
+
+@socketio.on('process_frame')
+def handle_process_frame(data):
+    # logger.debug(f"Received frame from {request.sid} for processing.") # Too verbose for every frame
+    if request.sid not in active_exercise_sessions:
+        logger.warning(f"Frame received from {request.sid} without an active session.")
+        socketio.emit('frame_error', {'error': 'No active session. Please start an exercise session first.'}, room=request.sid)
+        return
+
+    session_info = active_exercise_sessions.get(request.sid)
+    exercise_session = session_info['exercise']
+    session_exercise_type = session_info['type']
+
+    image_data_base64 = data.get('image')
+    frame_width = data.get('frame_width')
+    frame_height = data.get('frame_height')
+    # client_exercise_type = data.get('exercise_type') # Client sends this, ensure it matches session
+
+    # if client_exercise_type != session_exercise_type:
+    #     logger.warning(f"Mismatched exercise type from client {request.sid}. Expected {session_exercise_type}, got {client_exercise_type}")
+    #     socketio.emit('frame_error', {'error': f'Mismatched exercise type. Current session is for {session_exercise_type}.'}, room=request.sid)
+    #     return
+
+    if not all([image_data_base64, frame_width, frame_height]):
+        logger.warning(f"Missing data in process_frame for {request.sid}: image, frame_width, or frame_height missing.")
+        socketio.emit('frame_error', {'error': 'Missing image, frame_width, or frame_height.'}, room=request.sid)
+        return
+
+    try:
+        missing_padding = len(image_data_base64) % 4
+        if missing_padding:
+            image_data_base64 += '=' * (4 - missing_padding)
+        
+        image_bytes = base64.b64decode(image_data_base64)
+        pil_image = Image.open(io.BytesIO(image_bytes))
+        frame_for_estimation = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+    except Exception as e:
+        logger.error(f"Error decoding base64 image for {request.sid}: {e}")
+        socketio.emit('frame_error', {'error': f'Invalid base64 image data: {str(e)}'}, room=request.sid)
+        return
+
+    pose_estimator = get_pose_estimator_api_instance()
+    # The 'squat' parameter to estimate_pose is a default for drawing, actual logic is in exercise_session
+    results = pose_estimator.estimate_pose(frame_for_estimation, session_exercise_type) 
+
+    exercise_data_result = None
+    if results.pose_landmarks:
+        if session_exercise_type == 'squat':
+            exercise_data_result = exercise_session.track_squat(results.pose_landmarks.landmark, frame_width, frame_height)
+        elif session_exercise_type == 'push_up':
+            exercise_data_result = exercise_session.track_push_up(results.pose_landmarks.landmark, frame_width, frame_height)
+        elif session_exercise_type == 'hammer_curl':
+            exercise_data_result = exercise_session.track_hammer_curl(results.pose_landmarks.landmark, frame_width, frame_height)
+        
+        if exercise_data_result:
+            # logger.debug(f"Exercise data for {request.sid}: {exercise_data_result}")
+            socketio.emit('exercise_update', {'success': True, 'landmarks_detected': True, 'data': exercise_data_result}, room=request.sid)
+        else:
+            # This case should ideally not be reached if landmarks are detected and exercise type is valid
+            logger.error(f"Could not get exercise data for {request.sid}, type {session_exercise_type}, despite landmarks.")
+            socketio.emit('exercise_update', {'success': False, 'landmarks_detected': True, 'message': 'Error processing landmarks.'}, room=request.sid)
+    else:
+        # logger.info(f"No landmarks detected for {request.sid}.")
+        socketio.emit('exercise_update', {'success': True, 'landmarks_detected': False, 'message': 'No landmarks detected.'}, room=request.sid)
+
+    except Exception as e:
+        logger.error(f"Error processing frame for {request.sid}: {e}")
+        traceback.print_exc()
+        socketio.emit('frame_error', {'error': f'Internal server error during frame processing: {str(e)}'}, room=request.sid)
+
+
+if __name__ == '__main__':
+    try:
+        logger.info("Starting the Flask application on http://127.0.0.1:5000")
+        print("Starting Fitness Trainer app, please wait...")
+        print("Open http://127.0.0.1:5000 in your web browser when the server starts")
+        socketio.run(app, debug=True, host='0.0.0.0', port=5000)
+    except Exception as e:
+        logger.error(f"Failed to start application: {e}")
+        traceback.print_exc()

create_static_folders.py

@@ -0,0 +1,63 @@
+import os
+import shutil
+from pathlib import Path
+
+def create_directory_structure():
+    """Create the necessary directory structure for static files."""
+    base_dir = Path(__file__).parent
+    
+    # Create static directories
+    static_dir = base_dir / 'static'
+    css_dir = static_dir / 'css'
+    js_dir = static_dir / 'js'
+    images_dir = static_dir / 'images'
+    
+    # Create directories if they don't exist
+    for directory in [static_dir, css_dir, js_dir, images_dir]:
+        directory.mkdir(exist_ok=True)
+        print(f"Created directory: {directory}")
+    
+    # Create sample images if they don't exist
+    create_placeholder_image(images_dir / 'squat.png', "Squat")
+    create_placeholder_image(images_dir / 'push_up.png', "Push Up")
+    create_placeholder_image(images_dir / 'hammer_curl.png', "Hammer Curl")
+    
+    print("\nDirectory structure created successfully!")
+    print(f"Static files should be placed in: {static_dir}")
+    print("Make sure the following files exist:")
+    print(f"  - {images_dir / 'squat.png'}")
+    print(f"  - {images_dir / 'push_up.png'}")
+    print(f"  - {images_dir / 'hammer_curl.png'}")
+
+def create_placeholder_image(filepath, text="Exercise"):
+    """Create a simple placeholder image using PIL."""
+    try:
+        from PIL import Image, ImageDraw, ImageFont
+        
+        # Create a blank image with a colored background
+        img = Image.new('RGB', (200, 200), color=(73, 109, 137))
+        d = ImageDraw.Draw(img)
+        
+        # Try to use a default font
+        try:
+            font = ImageFont.truetype("arial.ttf", 18)
+        except IOError:
+            font = ImageFont.load_default()
+        
+        # Draw text in the center of the image
+        d.text((100, 100), text, fill=(255, 255, 255), anchor="mm", font=font)
+        
+        # Save the image
+        img.save(filepath)
+        print(f"Created placeholder image: {filepath}")
+        
+    except ImportError:
+        # If PIL is not available, create an empty file
+        print("PIL not installed. Installing empty image files.")
+        with open(filepath, 'wb') as f:
+            f.write(b'')
+        print(f"Created empty file: {filepath}")
+
+if __name__ == "__main__":
+    create_directory_structure()
+    print("\nRun 'pip install pillow' if you want to generate proper placeholder images.")

exercises/hammer_curl.py

@@ -0,0 +1,114 @@
+import cv2
+import numpy as np
+from pose_estimation.angle_calculation import calculate_angle
+from voice_feedback.feedback import  provide_hammer_curl_feedback , speak
+
+
+class HammerCurl:
+    def __init__(self):
+        self.counter_right = 0
+        self.counter_left = 0
+        self.stage_right = None  # 'up' or 'down' for right arm
+        self.stage_left = None  # 'up' or 'down' for left arm
+
+        self.angle_threshold = 40  # Angle threshold for misalignment
+        self.flexion_angle_up = 155  # Flexion angle for 'up' stage
+        self.flexion_angle_down = 35  # Flexion angle for 'down' stage
+
+        self.angle_threshold_up = 155  # Upper threshold for 'up' stage
+        self.angle_threshold_down = 47  # Lower threshold for 'down' stage
+
+    def calculate_shoulder_elbow_hip_angle(self, shoulder, elbow, hip):
+        """Calculate the angle between shoulder, elbow, and hip."""
+        return calculate_angle(elbow, shoulder, hip)
+
+    def calculate_shoulder_elbow_wrist(self, shoulder, elbow, wrist):
+        """Calculate the angle between shoulder, elbow, and wrist."""
+        return calculate_angle(shoulder, elbow, wrist)
+
+    def track_hammer_curl(self, landmarks, frame):
+        # Right arm landmarks (shoulder, elbow, hip, wrist)
+        shoulder_right = [int(landmarks[11].x * frame.shape[1]), int(landmarks[11].y * frame.shape[0])]
+        elbow_right = [int(landmarks[13].x * frame.shape[1]), int(landmarks[13].y * frame.shape[0])]
+        hip_right = [int(landmarks[23].x * frame.shape[1]), int(landmarks[23].y * frame.shape[0])]
+        wrist_right = [int(landmarks[15].x * frame.shape[1]), int(landmarks[15].y * frame.shape[0])]
+
+        # Left arm landmarks (shoulder, elbow, hip, wrist)
+        shoulder_left = [int(landmarks[12].x * frame.shape[1]), int(landmarks[12].y * frame.shape[0])]
+        elbow_left = [int(landmarks[14].x * frame.shape[1]), int(landmarks[14].y * frame.shape[0])]
+        hip_left = [int(landmarks[24].x * frame.shape[1]), int(landmarks[24].y * frame.shape[0])]
+        wrist_left = [int(landmarks[16].x * frame.shape[1]), int(landmarks[16].y * frame.shape[0])]
+
+        # Calculate the angle for counting (elbow flexion angle)
+        angle_right_counter = self.calculate_shoulder_elbow_wrist(shoulder_right, elbow_right, wrist_right)
+        angle_left_counter = self.calculate_shoulder_elbow_wrist(shoulder_left, elbow_left, wrist_left)
+
+        # Calculate the angle for the right arm (shoulder, elbow, hip)
+        angle_right = self.calculate_shoulder_elbow_hip_angle(shoulder_right, elbow_right, hip_right)
+
+        # Calculate the angle for the left arm (shoulder, elbow, hip)
+        angle_left = self.calculate_shoulder_elbow_hip_angle(shoulder_left, elbow_left, hip_left)
+
+        # Draw lines with improved style
+        self.draw_line_with_style(frame, shoulder_left, elbow_left, (0, 0, 255), 4)
+        self.draw_line_with_style(frame, elbow_left, wrist_left, (0, 0, 255), 4)
+
+        self.draw_line_with_style(frame, shoulder_right, elbow_right, (0, 0, 255), 4)
+        self.draw_line_with_style(frame, elbow_right, wrist_right, (0, 0, 255), 4)
+
+        # Add circles to highlight key points
+        self.draw_circle(frame, shoulder_left, (0, 0, 255), 8)
+        self.draw_circle(frame, elbow_left, (0, 0, 255), 8)
+        self.draw_circle(frame, wrist_left, (0, 0, 255), 8)
+
+        self.draw_circle(frame, shoulder_right, (0, 0, 255), 8)
+        self.draw_circle(frame, elbow_right, (0, 0, 255), 8)
+        self.draw_circle(frame, wrist_right, (0, 0, 255), 8)
+
+        # Convert the angles to integers and update the text positions
+        angle_text_position_left = (elbow_left[0] + 10, elbow_left[1] - 10)
+        cv2.putText(frame, f'Angle: {int(angle_left_counter)}', angle_text_position_left, cv2.FONT_HERSHEY_SIMPLEX, 0.5,
+                     (255, 255, 255), 2)
+
+        angle_text_position_right = (elbow_right[0] + 10, elbow_right[1] - 10)
+        cv2.putText(frame, f'Angle: {int(angle_right_counter)}', angle_text_position_right, cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    (255, 255, 255), 2)
+
+        warning_message_right = None
+        warning_message_left = None
+
+        # Check for misalignment based on shoulder-elbow-hip angle
+        if abs(angle_right) > self.angle_threshold:
+            warning_message_right = f"Right Shoulder-Elbow-Hip Misalignment! Angle: {angle_right:.2f}°"
+        if abs(angle_left) > self.angle_threshold:
+            warning_message_left = f"Left Shoulder-Elbow-Hip Misalignment! Angle: {angle_left:.2f}°"
+
+        if angle_right_counter > self.angle_threshold_up:
+            self.stage_right = "Flex"
+        elif self.angle_threshold_down < angle_right_counter < self.angle_threshold_up and self.stage_right == "Flex":
+            self.stage_right = "Up"
+        elif angle_right_counter < self.angle_threshold_down and self.stage_right=="Up":
+            self.stage_right = "Down"
+            self.counter_right +=1
+
+        if angle_left_counter > self.angle_threshold_up:
+            self.stage_left = "Flex"
+        elif self.angle_threshold_down < angle_left_counter < self.angle_threshold_up and self.stage_left == "Flex":
+            self.stage_left = "Up"
+        elif angle_left_counter < self.angle_threshold_down and self.stage_left == "Up":
+            self.stage_left = "Down"
+            self.counter_left +=1
+
+        # Progress percentages: 1 for "up", 0 for "down"
+        progress_right = 1 if self.stage_right == "up" else 0
+        progress_left = 1 if self.stage_left == "up" else 0
+
+        return self.counter_right, angle_right_counter, self.counter_left, angle_left_counter, warning_message_right, warning_message_left, progress_right, progress_left, self.stage_right, self.stage_left
+
+    def draw_line_with_style(self, frame, start_point, end_point, color, thickness):
+        cv2.line(frame, start_point, end_point, color, thickness, lineType=cv2.LINE_AA)
+
+    def draw_circle(self, frame, center, color, radius):
+        """Draw a circle with specified style."""
+        cv2.circle(frame, center, radius, color, -1)  # -1 to fill the circle

exercises/push_up.py

@@ -0,0 +1,130 @@
+import mediapipe as mp
+import time
+from pose_estimation.angle_calculation import calculate_angle
+
+class PushUp:
+    def __init__(self):
+        self.counter = 0
+        self.stage = "up"  # Changed from "Initial"
+        self.angle_threshold_up = 150
+        self.angle_threshold_down = 70
+        self.last_counter_update = time.time()
+        self.mp_pose = mp.solutions.pose # Added
+
+    def calculate_shoulder_elbow_wrist_angle(self, shoulder, elbow, wrist):
+        """Calculate the angle between shoulder, elbow, and wrist."""
+        return calculate_angle(shoulder, elbow, wrist)
+
+    def track_push_up(self, landmarks_mp, frame_width, frame_height):
+        lm = landmarks_mp # shortcut
+
+        # Left side landmarks
+        shoulder_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x * frame_width),
+                         int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y * frame_height)]
+        elbow_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].y * frame_height)]
+        wrist_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_WRIST.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.LEFT_WRIST.value].y * frame_height)]
+
+        # Right side landmarks
+        shoulder_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x * frame_width),
+                          int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y * frame_height)]
+        elbow_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].x * frame_width),
+                       int(lm[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].y * frame_height)]
+        wrist_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].x * frame_width),
+                       int(lm[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].y * frame_height)]
+
+        # Calculate angles
+        angle_left = self.calculate_shoulder_elbow_wrist_angle(shoulder_left, elbow_left, wrist_left)
+        angle_right = self.calculate_shoulder_elbow_wrist_angle(shoulder_right, elbow_right, wrist_right)
+
+        # Stage and Counter Logic
+        current_angle_for_logic = angle_left 
+        current_time = time.time()
+
+        if current_angle_for_logic > self.angle_threshold_up:
+            self.stage = "up"
+        elif self.angle_threshold_down < current_angle_for_logic < self.angle_threshold_up and self.stage == "up":
+            self.stage = "down"
+        elif current_angle_for_logic < self.angle_threshold_down and self.stage == "down":
+            if current_time - self.last_counter_update > 1:  # 1 second debounce
+                self.counter += 1
+                self.last_counter_update = current_time
+            self.stage = "up" # Transition back to up
+            
+        feedback = self._get_push_up_feedback(angle_left, angle_right, self.stage)
+
+        return {
+            "counter": self.counter,
+            "stage": self.stage,
+            "angle_left": angle_left,
+            "angle_right": angle_right,
+            "feedback": feedback
+        }
+
+    def _get_push_up_feedback(self, angle_left, angle_right, stage):
+        feedback = "Keep going!" # Default
+        
+        if stage == "down":
+            if min(angle_left, angle_right) < self.angle_threshold_down - 5:
+                feedback = "Good depth!"
+            elif min(angle_left, angle_right) > self.angle_threshold_down + 10:
+                feedback = "Go lower."
+        elif stage == "up":
+             feedback = "Push up!" # Or "Ready"
+        
+        if abs(angle_left - angle_right) > 25:
+            feedback += " Try to keep your push-up even." if feedback != "Keep going!" else "Try to keep your push-up even."
+        
+        return feedback.strip()
+
+    def get_drawing_annotations(self, landmarks_mp, frame_width, frame_height, exercise_data_dict):
+        annotations = []
+        lm = landmarks_mp # shortcut
+
+        # Pixel coordinates
+        shoulder_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x * frame_width),
+                         int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y * frame_height)]
+        elbow_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.LEFT_ELBOW.value].y * frame_height)]
+        wrist_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_WRIST.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.LEFT_WRIST.value].y * frame_height)]
+
+        shoulder_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x * frame_width),
+                          int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y * frame_height)]
+        elbow_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].x * frame_width),
+                       int(lm[self.mp_pose.PoseLandmark.RIGHT_ELBOW.value].y * frame_height)]
+        wrist_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].x * frame_width),
+                       int(lm[self.mp_pose.PoseLandmark.RIGHT_WRIST.value].y * frame_height)]
+
+        # Lines (original colors: left (0,0,255) -> BGR [255,0,0], right (102,0,0) -> BGR [0,0,102])
+        annotations.append({"type": "line", "start_point": shoulder_left, "end_point": elbow_left, "color_bgr": [255, 0, 0], "thickness": 2})
+        annotations.append({"type": "line", "start_point": elbow_left, "end_point": wrist_left, "color_bgr": [255, 0, 0], "thickness": 2})
+        annotations.append({"type": "line", "start_point": shoulder_right, "end_point": elbow_right, "color_bgr": [0, 0, 102], "thickness": 2})
+        annotations.append({"type": "line", "start_point": elbow_right, "end_point": wrist_right, "color_bgr": [0, 0, 102], "thickness": 2})
+
+        # Circles
+        annotations.append({"type": "circle", "center_point": shoulder_left, "radius": 8, "color_bgr": [255, 0, 0], "filled": True})
+        annotations.append({"type": "circle", "center_point": elbow_left, "radius": 8, "color_bgr": [255, 0, 0], "filled": True})
+        annotations.append({"type": "circle", "center_point": wrist_left, "radius": 8, "color_bgr": [255, 0, 0], "filled": True})
+        annotations.append({"type": "circle", "center_point": shoulder_right, "radius": 8, "color_bgr": [0, 0, 102], "filled": True})
+        annotations.append({"type": "circle", "center_point": elbow_right, "radius": 8, "color_bgr": [0, 0, 102], "filled": True})
+        annotations.append({"type": "circle", "center_point": wrist_right, "radius": 8, "color_bgr": [0, 0, 102], "filled": True})
+
+        # Text for angles
+        if 'angle_left' in exercise_data_dict:
+            annotations.append({"type": "text", "text_content": f"Angle L: {int(exercise_data_dict['angle_left'])}", 
+                                "position": [elbow_left[0] + 10, elbow_left[1] - 10], 
+                                "font_scale": 0.5, "color_bgr": [255, 255, 255], "thickness": 2})
+        if 'angle_right' in exercise_data_dict:
+            annotations.append({"type": "text", "text_content": f"Angle R: {int(exercise_data_dict['angle_right'])}", 
+                                "position": [elbow_right[0] + 10, elbow_right[1] - 10], 
+                                "font_scale": 0.5, "color_bgr": [255, 255, 255], "thickness": 2})
+
+        # Display main feedback from exercise_data_dict
+        if 'feedback' in exercise_data_dict:
+             annotations.append({"type": "text", "text_content": exercise_data_dict['feedback'],
+                                "position": [frame_width // 2 - 150, frame_height - 40], # Adjusted for longer text
+                                "font_scale": 0.7, "color_bgr": [0, 255, 0], "thickness": 2}) # Green for feedback
+        
+        return annotations

exercises/squat.py

@@ -0,0 +1,142 @@
+import mediapipe as mp
+from pose_estimation.angle_calculation import calculate_angle
+
+class Squat:
+    def __init__(self):
+        self.counter = 0
+        self.stage = "up"  # Initial stage
+        self.mp_pose = mp.solutions.pose # Added for convenience
+
+    def calculate_angle(self, point1, point2, point3): # Assuming these are pixel coordinates
+        return calculate_angle(point1, point2, point3)
+
+    def track_squat(self, landmarks_mp, frame_width, frame_height):
+        lm = landmarks_mp # shortcut
+
+        # Left side landmarks
+        shoulder_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x * frame_width),
+                         int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y * frame_height)]
+        hip_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_HIP.value].x * frame_width),
+                    int(lm[self.mp_pose.PoseLandmark.LEFT_HIP.value].y * frame_height)]
+        knee_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_KNEE.value].x * frame_width),
+                     int(lm[self.mp_pose.PoseLandmark.LEFT_KNEE.value].y * frame_height)]
+        # ankle_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_ANKLE.value].x * frame_width),
+        #               int(lm[self.mp_pose.PoseLandmark.LEFT_ANKLE.value].y * frame_height)]
+
+
+        # Right side landmarks
+        shoulder_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x * frame_width),
+                          int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y * frame_height)]
+        hip_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_HIP.value].x * frame_width),
+                     int(lm[self.mp_pose.PoseLandmark.RIGHT_HIP.value].y * frame_height)]
+        knee_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].y * frame_height)]
+        # ankle_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_ANKLE.value].x * frame_width),
+        #                int(lm[self.mp_pose.PoseLandmark.RIGHT_ANKLE.value].y * frame_height)]
+
+        # Calculate angles
+        angle_left = self.calculate_angle(shoulder_left, hip_left, knee_left)
+        angle_right = self.calculate_angle(shoulder_right, hip_right, knee_right)
+
+        # Stage and counter logic (using angle_left for primary logic)
+        current_angle_for_logic = angle_left 
+        if current_angle_for_logic > 170:
+            self.stage = "up"
+        elif 90 < current_angle_for_logic < 170 and self.stage == "up":
+            self.stage = "down"
+        elif current_angle_for_logic < 90 and self.stage == "down":
+            self.stage = "up"
+            self.counter += 1
+        
+        feedback_message = self._get_squat_feedback(angle_left, angle_right, self.stage, 
+                                                    knee_left, hip_left, shoulder_left, 
+                                                    knee_right, hip_right, shoulder_right)
+
+        return {
+            "counter": self.counter,
+            "stage": self.stage,
+            "angle_left": angle_left,
+            "angle_right": angle_right,
+            "feedback": feedback_message
+        }
+
+    def _get_squat_feedback(self, angle_left, angle_right, stage, 
+                            knee_left, hip_left, shoulder_left, 
+                            knee_right, hip_right, shoulder_right): # Added points for future use
+        feedback = "Keep going." # Default feedback
+
+        if stage == "down":
+            if min(angle_left, angle_right) < 80:
+                feedback = "Good depth!"
+            elif min(angle_left, angle_right) > 100: # Knees should be more bent
+                feedback = "Go lower."
+        
+        if abs(angle_left - angle_right) > 20: # Check for uneven squat
+             # Adding a check to see if there's significant movement, e.g., not in "up" stage fully extended
+            if not (stage == "up" and min(angle_left, angle_right) > 160): # Avoid this message if standing straight
+                feedback += " Try to keep your squat even." if feedback != "Keep going." else "Try to keep your squat even."
+
+
+        # Placeholder for more advanced feedback using the passed points:
+        # E.g., Knee valgus: check if knee_left.x < hip_left.x and knee_left.x > shoulder_left.x (simplified)
+        # E.g., Back posture: calculate angle shoulder-hip-ankle (requires ankle points)
+
+        return feedback.strip()
+
+
+    def get_drawing_annotations(self, landmarks_mp, frame_width, frame_height, exercise_data_dict):
+        annotations = []
+        lm = landmarks_mp # shortcut
+
+        # Re-calculate or retrieve necessary points (pixel coordinates)
+        # For simplicity, re-calculating here. Could be optimized by passing from track_squat.
+        shoulder_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].x * frame_width),
+                         int(lm[self.mp_pose.PoseLandmark.LEFT_SHOULDER.value].y * frame_height)]
+        hip_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_HIP.value].x * frame_width),
+                    int(lm[self.mp_pose.PoseLandmark.LEFT_HIP.value].y * frame_height)]
+        knee_left = [int(lm[self.mp_pose.PoseLandmark.LEFT_KNEE.value].x * frame_width),
+                     int(lm[self.mp_pose.PoseLandmark.LEFT_KNEE.value].y * frame_height)]
+
+        shoulder_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x * frame_width),
+                          int(lm[self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y * frame_height)]
+        hip_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_HIP.value].x * frame_width),
+                     int(lm[self.mp_pose.PoseLandmark.RIGHT_HIP.value].y * frame_height)]
+        knee_right = [int(lm[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].x * frame_width),
+                      int(lm[self.mp_pose.PoseLandmark.RIGHT_KNEE.value].y * frame_height)]
+
+        # Lines for left side (original color: (178, 102, 255) -> BGR: [255, 102, 178])
+        annotations.append({"type": "line", "start_point": shoulder_left, "end_point": hip_left, "color_bgr": [255, 102, 178], "thickness": 2})
+        annotations.append({"type": "line", "start_point": hip_left, "end_point": knee_left, "color_bgr": [255, 102, 178], "thickness": 2})
+
+        # Lines for right side (original color: (51, 153, 255) -> BGR: [255, 153, 51])
+        annotations.append({"type": "line", "start_point": shoulder_right, "end_point": hip_right, "color_bgr": [255, 153, 51], "thickness": 2})
+        annotations.append({"type": "line", "start_point": hip_right, "end_point": knee_right, "color_bgr": [255, 153, 51], "thickness": 2})
+
+        # Circles for left side
+        annotations.append({"type": "circle", "center_point": shoulder_left, "radius": 8, "color_bgr": [255, 102, 178], "filled": True})
+        annotations.append({"type": "circle", "center_point": hip_left, "radius": 8, "color_bgr": [255, 102, 178], "filled": True})
+        annotations.append({"type": "circle", "center_point": knee_left, "radius": 8, "color_bgr": [255, 102, 178], "filled": True})
+
+        # Circles for right side
+        annotations.append({"type": "circle", "center_point": shoulder_right, "radius": 8, "color_bgr": [255, 153, 51], "filled": True})
+        annotations.append({"type": "circle", "center_point": hip_right, "radius": 8, "color_bgr": [255, 153, 51], "filled": True})
+        annotations.append({"type": "circle", "center_point": knee_right, "radius": 8, "color_bgr": [255, 153, 51], "filled": True})
+
+        # Text for angles
+        if 'angle_left' in exercise_data_dict:
+            annotations.append({"type": "text", "text_content": f"Angle L: {int(exercise_data_dict['angle_left'])}", 
+                                "position": [knee_left[0] + 10, knee_left[1] - 10], 
+                                "font_scale": 0.5, "color_bgr": [255, 255, 255], "thickness": 2})
+        if 'angle_right' in exercise_data_dict:
+            annotations.append({"type": "text", "text_content": f"Angle R: {int(exercise_data_dict['angle_right'])}", 
+                                "position": [knee_right[0] + 10, knee_right[1] - 10], 
+                                "font_scale": 0.5, "color_bgr": [255, 255, 255], "thickness": 2})
+        
+        # Display main feedback from exercise_data_dict
+        if 'feedback' in exercise_data_dict:
+             annotations.append({"type": "text", "text_content": exercise_data_dict['feedback'],
+                                "position": [frame_width // 2 - 100, frame_height - 40], # Centered at bottom
+                                "font_scale": 0.7, "color_bgr": [0, 0, 255], "thickness": 2})
+
+
+        return annotations

feedback/indicators.py

@@ -0,0 +1,50 @@
+# feedback/indicators.py
+from utils.drawing_utils import draw_gauge_meter,draw_progress_bar,display_stage,display_counter
+
+display_counter_poisiton=(40, 240)
+display_stage_poisiton=(40, 270)
+display_counter_angel_color=(255,255,0)
+
+
+def draw_squat_indicators(frame, counter, angle, stage):
+    # Counter
+    display_counter(frame,counter, position=display_counter_poisiton, color=(0, 0, 0),background_color=(192,192,192))
+
+    # Stage
+    display_stage(frame, stage,"Stage", position=display_stage_poisiton, color=(0, 0, 0),background_color=(192,192,192))
+
+    draw_progress_bar(frame, exercise="squat", value=counter, position=(40, 170), size=(200, 20), color=(163, 245, 184, 1),background_color=(255,255,255))
+
+    draw_gauge_meter(frame, angle=angle, text="Squat Gauge Meter", position=(135, 415), radius=75, color=(0, 0, 255))
+
+def draw_pushup_indicators(frame, counter, angle, stage):
+    # Counter
+    display_counter(frame,counter, position=display_counter_poisiton, color=(0, 0, 0),background_color=(192,192,192))
+
+    display_stage(frame, stage,"Stage", position=display_stage_poisiton, color=(0, 0, 0),background_color=(192,192,192))
+    draw_progress_bar(frame, exercise="push_up", value=counter, position=(40, 170), size=(200, 20), color=(163, 245, 184, 1),background_color=(255,255,255))
+
+    text = "Push-u Gauge Meter"
+    draw_gauge_meter(frame, angle=angle,text=text, position=(350,80), radius=50, color=(0, 102, 204))
+
+
+def draw_hammercurl_indicators(frame, counter_right, angle_right, counter_left, angle_left, stage_right, stage_left):
+    display_counter_poisiton_left_arm = (40, 300)
+
+    # Right Arm Indicators
+    display_counter(frame, counter_right, position=display_counter_poisiton, color=(0, 0, 0),background_color=(192,192,192))
+
+    display_stage(frame, stage_right,"Right Stage", position=display_stage_poisiton, color=(0, 0, 0),background_color=(192,192,192))
+    display_stage(frame, stage_left,"Left Stage", position=display_counter_poisiton_left_arm, color=(0, 0, 0),background_color=(192,192,192))
+
+    # Progress Bars
+    draw_progress_bar(frame, exercise="hammer_curl", value=(counter_right+counter_left)/2, position=(40, 170), size=(200, 20), color=(163, 245, 184, 1),background_color=(255,255,255))
+
+    text_right = "Right Gauge Meter"
+    text_left = "Left Gauge Meter"
+
+    # Gauge Meters for Angles
+    draw_gauge_meter(frame, angle=angle_right,text=text_right, position=(1200,80), radius=50, color=(0, 102, 204))
+    draw_gauge_meter(frame, angle=angle_left,text=text_left, position=(1200,240), radius=50, color=(0, 102, 204))
+
+

feedback/information.py

@@ -0,0 +1,41 @@
+def get_exercise_info(exercise_type):
+    exercises = {
+        "hammer_curl": {
+            "name": "Hammer Curl",
+            "target_muscles": ["Biceps", "Brachialis"],
+            "equipment": "Dumbbells",
+            "reps": 8,
+            "sets": 1,
+            "rest_time": "60 seconds",
+            "benefits": [
+                "Improves bicep and forearm strength",
+                "Enhances grip strength"
+            ]
+        },
+        "push_up": {
+            "name": "Push-Up",
+            "target_muscles": ["Chest", "Triceps", "Shoulders"],
+            "equipment": "Bodyweight",
+            "reps": 10,
+            "sets": 1,
+            "rest_time": "45 seconds",
+            "benefits": [
+                "Builds upper body strength",
+                "Improves core stability"
+            ]
+        },
+        "squat": {
+            "name": "Squat",
+            "target_muscles": ["Quads", "Glutes", "Hamstrings"],
+            "equipment": "Bodyweight or Barbell",
+            "reps": 2,
+            "sets": 3,
+            "rest_time": "60 seconds",
+            "benefits": [
+                "Builds lower body strength",
+                "Improves mobility and balance"
+            ]
+        }
+    }
+
+    return exercises.get(exercise_type, {})

feedback/layout.py

@@ -0,0 +1,16 @@
+# feedback/layout.py
+
+from feedback.indicators import draw_squat_indicators, draw_pushup_indicators, draw_hammercurl_indicators
+
+def layout_indicators(frame, exercise_type, exercise_data):
+    if exercise_type == "squat":
+        counter, angle, stage = exercise_data
+        draw_squat_indicators(frame, counter, angle, stage)
+    elif exercise_type == "push_up":
+        counter, angle, stage = exercise_data
+        draw_pushup_indicators(frame, counter, angle, stage)
+    elif exercise_type == "hammer_curl":
+        (counter_right, angle_right, counter_left, angle_left,
+         warning_message_right, warning_message_left, progress_right, progress_left,stage_right,stage_left) = exercise_data
+        draw_hammercurl_indicators(frame, counter_right, angle_right, counter_left, angle_left, stage_right,stage_left)
+

live_test.html

@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Live Fitness Trainer Test (WebSocket)</title>
+    <script src="https://cdn.socket.io/4.7.2/socket.io.min.js"></script>
+    <style>
+        body { font-family: sans-serif; display: flex; flex-direction: column; align-items: center; margin: 0; padding: 20px; background-color: #f4f4f4; }
+        #controls { margin-bottom: 20px; padding: 15px; background-color: #fff; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        label, select, button { font-size: 1em; margin: 5px; }
+        button { padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer; }
+        button:disabled { background-color: #ccc; }
+        button:hover:not(:disabled) { background-color: #0056b3; }
+        #videoContainer { display: flex; flex-wrap: wrap; justify-content: center; gap: 20px; margin-bottom: 20px; }
+        video { border: 2px solid #007bff; transform: scaleX(-1); border-radius: 8px; background-color: #000; } /* Flip video for mirror effect */
+        #feedbackArea { border: 1px solid #ccc; padding: 15px; width: 320px; background-color: #fff; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+        #feedbackArea h3 { margin-top: 0; color: #007bff; }
+        #feedbackArea p { margin: 8px 0; }
+        #feedbackArea span { font-weight: bold; color: #333; }
+        /* .hidden class is not strictly needed as JS controls display style directly */
+        /* However, if used by JS: .hidden { display: none; } */
+    </style>
+</head>
+<body>
+    <h1>Live Fitness Trainer Test (WebSocket)</h1>
+
+    <div id="controls">
+        <label for="exerciseTypeSelect">Exercise:</label>
+        <select id="exerciseTypeSelect">
+            <option value="squat">Squat</option>
+            <option value="push_up">Push Up</option>
+            <option value="hammer_curl">Hammer Curl</option>
+        </select>
+        <button id="startButton">Start Trainer</button>
+        <button id="stopButton" disabled>Stop Trainer</button>
+    </div>
+
+    <div id="videoContainer">
+        <div>
+            <h3>Your Webcam</h3>
+            <video id="videoElement" width="320" height="240" autoplay playsinline></video>
+        </div>
+        <div id="feedbackArea">
+            <h3>Feedback & Status</h3>
+            <!-- These are not directly updated by websocket_trainer.js but can be kept for manual/other updates if needed -->
+            <p>Session ID: <span id="sessionIdDisplay">-</span></p> <!-- websocket_trainer.js doesn't update this -->
+            <p>Status: <span id="statusDisplay">Idle</span></p> <!-- websocket_trainer.js doesn't update this -->
+            <hr>
+
+            <!-- Generic UI for Squat/Push-up -->
+            <div class="generic-exercise-specific">
+                <p>Reps: <span id="repsDisplay">0</span></p>
+                <p>Stage: <span id="stageDisplay">-</span></p>
+                <p>Feedback: <span id="feedbackDisplay">-</span></p>
+                <p>Angle: <span id="angleDisplay">-</span></p>
+            </div>
+
+            <!-- Specific UI for Hammer Curl -->
+            <div class="hammer-curl-specific" style="display: none;"> <!-- Initially hidden by style, JS will manage -->
+                <p>Reps Left: <span id="repsLeftDisplay">0</span> | Reps Right: <span id="repsRightDisplay">0</span></p>
+                <p>Stage Left: <span id="stageLeftDisplay">-</span> | Stage Right: <span id="stageRightDisplay">-</span></p>
+                <p>Feedback Left: <span id="feedbackLeftDisplay">-</span></p>
+                <p>Feedback Right: <span id="feedbackRightDisplay">-</span></p>
+                <!-- The generic 'angleDisplay' is used for hammer curl angles by websocket_trainer.js -->
+            </div>
+        </div>
+    </div>
+
+    <script src="static/js/websocket_trainer.js"></script>
+</body>
+</html>

main.py

@@ -0,0 +1,82 @@
+import cv2
+from pose_estimation.estimation import PoseEstimator
+from exercises.squat import Squat
+from exercises.hammer_curl import HammerCurl
+from exercises.push_up import PushUp
+from feedback.layout import layout_indicators
+from feedback.information import get_exercise_info
+from utils.draw_text_with_background import draw_text_with_background
+
+def main():
+    video_path = r"C:\Users\yakupzengin\Fitness-Trainer\data\squat.mp4"
+    video_path = r"C:\Users\yakupzengin\Fitness-Trainer\data\push_up.mp4"
+    video_path = r"C:\Users\yakupzengin\Fitness-Trainer\data\dumbel-workout.mp4"
+
+    exercise_type = "hammer_curl"  # Egzersiz türünü belirleyin ("hammer_curl", "squat", "push_up")
+
+    cap = cv2.VideoCapture(0)
+    pose_estimator = PoseEstimator()
+
+    if exercise_type == "hammer_curl":
+        exercise = HammerCurl()
+    elif exercise_type == "squat":
+        exercise = Squat()
+    elif exercise_type == "push_up":
+        exercise = PushUp()
+    else:
+        print("Invalid exercise type.")
+        return
+
+    exercise_info = get_exercise_info(exercise_type)
+
+    fourcc = cv2.VideoWriter_fourcc(*'XVID')
+    output_file = r"C:\Users\yakupzengin\Fitness-Trainer\output\push-up.avi"
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    out = cv2.VideoWriter(output_file, fourcc, fps, (frame_width, frame_height))
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        results = pose_estimator.estimate_pose(frame, exercise_type)
+        if results.pose_landmarks:
+            if exercise_type == "squat":
+                counter, angle, stage = exercise.track_squat(results.pose_landmarks.landmark, frame)
+                layout_indicators(frame, exercise_type, (counter, angle, stage))
+            elif exercise_type == "hammer_curl":
+                (counter_right, angle_right, counter_left, angle_left,
+                 warning_message_right, warning_message_left, progress_right, progress_left, stage_right, stage_left) = exercise.track_hammer_curl(
+                    results.pose_landmarks.landmark, frame)
+                layout_indicators(frame, exercise_type,
+                                  (counter_right, angle_right, counter_left, angle_left,
+                                   warning_message_right, warning_message_left, progress_right, progress_left, stage_right, stage_left))
+            elif exercise_type == "push_up":
+                counter, angle, stage = exercise.track_push_up(results.pose_landmarks.landmark, frame)
+                layout_indicators(frame, exercise_type, (counter, angle, stage))
+
+        draw_text_with_background(frame, f"Exercise: {exercise_info.get('name', 'N/A')}", (40, 50),
+                                  cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255,), (118, 29, 14, 0.79), 1)
+        draw_text_with_background(frame, f"Reps: {exercise_info.get('reps', 0)}", (40, 80),
+                                  cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255,), (118, 29, 14, 0.79), 1)
+        draw_text_with_background(frame, f"Sets: {exercise_info.get('sets', 0)}", (40, 110),
+                                  cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255,), (118, 29, 14, 0.79),1 )
+
+        out.write(frame)
+
+        cv2.namedWindow(f"{exercise_type.replace('_', ' ').title()} Tracker", cv2.WINDOW_NORMAL)
+        cv2.resizeWindow(f"{exercise_type.replace('_', ' ').title()} Tracker", 1920, 1080)
+        cv2.imshow(f"{exercise_type.replace('_', ' ').title()} Tracker", frame)
+
+        if cv2.waitKey(10) & 0xFF == ord('q'):
+            break
+
+    cap.release()
+    out.release()
+    cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    main()