from os.path import dirname, join import webdataset as wds from PIL import Image import io import json import numpy as np import argparse import matplotlib import matplotlib.pyplot as plt import os try: import imageio HAS_IMAGEIO = True except ImportError: HAS_IMAGEIO = False try: import cv2 HAS_CV2 = True except ImportError: HAS_CV2 = False def dump_video(image_seq, output_path, fps=30, codec='libx264', quality=8): """ Dump a sequence of PIL Images to a video file. Args: image_seq: List of PIL Images output_path: Output video file path (e.g., 'output.mp4') fps: Frames per second (default: 30) codec: Video codec (default: 'libx264') quality: Video quality, 0-10, higher is better (default: 8) """ if not image_seq: print("Warning: Empty image sequence, skipping video dump") return if HAS_IMAGEIO: # Use imageio (simpler API) frames = [] for img in image_seq: # Convert PIL Image to numpy array frames.append(np.array(img)) # Write video # imageio v2 uses mimwrite, v3 uses get_writer try: # Try imageio v2 API imageio.mimwrite(output_path, frames, fps=fps, codec=codec, quality=quality) except (AttributeError, TypeError): # Fallback for imageio v3 try: writer = imageio.get_writer(output_path, fps=fps, codec=codec) for frame in frames: writer.append_data(frame) writer.close() except Exception: # Final fallback without codec writer = imageio.get_writer(output_path, fps=fps) for frame in frames: writer.append_data(frame) writer.close() print(f"Video saved to {output_path} using imageio") elif HAS_CV2: # Use OpenCV as fallback if not image_seq: return # Get image dimensions first_img = image_seq[0] height, width = first_img.size[1], first_img.size[0] # Define codec and create VideoWriter fourcc = cv2.VideoWriter_fourcc(*codec if len(codec) == 4 else 'mp4v') out = cv2.VideoWriter(output_path, fourcc, fps, (width, height)) for img in image_seq: # Convert PIL Image to numpy array (RGB -> BGR for OpenCV) img_array = np.array(img) if len(img_array.shape) == 3: if img_array.shape[2] == 3: img_array = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR) elif img_array.shape[2] == 4: img_array = cv2.cvtColor(img_array, cv2.COLOR_RGBA2BGR) out.write(img_array) out.release() print(f"Video saved to {output_path} using OpenCV") else: raise ImportError("Neither imageio nor cv2 is available. Please install one: pip install imageio[ffmpeg] or pip install opencv-python") # Parse 16bit depth to actual depth values def parse_depth_16bit(depth_image: Image.Image, max_depth: float) -> np.ndarray: """Parse 16-bit depth image back to actual depth values.""" # Convert PIL image to numpy array depth_array = np.array(depth_image, dtype=np.uint16) # Normalize to [0, 1] and multiply by max_depth to get actual depth depth_normalized = depth_array.astype(np.float32) / 65535.0 actual_depth = depth_normalized * max_depth return actual_depth def colorize_depth_map(depth, mask=None, reverse_color=False): from decord import VideoReader,cpu cm = matplotlib.colormaps["Spectral"] # colorize if reverse_color: img_colored_np = cm(1 - depth, bytes=False)[:, :, 0:3] # Invert the depth values before applying colormap else: img_colored_np = cm(depth, bytes=False)[:, :, 0:3] # (h,w,3) depth_colored = (img_colored_np * 255).astype(np.uint8) # if mask is not None: # masked_image = np.zeros_like(depth_colored) # masked_image[mask.numpy()] = depth_colored[mask.numpy()] # depth_colored_img = Image.fromarray(masked_image) # else: depth_colored_img = Image.fromarray(depth_colored) return depth_colored_img if __name__ == '__main__': args = argparse.ArgumentParser() args.add_argument('--data_path', type=str, default='data/TransPhy3D/parametric_train/training/0_materials.000000.tar') args.add_argument('--output_path', type=str, default='output') args = args.parse_args() os.makedirs(args.output_path, exist_ok=True) # Use WebDataset's built-in verification dataset = wds.WebDataset(args.data_path) data = {} depth_seq_raw = [] # Store raw 16bit depth images depth_max_values = [] # Store max_depth for each frame normal_seq = [] rgbs_seq = [] meta_info =[] # First pass: load all data including 16bit depth for sample in dataset: depth_img = None max_depth = None for key, value in sample.items(): # Ensure value is bytes-like if not isinstance(value, (bytes, bytearray)): continue # Match exact key names or check file extension if key == 'depth.png': # Load 16bit depth image depth_img = Image.open(io.BytesIO(value)) elif key == 'depth.json': # Load max_depth value depth_info = json.loads(value) max_depth = depth_info.get('max_depth', None) elif key == 'normal.png': img = Image.open(io.BytesIO(value)) normal_seq.append(img) elif key == 'image.png': img = Image.open(io.BytesIO(value)) rgbs_seq.append(img) elif key.endswith('.json'): meta_info.append(json.loads(value)) # Store depth data if both image and max_depth are available if depth_img is not None: depth_seq_raw.append(depth_img) depth_max_values.append(max_depth) #* depth processing depth_seq_vis = [] for depth_img, max_depth in zip(depth_seq_raw, depth_max_values): if max_depth is not None: # Parse 16bit depth to actual depth values #* show how to convert to original depth unit actual_depth = parse_depth_16bit(depth_img, max_depth) # Normalize for visualization (0-255) depth_normalized = actual_depth / max_depth # [0, 1] depth_colored_img = colorize_depth_map(depth_normalized) depth_seq_vis.append(depth_colored_img) else: # Fallback: use raw depth image if max_depth not available depth_seq_vis.append(depth_img.convert('L')) dump_video(rgbs_seq, join(args.output_path, 'output_rgb.mp4'), fps=30) dump_video(normal_seq, join(args.output_path, 'output_normal.mp4'), fps=30) dump_video(depth_seq_vis, join(args.output_path, 'output_depth.mp4'), fps=30)