latest

VideoToNPZ/gen_skes.py

@@ -37,7 +37,6 @@ adj = adj_mx_from_skeleton(skeleton)
 joints_left, joints_right = [4, 5, 6, 11, 12, 13], [1, 2, 3, 14, 15, 16]
 kps_left, kps_right = [4, 5, 6, 11, 12, 13], [1, 2, 3, 14, 15, 16]
 
-# Set up signal handler for keyboard interrupt
 def signal_handler(sig, frame):
     print("\nInterrupted by user, shutting down...")
     if 'pool' in locals() and pool is not None:
@@ -67,8 +66,13 @@ def generate_skeletons(video=''):
     cap = cv2.VideoCapture(video)
     width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
     height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
 
+    # 2D Keypoint Generation (handled by gen_video_kpts)
+    print('Generating 2D Keypoints:')
+    sys.stdout.flush()
     keypoints, scores = hrnet_pose(video, det_dim=416, gen_output=True)
+    
     keypoints, scores, valid_frames = h36m_coco_format(keypoints, scores)
     re_kpts = revise_kpts(keypoints, scores, valid_frames)
     num_person = len(re_kpts)
@@ -78,15 +82,19 @@ def generate_skeletons(video=''):
     pad = (81 - 1) // 2
     causal_shift = 0
 
-    prediction = gen_pose(re_kpts, valid_frames, width, height, model_pos, pad, causal_shift)
-
+    # 3D Pose Generation
     print('Recording 3D Pose:')
+    print(f"PROGRESS:100.00")  # Start 3D at 100%
+    sys.stdout.flush()
+    total_valid_frames = len(valid_frames) if valid_frames else total_frames
+    prediction = gen_pose(re_kpts, valid_frames, width, height, model_pos, pad, causal_shift)
+    # Simulate 3D progress (replace with gen_pose loop if shared)
+    for i in range(total_valid_frames):
+        progress = 100 + ((i + 1) / total_valid_frames * 100)  # 100-200% for 3D
+        print(f"PROGRESS:{progress:.2f}")
+        sys.stdout.flush()
+        time.sleep(0.01)  # Placeholder; remove if gen_pose has its own loop
 
-    # Add a loading bar
-    for i in tqdm(range(100)):
-        time.sleep(0.01)
-
-    # Create output directory with absolute path
     output_dir = os.path.abspath('../outputs/')
     print(f"Creating output directory: {output_dir}")
     os.makedirs(output_dir, exist_ok=True)
@@ -108,7 +116,6 @@ def arg_parse():
 
 if __name__ == "__main__":
     args = arg_parse()
-    # Use the video path as-is if absolute, otherwise prepend data_root
     if os.path.isabs(args.video):
         video_path = args.video
     else:

VideoToNPZ/lib/pose/hrnet/pose_estimation/gen_kpts.py

@@ -174,15 +174,14 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
 
     video_length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     print('Recording 2D pose ...')
-    import sys
-    from io import StringIO
+    sys.stdout.flush()  # Ensure initial message shows up immediately
 
     if animation:
         # Animation mode uses frame-by-frame processing like in the backup code
         kpts_result = []
         scores_result = []
         
-        for i in tqdm(range(video_length)):
+        for i in range(video_length):
             ret, frame = cap.read()
             if not ret:
                 break
@@ -192,6 +191,7 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
             
             if bboxs is None or not bboxs.any():
                 print('No person detected!')
+                sys.stdout.flush()
                 continue
                 
             # Track people
@@ -248,10 +248,7 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
                 if key & 0xFF == ord('q'):
                     break
     else:
-        # Optimized batch processing with Queue
-        old_stdout = sys.stdout
-        sys.stdout = StringIO()
-
+        # Optimized batch processing with Queue (no StringIO redirection)
         frame_queue = mp.Queue(maxsize=batch_size * 2)
         loader_thread = Thread(target=frame_loader, args=(video, frame_queue, video_length))
         loader_thread.start()
@@ -268,11 +265,14 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
                 # GPU batch processing
                 batch_frames = []
                 with torch.no_grad():
-                    for _ in tqdm(range(video_length)):
+                    for i in range(video_length):
                         frame = frame_queue.get()
                         if frame is None:
                             break
                         batch_frames.append(frame)
+                        progress = (i + 1) / video_length * 100
+                        print(f"PROGRESS:{progress:.2f}")
+                        sys.stdout.flush()  # Force per-frame update
                         
                         if len(batch_frames) >= batch_size:
                             kpts_batch, scores_batch = process_batch(batch_frames, human_model, pose_model,
@@ -283,6 +283,22 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
                                 scores_result[frame_idx:frame_idx + 1] = scores[None, :num_person]
                                 frame_idx += 1
                             batch_frames = []
+                            progress = (frame_idx / video_length) * 100
+                            print(f"PROGRESS:{progress:.2f}")
+                            sys.stdout.flush()  # Force after batch
+                    
+                    # Process remaining frames
+                    if batch_frames:
+                        kpts_batch, scores_batch = process_batch(batch_frames, human_model, pose_model,
+                                                                det_dim, num_person, args.thred_score,
+                                                                use_fp16, device)
+                        for kpts, scores in zip(kpts_batch, scores_batch):
+                            kpts_result[frame_idx:frame_idx + 1] = kpts[None, :num_person]
+                            scores_result[frame_idx:frame_idx + 1] = scores[None, :num_person]
+                            frame_idx += 1
+                        progress = (frame_idx / video_length) * 100
+                        print(f"PROGRESS:{progress:.2f}")
+                        sys.stdout.flush() # Force after batch
                     
                     # Process remaining frames
                     if batch_frames:
@@ -293,6 +309,9 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
                             kpts_result[frame_idx:frame_idx + 1] = kpts[None, :num_person]
                             scores_result[frame_idx:frame_idx + 1] = scores[None, :num_person]
                             frame_idx += 1
+                        progress = (frame_idx / video_length) * 100
+                        print(f"PROGRESS:{progress:.2f}")
+                        sys.stdout.flush()  # Force final update
             else:
                 # CPU batch processing with multiprocessing
                 pool = mp.Pool(processes=mp.cpu_count())
@@ -302,11 +321,14 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
                 
                 batch_frames = []
                 with torch.no_grad():
-                    for _ in tqdm(range(video_length)):
+                    for i in range(video_length):
                         frame = frame_queue.get()
                         if frame is None:
                             break
                         batch_frames.append(frame)
+                        progress = (i + 1) / video_length * 100
+                        print(f"PROGRESS:{progress:.2f}")
+                        sys.stdout.flush()  # Force per-frame update
                         if len(batch_frames) >= batch_size:
                             kpts_batch, scores_batch = process_func(batch_frames)
                             for kpts, scores in zip(kpts_batch, scores_batch):
@@ -314,6 +336,9 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
                                 scores_result[frame_idx:frame_idx + 1] = scores[None, :num_person]
                                 frame_idx += 1
                             batch_frames = []
+                            progress = (frame_idx / video_length) * 100
+                            print(f"PROGRESS:{progress:.2f}")
+                            sys.stdout.flush()  # Force after batch
                 
                     # Process remaining frames
                     if batch_frames:
@@ -322,20 +347,22 @@ def gen_video_kpts(video, det_dim=416, num_person=1, gen_output=False, batch_siz
                             kpts_result[frame_idx:frame_idx + 1] = kpts[None, :num_person]
                             scores_result[frame_idx:frame_idx + 1] = scores[None, :num_person]
                             frame_idx += 1
+                        progress = (frame_idx / video_length) * 100
+                        print(f"PROGRESS:{progress:.2f}")
+                        sys.stdout.flush()  # Force final update
                 
                 pool.close()
                 pool.join()
         except KeyboardInterrupt:
             print("\nInterrupted by user, shutting down...")
+            sys.stdout.flush()
             if pool is not None:
                 pool.terminate()
                 pool.join()
             loader_thread.join()
-            sys.stdout = old_stdout
             sys.exit(0)
 
         loader_thread.join()
-        sys.stdout = old_stdout
                 
     if gen_output and kpts_result.any():
         keypoints = kpts_result[:frame_idx].transpose(1, 0, 2, 3)

app.py

@@ -5,109 +5,187 @@ import os
 import time
 import shutil
 import tempfile
+import threading
+import queue
+from datetime import datetime
+from pathlib import Path
 
-def run_command(command, description, working_dir):
-    st.write(f"Running command: {' '.join(command)}")
+def run_command(command, working_dir, progress_bar, progress_text, step_start_progress, step_weight, show_progress=True):
     try:
-        start_time = time.time()
-        process = subprocess.run(
+        env = os.environ.copy()
+        env["PYTHONUNBUFFERED"] = "1"
+        
+        process = subprocess.Popen(
             command,
-            check=True,
             cwd=working_dir,
-            capture_output=True,
-            text=True
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+            env=env
         )
-        end_time = time.time()
-        execution_time = end_time - start_time
-        st.write(f"{description} completed in {execution_time:.2f} seconds")
-        if process.stdout:
-            st.text(f"Output:\n{process.stdout}")
-        if process.stderr:
-            st.text(f"Warnings:\n{process.stderr}")
-        return True
         
-    except subprocess.CalledProcessError as e:
-        st.error(f"Error in {description}: {e.stderr}")
-        return False
+        stdout_queue = queue.Queue()
+        stderr_queue = queue.Queue()
+        
+        def read_output(pipe, q, source):
+            for line in iter(pipe.readline, ''):
+                q.put((source, line))
+            pipe.close()
+        
+        stdout_thread = threading.Thread(target=read_output, args=(process.stdout, stdout_queue, 'stdout'))
+        stderr_thread = threading.Thread(target=read_output, args=(process.stderr, stderr_queue, 'stderr'))
+        stdout_thread.daemon = True
+        stderr_thread.daemon = True
+        stdout_thread.start()
+        stderr_thread.start()
+        
+        total_progress = step_start_progress
+        stderr_lines = []
+        
+        while process.poll() is None or not (stdout_queue.empty() and stderr_queue.empty()):
+            try:
+                source, line = next((q.get_nowait() for q in [stdout_queue, stderr_queue] if not q.empty()), (None, None))
+                if line:
+                    if source == 'stdout':
+                        if show_progress and line.startswith("PROGRESS:"):
+                            try:
+                                progress = float(line.strip().split("PROGRESS:")[1]) / 100
+                                if Path(command[1]).name == 'gen_skes.py':
+                                    # Scale 0-200% to 0-80%
+                                    adjusted_progress = step_start_progress + (progress / 2) * step_weight
+                                else:
+                                    # Scale 0-100% to 20% for conver_bvh.py
+                                    adjusted_progress = step_start_progress + (progress * step_weight)
+                                total_progress = min(adjusted_progress, step_start_progress + step_weight)
+                                progress_bar.progress(total_progress)
+                                progress_text.text(f"{int(total_progress * 100)}%")
+                            except ValueError:
+                                pass
+                    elif source == 'stderr':
+                        stderr_lines.append(line.strip())
+            except queue.Empty:
+                time.sleep(0.01)
+        
+        stdout_thread.join()
+        stderr_thread.join()
+        
+        if process.returncode != 0:
+            stderr_output = '\n'.join(stderr_lines)
+            st.error(f"Error in {Path(command[1]).name}:\n{stderr_output}")
+            return False
+        
+        if show_progress:
+            progress_bar.progress(step_start_progress + step_weight)
+            progress_text.text(f"{int((step_start_progress + step_weight) * 100)}%")
+        return True
     
     except Exception as e:
-        st.error(f"Unexpected error in {description}: {str(e)}")
+        st.error(f"Exception in {Path(command[1]).name}: {str(e)}")
         return False
 
+def cleanup_output_folder(output_dir, delay=1800):
+    time.sleep(delay)
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir, ignore_errors=True)
+        print(f"Deleted temporary output folder after timeout: {output_dir}")
+
 def process_video(video_file):
-    base_dir = os.path.dirname(os.path.abspath(__file__))
-    gen_skes_path = os.path.join(base_dir, "VideoToNPZ", "gen_skes.py")
-    convert_obj_path = os.path.join(base_dir, "convertNPZtoBVH", "conver_obj.py")
-    convert_bvh_path = os.path.join(base_dir, "convertNPZtoBVH", "conver_bvh.py")
+    base_dir = Path(__file__).parent.resolve()
     
-    st.write(f"Base directory: {base_dir}")
-    st.write(f"gen_skes_path: {gen_skes_path}")
+    gen_skes_path = base_dir / "VideoToNPZ" / "gen_skes.py"
+    convert_obj_path = base_dir / "convertNPZtoBVH" / "conver_obj.py"
+    convert_bvh_path = base_dir / "convertNPZtoBVH" / "conver_bvh.py"
     
     for script_path in [gen_skes_path, convert_obj_path, convert_bvh_path]:
-        if not os.path.exists(script_path):
+        if not script_path.exists():
             st.error(f"Required script not found: {script_path}")
             return None
     
     with tempfile.TemporaryDirectory() as tmp_dir:
-        video_path = os.path.join(tmp_dir, "input_video.mp4")
+        video_path = Path(tmp_dir) / "input_video.mp4"
         with open(video_path, "wb") as f:
             f.write(video_file.read())
         
-        if not os.path.exists(video_path):
+        if not video_path.exists():
             st.error(f"Video file not found at: {video_path}")
             return None
-        st.write(f"Video file saved at: {video_path}, size: {os.path.getsize(video_path)} bytes")
+        
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        output_dir = base_dir / f"outputs_{timestamp}"
+        output_dir.mkdir(exist_ok=True)
+        
+        if not os.access(output_dir, os.W_OK):
+            st.error(f"Cannot write to output directory: {output_dir}")
+            return None
+        
+        default_output_dir = base_dir / "outputs"
         
         pipeline_steps = [
-            {
-                "command": [sys.executable, gen_skes_path, "-v", video_path],
-                "description": "Generating skeletons",
-                "working_dir": os.path.dirname(gen_skes_path)
-            },
-            {
-                "command": [sys.executable, convert_obj_path],
-                "description": "Converting to OBJ sequence",
-                "working_dir": os.path.dirname(convert_obj_path)
-            },
-            {
-                "command": [sys.executable, convert_bvh_path],
-                "description": "Converting to BVH",
-                "working_dir": os.path.dirname(convert_bvh_path)
-            }
+            {"command": [sys.executable, str(gen_skes_path), "-v", str(video_path)], "working_dir": gen_skes_path.parent, "weight": 0.8, "show_progress": True},
+            {"command": [sys.executable, str(convert_obj_path), "--output-dir", str(output_dir)], "working_dir": convert_obj_path.parent, "weight": 0.0, "show_progress": False},
+            {"command": [sys.executable, str(convert_bvh_path), "--output-dir", str(output_dir)], "working_dir": convert_bvh_path.parent, "weight": 0.2, "show_progress": True}
         ]
         
-        successful = 0
-        failed = 0
-        progress_bar = st.progress(0)
-        status_text = st.empty()
+        progress_bar = st.progress(0.0)
+        progress_text = st.empty()  # Added for percentage display
+        total_progress = 0.0
         
         for i, step in enumerate(pipeline_steps):
-            status_text.text(f"Processing: {step['description']}...")
-            if run_command(step["command"], step["description"], step["working_dir"]):
-                successful += 1
-                if step["description"] == "Generating skeletons":
-                    npz_path = os.path.join(base_dir, "outputs", "npz", "input_video.npz")
-                    st.write(f"Expected NPZ file at: {npz_path}")
-                    if os.path.exists(npz_path):
-                        st.write(f"NPZ file found, size: {os.path.getsize(npz_path)} bytes")
-                    else:
-                        st.error("NPZ file not generated!")
-            else:
-                failed += 1
-            progress_bar.progress((i + 1) / len(pipeline_steps))
-        
-        status_text.text("Processing complete!")
-        
-        bvh_output_dir = os.path.join(os.path.dirname(convert_bvh_path), "../outputs/bvh")
-        bvh_file = os.path.join(bvh_output_dir, "output.bvh")
-        st.write(f"Checking for BVH file at: {bvh_file}")
-        
-        if os.path.exists(bvh_file) and successful == len(pipeline_steps):
-            return bvh_file
+            success = run_command(
+                step["command"], 
+                step["working_dir"], 
+                progress_bar, 
+                progress_text, 
+                total_progress, 
+                step["weight"], 
+                show_progress=step["show_progress"]
+            )
+            if not success:
+                st.error(f"Failed at step: {' '.join(map(str, step['command']))}")
+                if default_output_dir.exists():
+                    shutil.rmtree(default_output_dir, ignore_errors=True)
+                return None
+            
+            if i == 0 and default_output_dir.exists():
+                npz_dir = default_output_dir / "npz"
+                if npz_dir.exists():
+                    target_npz_dir = output_dir / "npz"
+                    shutil.move(str(npz_dir), str(target_npz_dir))
+                if default_output_dir.exists():
+                    shutil.rmtree(default_output_dir, ignore_errors=True)
+            
+            total_progress += step["weight"]
+            if step["show_progress"]:
+                progress_bar.progress(min(total_progress, 1.0))
+                progress_text.text(f"{int(total_progress * 100)}%")
+        
+        bvh_output_dir = output_dir / "bvh"
+        bvh_file = bvh_output_dir / "output.bvh"
+        
+        if bvh_file.exists():
+            cleanup_thread = threading.Thread(target=cleanup_output_folder, args=(output_dir,))
+            cleanup_thread.daemon = True
+            cleanup_thread.start()
+            
+            return {
+                'bvh_file': bvh_file,
+                'output_dir': output_dir
+            }
         else:
-            st.error("Failed to generate BVH file")
+            st.error(f"Failed to generate BVH file at: {bvh_file}")
+            if default_output_dir.exists():
+                shutil.rmtree(default_output_dir, ignore_errors=True)
             return None
 
+def cleanup_immediate(output_dir):
+    if output_dir and os.path.exists(output_dir):
+        shutil.rmtree(output_dir, ignore_errors=True)
+        st.success("")
+    else:
+        st.warning("")
+
 def main():
     st.title("Video to BVH Converter")
     st.write("Upload a video file to convert it to BVH format")
@@ -118,25 +196,27 @@ def main():
         st.video(uploaded_file)
         
         if st.button("Convert to BVH"):
-            with st.spinner("Processing video... This may take a few minutes"):
-                bvh_file = process_video(uploaded_file)
+            with st.spinner("Processing video..."):
+                conversion_result = process_video(uploaded_file)
                 
-                if bvh_file:
-                    with open(bvh_file, "rb") as f:
+                if conversion_result:
+                    with open(conversion_result['bvh_file'], "rb") as f:
                         st.download_button(
                             label="Download BVH File",
                             data=f,
                             file_name="output.bvh",
-                            mime="application/octet-stream"
+                            mime="application/octet-stream",
+                            on_click=cleanup_immediate,
+                            args=(conversion_result['output_dir'],)
                         )
-                    st.success("Conversion completed successfully!")
+                    st.success("Conversion completed successfully! File will be deleted after download or in 30 minutes.")
     
     st.markdown("""
     ### Instructions
     1. Upload a video file using the uploader above
     2. Click 'Convert to BVH' to start the conversion process
-    3. Wait for processing to complete
-    4. Download the resulting BVH file using the provided button
+    3. Watch the progress bar as it processes
+    4. Download the resulting BVH file - folder will be deleted immediately after download or after 30 minutes
     """)
 
 if __name__ == "__main__":

convertNPZtoBVH/conver_bvh.py

@@ -3,10 +3,11 @@ import numpy as np
 from scipy.spatial.transform import Rotation
 from collections import deque
 from tqdm import tqdm
+import sys
+import argparse
 
 print(f"Saving 3D Motion")
 
-
 def parse_obj(filename):
     vertices = []
     lines = []
@@ -23,7 +24,6 @@ def parse_obj(filename):
     except Exception as e:
         raise ValueError(f"Error parsing OBJ file {filename}: {str(e)}")
 
-
 def build_hierarchy(lines, root=0):
     num_joints = max(max(line) for line in lines) + 1
     adj = [[] for _ in range(num_joints)]
@@ -49,7 +49,6 @@ def build_hierarchy(lines, root=0):
             children[parent[c]].append(c)
     return parent, children
 
-
 def compute_offsets(vertices_ref, parent):
     num_joints = len(vertices_ref)
     offsets = np.zeros((num_joints, 3))
@@ -58,7 +57,6 @@ def compute_offsets(vertices_ref, parent):
             offsets[j] = vertices_ref[j] - vertices_ref[parent[j]]
     return offsets
 
-
 def compute_R_world(joint, vertices_ref, vertices_cur, children):
     if not children[joint]:
         return np.eye(3)
@@ -94,12 +92,9 @@ def compute_R_world(joint, vertices_ref, vertices_cur, children):
             R = U @ Vh
         return R
 
-
-def main():
-    output_dir = os.path.abspath('../outputs/')
-    os.makedirs(output_dir, exist_ok=True)
+def main(output_dir):
     folder = os.path.join(output_dir, 'obj_sequence')
-
+    
     try:
         obj_files = sorted([f for f in os.listdir(folder) if f.endswith('.obj')])
     except Exception as e:
@@ -118,36 +113,35 @@ def main():
         root = 0
 
         hierarchy_order = []
-
         def dfs(joint):
             hierarchy_order.append(joint)
             for child in children[joint]:
                 dfs(child)
-
         dfs(root)
 
         motion_data = []
-        for obj_file in tqdm(obj_files):
+        total_files = len(obj_files)
+        for i in range(total_files):
+            obj_file = obj_files[i]
             vertices_cur = parse_obj(os.path.join(folder, obj_file))[0]
             R_world = [compute_R_world(j, vertices_ref, vertices_cur, children) for j in range(num_joints)]
             R_local = [R_world[j] if parent[j] == -1 else R_world[parent[j]].T @ R_world[j] for j in range(num_joints)]
             euler_angles = [Rotation.from_matrix(R).as_euler('ZYX', degrees=True) for R in R_local]
             root_pos = vertices_cur[root]
             motion_line = list(root_pos) + list(euler_angles[root])
-            for j in hierarchy_order[1:]:
+            for j_idx, j in enumerate(hierarchy_order[1:], 1):
                 motion_line.extend(euler_angles[j])
+                progress = ((i / total_files) + (j_idx / len(hierarchy_order) / total_files)) * 100
+                print(f"PROGRESS:{progress:.2f}")
+                sys.stdout.flush()
             motion_data.append(motion_line)
 
-        # Note: Smoothing function has been removed
-        # Note: Elbow constraints have been removed
-
         bvh_dir = os.path.join(output_dir, 'bvh')
         os.makedirs(bvh_dir, exist_ok=True)
         bvh_file = os.path.join(bvh_dir, 'output.bvh')
 
         with open(bvh_file, 'w') as f:
             f.write("HIERARCHY\n")
-
             def write_hierarchy(joint, parent, f, indent=0):
                 if parent == -1:
                     f.write("ROOT Joint{}\n".format(joint))
@@ -156,8 +150,7 @@ def main():
                 f.write("  " * indent + "{\n")
                 f.write("  " * (indent + 1) + "OFFSET {:.6f} {:.6f} {:.6f}\n".format(*offsets[joint]))
                 if parent == -1:
-                    f.write("  " * (
-                                indent + 1) + "CHANNELS 6 Xposition Yposition Zposition Zrotation Yrotation Xrotation\n")
+                    f.write("  " * (indent + 1) + "CHANNELS 6 Xposition Yposition Zposition Zrotation Yrotation Xrotation\n")
                 else:
                     f.write("  " * (indent + 1) + "CHANNELS 3 Zrotation Yrotation Xrotation\n")
                 for child in children[joint]:
@@ -180,6 +173,8 @@ def main():
     except Exception as e:
         print(f"Error during processing: {e}")
 
-
 if __name__ == "__main__":
-    main()
+    parser = argparse.ArgumentParser('Convert OBJ sequence to BVH.')
+    parser.add_argument('--output-dir', type=str, default='../outputs/', help='Output directory containing obj_sequence')
+    args = parser.parse_args()
+    main(args.output_dir)

convertNPZtoBVH/conver_obj.py

@@ -1,51 +1,19 @@
 import numpy as np
 import os
 from datetime import datetime
+import argparse
 
 def define_human_connections():
-    """
-    Define connections for human stick figure with support for various poses
-    including crossed legs and complex movements
-    """
     return [
-        # Core body structure
-        [0, 7],  # Base spine to upper spine
-        [7, 8],  # Upper spine to neck
-        [8, 9],  # Neck to head base
-        [9, 10], # Head extension
-        
-        # Arms (with complete chains)
-        # Left arm
-        [7, 14],  # Spine to left shoulder
-        [14, 15], # Left upper arm
-        [15, 16], # Left forearm/hand
-        
-        # Right arm
-        [7, 11],  # Spine to right shoulder
-        [11, 12], # Right upper arm
-        [12, 13], # Right forearm/hand
-        
-        # Legs with crossed support
-        # Left leg (now crossing to right)
-        [0, 1],   # Hip to left thigh
-        [1, 2],   # Left thigh to knee
-        [2, 3],   # Left knee to foot
-        
-        # Right leg
-        [0, 4],   # Hip to right thigh
-        [4, 5],   # Right thigh to knee
-        [5, 6],   # Right knee to foot
-        
-        # Structural connections
-        [14, 11], # Shoulder cross support
-        [1, 4],   # Hip cross support
+        [0, 7], [7, 8], [8, 9], [9, 10],  # Core body
+        [7, 14], [14, 15], [15, 16],      # Left arm
+        [7, 11], [11, 12], [12, 13],      # Right arm
+        [0, 1], [1, 2], [2, 3],           # Left leg
+        [0, 4], [4, 5], [5, 6],           # Right leg
+        [14, 11], [1, 4],                 # Structural connections
     ]
 
 def npz_to_obj_sequence(npz_path, output_dir):
-    """
-    Convert NPZ motion capture data to OBJ sequence
-    with enhanced support for various poses and movements
-    """
     os.makedirs(output_dir, exist_ok=True)
     data = np.load(npz_path)
     reconstruction = data['reconstruction'][0]
@@ -53,62 +21,35 @@ def npz_to_obj_sequence(npz_path, output_dir):
     num_frames = reconstruction.shape[0]
     connections = define_human_connections()
     
-    # Increased scale for better visibility
-    scale = 150.0  # Adjusted scale factor
+    scale = 150.0
     
     for frame_idx in range(num_frames):
         vertices = reconstruction[frame_idx]
         output_path = os.path.join(output_dir, f"frame_{frame_idx:04d}.obj")
         
         with open(output_path, 'w') as f:
-            # Write vertices with enhanced precision
             for v in vertices:
-                # Coordinate system transformation with improved scaling
                 x, y, z = v[0] * scale, v[2] * scale, v[1] * scale
                 f.write(f"v {x:.8f} {y:.8f} {z:.8f}\n")
-            
-            # Write connections
             for conn in connections:
                 f.write(f"l {conn[0] + 1} {conn[1] + 1}\n")
-    
 
 def analyze_vertex_data(npz_path):
-    """
-    Enhanced analysis function to help understand the motion data
-    and verify correct vertex positions
-    """
     data = np.load(npz_path)
     reconstruction = data['reconstruction'][0]
-    
-    
-    # Calculate full range of motion
     x_min, x_max = reconstruction[:,:,0].min(), reconstruction[:,:,0].max()
     y_min, y_max = reconstruction[:,:,1].min(), reconstruction[:,:,1].max()
     z_min, z_max = reconstruction[:,:,2].min(), reconstruction[:,:,2].max()
-    
 
-def process_motion_capture(npz_file):
+def process_motion_capture(npz_file, output_dir):
     try:
-        # Verify input file exists
         if not os.path.exists(npz_file):
             raise FileNotFoundError(f"Input file {npz_file} not found")
         
-        # Define base output directory
-        base_output_dir = os.path.abspath('../outputs/')
-        # print(output_dir)
-        os.makedirs(base_output_dir, exist_ok=True)
-        # base_output_dir = r"C:\Users\ROGST\Programming\Python\videotobvh\convertNPZtoBVH\outputs"
-        
-        # Create a unique output directory with timestamp to avoid overwriting
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        output_dir = os.path.join(base_output_dir, f"obj_sequence")
-        
-        # Analyze data first
+        # Use the provided output_dir with 'obj_sequence' subfolder
+        obj_output_dir = os.path.join(output_dir, "obj_sequence")
         analyze_vertex_data(npz_file)
-        
-        # Convert to OBJ sequence
-        npz_to_obj_sequence(npz_path=npz_file, output_dir=output_dir)
-        
+        npz_to_obj_sequence(npz_path=npz_file, output_dir=obj_output_dir)
         
     except Exception as e:
         print(f"Error processing motion capture data: {str(e)}")
@@ -118,24 +59,25 @@ def get_npz_paths(folder_path):
     if not os.path.isdir(folder_path):
         raise FileNotFoundError(f"Directory not found: {folder_path}")
     
-    # Find the first .npz file in the directory
     for file in os.listdir(folder_path):
         if file.endswith('.npz'):
-            npz_path = os.path.join(folder_path, file)
-            return npz_path
+            return os.path.join(folder_path, file)
     
-    # If no .npz file is found
     raise FileNotFoundError(f"No NPZ files found in directory: {folder_path}")
 
+def arg_parse():
+    parser = argparse.ArgumentParser('Convert NPZ to OBJ sequence.')
+    parser.add_argument('--output-dir', type=str, default='../outputs/', help='Output directory for results')
+    args = parser.parse_args()
+    return args
+
 if __name__ == "__main__":
-    # Define the directory where the NPZ file is located
-    output_dir = os.path.abspath('../outputs/npz/')
-    os.makedirs(output_dir, exist_ok=True)
-    input_dir = output_dir
+    args = arg_parse()
+    input_dir = os.path.join(os.path.abspath(args.output_dir), 'npz')
+    os.makedirs(input_dir, exist_ok=True)
     
     try:
-        # Get the first available NPZ file from the directory
         npz_file = get_npz_paths(input_dir)
-        process_motion_capture(npz_file)
+        process_motion_capture(npz_file, args.output_dir)
     except FileNotFoundError as e:
         print(f"Error: {str(e)}")