Upload 6 files

README.md

@@ -1,14 +1,31 @@
----
-title: LSPW
-emoji: 🖼
-colorFrom: purple
-colorTo: red
-sdk: gradio
-sdk_version: 5.44.0
-app_file: app.py
-pinned: false
-license: lgpl-3.0
-short_description: Long-Term Spatiotemporal Periodic Workflows
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Unsupervised Discovery of Long-Term Spatiotemporal Periodic Workflows in Human Activities
+
+[Project Page](https://sites.google.com/view/periodicworkflow) | [arXiv](https://www.arxiv.org/abs/2511.14945)
+
+## Abstract
+
+Periodic human activities with implicit workflows are common in manufacturing, sports, and daily life. While short-term periodic activities—characterized by simple structures and high-contrast patterns—have been widely studied, long-term periodic workflows with low-contrast patterns remain largely underexplored.
+
+To bridge this gap, we introduce the first benchmark comprising 580 multimodal human activity sequences featuring long-term periodic workflows. The benchmark supports three evaluation tasks aligned with real-world applications: unsupervised periodic workflow detection, task completion tracking, and procedural anomaly detection. We also propose a lightweight, training-free baseline for modeling diverse periodic workflow patterns.
+
+
+## Usage
+
+### Dependencies
+Ensure you have the following Python packages installed:
+- `numpy`
+- `scikit-learn`
+- `tqdm`
+- `matplotlib`
+- `scipy`
+
+You can install them using pip:
+```bash
+pip install numpy scikit-learn tqdm matplotlib scipy
+```
+
+### Estimation
+Run the workflow detection function to perform unsupervised periodic workflow detection on the dataset. 
+
+
+

app.py

@@ -1,154 +1,149 @@
-import gradio as gr
-import numpy as np
-import random
-
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
-import torch
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
-
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
-
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
-
-    return image, seed
-
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
-
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
-}
-"""
-
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
-
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
-
-            run_button = gr.Button("Run", scale=0, variant="primary")
-
-        result = gr.Image(label="Result", show_label=False)
-
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
-
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
-            )
-
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-
-            with gr.Row():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
-
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
-
-            with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
-                )
-
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
-                )
-
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
-        ],
-        outputs=[result, seed],
-    )
-
-if __name__ == "__main__":
-    demo.launch()
+import gradio as gr
+import numpy as np
+import os
+import glob
+import pickle
+import json
+from utils.render import render_smpl
+from periodic_detection_function import run_periodic_detection
+
+DATA_DIR = "data"
+OUTPUT_DIR = "outputs"
+
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def get_candidates():
+    """List all pickle files in data directory."""
+    files = glob.glob(os.path.join(DATA_DIR, "*.pkl"))
+    return [os.path.basename(f) for f in files]
+
+def load_and_render(candidate_file):
+    """
+    Load the selected pickle file, render it to a video, and return the video path.
+    """
+    if not candidate_file:
+        return None
+    
+    pkl_path = os.path.join(DATA_DIR, candidate_file)
+    output_video_path = os.path.join(OUTPUT_DIR, f"{candidate_file.replace('.pkl', '')}_rendered.mp4")
+    
+    # Check for pre-rendered video in data/
+    pre_rendered_path = os.path.join(DATA_DIR, candidate_file.replace('.pkl', '.mp4'))
+    if os.path.exists(pre_rendered_path):
+        print(f"Using pre-rendered video: {pre_rendered_path}")
+        return pre_rendered_path
+
+    # If not found, fall back to rendering (or re-render if desired, but user wants direct use)
+    # Keeping fallback just in case
+    try:
+        with open(pkl_path, 'rb') as f:
+            data = pickle.load(f)
+        
+        # Data shape check
+        if len(data.shape) != 3 or data.shape[1] != 24 or data.shape[2] != 3:
+            raise ValueError(f"Unexpected data shape: {data.shape}. Expected (Frames, 24, 3)")
+            
+        print(f"Rendering {candidate_file}...")
+        render_smpl(data, output_video_path, fps=30)
+        return output_video_path
+    
+    except Exception as e:
+        print(f"Error rendering {candidate_file}: {e}")
+        return None
+
+def run_analysis(candidate_file, rendered_video_path):
+    """
+    Run periodic detection on the rendered video and trajectory data.
+    """
+    if not candidate_file or not rendered_video_path:
+        return None, "Please select a candidate and wait for rendering first."
+    
+    pkl_path = os.path.join(DATA_DIR, candidate_file)
+    output_video_path = os.path.join(OUTPUT_DIR, f"{candidate_file.replace('.pkl', '')}_result.mp4")
+    
+    try:
+        print(f"Running detection on {candidate_file}...")
+        # Note: run_periodic_detection expects [Frames, N_feats] usually or generic trajectory.
+        # The pickle contains (Frames, 24, 3). 
+        # The spatiotemporal_clustering in helper seems to handle reshaping or expects specific shape.
+        # Looking at periodic_detection_function.py line 46: 
+        # trajectories = trajectories.reshape(trajectories.shape[0],-1)
+        # So it flattens (Frames, 24, 3) to (Frames, 72), which is fine.
+        
+        results = run_periodic_detection(
+            video_path=rendered_video_path,
+            trajectory_path=pkl_path,
+            output_video_path=output_video_path,
+            n_clusters=9,
+            sampling_rate=1,
+            make_video=True
+        )
+        
+        if "error" in results:
+            return None, json.dumps(results, indent=2)
+            
+        # Format results for display
+        display_results = {
+            "workflow branches": results.get("workflow"),
+            "period_boundaries": results.get("period_boundaries"),
+            "num_periods": results.get("num_periods"),
+            "window_size": results.get("window_size")
+        }
+        
+        return results.get("output_video"), json.dumps(display_results, indent=2)
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return None, f"Error during analysis: {str(e)}"
+
+def reset_all():
+    return None, None, None, None
+
+# Gradio Interface
+with gr.Blocks(title="Periodic Workflow Detection Demo") as demo:
+    gr.Markdown("# Periodic Workflow Detection Demo")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Select Input")
+            candidate_dropdown = gr.Dropdown(
+                choices=get_candidates(),
+                label="Select Candidates",
+                value=None
+            )
+            
+            gr.Markdown("### Input Visualization")
+            input_video = gr.Video(label="Spatiotemporal Sequence", interactive=False)
+            
+        with gr.Column(scale=1):
+            gr.Markdown("### 2. Run Detection")
+            run_btn = gr.Button("Run Analysis", variant="primary")
+            
+            gr.Markdown("### Results")
+            text_output = gr.JSON(label="Numerical Results")
+            result_video = gr.Video(label="Detection Visualization", interactive=False)
+            
+            reset_btn = gr.Button("Reset", variant="secondary")
+
+    # Interactions
+    candidate_dropdown.change(
+        fn=load_and_render,
+        inputs=[candidate_dropdown],
+        outputs=[input_video]
+    )
+    
+    run_btn.click(
+        fn=run_analysis,
+        inputs=[candidate_dropdown, input_video],
+        outputs=[result_video, text_output]
+    )
+    
+    reset_btn.click(
+        fn=reset_all,
+        inputs=[],
+        outputs=[candidate_dropdown, input_video, result_video, text_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

periodic_detection_function.py

@@ -0,0 +1,347 @@
+import numpy as np
+import pickle
+import json
+import string
+import cv2
+from tqdm import tqdm
+import os
+from utils.periodic_detection_helper import *
+from utils.plot import *
+def run_periodic_detection(video_path, trajectory_path, output_video_path=None, n_clusters=8, sampling_rate=1, make_video=True):
+    """
+    Run periodic detection on a video and its associated trajectories
+    
+    Parameters:
+    - video_path: Path to the video file
+    - trajectory_path: Path to the trajectory file (pickle or json)
+    - output_video_path: Path where the output video will be saved (default: same as input with _periodic suffix)
+    - n_clusters: Number of clusters for spatiotemporal clustering (default: 9)
+    - sampling_rate: Sampling rate for trajectories (default: 1)
+    - make_video: Whether to create a visualization video (default: True)
+    
+    Returns:
+    - Dictionary containing workflow, period boundaries, and other results
+    """
+
+    # Main function execution starts here
+    # Setup output video path if not provided
+    if output_video_path is None:
+        base_name = os.path.splitext(video_path)[0]
+        output_video_path = f"{base_name}_periodic.mp4"
+    
+    # Load trajectories from either pickle or json
+    file_ext = os.path.splitext(trajectory_path)[1].lower()
+    try:
+        if file_ext == '.pkl':
+            with open(trajectory_path, 'rb') as f:
+                trajectories = pickle.load(f)
+        elif file_ext == '.json':
+            with open(trajectory_path, 'r') as f:
+                trajectories = np.array(json.load(f))
+        else:
+            raise ValueError(f"Unsupported trajectory file format: {file_ext}. Use .pkl or .json")
+    except Exception as e:
+        return {"error": f"Failed to load trajectories: {str(e)}"}
+    
+    trajectories = trajectories.reshape(trajectories.shape[0],-1)
+    trajectories = trajectories[::sampling_rate, :]
+    cluster_labels, hard_token, soft_token, centroids = spatiotemporal_clustering(trajectories, 9)
+    sequence = number_to_alpha(cluster_labels)
+    num_frames = len(sequence) 
+
+    window_sizes, magnitudes = dominant_fourier_frequency_2d(soft_token, lbound=10, ubound=max(len(soft_token.T), len(soft_token))//2)
+
+    if len(window_sizes) == 0:
+        return {"error": "No dominant frequencies found"}
+    
+
+    ### optimize win size
+    scores = []
+    for win in window_sizes[:10]: # select top 10 window sizes
+        temporal_buffer = int(win*0.2)
+        periods = []
+        for i in range(num_frames//win):
+            clip = sequence[max(0, win*i-temporal_buffer):min(num_frames, win*(i+1)+temporal_buffer )]
+            periods.append(clip)
+        
+        compressed_periods = []
+        for p in periods:
+            compressed_periods.append(fuse_adjacent(p))
+        score = calculate_similarity_score(compressed_periods)
+        scores.append(score)
+    if not scores:
+        return {"error": "Failed to calculate similarity scores"}
+    
+
+    win = window_sizes[np.argmax(scores)]
+    print('selected_win:{}'.format(win))
+    temporal_buffer = int(win*0.2)
+    periods = []
+    for i in range(num_frames//win):
+        clip = sequence[max(0, win*i-temporal_buffer):min(num_frames, win*(i+1)+temporal_buffer )]
+        periods.append(clip)
+
+    compressed_periods = []
+    for p in periods:
+        compressed_periods.append(fuse_adjacent(p))
+
+        aligned_sequences = msa(compressed_periods[:3])
+
+    while '-' in [x[-1] for x in aligned_sequences]:
+        i = find_dash_end_index(aligned_sequences)
+        if i!=0:
+            aligned_sequences = [s[:i] for s in aligned_sequences]
+        else:
+            aligned_sequences = aligned_sequences
+
+    i = find_longest_repeated_ends(aligned_sequences)
+    if i!=0:
+        aligned_sequences = [s[:-i] for s in aligned_sequences]
+    else:
+        aligned_sequences = aligned_sequences
+    aligned_sequences
+
+    workflow_str = summarize_strings(aligned_sequences)
+
+    if not workflow_str:
+        return {"error": "Empty workflow string after summary"}
+
+    while workflow_str and workflow_str[0]=='_':
+        workflow_str = workflow_str[1:]
+
+    while workflow_str and workflow_str[-1]=='_':
+        workflow_str = workflow_str[:-1]
+
+    if not workflow_str:
+        return {"error": "Empty workflow string"}
+
+    workflow_str_len = len(workflow_str)
+
+    workflow = [[] for _ in range(workflow_str_len)]
+    for seq in aligned_sequences:
+        pointer = 0
+        Flag = False
+        
+        pos_skip_sign = seq.find('-')
+        if pos_skip_sign==-1: pos_skip_sign = workflow_str_len //2
+        pos_skip_sign = min(pos_skip_sign, workflow_str.find('_'))
+        pos_skip_sign = max(pos_skip_sign, 1)
+
+        for i in range(len(seq)):
+            l = seq[i]
+            if pointer==workflow_str_len:
+                break
+            if seq[i:i+pos_skip_sign] == workflow_str[:pos_skip_sign]:
+                Flag = True
+            if Flag:
+                workflow[pointer].append(l.replace("-", "_")+'{:02}'.format(pointer))
+                pointer += 1
+
+    # Create multi-path workflow
+    try:
+        workflow_multi_paths = np.stack([''.join([y[0] for i, y in enumerate(x)]) for x in np.stack(workflow).T])
+    except:
+        workflow_multi_paths = []
+
+    seg_labels = {}
+    seg_ind = -1
+    transcript_pointer = -1
+    workflow_str_len = len(workflow_str)
+    workflow_section_len = {}
+    for frame_number, l in enumerate(sequence):
+        # Only start new segment if current one is long enough (approx win size) or it's the first one
+        if l==workflow_str[0] and workflow_str[transcript_pointer]==workflow_str[-1]:
+             if seg_ind == -1 or len(seg_labels[seg_ind]) > 0.5 * win:
+                transcript_pointer = 0
+                seg_ind += 1
+                seg_labels[seg_ind] = {}
+                workflow_section_len[seg_ind] = {}
+                workflow_section_len[seg_ind][transcript_pointer] = 0
+        if transcript_pointer==-1: continue
+        if transcript_pointer < workflow_str_len-1:
+            if l == workflow_str[transcript_pointer+1]:
+                transcript_pointer += 1
+                workflow_section_len[seg_ind][transcript_pointer] = 0
+        if transcript_pointer < workflow_str_len-1:
+            if workflow_str[transcript_pointer+1]=='_':
+                transcript_pointer += 1
+                workflow_section_len[seg_ind][transcript_pointer] = 0
+
+        if transcript_pointer == workflow_str_len-1 and workflow_section_len[seg_ind][transcript_pointer]>1 and l != workflow_str[transcript_pointer]:
+            continue
+
+        seg_labels[seg_ind][frame_number] = l
+        workflow_section_len[seg_ind][transcript_pointer] +=1
+
+    workflow_section_len = [v for k,v in workflow_section_len.items() if len(v)>workflow_str_len*0.3]
+    workflow_section_len_array = []
+    for idx in range(len(workflow_section_len)):
+        workflow_section_len_array.append(list(workflow_section_len[idx].values()))
+
+    if len(workflow_section_len_array)>0:
+
+        sublist_max_len = max(len(sublist) for sublist in workflow_section_len_array)
+        workflow_section_len_array = [sublist for sublist in workflow_section_len_array if len(sublist)==sublist_max_len]
+        workflow_section_len_array = np.stack(workflow_section_len_array)
+        workflow_section_len = np.median(workflow_section_len_array,0)
+    else:
+        workflow_section_len = np.zeros(workflow_str_len)
+
+    ### Task 1
+    period_num = len([x for x in seg_labels.values() if len(x)>0.5*win])
+    print("period_num: {}".format(period_num))
+    print("seg_labels_index: {}".format(seg_labels.keys()))
+    if period_num>0:
+        period_boundaries = {}
+        for p_id, (k,v) in enumerate(seg_labels.items()):
+            frame_list = np.sort(list(v.keys()))
+            # Convert to python int for JSON serialization
+            period_boundaries[p_id] = [int(frame_list[0]), int(frame_list[-1])]
+            if p_id > 0: period_boundaries[p_id-1][1] = int(frame_list[0]-1)
+
+    else:
+        period_num = num_frames//win
+        period_boundaries = [[int((i-1)*win), int(i*win)] for i in range(1,period_num+1)]
+
+    print(f'Workflow: {workflow_str}')
+    for i, boundary in period_boundaries.items():
+        print(f"Priod {i+1}: with boundaries of {boundary} ")
+
+
+    # Make visualization video if requested
+    if make_video and os.path.exists(video_path):
+        print("Generating Video...")
+        
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            print("Error opening video file")
+            cap.release()
+            return {
+                "workflow": workflow_str,
+                "period_boundaries": period_boundaries,
+                "error_video": "Failed to open video file"
+            }
+        # Make token legends
+        images = []
+        tokens = []
+        #for c in all_chars:
+        for c in np.unique(list(sequence)):
+            if c=='_': continue
+            tokens.append(c)
+            c = alpha_to_number(c)
+            frame_number = np.where(cluster_labels==c)[0][0] 
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+            ret, frame = cap.read()
+            images.append(frame[:,:,::-1])
+        plot_images_with_token(images, ''.join(tokens))
+        
+        W = 640
+        H = 640
+        height = 80
+        video_sampling_rate = 10
+        
+        unique_labels = sorted(set(list(sequence)))
+        unique_chars = sorted(set(string.ascii_lowercase))[:15]
+        hues = np.linspace(0, 1, len(unique_chars), endpoint=False)
+        color_map = {char: hsv_to_rgb(hue, 0.8, 0.9) for char, hue in zip(unique_chars, hues)}
+        
+        if seg_labels:
+            max_period_len = max([len(v) for v in seg_labels.values()])
+        else:
+            max_period_len = win
+        
+        prog_bar_w = int(max_period_len // video_sampling_rate) + 300 + 50 # Add 50 px buffer
+        progress_bar = np.ones((H, prog_bar_w, 3), dtype=np.float32)
+        
+        # Try to load anchor image or create a blank one
+        try:
+            if os.path.exists("anchors.jpg"):
+                anchor = cv2.imread("anchors.jpg")
+                anchor = cv2.resize(anchor, (W + prog_bar_w, 380))
+            else:
+                anchor = np.ones((380, W + prog_bar_w, 3), dtype=np.uint8) * 255
+        except:
+            anchor = np.ones((380, W + prog_bar_w, 3), dtype=np.uint8) * 255
+        
+        # Setup video writer
+        # Setup video writer with robust codec handling
+        
+        # Try H.264 (avc1) first
+        fourcc_code = 'avc1'
+        fourcc = cv2.VideoWriter_fourcc(*fourcc_code)
+        out = cv2.VideoWriter(output_video_path, fourcc, 30, (anchor.shape[1], H + anchor.shape[0]))
+        
+        if not out.isOpened():
+             print(f"{fourcc_code} failed. Trying h264...")
+             fourcc_code = 'h264'
+             fourcc = cv2.VideoWriter_fourcc(*fourcc_code)
+             out = cv2.VideoWriter(output_video_path, fourcc, 30, (anchor.shape[1], H + anchor.shape[0]))
+             
+        if not out.isOpened():
+             print(f"{fourcc_code} failed. Trying vp80...")
+             fourcc_code = 'vp80'
+             fourcc = cv2.VideoWriter_fourcc(*fourcc_code)
+             out = cv2.VideoWriter(output_video_path, fourcc, 30, (anchor.shape[1], H + anchor.shape[0]))
+             
+        if not out.isOpened():
+             print(f"{fourcc_code} failed. Trying mp4v (less compatible)...")
+             fourcc_code = 'mp4v'
+             fourcc = cv2.VideoWriter_fourcc(*fourcc_code)
+             out = cv2.VideoWriter(output_video_path, fourcc, 30, (anchor.shape[1], H + anchor.shape[0]))
+             
+        if not out.isOpened():
+            print("Error: Could not open video writer with any compatible codec.")
+        
+        i, j = 0, 0
+        for k in tqdm(list(seg_labels.keys())):
+            if not seg_labels[k]:  # Skip empty segments
+                continue
+                
+            labels = list(seg_labels[k].values())
+            frame_ids = list(seg_labels[k].keys())
+            j += len(seg_labels[k])
+            
+            cv2.putText(progress_bar, f'Period {k+1}', (5, height*k+30), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+            
+            for m, (l, frame_id) in enumerate(zip(labels[::video_sampling_rate], frame_ids[::video_sampling_rate])):
+                try:
+                    progress_bar[height*k:height*(k+1), 300+m, :] = color_map[l.lower()]
+                    
+                    cap.set(cv2.CAP_PROP_POS_FRAMES, frame_id)
+                    ret, frame = cap.read()
+                    if not ret:
+                        continue
+                        
+                    frame = cv2.resize(frame, (W, H))
+                    cv2.putText(frame, f"Frame: {frame_id}", (50, 50), 
+                               cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
+                    
+                    frame = np.concatenate([frame, (progress_bar*255).astype(np.uint8)[:,:,::-1]], axis=1)
+                    frame = np.concatenate([frame, anchor], axis=0)
+                    out.write(frame)
+                except Exception as e:
+                    print(f"Error in video generation: {str(e)}")
+                    continue
+            
+            cv2.putText(progress_bar, f'Frame: {(i+1):04d}-{j:04d}', (5, height*k+52), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2)
+            i += len(seg_labels[k])
+            
+            try:
+                out.write(frame)
+            except:
+                pass
+        
+        # Release resources
+        cap.release()
+        out.release()
+    
+    # Return results
+    return {
+        "workflow": workflow_multi_paths.tolist() if isinstance(workflow_multi_paths, np.ndarray) else workflow_multi_paths,
+        "period_boundaries": period_boundaries,
+        "window_size": int(win),
+        "num_periods": int(period_num),
+        "output_video": output_video_path if make_video else None
+    }

preprocess_videos.py

@@ -0,0 +1,48 @@
+
+import os
+import glob
+import pickle
+import sys
+
+# Add current dir to path
+sys.path.append(os.getcwd())
+
+from utils.render import render_smpl
+
+DATA_DIR = "data"
+
+def batch_render():
+    if not os.path.exists(DATA_DIR):
+        print(f"Data directory {DATA_DIR} not found.")
+        return
+
+    pkl_files = glob.glob(os.path.join(DATA_DIR, "*.pkl"))
+    print(f"Found {len(pkl_files)} pickle files.")
+
+    for pkl_path in pkl_files:
+        base_name = os.path.splitext(os.path.basename(pkl_path))[0]
+        mp4_path = os.path.join(DATA_DIR, f"{base_name}.mp4")
+
+        # Skip if already exists (optional, but good for speed if re-running)
+        # User requested render all, so maybe force? 
+        # "Render all pkl files ... and save them" implies doing it. 
+        # But if we want to update them with new rendering logic, we must overwrite.
+        
+        print(f"Processing {base_name}...")
+        try:
+            with open(pkl_path, 'rb') as f:
+                data = pickle.load(f)
+            
+            # Data shape check
+            if len(data.shape) != 3 or data.shape[1] != 24 or data.shape[2] != 3:
+                print(f"Skipping {base_name}: Unexpected shape {data.shape}")
+                continue
+
+            render_smpl(data, mp4_path, fps=30)
+            print(f"Saved {mp4_path}")
+            
+        except Exception as e:
+            print(f"Failed to render {base_name}: {e}")
+
+if __name__ == "__main__":
+    batch_render()

requirements.txt

@@ -1,6 +1,8 @@
-accelerate
-diffusers
-invisible_watermark
-torch
-transformers
-xformers
+gradio
+matplotlib
+opencv-python
+networkx
+numpy 
+scikit-learn 
+tqdm 
+scipy

verify_app.py

@@ -0,0 +1,39 @@
+
+import os
+import glob
+from app import load_and_render, run_analysis, DATA_DIR
+
+def verify():
+    print("Verifying data availability...")
+    candidates = glob.glob(os.path.join(DATA_DIR, "*.pkl"))
+    if not candidates:
+        print("No candidates found in data directory!")
+        return
+    
+    # Prioritize full samples over test_small.pkl
+    candidate_file = "p_005.pkl"
+
+    print(f"Testing with candidate: {candidate_file}")
+    
+    # Test Loading and Rendering
+    print("\n--- Testing load_and_render ---")
+    video_path = load_and_render(candidate_file)
+    
+    if not video_path or not os.path.exists(video_path):
+        print(f"FAILED: Video rendering failed for {candidate_file}")
+        return
+    print(f"SUCCESS: Video rendered as {video_path}")
+    
+    # Test Analysis
+    print("\n--- Testing run_analysis ---")
+    output_video, output_json = run_analysis(candidate_file, video_path)
+    
+    if not output_video:
+        print(f"FAILED: Analysis failed. Error: {output_json}")
+    else:
+        print(f"SUCCESS: Analysis complete.")
+        print(f"Output Video: {output_video}")
+        # print(f"JSON Result: {output_json}")
+
+if __name__ == "__main__":
+    verify()