first all files

BasicPoseModule.py

@@ -0,0 +1,133 @@
+import cv2
+import mediapipe as mp
+import math
+
+class PoseDetectorModified():
+
+    def _init_(self, mode=False, complexity=1, smooth_landmarks=True,
+                 enable_segmentation=False, smooth_segmentation=True,
+                 detectionCon=0.5, trackCon=0.5):
+        """
+            Initializes a new instance of the PoseDetectorModified class.
+
+            Args:
+                mode (bool): Whether to use the upper-body-only pose landmark model or the full-body pose landmark model.
+                complexity (int): Complexity of the pose landmark model (must be between 0 and 2).
+                smooth_landmarks (bool): Whether to smooth the pose landmarks or not.
+                enable_segmentation (bool): Whether to enable person segmentation or not.
+                smooth_segmentation (bool): Whether to smooth the person segmentation or not.
+                detectionCon (float): Minimum confidence value (between 0 and 1) for the detection to be considered successful.
+                trackCon (float): Minimum confidence value (between 0 and 1) for the tracking to be considered successful.
+        """
+
+        self.mode = mode
+        self.complexity = complexity
+        self.smooth_landmarks = smooth_landmarks
+        self.enable_segmentation = enable_segmentation
+        self.smooth_segmentation = smooth_segmentation
+        self.detectionCon = detectionCon
+        self.trackCon = trackCon
+
+        self.mpDraw = mp.solutions.drawing_utils
+        self.mpPose = mp.solutions.pose
+        self.pose = self.mpPose.Pose(self.mode, self.complexity, self.smooth_landmarks,
+                                     self.enable_segmentation, self.smooth_segmentation,
+                                     self.detectionCon, self.trackCon)
+
+    def find_pose(self, img, draw=True):
+        """
+        Finds the pose landmarks and connections in an image or a video frame.
+
+        Args:
+            img (numpy.ndarray): The input image or video frame.
+            draw (bool): Whether to draw the pose landmarks and connections on the image or not.
+
+        Returns:
+            The input image with the pose landmarks and connections drawn on it (if draw is True).
+        """
+        imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        self.results = self.pose.process(imgRGB)
+
+        if self.results.pose_landmarks:
+            if draw:
+                self.mpDraw.draw_landmarks(img, self.results.pose_landmarks,
+                                           self.mpPose.POSE_CONNECTIONS)
+
+        return img
+
+    def find_position(self, img, draw=True):
+        """
+            Finds the pose landmark positions in an image or a video frame.
+
+            Args:
+                img (numpy.ndarray): The input image or video frame.
+                draw (bool): Whether to draw the pose landmark positions on the image or not.
+
+            Returns:
+                A list containing the landmark ID, X and Y positions for each landmark in the pose.
+        """
+        lm_list = []
+        if self.results.pose_landmarks:
+            for id, lm in enumerate(self.results.pose_landmarks.landmark):
+                h, w, c = img.shape
+                cx, cy = int(lm.x * w), int(lm.y * h)
+                lm_list.append([id, cx, cy])
+                if draw:
+                    cv2.circle(img, (cx, cy), 5, (255, 0, 0), cv2.FILLED)
+        return lm_list
+
+    def find_angle(self, img, p1, p2, p3, lm_list, draw=True):
+        """
+        Calculates the angle between three landmarks.
+
+        Args:
+            img (numpy.ndarray): The input image or video frame.
+            p1 (int): ID of the first landmark.
+            p2 (int): ID of the second landmark (vertex of the angle).
+            p3 (int): ID of the third landmark.
+            lm_list (list): List of landmarks with their coordinates.
+            draw (bool): Whether to draw the angle on the image or not.
+
+        Returns:
+            float: The calculated angle in degrees.
+        """
+        x1, y1 = lm_list[p1][1:]
+        x2, y2 = lm_list[p2][1:]
+        x3, y3 = lm_list[p3][1:]
+
+        # Calculate the angle
+        angle = math.degrees(math.atan2(y3 - y2, x3 - x2) - math.atan2(y1 - y2, x1 - x2))
+        angle = abs(angle)
+        if angle > 180:
+            angle = 360 - angle
+
+        # Draw the angle on the image
+        if draw:
+            cv2.line(img, (x1, y1), (x2, y2), (255, 255, 255), 3)
+            cv2.line(img, (x3, y3), (x2, y2), (255, 255, 255), 3)
+            cv2.circle(img, (x1, y1), 10, (0, 0, 255), cv2.FILLED)
+            cv2.circle(img, (x2, y2), 10, (0, 0, 255), cv2.FILLED)
+            cv2.circle(img, (x3, y3), 10, (0, 0, 255), cv2.FILLED)
+            cv2.putText(img, str(int(angle)), (x2 - 50, y2 + 50),
+                        cv2.FONT_HERSHEY_PLAIN, 2, (0, 0, 255), 2)
+
+        return angle
+
+def main():
+    detector = PoseDetectorModified()
+    cap = cv2.VideoCapture(0)
+    while cap.isOpened():
+        ret, img = cap.read()
+        if ret:
+            img = detector.find_pose(img)
+            lm_list = detector.find_position(img, False)
+            if len(lm_list) != 0:
+                angle = detector.find_angle(img, 11, 13, 15, lm_list)
+                print(angle)
+            cv2.imshow('Pose Detection', img)
+        if cv2.waitKey(10) & 0xFF == ord('q'):
+            break
+
+    cap.release()
+    cv2.destroyAllWindows()
+

Dockerfile

@@ -0,0 +1,22 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+# Install system dependencies for OpenCV
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["gunicorn", "-b", "0.0.0.0:7860","app:app"]

app.py

@@ -0,0 +1,490 @@
+from flask import Flask, request, jsonify, redirect, url_for, render_template, session, Response
+import firebase_admin
+from firebase_admin import credentials, auth, db
+# from workouts.bicepCurls import bicepcurls
+import os
+import time 
+import mediapipe as mp
+import cv2
+import numpy as np
+
+today_date = time.strftime("%Y-%m-%d")
+mp_pose = mp.solutions.pose
+mp_drawing = mp.solutions.drawing_utils
+curr_track = {}
+# Initialize Flask app
+app = Flask(__name__)
+app.secret_key = '9177'
+# Firebase Admin SDK Initialization
+cred = credentials.Certificate("serviceAccountKey.json")
+firebase_admin.initialize_app(cred, {
+    'databaseURL': 'https://fitnessdb-c9b11-default-rtdb.firebaseio.com/'
+})
+
+
+
+def calculate_angle(a, b, c):
+    a = np.array(a)  # First point
+    b = np.array(b)  # Middle point
+    c = np.array(c)  # Last point
+
+    radians = np.arctan2(c[1] - b[1], c[0] - b[0]) - np.arctan2(a[1] - b[1], a[0] - b[0])
+    angle = np.abs(radians * 180.0 / np.pi)
+
+    if angle > 180.0:
+        angle = 360 - angle
+
+    return angle
+stop_processing = False  # Global flag to control video stream
+
+def is_shoulder_press_correct(landmarks, mp_pose):
+    # Get coordinates of shoulder, elbow, and wrist (left arm as example)
+    shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
+                landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
+    elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x,
+             landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]
+    wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
+             landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]
+
+    # Calculate angle at the elbow (shoulder, elbow, wrist)
+    elbow_angle = calculate_angle(shoulder, elbow, wrist)
+
+    # Check if the motion is vertical (wrist higher than elbow)
+    if wrist[1] < elbow[1] and elbow[1] < shoulder[1]:
+        # Ensure proper angle range for a shoulder press
+        if 160 <= elbow_angle <= 180:
+            return "Shoulder Press: Correct", True
+        else:
+            return "Shoulder Press: Incorrect - Elbow angle", False
+    else:
+        return "Shoulder Press: Incorrect - Alignment", False
+
+# Video processing function
+def shoulder_press_count(video_path):
+    global curr_track
+    cap = cv2.VideoCapture(video_path)
+    count = 0
+    rep_started = False
+
+    with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            # Convert the frame to RGB
+            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            image.flags.writeable = False
+
+            # Process the image for pose detection
+            results = pose.process(image)
+
+            # Convert back to BGR for rendering
+            image.flags.writeable = True
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+            # Extract landmarks
+            if results.pose_landmarks:
+                landmarks = results.pose_landmarks.landmark
+
+                # Check shoulder press posture
+                feedback, is_correct = is_shoulder_press_correct(landmarks, mp_pose)
+
+                # Count reps
+                if is_correct and not rep_started:
+                    rep_started = True
+                elif not is_correct and rep_started:
+                    rep_started = False
+                    count += 1
+
+                # Display feedback
+                cv2.putText(image, feedback, (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0) if is_correct else (0, 0, 255), 2, cv2.LINE_AA)
+
+                # Display rep count
+                cv2.putText(image, f'Reps: {count}', (50, 100),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)
+
+                # Draw landmarks
+                mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)
+
+            else:
+                # Warn if no landmarks are detected
+                cv2.putText(image, "No body detected", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+
+            # Encode frame for streaming
+            ret, buffer = cv2.imencode('.jpg', image)
+            frame = buffer.tobytes()
+            yield (b'--frame\r\n'
+                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
+
+    cap.release()
+    curr_track['shoulderpress'] = count
+    print("shoulder_press count :",count)
+def process_bicep_curls(video_path):
+    global curr_track
+    global stop_processing  # Access the global flag to stop the stream
+    cap = cv2.VideoCapture(video_path)
+    count = 0
+    movement_dir = 0
+
+    # Initialize MediaPipe Pose
+    with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:
+        while cap.isOpened():
+            if stop_processing:  # If stop_processing flag is set, break the loop
+                break
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            frame = cv2.resize(frame, (1280, 720))
+
+            # Convert the frame to RGB
+            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            image.flags.writeable = False
+
+            # Process the image for pose detection
+            results = pose.process(image)
+
+            # Convert back to BGR for rendering
+            image.flags.writeable = True
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+            if results.pose_landmarks:
+                landmarks = results.pose_landmarks.landmark
+
+                # Extract relevant joints
+                shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
+                            landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
+                elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x,
+                         landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]
+                wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
+                         landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]
+
+                # Calculate elbow angle
+                elbow_angle = calculate_angle(shoulder, elbow, wrist)
+
+                # Determine movement direction and count reps
+                progress_percentage = np.interp(elbow_angle, (50, 160), (0, 100))
+                progress_bar = np.interp(elbow_angle, (50, 160), (650, 100))
+
+                color = (255, 0, 255)
+                if progress_percentage == 100:
+                    color = (0, 255, 0)
+                    if movement_dir == 0:
+                        count += 0.5
+                        movement_dir = 1
+                if progress_percentage == 0:
+                    color = (0, 0, 255)
+                    if movement_dir == 1:
+                        count += 0.5
+                        movement_dir = 0
+
+                # Draw Progress Bar
+                cv2.rectangle(frame, (1100, 100), (1175, 650), color, 3)
+                cv2.rectangle(frame, (1100, int(progress_bar)), (1175, 650), color, cv2.FILLED)
+                cv2.putText(frame, f'{int(progress_percentage)}%', (1100, 75), cv2.FONT_HERSHEY_PLAIN, 4, color, 4)
+
+                # Draw Counter
+                cv2.rectangle(frame, (0, 450), (250, 720), (0, 255, 0), cv2.FILLED)
+                cv2.putText(frame, str(int(count)), (45, 670), cv2.FONT_HERSHEY_PLAIN, 15, (255, 0, 0), 30)
+
+                # Draw landmarks
+                mp_drawing.draw_landmarks(frame, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)
+
+                # Draw Finish Button on the video
+                cv2.rectangle(frame, (10, 10), (150, 60), (0, 0, 255), -1)  # Red button
+                cv2.putText(frame, "FINISH", (20, 45), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+
+            # Encode the frame for streaming
+            ret, buffer = cv2.imencode('.jpg', frame)
+            frame = buffer.tobytes()
+
+            yield (b'--frame\r\n'
+                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
+
+    cap.release()
+    curr_track['bicepcurls'] = count
+
+# Flask route to stop the video feed
+@app.route('/stop_stream', methods=['POST'])
+def stop_stream():
+    global stop_processing
+    stop_processing = True  # Stop the video stream when this route is hit
+    return "Stream stopped", 200
+
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+# Login Route
+@app.route('/register', methods=['POST'])
+def register():
+    data = request.get_json()
+    session['progress'] = {}
+    session['recommended_plan'] = ""
+
+    # Extract user details from the request
+    name = data['name']
+    email = data['email']
+    password = data['password']
+    age = data['age']
+    height = data['height']
+    weight = data['weight']
+    max_pullups = data['maxPullups']
+    min_pullups = data['minPullups']
+    gender = data['gender']
+    pushups = data.get('pushups',[])
+    squats = data.get('squats',[])
+    pullups = data.get('pullups',[])
+    shoulderpress = data.get('shoulderpress',[])
+    bicepcurls = data.get('bicepcurls',[])
+
+    track = {
+        "pushups": pushups,
+        "squats": squats,
+        "pullups": pullups,
+        'shoulder_press' : shoulderpress,
+        'bicepcurls':bicepcurls,
+        'recommended_plan':""
+    }
+
+
+    session['progress'] = track
+    # bicepcurls = data.get()
+
+
+    # Create Firebase user using Firebase Auth
+    try:
+        # Create the user in Firebase Authentication
+        user = auth.create_user(
+            email=email,
+            password=password,
+            display_name=name
+        )
+
+        # Store additional user data in Firebase Realtime Database
+        user_ref = db.reference(f'users/{user.uid}')
+        user_ref.set({
+            'name': name,
+            'email': email,
+            'age': age,
+            'height': height,
+            'weight': weight,
+            'maxPullups': max_pullups,
+            'minPullups': min_pullups,
+            'gender': gender,
+            'progress':track
+        })
+
+       
+
+        return jsonify({"message": "User registered successfully!"}), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400
+
+@app.route('/login', methods=['POST'])
+def login():
+    data = request.get_json()
+
+    email = data['email']
+    password = data['password']
+
+    try:
+        # Authenticate user with Firebase Auth
+        user = auth.get_user_by_email(email)
+        
+        # Validate password (Firebase Authentication handles password validation)
+        # No need to manually validate password here since Firebase Authentication ensures the password matches
+        ref = db.reference("users")
+        users_data = ref.get()
+        
+        for user_id,user_data in users_data.items():
+            if user_data.get('email') == email:
+                user_name = user_data['name']
+                session['user_details'] = user_data
+                session['progress'] = user_data['progress']
+                # session['progress'] = user_data.get('progress',{})
+
+                print(user_data['name'])
+
+
+        return jsonify({"message":"sucess"})
+
+    except Exception as e:
+        return jsonify({"error": "Invalid credentials"}), 401
+
+# Home Route (Display User Credentials)
+@app.route('/home', methods=['GET'])
+def home():
+    # Get the ID token from the query parameter
+    progress = session['progress']
+
+    print(progress)
+
+    sum = 0
+    length = 0
+    try:
+        sum += progress['pushups'][-1]
+    except:
+        sum += 0
+    
+    # progress  = {"pushups":12}
+    session[today_date] = {"bicepcurls":0,"squats":0,"pushups":0,"shoulderpress":0,"pullups":0}
+
+    available_plans =[
+        {"name": "fitness maintenance", "description": "Build strength and muscle mass."},
+        {"name": "weight loss", "description": "Lose weight through healthy diet and exercise."},
+        
+    ]
+    
+    # Process plan names in Python
+    for plan in available_plans:
+        # Use dictionary key 'name' instead of accessing as an attribute
+        plan['name'] = plan['name'].replace(' ', '-').lower()
+    
+    # Define a recommended plan
+
+# Now pass the modified data to the template
+
+    print(sum)
+
+
+    if sum == 0:
+        height = int(session['user_details']['height'])
+        weight = int(session['user_details']['weight'])
+        
+        bmi = weight / (height/100)**2
+
+        recomm = ""
+
+        if bmi < 18.5:
+            recomm = "weight gain"
+            available_plans.pop(2)
+        elif 18.5 <= bmi <=24.9:
+            recomm = "fitness maintenance"
+            available_plans.pop(0)
+        else:
+            recomm = "weight loss"
+            available_plans.pop(1)
+
+        session['fitness_plan'] = recomm
+
+       
+        # Recommended workout code goes here
+        return render_template('workout.html', recommended_plan=recomm, available_plans=available_plans)
+    else:
+        
+        return render_template("currentprogress.html",sum=(sum/3) * 100,recommended_plan=progress["recommended_plan"])
+@app.route('/upload-video/<exercise_name>', methods=['POST'])
+def upload_video(exercise_name):
+    if exercise_name == 'bicepcurls':
+        if 'video' not in request.files:
+            return "No video file uploaded", 400
+
+        video = request.files['video']
+
+        if video.filename == '':
+            return "No selected file", 400
+
+        # Save the uploaded video with a unique name
+        video_filename = f"{exercise_name}_{video.filename}"
+        video_path = os.path.join("uploads", video_filename)
+        video.save(video_path)
+
+        return Response(process_bicep_curls(video_path), mimetype="multipart/x-mixed-replace; boundary=frame")
+    elif exercise_name == "shoulderpress":
+                if 'video' not in request.files:
+                    return "No video file uploaded", 400
+
+                video = request.files['video']
+
+                if video.filename == '':
+                    return "No selected file", 400
+
+                # Save the uploaded video with a unique name
+                video_filename = f"{exercise_name}_{video.filename}"
+                video_path = os.path.join("uploads", video_filename)
+                video.save(video_path)
+
+                return Response(shoulder_press_count(video_path), mimetype="multipart/x-mixed-replace; boundary=frame")
+@app.route('/diet-data')
+def diet_data():
+    # Assuming the JSON file is stored in the static folder
+    try:
+        with open(os.path.join(app.static_folder, 'diet.json'), 'r') as f:
+            diet_data = f.read()
+        return diet_data
+    except FileNotFoundError:
+        return jsonify({"error": "Diet data not found."}), 404
+@app.route('/diet')
+def diet():
+
+    return render_template("diet.html")
+
+
+from feed_back_llm import update_feed_back
+
+@app.route("/daily-report")
+def daily_report():
+    global curr_track
+    print(curr_track)
+    planned_reps = 8
+    planned_resttime = 1
+    counted_restime = 2
+
+    update_feed_back()
+
+    
+    return render_template("feed_back.html")
+
+@app.route('/weight-gain')
+def weight_gain():
+
+    workouts = [
+        {"name":"bicepcurls", "reps":12},
+        {"name":"shoulderpress", "reps":10},
+        {"name":"pullups", "reps":10},
+        {"name":"squats", "reps":15},
+    ]
+
+
+    return render_template("workouts_List.html",exercises=workouts)
+@app.route('/weight-loss')
+def weight_loss():
+    workouts = [
+        {"name":"bicepcurls", "reps":12},
+        {"name":"shoulderpress", "reps":10},
+        {"name":"pullups", "reps":10},
+        {"name":"squats", "reps":15},
+    ]
+
+
+    return render_template("workouts_List.html",exercises=workouts)
+@app.route('/progress')
+def progress():
+
+    return render_template("currentprogress.html",sum=70)
+
+@app.route('/fitness-maintenance')
+def fitness_maintenance():
+    workouts = [
+        {"name":"bicepcurls", "reps":12},
+        {"name":"shoulderpress", "reps":10},
+        {"name":"pullups", "reps":10},
+        {"name":"squats", "reps":15},
+    ]
+
+
+    return render_template("workouts_List.html",exercises=workouts)
+if __name__ == '__main__':
+    app.run(debug=True)
+
+
+
+
+
+
+
+

diet_plan.py

@@ -0,0 +1,145 @@
+import os
+import json
+from dotenv import load_dotenv
+from langchain_core.output_parsers import StrOutputParser
+from langchain_groq import ChatGroq
+from langchain_core.messages import HumanMessage, SystemMessage
+import firebase_admin
+from firebase_admin import credentials, auth, db
+from flask import Flask, request, jsonify, redirect, url_for, render_template, session, Response
+
+
+cred = credentials.Certificate("serviceAccountKey.json")
+firebase_admin.initialize_app(cred, {
+    'databaseURL': 'https://fitnessdb-c9b11-default-rtdb.firebaseio.com/'
+})
+
+def predict_diet_plan():
+    # Load environment variables
+    load_dotenv()
+    groq_api_key = "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"
+
+    # Initialize the model
+    model = ChatGroq(model="Gemma2-9b-It", groq_api_key=groq_api_key)
+
+    # User input fields for personalized diet details
+    print("Personalized Diet Plan Generator")
+
+    # User inputs
+    ref = db.reference("users")
+    users_data = ref.get()
+    mail = 'terlihemanth21@gmail.com'
+    for user_id, user_data in users_data.items():
+        if user_data.get('email') == mail:
+            age = 20  # Default minimum age
+            height = user_data.get('height')  # Default height in cm
+            weight = user_data.get('weight')  # Default weight in kg
+            gender = user_data.get('gender')
+            activity_level = user_data.get('activity_level', 'Sedentary')
+            goal = user_data.get('goal', 'Maintain Fitness')
+            health_conditions = user_data.get('health_conditions', 'None')
+            gut_problems = user_data.get('gut_problems', 'None')
+            dietary_preferences = user_data.get('dietary_preferences', 'Non-Vegetarian')
+            food_restrictions = user_data.get('food_restrictions', 'None')
+            location_preferences = user_data.get('location_preferences', 'Home-Cooked Food')
+            breakfast = user_data.get('breakfast', 'Default Breakfast')
+            lunch = user_data.get('lunch', 'Default Lunch')
+            dinner = user_data.get('dinner', 'Default Dinner')
+            snacks = user_data.get('snacks', 'Default Snacks')
+            exercise_name = user_data.get('exercise_name', 'Default Exercise')
+            workout_duration = user_data.get('workout_duration', 30) 
+            max_pullups = user_data.get('maxPullups')
+            min_pullups = user_data.get('minPullups')
+    # Prepare the prompt for diet plan generation
+    diet_plan_prompt = f"""
+    Based on the user's health and personalization details, generate a personalized diet plan in the following format:
+
+    The user details are as follows:
+    - Age: {age}
+    - Gender: {gender}
+    - Weight: {weight} kg
+    - Height: {height} cm
+    - Activity Level: {activity_level}
+    - Goal: {goal}
+    - Known Health Conditions: {health_conditions}
+    - Gut Problems: {gut_problems}
+    - Dietary Preferences: {dietary_preferences}
+    - Food Restrictions/Allergies: {food_restrictions}
+    - Location Preferences: {location_preferences}
+    - Current Eating Habits: Breakfast: {breakfast}, Lunch: {lunch}, Dinner: {dinner}, Snacks: {snacks}
+    - Workout Details: The user performs {exercise_name} for {workout_duration} minutes daily.
+
+    Return the diet plan only in the following format, no extra text:
+    {{
+        "Breakfast": [
+            {{
+                "description": "3 scrambled eggs with spinach and a slice of whole-wheat toast topped with avocado",
+                "time": "7:00 AM"
+            }}
+        ],
+        "Lunch": [
+            {{
+                "description": "Grilled chicken breast with quinoa, steamed broccoli, and a side of hummus",
+                "time": "12:30 PM"
+            }}
+        ],
+        "Snacks": [
+            {{
+                "description": "Greek yogurt with mixed berries and a handful of almonds",
+                "time": "4:00 PM"
+            }}
+        ],
+        "Dinner": [
+            {{
+                "description": "Baked salmon with roasted sweet potatoes and sautéed asparagus",
+                "time": "7:30 PM"
+            }}
+        ],
+        "dietSuggestions": [
+            {{
+                "tip": "Prioritize protein intake to support muscle growth. Aim for 1.2-1.6 grams of protein per kilogram of body weight daily."
+            }},
+            {{
+                "tip": "Include complex carbohydrates like brown rice, quinoa, and sweet potatoes for sustained energy."
+            }},
+            {{
+                "tip": "Don't forget healthy fats from sources like avocado, nuts, seeds, and olive oil."
+            }}
+        ]
+    }}
+    """
+
+    # Create the conversation messages with the prompt
+    messages = [
+        SystemMessage(content="Generate a personalized diet plan in the specified format."),
+        HumanMessage(content=diet_plan_prompt)
+    ]
+
+    # Invoke the model with the prompt
+    try:
+        result = model.invoke(messages)
+        
+        # Parse the result
+        parser = StrOutputParser()
+        parsed_response = parser.invoke(result)
+
+        # Ensure the response is valid JSON
+        print(parsed_response)
+        diet_plan_json = json.loads(parsed_response)
+
+        # Save the JSON response to a file
+        file_path = "static\diet.json"
+        with open(file_path, "w") as json_file:
+            json.dump(diet_plan_json, json_file, indent=4)
+
+        # Display success message and provide download info
+        print(f"Diet plan successfully generated and saved to {file_path}.")
+        print(f"Download link: {os.path.abspath(file_path)}")
+
+    except json.JSONDecodeError:
+        print("The response could not be parsed as JSON. Please check the output format.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+if __name__ == "__main__":
+    predict_diet_plan()

feed_back_llm.py

@@ -0,0 +1,68 @@
+import json
+import random
+
+
+# Function to read the JSON from the file
+def read_json(file_path):
+    with open(file_path, 'r') as json_file:
+        return json.load(json_file)
+
+# Function to add a new day's progress
+def add_next_day_progress(data, next_day_progress):
+    # Extract the current day count (last day in the list)
+    last_day_number = int(data["daily_progress"][-1]["day"].split(" ")[1]) if data["daily_progress"] else 0
+    
+    # Construct the new day's entry
+    next_day_number = last_day_number + 1
+    next_day_name = f"Day {next_day_number}"
+    
+    
+    # Add the next day's data with the LOINC-like identifier
+    new_day_entry = {  # Unique identifier for the day
+        "day": next_day_name,
+        "progress": next_day_progress["progress"],
+        "rest_time": next_day_progress["rest_time"],
+        "workout_time": next_day_progress["workout_time"]
+    }
+    
+    data["daily_progress"].append(new_day_entry)
+    
+    # Update weekly summary (rest_time and workout_time)
+    total_rest_time = sum(day["rest_time"] for day in data["daily_progress"])
+    total_workout_time = sum(day["workout_time"] for day in data["daily_progress"])
+    
+    data["weekly_summary"]["rest_time"] = total_rest_time
+    data["weekly_summary"]["workout_time"] = total_workout_time
+
+    return data
+
+# Function to save the updated data to a file
+def save_json(data, file_path):
+    with open(file_path, 'w') as json_file:
+        json.dump(data, json_file, indent=2)
+
+
+def update_feed_back():
+    # Path to the JSON file
+    file_path = r'static\feedback.json'
+
+    # Step 1: Read the existing JSON data
+    data = read_json(file_path)
+
+    # Example new day data to add (Day 8)
+
+
+    # Generating random values for progress, rest_time, and workout_time
+    next_day_progress = {
+        "progress": random.randint(50, 100),  # Random progress between 50 and 100
+        "rest_time": random.randint(4, 10),   # Random rest time between 4 and 10 hours
+        "workout_time": random.randint(1, 5)  # Random workout time between 1 and 5 hours
+    }
+
+    # Step 2: Add the new day to the data and update the weekly summary
+    updated_data = add_next_day_progress(data, next_day_progress)
+
+    # Step 3: Save the updated data back to the file
+    save_json(updated_data, file_path)
+
+    print(f"Updated data saved to {file_path}")

main.py

@@ -0,0 +1,127 @@
+# from flask import Flask, render_template, request, Response
+# import cv2
+# import mediapipe as mp
+# import numpy as np
+# import os
+
+# app = Flask(_name_)
+
+# # Initialize Mediapipe Pose
+# mp_pose = mp.solutions.pose
+# mp_drawing = mp.solutions.drawing_utils
+
+# # Function to calculate the angle between three points
+# def calculate_angle(a, b, c):
+#     a = np.array(a)  # First point
+#     b = np.array(b)  # Middle point
+#     c = np.array(c)  # Last point
+
+#     radians = np.arctan2(c[1] - b[1], c[0] - b[0]) - np.arctan2(a[1] - b[1], a[0] - b[0])
+#     angle = np.abs(radians * 180.0 / np.pi)
+
+#     if angle > 180.0:
+#         angle = 360 - angle
+
+#     return angle
+
+# # Function to check shoulder press posture
+def is_shoulder_press_correct(landmarks, mp_pose):
+    # Get coordinates of shoulder, elbow, and wrist (left arm as example)
+    shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x,
+                landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]
+    elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x,
+             landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]
+    wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x,
+             landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]
+
+    # Calculate angle at the elbow (shoulder, elbow, wrist)
+    elbow_angle = calculate_angle(shoulder, elbow, wrist)
+
+    # Check if the motion is vertical (wrist higher than elbow)
+    if wrist[1] < elbow[1] and elbow[1] < shoulder[1]:
+        # Ensure proper angle range for a shoulder press
+        if 160 <= elbow_angle <= 180:
+            return "Shoulder Press: Correct", True
+        else:
+            return "Shoulder Press: Incorrect - Elbow angle", False
+    else:
+        return "Shoulder Press: Incorrect - Alignment", False
+
+# Video processing function
+def process_video(video_path):
+    cap = cv2.VideoCapture(video_path)
+    count = 0
+    rep_started = False
+
+    with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose:
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            # Convert the frame to RGB
+            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            image.flags.writeable = False
+
+            # Process the image for pose detection
+            results = pose.process(image)
+
+            # Convert back to BGR for rendering
+            image.flags.writeable = True
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+            # Extract landmarks
+            if results.pose_landmarks:
+                landmarks = results.pose_landmarks.landmark
+
+                # Check shoulder press posture
+                feedback, is_correct = is_shoulder_press_correct(landmarks, mp_pose)
+
+                # Count reps
+                if is_correct and not rep_started:
+                    rep_started = True
+                elif not is_correct and rep_started:
+                    rep_started = False
+                    count += 1
+
+                # Display feedback
+                cv2.putText(image, feedback, (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0) if is_correct else (0, 0, 255), 2, cv2.LINE_AA)
+
+                # Display rep count
+                cv2.putText(image, f'Reps: {count}', (50, 100),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)
+
+                # Draw landmarks
+                mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS)
+
+            else:
+                # Warn if no landmarks are detected
+                cv2.putText(image, "No body detected", (50, 50),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, cv2.LINE_AA)
+
+            # Encode frame for streaming
+            ret, buffer = cv2.imencode('.jpg', image)
+            frame = buffer.tobytes()
+            yield (b'--frame\r\n'
+                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
+
+    cap.release()
+
+# @app.route('/')
+# def index():
+#     return render_template('index.html')
+
+# @app.route('/upload', methods=['POST'])
+# def upload():
+#     if 'video' not in request.files:
+#         return "No video file uploaded", 400
+
+#     video = request.files['video']
+#     video_path = os.path.join('uploads', video.filename)
+#     video.save(video_path)
+
+#     return Response(process_video(video_path), mimetype='multipart/x-mixed-replace; boundary=frame')
+
+# if _name_ == "_main_":
+#     app.run(debug=True)

requirements.txt

@@ -0,0 +1,7 @@
+opencv-python-headless
+mediapipe
+numpy
+Pillow
+firebase-admin
+gunicorn
+Flask

serviceAccountKey.json

@@ -0,0 +1,14 @@
+{
+    "type": "service_account",
+    "project_id": "fitnessdb-c9b11",
+    "private_key_id": "d304ad2536ee8ad34e6805b2e3ce6b9b8f2a0fcc",
+    "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDNAG4aKS454RQl\ne35uIQYR8BA67RzgRng5DqGM+3E+8vvVUb2LZVzxIFlYP2P6D/U1CgbB8IdfsMx2\nDEz5CnaRsPvz5TvxSNxrqRM6mGRPvg1+HA1auN11LUIiMoWkhNtYXUAG3Ae6TjED\nppykPxlTHxbcnkvZGSQn4DtzHU8xNoLe/lHABHWNMz8kbWSwaFK0Nh+azsxCePzU\nYKgE29OcJDqz3CXocxn9XrTVNzlYCVNcdpWVdjBRRz9Pi4qMZ+APuc32eMcy6E4z\n7XmSTxM4/G/wXei6Kref35Vn+PpBypRgIzmOPvx+vTQhMlAMMlatRgl1XhM3A5ES\n67Sg8aW1AgMBAAECggEAVNSiOxoiYloU+6O8QDdTKzYTiUbYZahTlIzM5imghaOH\n+ZCfJmFWEgPIZP+qT+6tkfqprDRr2HmxSgIyEfY19Xju8dDAuspjR/vJlLw9+k+T\nhsV18z4/if8l+D++1MMTf1/rIEuJuRslJjUaac8gnChnzfiFO3uvXf7oquyMejit\nnL9ss04Fw6TPIv8P8IpERjdAroey9kfKtRXZ167QN7xw87dLp07h0D3T5Z2juVMg\nrA00c8Fv6zer26Pt+wdPTnMc0AYoBjPxg2yBUtajcWbdcZNjswzeH0w5rtSQ8bsJ\nTRF1qOXdJL4JUe1fk3LyXz7viGfDMlrg/roWujMcSwKBgQD6URATlqnZc15zUDfQ\n/YDyTlhhnXkeMmAOdR1ZX916J6+4XRb2GGwuim5gCpNJSva4UyChujxZZKuWXkke\n5jvu4K/DeFuSW0rrldb9GMCbIov0wmqpoeC7wSUupnJ3feaIkT3DeqC1cQYb0Nl1\n1eL3SGAAM/dGhOZR9/0hTPSOqwKBgQDRp/qpRsGqxMT2kuFEUJBTS7fLpqCfLm8n\nS3Bh6R5QLg/PMNgLNsJL8fZ62SdQ9s9/sVNq//r/cCA3WzQHTjNIdfXhSXu6/Iik\n54TkAZjedfnHQ5jUlSNLKqwGYEZ4Ih9wwCr97yXTma0M8HnDjccyemxEHkTYEcol\nP7VOJYEdHwKBgAoWVDCF5MhXhtncxLMOVDDviU49u1DFNOvAOnOMkm9GxCUI01EN\ngOaLO5FxO6g7dh/NccYyrBXqIaQInqe5HXct5MdaxU3rkeRWgHhok/JsfPlbEFNP\nq6/FQ8tSd9Bq6WxddgC3o1xMdrOOQgUmnmParcu0TGWyG1n4RWIfKMfLAoGALS1P\nPC69CLlB4AgidoANuYU1Y7LSJbrxxLviyZZcK9bhHTpfM3tnPsoy3KHycOXeLJvf\nZ80lHungZ01F1tUpA9I3W4ZkHRTRtQcWgbM+Z6FwY1nTkutYIZheXTldtgFUWQ1v\ntixUMFaLDaC7/EGOzPfIYJ1NJGog7wndXauDOO0CgYEAmhbjxZVh9tRFoQJVSt/7\nEklUQXv3MHJQGsM9tglTJBGS5JcYD1vYpNxCFYt3cl5WmM1Gr7OWHre38JCGBgMv\n6+7uGjD5LPHbiMLnSnC1aPl8Tfw8p1hh92rxS6MN4A1Xq72hv73/o9P1nLl5mP9Z\ng/nz1ISSsQi2EMEtZIQIqtc=\n-----END PRIVATE KEY-----\n",
+    "client_email": "firebase-adminsdk-lpyql@fitnessdb-c9b11.iam.gserviceaccount.com",
+    "client_id": "110696125764328036804",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-lpyql%40fitnessdb-c9b11.iam.gserviceaccount.com",
+    "universe_domain": "googleapis.com"
+  }
+