comparison photo

README.md

@@ -11,8 +11,8 @@ A tool for analyzing golf swings using computer vision and AI.
 - Club and ball trajectory analysis
 - LLM-powered swing analysis and coaching tips (OpenAI GPT-4/3.5 or local Ollama models)
 - Annotated video generation
-- Side-by-side comparison with professional golfer
-- Improvement recommendations from AI analysis
+- Key position comparison with professional golfer (3 critical swing positions)
+- Detailed improvement recommendations with visual analysis
 
 ## Setup
 
@@ -74,8 +74,12 @@ streamlit run app/streamlit_app.py
 2. Click "Analyze Swing" to process the video
 3. View the swing phase breakdown and metrics
 4. Generate an annotated video showing the analysis
-5. Compare your swing side-by-side with a professional golfer
-6. Get AI-powered improvement recommendations
+5. Compare your swing at 3 key positions with a professional golfer:
+   - Starting position (setup)
+   - Top of backswing
+   - Impact with ball
+6. Get detailed improvement recommendations for each swing phase
+7. Download comparison images and analysis results
 
 ## Technical Details
 

app/streamlit_app.py

@@ -23,7 +23,7 @@ from app.models.pose_estimator import analyze_pose
 from app.models.swing_analyzer import segment_swing, analyze_trajectory
 from app.models.llm_analyzer import generate_swing_analysis, create_llm_prompt, prepare_data_for_llm, check_llm_services
 from app.utils.visualizer import create_annotated_video
-from app.utils.comparison import create_frame_by_frame_comparison
+from app.utils.comparison import create_key_frame_comparison
 
 # Set page config
 st.set_page_config(page_title="Par-ity Project: Golf Swing Analysis 🏌️‍♀️",
@@ -304,7 +304,7 @@ def main():
             with options_col3:
                 if enable_pro_comparison and st.session_state.pro_reference_path:
                     st.info(
-                        "**Option 3: Compare With Pro**\n\nSee a side-by-side frame-by-frame comparison with a professional golfer's swing."
+                        "**Option 3: Compare With Pro**\n\nSee side-by-side comparisons of 3 key swing positions with a professional golfer, including improvement tips for each phase."
                     )
 
         except Exception as e:
@@ -365,7 +365,7 @@ def main():
         # Add pro comparison button if enabled
         if enable_pro_comparison and st.session_state.pro_reference_path and button_col3:
             with button_col3:
-                comparison_clicked = st.button("Compare With Pro",
+                comparison_clicked = st.button("Compare Key Positions",
                                               key="pro_comparison",
                                               use_container_width=True)
         else:
@@ -480,41 +480,91 @@ def main():
         # Handle pro comparison video creation
         if comparison_clicked and st.session_state.pro_reference_path:
             try:
-                with st.spinner("Creating frame-by-frame comparison..."):
+                with st.spinner("Creating key frame comparison..."):
                     # Get data from session state
                     user_video_path = st.session_state.analysis_data['video_path']
-                    pro_video_path = st.session_state.pro_reference_path
+                    user_swing_phases = st.session_state.analysis_data['swing_phases']
                     
-                    # Create the comparison video
-                    comparison_path = create_frame_by_frame_comparison(
+                    # Create the key frame comparison using static pro reference images
+                    # Don't pass pro_video_path to ensure it uses the static images
+                    comparison_data = create_key_frame_comparison(
                         user_video_path,
-                        pro_video_path
+                        user_swing_phases=user_swing_phases,
+                        use_pro_images=True
                     )
                     
-                    # Verify the file exists
-                    if not os.path.exists(comparison_path):
-                        raise FileNotFoundError(
-                            f"Comparison video file not found at {comparison_path}")
-                    
-                    # Store the comparison video path in session state
-                    st.session_state.comparison_video_path = comparison_path
+                    # Store the comparison data in session state
+                    st.session_state.comparison_data = comparison_data
                 
-                # Display success message and video
-                st.success("Frame-by-frame comparison created successfully!")
-                st.subheader("Side-by-Side Comparison with Pro Golfer")
+                # Display success message
+                st.success("Key frame comparison created successfully!")
+                st.subheader("Swing Analysis: Key Position Comparison")
                 
-                # Display video with larger width
-                display_video(comparison_path, width=800)
+                # Display each comparison with comments
+                phases = ['setup', 'backswing', 'impact']
                 
-                # Show download button
-                with open(comparison_path, "rb") as file:
-                    video_bytes = file.read()
-                    st.download_button(
-                        label="Download Comparison Video",
-                        data=video_bytes,
-                        file_name=os.path.basename(comparison_path),
-                        mime="video/mp4"
-                    )
+                for phase in phases:
+                    if phase in comparison_data:
+                        data = comparison_data[phase]
+                        
+                        # Display the comparison image
+                        st.subheader(f"{data['title']}")
+                        
+                        # Display the image
+                        if os.path.exists(data['image_path']):
+                            st.image(data['image_path'], use_column_width=True)
+                            
+                            # Create download button for the image
+                            with open(data['image_path'], "rb") as file:
+                                image_bytes = file.read()
+                                st.download_button(
+                                    label=f"Download {data['title']} Comparison",
+                                    data=image_bytes,
+                                    file_name=os.path.basename(data['image_path']),
+                                    mime="image/jpeg",
+                                    key=f"download_{phase}"
+                                )
+                        
+                        # Display improvement comments
+                        comments = data['comments']
+                        
+                        col1, col2 = st.columns(2)
+                        
+                        with col1:
+                            st.markdown("**🏆 Professional Analysis:**")
+                            for analysis in comments['pro_analysis']:
+                                st.markdown(f"• {analysis}")
+                        
+                        with col2:
+                            st.markdown("**🔄 User vs Professional Comparison:**")
+                            for comparison in comments['comparison']:
+                                st.markdown(f"• {comparison}")
+                        
+                        st.markdown("---")  # Add separator between phases
+                
+                # Add general guidance
+                with st.expander("How to Use This Analysis", expanded=False):
+                    st.markdown("""
+                    ### How to Interpret These Comparisons
+                    
+                    Each comparison shows your swing position (left) next to a professional golfer's position (right) at three critical moments:
+                    
+                    1. **Starting Position**: Your setup and address position
+                    2. **Top of Backswing**: The highest point of your backswing
+                    3. **Impact with Ball**: The moment of contact with the ball
+                    
+                    **Tips for Improvement:**
+                    - Compare your body positioning, posture, and club position to the pro
+                    - Focus on one aspect at a time (e.g., posture, then weight distribution)
+                    - Practice the positions slowly without a ball first
+                    - Use a mirror or video recording to check your positions
+                    - Work with a golf instructor for personalized feedback
+                    
+                    **Remember:** Every golfer is different, so focus on the fundamental principles rather than trying to copy every detail exactly.
+                    """)
+            
+            except Exception as e:
+                st.error(f"Error creating key frame comparison: {str(e)}")
                 
                 # Add some guidance for interpreting the comparison
                 with st.expander("How to use this comparison", expanded=True):
@@ -532,9 +582,6 @@ def main():
                     
                     Try pausing the video at key positions to analyze differences in detail.
                     """)
-            
-            except Exception as e:
-                st.error(f"Error creating comparison video: {str(e)}")
 
 
 if __name__ == "__main__":

app/utils/comparison.py

@@ -52,6 +52,302 @@ def extract_frames(video_path, max_frames=100):
     return frames
 
 
+def extract_key_swing_frames(video_path, swing_phases=None):
+    """
+    Extract 3 key frames from a golf swing video:
+    1. Starting position (setup)
+    2. Top of backswing
+    3. Impact with ball
+    
+    Args:
+        video_path (str): Path to the video file
+        swing_phases (dict): Optional swing phase data for precise frame selection
+        
+    Returns:
+        dict: Dictionary with keys 'setup', 'backswing', 'impact' 
+              and frame images as values
+    """
+    if not os.path.exists(video_path):
+        raise ValueError(f"Video file not found: {video_path}")
+        
+    cap = cv2.VideoCapture(video_path)
+    
+    if not cap.isOpened():
+        raise ValueError(f"Could not open video: {video_path}")
+    
+    # Get total frame count
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+    key_frames = {}
+    
+    if swing_phases:
+        # Use provided swing phase data for precise frame selection
+        frame_indices = {
+            'setup': swing_phases.get('setup', [0])[0] if swing_phases.get('setup') else 0,
+            'backswing': swing_phases.get('backswing', [total_frames//3])[-1] if swing_phases.get('backswing') else total_frames//3,
+            'impact': swing_phases.get('impact', [total_frames//2])[len(swing_phases.get('impact', [total_frames//2]))//2] if swing_phases.get('impact') else total_frames//2
+        }
+    else:
+        # Use estimated frame positions for 3 frames
+        frame_indices = {
+            'setup': 0,  # First frame
+            'backswing': total_frames // 3,  # 33% through
+            'impact': int(total_frames * 0.6)  # 60% through
+        }
+    
+    # Extract the specific frames
+    for phase, frame_idx in frame_indices.items():
+        cap.set(cv2.CAP_PROP_POS_FRAMES, min(frame_idx, total_frames - 1))
+        ret, frame = cap.read()
+        if ret:
+            # Keep original orientation - no rotation
+            key_frames[phase] = frame
+        else:
+            # If frame extraction fails, use a black frame
+            key_frames[phase] = np.zeros((480, 640, 3), dtype=np.uint8)
+    
+    cap.release()
+    
+    return key_frames
+
+
+def generate_improvement_comments(phase):
+    """
+    Generate improvement comments for each swing phase in Professional/Comparison format
+    
+    Args:
+        phase (str): The swing phase ('setup', 'backswing', 'impact')
+        
+    Returns:
+        dict: Dictionary with 'pro_analysis' and 'comparison' keys
+    """
+    comments = {
+        'setup': {
+            'pro_analysis': [
+                "Balanced stance with feet shoulder-width apart",
+                "Even weight distribution on both feet",
+                "Neutral grip with hands in proper position",
+                "Athletic posture with slight forward bend",
+                "Ball positioned correctly for club selection"
+            ],
+            'comparison': [
+                "Compare your stance width to the pro's balanced setup",
+                "Check if your weight is evenly distributed like the pro",
+                "Ensure your grip matches the pro's neutral hand position",
+                "Adjust your posture to match the pro's athletic stance",
+                "Position the ball in your stance similar to the pro"
+            ]
+        },
+        'backswing': {
+            'pro_analysis': [
+                "Full 90+ degree shoulder rotation",
+                "Controlled hip turn with stable lower body",
+                "Club on proper swing plane at top",
+                "Consistent spine angle throughout",
+                "Minimal weight shift to right side"
+            ],
+            'comparison': [
+                "Increase your shoulder turn to match the pro's full rotation",
+                "Control your hip movement like the pro's stable base",
+                "Adjust your club position to match the pro's swing plane",
+                "Maintain spine angle consistency like the professional",
+                "Minimize weight shift compared to the pro's centered position"
+            ]
+        },
+        'impact': {
+            'pro_analysis': [
+                "Weight shifted to front foot (70-80%)",
+                "Hands ahead of ball at impact",
+                "Square club face to target line",
+                "Head behind ball with steady position",
+                "Hips and shoulders aligned to target"
+            ],
+            'comparison': [
+                "Shift more weight to your front foot like the pro",
+                "Get your hands ahead of the ball like the professional",
+                "Square your club face to match the pro's alignment",
+                "Keep your head steady and behind the ball like the pro",
+                "Align your body to the target like the professional"
+            ]
+        }
+    }
+    
+    return comments.get(phase, {'pro_analysis': [], 'comparison': []})
+
+
+def load_pro_reference_images(pro_images_dir="pro_reference"):
+    """
+    Load professional golfer reference images from directory
+    
+    Args:
+        pro_images_dir (str): Directory containing professional reference images
+        
+    Returns:
+        dict: Dictionary with phase names as keys and image arrays as values
+    """
+    # Get the absolute path to the pro_reference directory
+    # This ensures it works regardless of the current working directory
+    if not os.path.isabs(pro_images_dir):
+        # Get the directory where this script is located
+        script_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        pro_images_dir = os.path.join(script_dir, pro_images_dir)
+    
+    pro_frames = {}
+    
+    # Expected filenames for the 3 phases
+    phase_files = {
+        'setup': 'setup.jpg',
+        'backswing': 'backswing.jpg', 
+        'impact': 'impact.jpg'
+    }
+    
+    for phase, filename in phase_files.items():
+        image_path = os.path.join(pro_images_dir, filename)
+        if os.path.exists(image_path):
+            image = cv2.imread(image_path)
+            if image is not None:
+                pro_frames[phase] = image
+            else:
+                # Create a placeholder if image can't be loaded
+                pro_frames[phase] = np.zeros((480, 640, 3), dtype=np.uint8)
+        else:
+            # Create a placeholder if file doesn't exist
+            pro_frames[phase] = np.zeros((480, 640, 3), dtype=np.uint8)
+    
+    return pro_frames
+
+
+def create_key_frame_comparison(user_video_path, pro_video_path=None, user_swing_phases=None, pro_swing_phases=None, output_dir="downloads", use_pro_images=True):
+    """
+    Create a comparison of 3 key frames between user and pro golfer swings
+    
+    Args:
+        user_video_path (str): Path to the user's golf swing video
+        pro_video_path (str): Path to the professional golfer's swing video (optional if use_pro_images=True)
+        user_swing_phases (dict): Optional swing phase data for user video
+        pro_swing_phases (dict): Optional swing phase data for pro video
+        output_dir (str): Directory to save the comparison images
+        use_pro_images (bool): Whether to use provided pro reference images instead of video
+        
+    Returns:
+        dict: Dictionary with phase names as keys and image paths as values
+    """
+    # Extract key frames from user video
+    user_frames = extract_key_swing_frames(user_video_path, user_swing_phases)
+    
+    # Get pro frames either from provided images or video
+    if use_pro_images:
+        pro_frames = load_pro_reference_images()
+    else:
+        pro_frames = extract_key_swing_frames(pro_video_path, pro_swing_phases)
+    
+    # Create output directory with absolute path
+    output_dir = os.path.abspath(output_dir)
+    os.makedirs(output_dir, exist_ok=True)
+    
+    comparison_data = {}
+    phases = ['setup', 'backswing', 'impact']
+    phase_titles = ['Starting Position', 'Top of Backswing', 'Impact with Ball']
+    
+    for i, phase in enumerate(phases):
+        # Get frames for this phase
+        user_frame = user_frames.get(phase, np.zeros((480, 640, 3), dtype=np.uint8))
+        pro_frame = pro_frames.get(phase, np.zeros((480, 640, 3), dtype=np.uint8))
+        
+        # Resize frames to consistent size while maintaining portrait orientation
+        target_height = 400
+        user_frame = resize_frame_maintain_aspect(user_frame, target_height)
+        pro_frame = resize_frame_maintain_aspect(pro_frame, target_height)
+        
+        # Create side-by-side comparison
+        comparison_image = create_side_by_side_image(user_frame, pro_frame, phase_titles[i])
+        
+        # Save the comparison image with absolute path
+        video_name = os.path.splitext(os.path.basename(user_video_path))[0]
+        output_path = os.path.join(output_dir, f"{video_name}_{phase}_comparison.jpg")
+        
+        # Ensure the image is saved successfully
+        success = cv2.imwrite(output_path, comparison_image)
+        if not success:
+            print(f"Warning: Failed to save image to {output_path}")
+        else:
+            print(f"Successfully saved comparison image: {output_path}")
+        
+        # Get improvement comments
+        comments = generate_improvement_comments(phase)
+        
+        comparison_data[phase] = {
+            'image_path': output_path,
+            'title': phase_titles[i],
+            'comments': comments
+        }
+    
+    return comparison_data
+
+
+def resize_frame_maintain_aspect(frame, target_height):
+    """
+    Resize frame to target height while maintaining aspect ratio
+    
+    Args:
+        frame (numpy.ndarray): Input frame
+        target_height (int): Target height
+        
+    Returns:
+        numpy.ndarray: Resized frame
+    """
+    h, w = frame.shape[:2]
+    target_width = int(w * (target_height / h))
+    return cv2.resize(frame, (target_width, target_height))
+
+
+def create_side_by_side_image(user_frame, pro_frame, title):
+    """
+    Create a side-by-side comparison image
+    
+    Args:
+        user_frame (numpy.ndarray): User's swing frame
+        pro_frame (numpy.ndarray): Pro's swing frame
+        title (str): Title for the comparison
+        
+    Returns:
+        numpy.ndarray: Combined comparison image
+    """
+    # Get dimensions
+    user_h, user_w = user_frame.shape[:2]
+    pro_h, pro_w = pro_frame.shape[:2]
+    
+    # Create padding and title space
+    padding = 20
+    title_height = 60
+    max_height = max(user_h, pro_h)
+    total_width = user_w + pro_w + padding
+    total_height = max_height + title_height
+    
+    # Create blank canvas
+    canvas = np.ones((total_height, total_width, 3), dtype=np.uint8) * 255
+    
+    # Add title
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    title_size = cv2.getTextSize(title, font, 1.2, 2)[0]
+    title_x = (total_width - title_size[0]) // 2
+    cv2.putText(canvas, title, (title_x, 40), font, 1.2, (0, 0, 0), 2)
+    
+    # Add user frame
+    y_offset = title_height + (max_height - user_h) // 2
+    canvas[y_offset:y_offset + user_h, 0:user_w] = user_frame
+    
+    # Add pro frame
+    y_offset = title_height + (max_height - pro_h) // 2
+    canvas[y_offset:y_offset + pro_h, user_w + padding:user_w + padding + pro_w] = pro_frame
+    
+    # Draw vertical separator line
+    line_x = user_w + padding // 2
+    cv2.line(canvas, (line_x, title_height), (line_x, total_height), (200, 200, 200), 2)
+    
+    return canvas
+
+
 def normalize_frames(frames, target_height=480):
     """
     Normalize frames to a consistent size while maintaining aspect ratio

app/utils/visualizer.py

@@ -94,14 +94,11 @@ def create_annotated_video(video_path,
                 elif rotation_value == 270:  # 270 degrees clockwise
                     rotation = 90  # We'll rotate counterclockwise, so 90
             except:
-                # If metadata reading fails, use the dimensions-based detection
+                # If metadata reading fails, don't apply any rotation
                 rotation = 0
         
-        # If no rotation metadata or reading failed, use dimensions-based detection
-        if rotation == 0:
-            # Check if video is in portrait mode (height > width)
-            if height > width * 1.2:  # If height is significantly greater than width
-                rotation = 90  # Rotate 90 degrees counterclockwise
+        # Don't apply automatic rotation based on dimensions
+        # Keep the video in its original orientation
         
         # Close the video capture
         cap.release()