Upload 67 files

.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

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,83 @@
----
-title: LiveTrain
-emoji: 🔥
-colorFrom: blue
-colorTo: yellow
-sdk: docker
-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.
+
+## Features
+
+- Real-time pose estimation using MediaPipe
+- Multiple exercise types: Squats, Push-ups, and Hammer Curls
+- Customizable sets and repetitions
+- Exercise form feedback
+- Progress tracking
+- Web interface for easy access
+
+## Installation
+
+1. Clone the repository:
+
+   ```
+   git clone https://github.com/yourusername/fitness-trainer-pose-estimation.git
+   cd fitness-trainer-pose-estimation
+   ```
+
+2. Install dependencies:
+
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Set up the static folder structure:
+
+   ```
+   mkdir -p static/images
+   ```
+
+4. Add exercise images to the static/images folder:
+   - squat.png
+   - push_up.png
+   - hammer_curl.png
+
+## Usage
+
+1. Start the Flask server:
+
+   ```
+   python app.py
+   ```
+
+2. Open a web browser and navigate to:
+
+   ```
+   http://127.0.0.1:5000
+   ```
+
+3. Select an exercise type, set your desired number of repetitions and sets, then click "Start Workout"
+
+4. Position yourself in front of your camera so that your full body is visible
+
+5. Follow the on-screen guidance to perform the exercise correctly
+
+## Project Structure
+
+- `app.py` - Main Flask application
+- `templates/` - HTML templates
+- `static/` - CSS, JavaScript, and images
+- `pose_estimation/` - Pose estimation modules
+- `exercises/` - Exercise tracking classes
+- `feedback/` - User feedback modules
+- `utils/` - Helper functions and utilities
+
+## Technologies Used
+
+- Flask - Web framework
+- OpenCV - Computer vision
+- MediaPipe - Pose estimation
+- HTML/CSS/JavaScript - Frontend
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

app.py

@@ -0,0 +1,314 @@
+from flask import Flask, render_template, Response, request, jsonify, session, redirect, url_for
+import cv2
+import threading
+import time
+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)
+# 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!"
+
+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")
+        app.run(debug=True)
+    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,77 @@
+import cv2
+import time
+from pose_estimation.angle_calculation import calculate_angle
+
+class PushUp:
+    def __init__(self):
+        self.counter = 0
+        self.stage = "Initial"  # 'up' or 'down'
+        self.angle_threshold_up = 150  # Upper threshold for 'up' stage
+        self.angle_threshold_down = 70  # Lower threshold for 'down' stage
+        self.last_counter_update = time.time()  # Track the time of the last counter update
+
+    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, frame):
+        # Right side landmarks (shoulder, elbow, wrist)
+        shoulder_left = [int(landmarks[11].x * frame.shape[1]), int(landmarks[11].y * frame.shape[0])]
+        elbow_left = [int(landmarks[13].x * frame.shape[1]), int(landmarks[13].y * frame.shape[0])]
+        wrist_left = [int(landmarks[15].x * frame.shape[1]), int(landmarks[15].y * frame.shape[0])]
+
+        shoulder_right = [int(landmarks[12].x * frame.shape[1]), int(landmarks[12].y * frame.shape[0])]
+        elbow_right = [int(landmarks[14].x * frame.shape[1]), int(landmarks[14].y * frame.shape[0])]
+        wrist_right = [int(landmarks[16].x * frame.shape[1]), int(landmarks[16].y * frame.shape[0])]
+
+        # Calculate angles for push-up tracking
+        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)
+
+        # Draw lines with improved style
+        self.draw_line_with_style(frame, shoulder_left, elbow_left, (0, 0, 255), 2)
+        self.draw_line_with_style(frame, elbow_left, wrist_left, (0, 0, 255), 2)
+
+        self.draw_line_with_style(frame, shoulder_right, elbow_right, (102, 0, 0), 2)
+        self.draw_line_with_style(frame, elbow_right, wrist_right, (102, 0, 0), 2)
+
+        # Draw 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, (102, 0, 0), 8)
+        self.draw_circle(frame, elbow_right, (102, 0, 0), 8)
+        self.draw_circle(frame, wrist_right, (102, 0, 0), 8)
+
+        # Update angle text positions and display
+        angle_text_position_left = (elbow_left[0] + 10, elbow_left[1] - 10)
+        cv2.putText(frame, f'Angle: {int(angle_left)}', 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)}', angle_text_position_right, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
+
+        # Get current time
+        current_time = time.time()
+
+        # Update stage and counter
+        if angle_left > self.angle_threshold_up:
+            self.stage = "Starting position"
+        elif self.angle_threshold_down < angle_left < self.angle_threshold_up and self.stage == "Starting position":
+            self.stage = "Descent"
+        elif angle_left < self.angle_threshold_down and self.stage == "Descent":
+            self.stage = "Ascent"
+            # Increment counter only if enough time has passed since last update
+            if current_time - self.last_counter_update > 1:  # 1 second threshold
+                self.counter += 1
+                self.last_counter_update = current_time
+
+        return self.counter, angle_left, self.stage
+
+    def draw_line_with_style(self, frame, start_point, end_point, color, thickness):
+        """Draw a line with specified style."""
+        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/squat.py

@@ -0,0 +1,62 @@
+import cv2
+from pose_estimation.angle_calculation import calculate_angle
+
+class Squat:
+    def __init__(self):
+        self.counter = 0
+        self.stage = None
+
+    def calculate_angle(self, hip, knee, ankle):
+        return calculate_angle(hip, knee, ankle)
+
+    def track_squat(self, landmarks, frame):
+        # Landmark coordinates
+        hip = [int(landmarks[23].x * frame.shape[1]), int(landmarks[23].y * frame.shape[0])]
+        knee = [int(landmarks[25].x * frame.shape[1]), int(landmarks[25].y * frame.shape[0])]
+        shoulder = [int(landmarks[11].x * frame.shape[1]), int(landmarks[11].y * frame.shape[0])]
+
+        hip_right = [int(landmarks[24].x * frame.shape[1]), int(landmarks[24].y * frame.shape[0])]
+        knee_right = [int(landmarks[26].x * frame.shape[1]), int(landmarks[26].y * frame.shape[0])]
+        shoulder_right = [int(landmarks[12].x * frame.shape[1]), int(landmarks[12].y * frame.shape[0])]
+
+        # Calculate angles
+        angle = self.calculate_angle(shoulder, hip, knee)
+        angle_right = self.calculate_angle(shoulder_right, hip_right, knee_right)
+
+        # Draw lines and circles to highlight key points
+        self.draw_line_with_style(frame, shoulder, hip, (178, 102, 255), 2)
+        self.draw_line_with_style(frame, hip, knee, (178, 102, 255), 2)
+        self.draw_line_with_style(frame, shoulder_right, hip_right, (51, 153, 255), 2)
+        self.draw_line_with_style(frame, hip_right, knee_right, (51, 153, 255), 2)
+
+        self.draw_circle(frame, shoulder, (178, 102, 255), 8)
+        self.draw_circle(frame, hip, (178, 102, 255), 8)
+        self.draw_circle(frame, knee, (178, 102, 255), 8)
+        self.draw_circle(frame, shoulder_right, (51, 153, 255), 8)
+        self.draw_circle(frame, hip_right, (51, 153, 255), 8)
+        self.draw_circle(frame, knee_right, (51, 153, 255), 8)
+
+        # Display angles on screen
+        angle_text_position = (knee[0] + 10, knee[1] - 10)
+        cv2.putText(frame, f'Angle Left: {int(angle)}', angle_text_position, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
+
+        angle_text_position_right = (knee_right[0] + 10, knee_right[1] - 10)
+        cv2.putText(frame, f'Angle Right: {int(angle_right)}', angle_text_position_right, cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
+
+        # Update exercise stage and counter
+        if angle > 170:
+            self.stage = "Starting Position"
+        elif 90 < angle < 170 and self.stage == "Starting Position":
+            self.stage = "Descent"
+        elif angle < 90 and self.stage == "Descent":
+            self.stage = "Ascent"
+            self.counter += 1
+        return self.counter, angle, self.stage
+
+    def draw_line_with_style(self, frame, start_point, end_point, color, thickness):
+        """Draw a line with specified style."""
+        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

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)
+

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()

pose_estimation/angle_calculation.py

@@ -0,0 +1,23 @@
+import math
+
+def calculate_angle(a,b,c):
+    # abc npktaları [x,y,z] noktaları
+
+    ba = [a[0] - b[0], a[1] - b[1]]
+    bc = [c[0] - b[0], c[1] - b[1]]
+
+
+    # dot product (iç çarpım) hesapla: ba · bc
+    dot_product = ba[0] * bc[0] + ba[1] * bc[1]
+
+    # Vektörlerin büyüklüklerini hesapla
+    magnitude_ba = math.sqrt(ba[0] ** 2 + ba[1] ** 2)
+    magnitude_bc = math.sqrt(bc[0] ** 2 + bc[1] ** 2)
+
+    # Kosinüs açısını hesapla
+    cosine_angle = dot_product / (magnitude_ba * magnitude_bc)
+
+    # Açı hesapla ve dereceye çevir
+    angle = math.degrees(math.acos(cosine_angle))
+
+    return angle

pose_estimation/estimation.py

@@ -0,0 +1,81 @@
+import cv2
+import mediapipe as mp
+from exercises.hammer_curl import HammerCurl
+
+class PoseEstimator:
+    def __init__(self):
+        self.mp_pose = mp.solutions.pose
+        self.pose = self.mp_pose.Pose()
+        self.mp_drawing = mp.solutions.drawing_utils
+
+    def estimate_pose(self, frame, exercise_type):
+        # BGR to RGB
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+        # Pose estimate
+        results = self.pose.process(rgb_frame)
+
+        # Draw landmarks and specific connections based on exercise type
+        if results.pose_landmarks:
+            # Draw specific landmarks and connections based on exercise_type
+            if exercise_type == "squat":
+                self.draw_squat_lines(frame, results.pose_landmarks.landmark)
+            elif exercise_type == "push_up":
+                self.draw_push_up_lines(frame, results.pose_landmarks.landmark)
+            elif exercise_type == "hammer_curl":
+                self.draw_hammerl_curl_lines(frame, results.pose_landmarks.landmark)
+
+        return results
+    def draw_hammerl_curl_lines(self, frame, landmarks):
+
+        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])]
+
+        # Draw lines with improved style
+        cv2.line(frame, shoulder_left, elbow_left, (0, 0, 255), 4,2)
+        cv2.line(frame, elbow_left, wrist_left, (0, 0, 255), 4,2)
+
+        cv2.line(frame, shoulder_right, elbow_right, (0, 0, 255), 4,2)
+        cv2.line(frame, elbow_right, wrist_right, (0, 0, 255), 4,2)
+
+
+
+    def draw_squat_lines(self, frame, landmarks):
+        # Squat specific lines (hip, knee, shoulder)
+        hip = [int(landmarks[23].x * frame.shape[1]), int(landmarks[23].y * frame.shape[0])]
+        knee = [int(landmarks[25].x * frame.shape[1]), int(landmarks[25].y * frame.shape[0])]
+        shoulder = [int(landmarks[11].x * frame.shape[1]), int(landmarks[11].y * frame.shape[0])]
+
+        hip_right = [int(landmarks[24].x * frame.shape[1]), int(landmarks[24].y * frame.shape[0])]
+        knee_right = [int(landmarks[26].x * frame.shape[1]), int(landmarks[26].y * frame.shape[0])]
+        shoulder_right = [int(landmarks[12].x * frame.shape[1]), int(landmarks[12].y * frame.shape[0])]
+
+        # Draw lines for squat
+        cv2.line(frame, shoulder, hip, (178, 102, 255), 2)
+        cv2.line(frame, hip, knee, (178, 102, 255), 2)
+        cv2.line(frame, shoulder_right, hip_right, (51, 153, 255), 2)
+        cv2.line(frame, hip_right, knee_right, (51, 153, 255), 2)
+
+    def draw_push_up_lines(self, frame, landmarks):
+        # Push-up specific lines (shoulder, elbow, wrist)
+        shoulder_left = [int(landmarks[11].x * frame.shape[1]), int(landmarks[11].y * frame.shape[0])]
+        elbow_left = [int(landmarks[13].x * frame.shape[1]), int(landmarks[13].y * frame.shape[0])]
+        wrist_left = [int(landmarks[15].x * frame.shape[1]), int(landmarks[15].y * frame.shape[0])]
+
+        shoulder_right = [int(landmarks[12].x * frame.shape[1]), int(landmarks[12].y * frame.shape[0])]
+        elbow_right = [int(landmarks[14].x * frame.shape[1]), int(landmarks[14].y * frame.shape[0])]
+        wrist_right = [int(landmarks[16].x * frame.shape[1]), int(landmarks[16].y * frame.shape[0])]
+
+        # Draw lines for push-up
+        cv2.line(frame, shoulder_left, elbow_left, (0, 0, 255), 2)
+        cv2.line(frame, elbow_left, wrist_left, (0, 0, 255), 2)
+        cv2.line(frame, shoulder_right, elbow_right, (102, 0, 0), 2)
+        cv2.line(frame, elbow_right, wrist_right, (102, 0, 0), 2)

static/css/dashboard.css

@@ -0,0 +1,138 @@
+.main-nav {
+  margin-top: 15px;
+}
+
+.main-nav ul {
+  display: flex;
+  list-style: none;
+  justify-content: center;
+  gap: 25px;
+}
+
+.nav-link {
+  text-decoration: none;
+  color: #555;
+  font-weight: 500;
+  padding: 8px 15px;
+  border-radius: 5px;
+  transition: all 0.3s;
+}
+
+.nav-link:hover {
+  color: #3498db;
+  background-color: rgba(52, 152, 219, 0.1);
+}
+
+.nav-link.active {
+  color: #3498db;
+  border-bottom: 2px solid #3498db;
+}
+
+.dashboard-content {
+  display: flex;
+  flex-direction: column;
+  gap: 30px;
+}
+
+.stats-summary {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 20px;
+  justify-content: space-between;
+}
+
+.stat-card {
+  flex: 1 1 200px;
+  background-color: white;
+  border-radius: 10px;
+  padding: 20px;
+  text-align: center;
+  box-shadow: 0 4px 10px rgba(0, 0, 0, 0.05);
+  transition: transform 0.3s;
+}
+
+.stat-card:hover {
+  transform: translateY(-5px);
+}
+
+.stat-card h3 {
+  font-size: 1rem;
+  color: #777;
+  margin-bottom: 10px;
+}
+
+.stat-value {
+  font-size: 2.5rem;
+  font-weight: 700;
+  color: #3498db;
+}
+
+.charts-container {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 20px;
+}
+
+.chart-card {
+  flex: 1 1 400px;
+  background-color: white;
+  border-radius: 10px;
+  padding: 20px;
+  box-shadow: 0 4px 10px rgba(0, 0, 0, 0.05);
+}
+
+.chart-card h3 {
+  font-size: 1.2rem;
+  color: #555;
+  margin-bottom: 15px;
+  text-align: center;
+}
+
+.recent-workouts {
+  background-color: white;
+  border-radius: 10px;
+  padding: 20px;
+  box-shadow: 0 4px 10px rgba(0, 0, 0, 0.05);
+}
+
+.recent-workouts h2 {
+  font-size: 1.5rem;
+  color: #3a3a3a;
+  margin-bottom: 15px;
+}
+
+.workout-table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.workout-table th,
+.workout-table td {
+  padding: 12px 15px;
+  text-align: left;
+  border-bottom: 1px solid #eee;
+}
+
+.workout-table th {
+  background-color: #f9f9f9;
+  color: #555;
+  font-weight: 500;
+}
+
+.workout-table tr:hover {
+  background-color: #f5f5f5;
+}
+
+@media (max-width: 768px) {
+  .stats-summary {
+    flex-direction: column;
+  }
+
+  .charts-container {
+    flex-direction: column;
+  }
+
+  .workout-table {
+    font-size: 0.9rem;
+  }
+}

static/css/style.css

@@ -0,0 +1,210 @@
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+  font-family: 'Roboto', sans-serif;
+}
+
+body {
+  background-color: #f5f5f5;
+  color: #333;
+}
+
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 20px;
+}
+
+header {
+  text-align: center;
+  margin-bottom: 30px;
+}
+
+header h1 {
+  font-size: 2.5rem;
+  color: #3a3a3a;
+  margin-bottom: 10px;
+}
+
+header p {
+  font-size: 1.2rem;
+  color: #666;
+}
+
+.main-content {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 20px;
+}
+
+.video-container {
+  flex: 1 1 600px;
+  border-radius: 10px;
+  overflow: hidden;
+  box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+}
+
+.video-container img {
+  width: 100%;
+  height: auto;
+  display: block;
+}
+
+.controls {
+  flex: 1 1 300px;
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.controls h2 {
+  font-size: 1.5rem;
+  margin-bottom: 15px;
+  color: #3a3a3a;
+  border-bottom: 2px solid #3498db;
+  padding-bottom: 5px;
+}
+
+.exercise-options {
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+.exercise-option {
+  flex: 1 1 calc(33% - 10px);
+  min-width: 80px;
+  background-color: white;
+  border-radius: 8px;
+  overflow: hidden;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+  transition:
+    transform 0.3s,
+    box-shadow 0.3s;
+  cursor: pointer;
+  text-align: center;
+}
+
+.exercise-option:hover {
+  transform: translateY(-5px);
+  box-shadow: 0 5px 15px rgba(0, 0, 0, 0.15);
+}
+
+.exercise-option.selected {
+  border: 2px solid #3498db;
+  transform: translateY(-5px);
+}
+
+.exercise-option img {
+  width: 100%;
+  height: 100px;
+  object-fit: cover;
+}
+
+.exercise-option h3 {
+  padding: 10px;
+  font-size: 1rem;
+}
+
+.config-inputs {
+  display: flex;
+  gap: 15px;
+}
+
+.input-group {
+  flex: 1;
+}
+
+.input-group label {
+  display: block;
+  margin-bottom: 5px;
+  font-weight: 500;
+}
+
+.input-group input {
+  width: 100%;
+  padding: 8px 12px;
+  border: 1px solid #ddd;
+  border-radius: 5px;
+  font-size: 1rem;
+}
+
+.action-buttons {
+  display: flex;
+  gap: 10px;
+}
+
+.btn {
+  flex: 1;
+  padding: 12px 20px;
+  border: none;
+  border-radius: 5px;
+  font-size: 1rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background-color 0.3s;
+}
+
+.primary-btn {
+  background-color: #3498db;
+  color: white;
+}
+
+.primary-btn:hover {
+  background-color: #2980b9;
+}
+
+.secondary-btn {
+  background-color: #e74c3c;
+  color: white;
+}
+
+.secondary-btn:hover {
+  background-color: #c0392b;
+}
+
+.btn:disabled {
+  background-color: #ccc;
+  cursor: not-allowed;
+}
+
+.workout-status {
+  background-color: white;
+  border-radius: 8px;
+  padding: 15px;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+}
+
+.status-display {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.status-item {
+  display: flex;
+  justify-content: space-between;
+  padding: 5px 0;
+  border-bottom: 1px solid #eee;
+}
+
+.status-label {
+  font-weight: 500;
+  color: #555;
+}
+
+.status-value {
+  font-weight: 700;
+  color: #3498db;
+}
+
+@media (max-width: 768px) {
+  .main-content {
+    flex-direction: column;
+  }
+
+  .config-inputs {
+    flex-direction: column;
+  }
+}

static/images/README.txt

@@ -0,0 +1,7 @@
+This directory should contain the following images:
+- squat.png
+- push_up.png
+- hammer_curl.png
+
+These images will be used as icons on the exercise selection page.
+You can use any appropriate images for these exercises.