Upload 12 files

.gitattributes

@@ -33,3 +33,4 @@ 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
+generated-icon.png filter=lfs diff=lfs merge=lfs -text

.replit

@@ -0,0 +1,38 @@
+modules = ["python-3.11", "postgresql-16"]
+
+[nix]
+channel = "stable-24_05"
+
+[workflows]
+runButton = "Project"
+
+[[workflows.workflow]]
+name = "Project"
+mode = "parallel"
+author = "agent"
+
+[[workflows.workflow.tasks]]
+task = "workflow.run"
+args = "Pose Detection App"
+
+[[workflows.workflow]]
+name = "Pose Detection App"
+author = "agent"
+
+[workflows.workflow.metadata]
+agentRequireRestartOnSave = false
+
+[[workflows.workflow.tasks]]
+task = "packager.installForAll"
+
+[[workflows.workflow.tasks]]
+task = "shell.exec"
+args = "streamlit run app.py --server.port 8501"
+waitForPort = 8501
+
+[deployment]
+run = ["sh", "-c", "streamlit run app.py --server.port 8501"]
+
+[[ports]]
+localPort = 8501
+externalPort = 80

animation_exporter.py

@@ -0,0 +1,105 @@
+import json
+import struct
+
+class AnimationExporter:
+    SUPPORTED_FORMATS = ['uasset', 'fbx', 'bvh']
+    
+    def __init__(self):
+        self.fps = 30
+        self.unreal_scale = 100.0  # Convert to Unreal units (cm)
+        self.export_format = 'uasset'
+        
+    def set_export_format(self, format_name: str):
+        if format_name.lower() not in self.SUPPORTED_FORMATS:
+            raise ValueError(f"Unsupported format. Must be one of {self.SUPPORTED_FORMATS}")
+        self.export_format = format_name.lower()
+
+    def export_pose(self, skeleton_data):
+        """
+        Export single pose to Unreal Engine compatible format
+        """
+        if not skeleton_data:
+            return None
+
+        # Create animation data structure
+        animation_data = {
+            'version': 1,
+            'skeleton_name': 'PoseSkeletalMesh',
+            'bones': []
+        }
+
+        # Convert skeleton data to Unreal format
+        for bone_name, bone_data in skeleton_data.items():
+            bone = {
+                'name': bone_name,
+                'position': self._convert_position(bone_data['position']),
+                'rotation': self._convert_rotation(bone_data['rotation'])
+            }
+            animation_data['bones'].append(bone)
+
+        # Convert to binary format
+        return self._to_binary(animation_data)
+
+    def export_animation(self, animation_frames):
+        """
+        Export animation sequence to Unreal Engine compatible format
+        """
+        if not animation_frames:
+            return None
+
+        # Create animation sequence data structure
+        animation_data = {
+            'version': 1,
+            'skeleton_name': 'AnimationSkeletalMesh',
+            'frame_rate': self.fps,
+            'frames': []
+        }
+
+        # Convert each frame
+        for frame in animation_frames:
+            frame_data = []
+            for bone_name, bone_data in frame.items():
+                bone = {
+                    'name': bone_name,
+                    'position': self._convert_position(bone_data['position']),
+                    'rotation': self._convert_rotation(bone_data['rotation'])
+                }
+                frame_data.append(bone)
+            animation_data['frames'].append(frame_data)
+
+        # Convert to binary format
+        return self._to_binary(animation_data)
+
+    def _convert_position(self, position):
+        """
+        Convert position to Unreal Engine coordinate system
+        """
+        return [
+            position[0] * self.unreal_scale,
+            -position[2] * self.unreal_scale,
+            position[1] * self.unreal_scale
+        ]
+
+    def _convert_rotation(self, rotation):
+        """
+        Convert rotation to Unreal Engine coordinate system (quaternion)
+        """
+        # Simple conversion - can be enhanced for better accuracy
+        return [
+            rotation[0],
+            -rotation[2],
+            rotation[1],
+            1.0  # w component
+        ]
+
+    def _to_binary(self, data):
+        """
+        Convert animation data to binary format
+        """
+        # Create binary header
+        header = struct.pack('4s2I', b'UEAN', 1, len(json.dumps(data)))
+        
+        # Convert data to JSON and then to bytes
+        json_data = json.dumps(data).encode('utf-8')
+        
+        return header + json_data

animation_renderer.py

@@ -0,0 +1,61 @@
+import numpy as np
+from dataclasses import dataclass
+from typing import List, Dict, Tuple
+
+@dataclass
+class KeyFrame:
+    timestamp: float
+    landmarks: np.ndarray
+    connections: List[Tuple[int, int]]
+
+class AnimationRenderer:
+    def __init__(self, fps: int = 30):
+        self.fps = fps
+        self.keyframes: List[KeyFrame] = []
+        self.current_frame = 0
+        self.total_frames = 0
+        
+    def add_keyframe(self, landmarks: np.ndarray, connections: List[Tuple[int, int]], timestamp: float):
+        """Add a new keyframe to the animation sequence"""
+        keyframe = KeyFrame(timestamp=timestamp, landmarks=landmarks, connections=connections)
+        self.keyframes.append(keyframe)
+        self.total_frames = max(self.total_frames, int(timestamp * self.fps))
+    
+    def interpolate_poses(self, start_frame: KeyFrame, end_frame: KeyFrame, alpha: float) -> np.ndarray:
+        """Interpolate between two poses using linear interpolation"""
+        return start_frame.landmarks + alpha * (end_frame.landmarks - start_frame.landmarks)
+    
+    def get_frame_at_time(self, time: float) -> Tuple[np.ndarray, List[Tuple[int, int]]]:
+        """Get interpolated frame at specified time"""
+        if not self.keyframes:
+            return None, []
+            
+        # Find surrounding keyframes
+        next_idx = 0
+        for i, kf in enumerate(self.keyframes):
+            if kf.timestamp > time:
+                next_idx = i
+                break
+                
+        if next_idx == 0:
+            return self.keyframes[0].landmarks, self.keyframes[0].connections
+            
+        prev_idx = next_idx - 1
+        prev_frame = self.keyframes[prev_idx]
+        next_frame = self.keyframes[next_idx]
+        
+        # Calculate interpolation factor
+        alpha = (time - prev_frame.timestamp) / (next_frame.timestamp - prev_frame.timestamp)
+        interpolated_landmarks = self.interpolate_poses(prev_frame, next_frame, alpha)
+        
+        return interpolated_landmarks, prev_frame.connections
+    
+    def get_next_frame(self) -> Tuple[np.ndarray, List[Tuple[int, int]]]:
+        """Get the next frame in the animation sequence"""
+        if not self.keyframes or self.current_frame >= self.total_frames:
+            return None, []
+            
+        time = self.current_frame / self.fps
+        self.current_frame += 1
+        
+        return self.get_frame_at_time(time)

app.py

@@ -0,0 +1,304 @@
+
+import streamlit as st
+import cv2
+import numpy as np
+import tempfile
+from typing import Optional, Tuple
+from datetime import datetime
+
+from pose_detector import PoseDetector
+from skeleton_generator import SkeletonGenerator
+from animation_exporter import AnimationExporter
+from utils import process_video, process_image, process_gif
+from database import get_db, ProcessedFile, PoseData, AnimationData
+
+def init_page():
+    """Initialize Streamlit page configuration and styling."""
+    st.set_page_config(layout="wide", page_title="Pose Detection & Animation Generator")
+    with open('static/style.css') as f:
+        st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
+    
+    # Theme selection
+    theme = st.sidebar.selectbox("Theme", ["Light", "Dark"], key="theme")
+    if theme == "Dark":
+        st.markdown("""
+        <style>
+        .stApp { background-color: #1E1E1E; color: #FFFFFF; }
+        </style>
+        """, unsafe_allow_html=True)
+    
+    # Detection settings
+    st.sidebar.title("Settings")
+    
+    # Detection settings
+    confidence_threshold = st.sidebar.slider(
+        "Detection Confidence",
+        min_value=0.0,
+        max_value=1.0,
+        value=0.5,
+        step=0.1
+    )
+    
+    # Export format selection
+    export_format = st.sidebar.selectbox(
+        "Export Format",
+        options=['uasset', 'fbx', 'bvh'],
+        key='export_format'
+    )
+    
+    # Manual correction mode
+    enable_corrections = st.sidebar.checkbox("Enable Manual Corrections")
+    if enable_corrections:
+        st.sidebar.info("Click on landmarks in the preview to adjust their positions")
+    
+    # Custom skeleton mapping
+    show_mapping = st.sidebar.expander("Skeleton Mapping")
+    with show_mapping:
+        st.text_area("Custom Mapping (JSON)", value="{}", key="custom_mapping")
+    
+    st.title("Pose Detection & Animation Generator")
+    return confidence_threshold
+
+def init_components() -> Tuple[PoseDetector, SkeletonGenerator, AnimationExporter]:
+    """Initialize the main processing components."""
+    return PoseDetector(), SkeletonGenerator(), AnimationExporter()
+
+def handle_upload(file_type: str, uploaded_file, components: Tuple, db_session) -> Optional[ProcessedFile]:
+    """Process uploaded file and store results in database."""
+    pose_detector, skeleton_generator, animation_exporter = components
+    
+    processed_file = ProcessedFile(
+        filename=uploaded_file.name,
+        file_type='video' if uploaded_file.type == 'image/gif' else file_type,
+        processing_status="processing"
+    )
+    db_session.add(processed_file)
+    db_session.commit()
+    db_session.refresh(processed_file)
+    
+    return processed_file
+
+def main():
+    init_page()
+    components = init_components()
+    
+    try:
+        uploaded_file = st.file_uploader(
+            "Choose an image or video file (max 50MB)", 
+            type=['jpg', 'jpeg', 'png', 'mp4', 'avi', 'gif']
+        )
+        if uploaded_file is not None:
+            st.cache_data.clear()  # Clear cache to prevent stale data
+    except Exception as e:
+        st.error("Network error occurred. Please try uploading again.")
+        return
+
+    if uploaded_file is None:
+        st.warning("Please upload a file to begin.")
+        return
+        
+    if uploaded_file.type == 'video/mp4':
+        try:
+            st.info("Processing video... This may take a moment.")
+            file_size = len(uploaded_file.getvalue()) / (1024 * 1024)  # Size in MB
+            if file_size > 50:
+                st.error("Video file size must be under 50MB. Please upload a smaller file.")
+                return
+                
+            # Validate video file
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tfile:
+                tfile.write(uploaded_file.getvalue())
+                cap = cv2.VideoCapture(tfile.name)
+                if not cap.isOpened():
+                    st.error("Invalid video file. Please try a different file.")
+                    return
+                cap.release()
+        except Exception as e:
+            st.error(f"Error processing video: {str(e)}")
+            return
+
+    if uploaded_file is None:
+        return
+
+    db = next(get_db())
+    try:
+        file_type = uploaded_file.type.split('/')[0]
+        is_gif = uploaded_file.type == 'image/gif'
+        
+        processed_file = handle_upload(file_type, uploaded_file, components, db)
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.subheader("Original")
+        with col2:
+            st.subheader("Processed")
+
+        try:
+            if file_type == 'image' and not is_gif:
+                process_image_upload(uploaded_file, components, processed_file, db, col1, col2)
+            elif file_type == 'video' or is_gif:
+                process_video_upload(uploaded_file, components, processed_file, db, is_gif, col1, col2)
+        except Exception as e:
+            st.error(f"Processing error: {str(e)}")
+            processed_file.processing_status = "failed"
+            db.commit()
+            return
+
+        processed_file.processing_status = "completed"
+        db.commit()
+
+    except Exception as e:
+        st.error(f"An error occurred: {str(e)}")
+    finally:
+        db.close()
+
+def process_image_upload(uploaded_file, components, processed_file, db, col1, col2):
+    """Handle image file upload processing."""
+    pose_detector, skeleton_generator, animation_exporter = components
+    
+    file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+    image = cv2.imdecode(file_bytes, 1)
+
+    with col1:
+        st.image(cv2.cvtColor(image, cv2.COLOR_BGR2RGB), use_column_width=True)
+
+    processed_image, skeleton_data = process_image(image, pose_detector, skeleton_generator)
+
+    if not skeleton_data:
+        raise ValueError("No pose detected in the image")
+
+    save_pose_data(db, processed_file.id, skeleton_data)
+    animation_data_binary = animation_exporter.export_pose(skeleton_data)
+    save_animation_data(db, processed_file.id, skeleton_data)
+
+    with col2:
+        # Create a canvas for manual corrections
+        canvas_container = st.empty()
+        processed_rgb = cv2.cvtColor(processed_image, cv2.COLOR_BGR2RGB)
+        
+        # Add manual correction controls
+        if st.button("Enable Manual Correction"):
+            st.session_state.manual_correction = True
+            st.session_state.current_landmarks = skeleton_data
+            
+        if st.session_state.get('manual_correction', False):
+            # Display current joint positions
+            joints = st.session_state.current_landmarks
+            
+            selected_joint = st.selectbox("Select Joint to Adjust", list(joints.keys()))
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                x_pos = st.slider("X Position", 0.0, 1.0, float(joints[selected_joint]['position'][0]), 0.01)
+            with col2:
+                y_pos = st.slider("Y Position", 0.0, 1.0, float(joints[selected_joint]['position'][1]), 0.01)
+            
+            if st.button("Apply Changes"):
+                joints[selected_joint]['position'][0] = x_pos
+                joints[selected_joint]['position'][1] = y_pos
+                st.session_state.current_landmarks = joints
+                processed_image = pose_detector.draw_corrected_pose(image, joints)
+                processed_rgb = cv2.cvtColor(processed_image, cv2.COLOR_BGR2RGB)
+                
+            if st.button("Save Corrections"):
+                save_corrected_pose(db, processed_file.id, st.session_state.current_landmarks)
+                st.success("Corrections saved successfully!")
+                
+        canvas_container.image(processed_rgb, use_column_width=True)
+
+    provide_download_button(animation_data_binary)
+
+def process_video_upload(uploaded_file, components, processed_file, db, is_gif, col1, col2):
+    """Handle video/GIF file upload processing."""
+    pose_detector, skeleton_generator, animation_exporter = components
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.gif' if is_gif else '.mp4') as tfile:
+        tfile.write(uploaded_file.read())
+        video_path = tfile.name
+
+        with col1:
+            st.video(video_path)
+
+        if is_gif:
+            processed_video_path, animation_frames = process_gif(video_path, pose_detector, skeleton_generator)
+        else:
+            processed_video_path, animation_frames = process_video(video_path, pose_detector, skeleton_generator)
+
+        if not animation_frames:
+            raise ValueError("No poses detected in the video/gif")
+
+        save_video_data(db, processed_file.id, animation_frames)
+        animation_data_binary = animation_exporter.export_animation(animation_frames)
+
+        with col2:
+            if processed_video_path:
+                st.video(processed_video_path)
+
+        provide_download_button(animation_data_binary)
+        
+        cleanup_temp_files(video_path, processed_video_path)
+
+def save_pose_data(db, file_id: int, skeleton_data: dict):
+    """Save pose data to database."""
+    pose_data = PoseData(file_id=file_id, landmarks=skeleton_data)
+    db.add(pose_data)
+    db.commit()
+
+def save_animation_data(db, file_id: int, skeleton_data: dict):
+    """Save animation data to database."""
+    animation_data = AnimationData(
+        file_id=file_id,
+        skeleton_data=skeleton_data
+    )
+    db.add(animation_data)
+    db.commit()
+
+def save_video_data(db, file_id: int, animation_frames: list):
+    """Save video frame data to database."""
+    for frame_num, frame_data in enumerate(animation_frames):
+        pose_data = PoseData(
+            file_id=file_id,
+            frame_number=frame_num,
+            landmarks=frame_data
+        )
+        db.add(pose_data)
+    db.commit()
+
+def provide_download_button(animation_data_binary):
+    """Provide download button for animation data."""
+    st.download_button(
+        label="Download Animation Data",
+        data=animation_data_binary,
+        file_name="animation.uasset",
+        mime="application/octet-stream"
+    )
+
+def cleanup_temp_files(*file_paths):
+    """Clean up temporary files."""
+    for file_path in file_paths:
+        if file_path:
+            try:
+                import os
+                os.unlink(file_path)
+            except Exception:
+                pass
+
+def show_instructions():
+    """Show usage instructions."""
+    with st.expander("Instructions"):
+        st.markdown("""
+        1. Upload an image or video file using the file uploader above
+        2. Wait for the pose detection and skeleton generation to complete
+        3. Preview the results in the right column
+        4. Download the animation data for use in Unreal Engine
+
+        Supported file formats:
+        - Images: JPG, JPEG, PNG
+        - Videos: MP4, AVI, GIF
+        """)
+
+if __name__ == "__main__":
+    main()
+    show_instructions()

database.py

@@ -0,0 +1,61 @@
+import os
+from sqlalchemy import create_engine, Column, Integer, String, JSON, ForeignKey, DateTime, Boolean
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+from datetime import datetime
+
+# Create database engine
+DATABASE_URL = os.environ.get('DATABASE_URL')
+if not DATABASE_URL:
+    raise ValueError("DATABASE_URL environment variable is not set")
+
+engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+class ProcessedFile(Base):
+    __tablename__ = "processed_files"
+
+    id = Column(Integer, primary_key=True, index=True)
+    filename = Column(String, nullable=False)
+    file_type = Column(String, nullable=False)  # 'image' or 'video'
+    processing_status = Column(String, nullable=False, default="pending")
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    pose_data = relationship("PoseData", back_populates="file")
+    animation_data = relationship("AnimationData", back_populates="file")
+
+class PoseData(Base):
+    __tablename__ = "pose_data"
+
+    id = Column(Integer, primary_key=True, index=True)
+    file_id = Column(Integer, ForeignKey("processed_files.id"), nullable=False)
+    frame_number = Column(Integer, default=0)  # 0 for images, frame number for videos
+    landmarks = Column(JSON, nullable=False)
+    corrected_landmarks = Column(JSON)
+    is_corrected = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    file = relationship("ProcessedFile", back_populates="pose_data")
+
+class AnimationData(Base):
+    __tablename__ = "animation_data"
+
+    id = Column(Integer, primary_key=True, index=True)
+    file_id = Column(Integer, ForeignKey("processed_files.id"), nullable=False)
+    skeleton_data = Column(JSON, nullable=False)
+    export_format = Column(String, nullable=False, default="unreal")
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    file = relationship("ProcessedFile", back_populates="animation_data")
+
+# Create all tables
+Base.metadata.create_all(bind=engine)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

pose_detector.py

@@ -0,0 +1,271 @@
+import mediapipe as mp
+import numpy as np
+import cv2
+from typing import List, Tuple, Optional
+
+class PoseDetector:
+    def __init__(self):
+        self.mp_pose = mp.solutions.pose
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.mp_drawing_styles = mp.solutions.drawing_styles
+
+        # Define pose connections for smooth animation
+        self.pose_connections = [
+            # Spine Chain
+            (self.mp_pose.PoseLandmark.NOSE.value, self.mp_pose.PoseLandmark.LEFT_SHOULDER.value),
+            (self.mp_pose.PoseLandmark.NOSE.value, self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value),
+            (self.mp_pose.PoseLandmark.LEFT_SHOULDER.value, self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value),
+            (self.mp_pose.PoseLandmark.LEFT_SHOULDER.value, self.mp_pose.PoseLandmark.LEFT_HIP.value),
+            (self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value, self.mp_pose.PoseLandmark.RIGHT_HIP.value),
+            (self.mp_pose.PoseLandmark.LEFT_HIP.value, self.mp_pose.PoseLandmark.RIGHT_HIP.value),
+            
+            # Left Arm Chain
+            (self.mp_pose.PoseLandmark.LEFT_SHOULDER.value, self.mp_pose.PoseLandmark.LEFT_ELBOW.value),
+            (self.mp_pose.PoseLandmark.LEFT_ELBOW.value, self.mp_pose.PoseLandmark.LEFT_WRIST.value),
+            (self.mp_pose.PoseLandmark.LEFT_WRIST.value, self.mp_pose.PoseLandmark.LEFT_THUMB.value),
+            
+            # Right Arm Chain
+            (self.mp_pose.PoseLandmark.RIGHT_SHOULDER.value, self.mp_pose.PoseLandmark.RIGHT_ELBOW.value),
+            (self.mp_pose.PoseLandmark.RIGHT_ELBOW.value, self.mp_pose.PoseLandmark.RIGHT_WRIST.value),
+            (self.mp_pose.PoseLandmark.RIGHT_WRIST.value, self.mp_pose.PoseLandmark.RIGHT_THUMB.value),
+            
+            # Left Leg Chain
+            (self.mp_pose.PoseLandmark.LEFT_HIP.value, self.mp_pose.PoseLandmark.LEFT_KNEE.value),
+            (self.mp_pose.PoseLandmark.LEFT_KNEE.value, self.mp_pose.PoseLandmark.LEFT_ANKLE.value),
+            (self.mp_pose.PoseLandmark.LEFT_ANKLE.value, self.mp_pose.PoseLandmark.LEFT_FOOT_INDEX.value),
+            
+            # Right Leg Chain
+            (self.mp_pose.PoseLandmark.RIGHT_HIP.value, self.mp_pose.PoseLandmark.RIGHT_KNEE.value),
+            (self.mp_pose.PoseLandmark.RIGHT_KNEE.value, self.mp_pose.PoseLandmark.RIGHT_ANKLE.value),
+            (self.mp_pose.PoseLandmark.RIGHT_ANKLE.value, self.mp_pose.PoseLandmark.RIGHT_FOOT_INDEX.value),
+        ]
+
+        # Drawing specifications
+        self.landmark_drawing_spec = self.mp_drawing.DrawingSpec(
+            color=(0, 255, 0),  # Green color
+            thickness=2,
+            circle_radius=2
+        )
+        self.connection_drawing_spec = self.mp_drawing.DrawingSpec(
+            color=(255, 255, 0),  # Yellow color
+            thickness=2
+        )
+
+    def detect(self, image, manual_corrections=None) -> Tuple[Optional[np.ndarray], np.ndarray]:
+        """
+        Detect pose in the given image
+        Args:
+            image: Input image
+            manual_corrections: Dictionary of landmark indices and their corrected positions
+        Returns: (landmarks, annotated_image)
+        """
+        
+    def draw_corrected_pose(self, image: np.ndarray, corrected_joints: dict) -> np.ndarray:
+        """Draw pose with manually corrected joint positions"""
+        annotated_image = image.copy()
+        h, w = image.shape[:2]
+        
+        # Draw connections
+        for start_name, end_name in self.pose_connections:
+            if start_name in corrected_joints and end_name in corrected_joints:
+                start_pos = corrected_joints[start_name]['position']
+                end_pos = corrected_joints[end_name]['position']
+                
+                start_px = (int(start_pos[0] * w), int(start_pos[1] * h))
+                end_px = (int(end_pos[0] * w), int(end_pos[1] * h))
+                
+                cv2.line(annotated_image, start_px, end_px, (0, 255, 0), 3)
+        
+        # Draw joints
+        for joint_name, joint_data in corrected_joints.items():
+            pos = joint_data['position']
+            px_pos = (int(pos[0] * w), int(pos[1] * h))
+            
+            # Draw joint
+            cv2.circle(annotated_image, px_pos, 5, (0, 255, 255), -1)
+            
+            # Draw joint name
+            cv2.putText(annotated_image, joint_name, 
+                       (px_pos[0], px_pos[1] - 10),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+                       
+        return annotated_image
+        with self.mp_pose.Pose(
+            static_image_mode=True,
+            model_complexity=2,
+            min_detection_confidence=0.5,
+            min_tracking_confidence=0.5
+        ) as pose:
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            results = pose.process(image_rgb)
+
+            annotated_image = image.copy()
+
+            if results.pose_landmarks:
+                # Draw skeleton with more prominent visualization
+                self.landmark_drawing_spec.thickness = 4
+                self.connection_drawing_spec.thickness = 3
+                
+                # Draw landmarks first
+                self.mp_drawing.draw_landmarks(
+                    image=annotated_image,
+                    landmark_list=results.pose_landmarks,
+                    connections=self.mp_pose.POSE_CONNECTIONS,
+                    landmark_drawing_spec=self.landmark_drawing_spec,
+                    connection_drawing_spec=self.connection_drawing_spec
+                )
+                
+                # Draw additional smooth connections
+                self._draw_smooth_connections(
+                    annotated_image,
+                    results.pose_landmarks,
+                    self.pose_connections
+                )
+
+                landmarks = np.array([[lm.x, lm.y, lm.z] for lm in results.pose_landmarks.landmark])
+                return landmarks, annotated_image
+
+            return None, annotated_image
+
+    def _draw_smooth_connections(self, image: np.ndarray, landmarks, connections: List[Tuple[int, int]]):
+        """Draw smooth connections between landmarks in Maya-like style"""
+        h, w = image.shape[:2]
+        
+        # Maya-style bone names mapping
+        bone_names = {
+            0: "Head",
+            11: "Neck",
+            12: "Spine2",
+            23: "Hips",
+            24: "Spine",
+            13: "LeftArm",
+            14: "RightArm",
+            15: "LeftForeArm",
+            16: "RightForeArm",
+            25: "LeftLeg",
+            26: "RightLeg",
+            27: "LeftFoot",
+            28: "RightFoot",
+            31: "LeftToeBase",
+            32: "RightToeBase"
+        }
+
+        # Maya-style colors
+        joint_color = (0, 255, 255)  # Cyan for joints
+        bone_color = (0, 255, 0)    # Green for bones
+        text_color = (255, 255, 255) # White for text
+
+        for connection in connections:
+            start_idx, end_idx = connection
+            start_point = landmarks.landmark[start_idx]
+            end_point = landmarks.landmark[end_idx]
+
+            # Convert normalized coordinates to pixel coordinates
+            start_pos = (int(start_point.x * w), int(start_point.y * h))
+            end_pos = (int(end_point.x * w), int(end_point.y * h))
+
+            # Draw bone connection (thicker, Maya-style)
+            cv2.line(
+                image,
+                start_pos,
+                end_pos,
+                bone_color,
+                3,  # Thicker lines for bones
+                cv2.LINE_AA
+            )
+
+            # Draw joints as larger circles
+            for pos, idx in [(start_pos, start_idx), (end_pos, end_idx)]:
+                # Draw joint
+                cv2.circle(
+                    image,
+                    pos,
+                    5,  # Larger radius for joints
+                    joint_color,
+                    -1,  # Filled circle
+                    cv2.LINE_AA
+                )
+                
+                # Draw bone name if it exists in mapping
+                if idx in bone_names:
+                    # Position text above the joint
+                    text_pos = (pos[0], pos[1] - 10)
+                    cv2.putText(
+                        image,
+                        bone_names[idx],
+                        text_pos,
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.5,  # Font scale
+                        text_color,
+                        1,    # Thickness
+                        cv2.LINE_AA
+                    )
+
+    def detect_video_frame(self, frame):
+        """
+        Detect pose in video frame with optimized parameters for video
+        """
+        with self.mp_pose.Pose(
+            static_image_mode=False,
+            model_complexity=2,  # Increased complexity for better accuracy
+            smooth_landmarks=True,
+            min_detection_confidence=0.3,  # Lower threshold to detect more poses
+            min_tracking_confidence=0.3,   # Lower threshold for better tracking
+            enable_segmentation=False      # Disable segmentation to reduce overhead
+        ) as pose:
+            image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            results = pose.process(image_rgb)
+            
+            annotated_frame = frame.copy()
+            
+            if results.pose_landmarks:
+                # Draw landmarks with maximum visibility
+                self.landmark_drawing_spec.thickness = 6
+                self.connection_drawing_spec.thickness = 5
+                self.landmark_drawing_spec.circle_radius = 4
+                
+                # Enhanced temporal smoothing for landmarks
+                if hasattr(self, 'previous_landmarks'):
+                    smoothing_factor = 0.8  # Adjust smoothing strength (0.0-1.0)
+                    for i, landmark in enumerate(results.pose_landmarks.landmark):
+                        if self.previous_landmarks is not None:
+                            if landmark.visibility < 0.7 or self.previous_landmarks[i].visibility > 0.8:
+                                # Apply temporal smoothing
+                                landmark.x = smoothing_factor * self.previous_landmarks[i].x + (1 - smoothing_factor) * landmark.x
+                                landmark.y = smoothing_factor * self.previous_landmarks[i].y + (1 - smoothing_factor) * landmark.y
+                                landmark.z = smoothing_factor * self.previous_landmarks[i].z + (1 - smoothing_factor) * landmark.z
+                                landmark.visibility = max(landmark.visibility, self.previous_landmarks[i].visibility * 0.9)
+                
+                # Store current landmarks for next frame
+                self.previous_landmarks = results.pose_landmarks.landmark
+                
+                # Draw the skeleton first
+                self._draw_smooth_connections(
+                    annotated_frame,
+                    results.pose_landmarks,
+                    self.pose_connections
+                )
+                
+                # Then draw the landmarks
+                self.mp_drawing.draw_landmarks(
+                    image=annotated_frame,
+                    landmark_list=results.pose_landmarks,
+                    connections=self.mp_pose.POSE_CONNECTIONS,
+                    landmark_drawing_spec=self.landmark_drawing_spec,
+                    connection_drawing_spec=self.connection_drawing_spec
+                )
+                
+                landmarks = np.array([[lm.x, lm.y, lm.z] for lm in results.pose_landmarks.landmark])
+                return landmarks, annotated_frame
+            elif hasattr(self, 'previous_landmarks') and self.previous_landmarks is not None:
+                # Use previous frame's data if no detection in current frame
+                results.pose_landmarks = type('obj', (object,), {'landmark': self.previous_landmarks})
+                self._draw_smooth_connections(
+                    annotated_frame,
+                    results.pose_landmarks,
+                    self.pose_connections
+                )
+                landmarks = np.array([[lm.x, lm.y, lm.z] for lm in self.previous_landmarks])
+                return landmarks, annotated_frame
+                
+            return None, annotated_frame

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "mediapipe>=0.10.20",
+    "numpy>=1.26.4",
+    "opencv-python>=4.11.0.86",
+    "psycopg2-binary>=2.9.10",
+    "sqlalchemy>=2.0.37",
+    "streamlit>=1.42.0",
+]

replit.nix

@@ -0,0 +1,7 @@
+{pkgs}: {
+  deps = [
+    pkgs.ffmpeg
+    pkgs.libGLU
+    pkgs.libGL
+  ];
+}

skeleton_generator.py

@@ -0,0 +1,81 @@
+import numpy as np
+
+class SkeletonGenerator:
+    def __init__(self, custom_mapping=None):
+        # Define default Maya-compatible bone names and their corresponding MediaPipe indices
+        self.bone_mapping = {
+            # Root & Spine
+            'Hips': 23,          # HIPS/Pelvis
+            'Spine': 24,         # Lower spine
+            'Spine1': 12,        # Mid spine
+            'Spine2': 11,        # Upper spine
+            
+            # Head & Neck
+            'Neck': 11,          # BASE_NECK
+            'Head': 0,           # HEAD (using nose as reference)
+            
+            # Left Arm Chain
+            'LeftShoulder': 11,  # LEFT_SHOULDER
+            'LeftArm': 13,       # LEFT_UPPER_ARM
+            'LeftForeArm': 15,   # LEFT_LOWER_ARM
+            'LeftHand': 15,      # LEFT_HAND (using wrist as reference)
+            
+            # Right Arm Chain
+            'RightShoulder': 12, # RIGHT_SHOULDER
+            'RightArm': 14,      # RIGHT_UPPER_ARM
+            'RightForeArm': 16,  # RIGHT_LOWER_ARM
+            'RightHand': 16,     # RIGHT_HAND (using wrist as reference)
+            
+            # Left Leg Chain
+            'LeftUpLeg': 23,     # LEFT_UPPER_LEG
+            'LeftLeg': 25,       # LEFT_LOWER_LEG
+            'LeftFoot': 27,      # LEFT_FOOT
+            'LeftToeBase': 31,   # LEFT_TOE
+            
+            # Right Leg Chain
+            'RightUpLeg': 24,    # RIGHT_UPPER_LEG
+            'RightLeg': 26,      # RIGHT_LOWER_LEG
+            'RightFoot': 28,     # RIGHT_FOOT
+            'RightToeBase': 32,  # RIGHT_TOE
+        }
+
+    def generate_skeleton(self, landmarks):
+        """
+        Convert MediaPipe landmarks to Maya-compatible skeleton data
+        """
+        if landmarks is None:
+            return None
+
+        skeleton_data = {}
+
+        # Convert landmarks to skeleton joint positions
+        for bone_name, landmark_idx in self.bone_mapping.items():
+            position = landmarks[landmark_idx]
+            rotation = self._calculate_bone_rotation(landmarks, landmark_idx)
+
+            # Convert NumPy arrays to regular Python lists
+            skeleton_data[bone_name] = {
+                'position': position.tolist(),
+                'rotation': rotation.tolist()
+            }
+
+        return skeleton_data
+
+    def _calculate_bone_rotation(self, landmarks, landmark_idx):
+        """
+        Calculate bone rotation based on connected landmarks
+        """
+        # Simple rotation calculation - can be enhanced for better accuracy
+        rotation = np.zeros(3)
+
+        if landmark_idx > 0:
+            # Calculate rotation based on parent-child relationship
+            parent_idx = landmark_idx - 1
+            direction = landmarks[landmark_idx] - landmarks[parent_idx]
+
+            # Convert direction to euler angles (simplified)
+            rotation[0] = np.arctan2(direction[1], direction[2])  # pitch
+            rotation[1] = np.arctan2(direction[0], direction[2])  # yaw
+            rotation[2] = np.arctan2(direction[0], direction[1])  # roll
+
+        return rotation

utils.py

@@ -0,0 +1,178 @@
+import cv2
+import tempfile
+import numpy as np
+import os
+from animation_renderer import AnimationRenderer
+
+def process_image(image, pose_detector, skeleton_generator):
+    """
+    Process single image for pose detection and skeleton generation
+    """
+    try:
+        # Detect pose
+        landmarks, annotated_image = pose_detector.detect(image)
+
+        if landmarks is not None:
+            # Generate skeleton data
+            skeleton_data = skeleton_generator.generate_skeleton(landmarks)
+            return annotated_image, skeleton_data
+
+        return image, None
+    except Exception as e:
+        print(f"Error processing image: {str(e)}")
+        return image, None
+
+def process_video(video_path, pose_detector, skeleton_generator):
+    """
+    Process video for pose detection and skeleton generation with improved error handling and chunked processing
+    """
+    cap = None
+    out = None
+    try:
+        # Optimize video processing
+        chunk_size = 5  # Process fewer frames at a time
+        buffer_size = 512*1024  # Smaller buffer for stability
+        cv2.setNumThreads(2)  # Allow 2 threads for better performance
+        cv2.ocl.setUseOpenCL(False)  # Disable OpenCL to prevent crashes
+
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise ValueError("Could not open video file")
+
+        # Get video properties with error checking
+        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        fps = int(cap.get(cv2.CAP_PROP_FPS)) or 30
+
+        # Limit dimensions for better performance
+        target_width = 480
+        if frame_width > target_width:
+            scale = target_width / frame_width
+            frame_width = target_width
+            frame_height = int(frame_height * scale)
+
+        # Create temporary file with better error handling
+        try:
+            temp_output = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
+            output_path = temp_output.name
+        except Exception as e:
+            raise RuntimeError(f"Failed to create temporary file: {str(e)}")
+
+        # Set lower resolution for processing
+        cap.set(cv2.CAP_PROP_FRAME_WIDTH, 480)
+        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 360)
+
+        if not cap.isOpened():
+            return None, None
+
+        # Get video properties
+        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+        if fps == 0:  # Handle GIF files which might report 0 fps
+            fps = 30
+
+        # Initialize animation renderer
+        renderer = AnimationRenderer(fps=fps)
+
+        # Create temporary file for processed video
+        temp_output = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
+        output_path = temp_output.name
+
+        # Initialize video writer with more efficient settings
+        max_dimension = 480  # Reduced max dimension
+        if frame_width > max_dimension or frame_height > max_dimension:
+            scale = min(max_dimension/frame_width, max_dimension/frame_height)
+            frame_width = int(frame_width * scale)
+            frame_height = int(frame_height * scale)
+
+        # Use MP4V codec which is more memory efficient
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, min(fps, 30), (frame_width, frame_height))
+
+        animation_frames = []
+        frame_count = 0
+        frame_time = 0.0
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            # Resize frame to reduce memory usage
+            if frame.shape[1] > frame_width:
+                frame = cv2.resize(frame, (frame_width, frame_height))
+
+            try:
+                # Resize frame for better detection
+                frame_height, frame_width = frame.shape[:2]
+                if frame_width > 640:
+                    scale = 640 / frame_width
+                    frame = cv2.resize(frame, (640, int(frame_height * scale)))
+                
+                # Process frame with error handling and retry
+                retries = 3
+                while retries > 0:
+                    landmarks, annotated_frame = pose_detector.detect_video_frame(frame)
+                    if landmarks is not None:
+                        break
+                    retries -= 1
+
+                # Ensure frame is properly encoded before writing
+                if annotated_frame is not None:
+                    out.write(annotated_frame)
+                else:
+                    out.write(frame)
+
+                if landmarks is not None:
+                    # Generate skeleton data with error checking
+                    try:
+                        skeleton_data = skeleton_generator.generate_skeleton(landmarks)
+                        animation_frames.append(skeleton_data)
+                        renderer.add_keyframe(landmarks, pose_detector.pose_connections, frame_time)
+                    except Exception as e:
+                        print(f"Frame {frame_count} skeleton generation error: {str(e)}")
+                        if animation_frames:
+                            animation_frames.append(animation_frames[-1])
+                elif animation_frames:
+                    animation_frames.append(animation_frames[-1])
+
+            except Exception as e:
+                print(f"Frame {frame_count} processing error: {str(e)}")
+                continue
+
+            frame_count += 1
+            frame_time = frame_count / fps
+
+            if frame_count > 1000:  # Safety limit for very long videos
+                break
+
+
+        # Release resources
+        if cap is not None:
+            cap.release()
+        if out is not None:
+            out.release()
+
+        # Convert output video to proper format using more compatible settings
+        converted_output = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
+        os.system(f'ffmpeg -y -i {output_path} -vcodec libx264 -preset ultrafast -pix_fmt yuv420p {converted_output.name}')
+        os.unlink(output_path)  # Remove the original output
+
+        return converted_output.name, animation_frames
+
+    except Exception as e:
+        print(f"Error processing video: {str(e)}")
+        # Cleanup resources
+        if cap is not None:
+            cap.release()
+        if out is not None:
+            out.release()
+        return None, None
+
+def process_gif(gif_path, pose_detector, skeleton_generator):
+    """
+    Process GIF for pose detection and skeleton generation
+    """
+    return process_video(gif_path, pose_detector, skeleton_generator)