Upload folder using huggingface_hub

utils.py

@@ -0,0 +1,276 @@
+
+from PIL import Image, ImageDraw
+from torch.utils.data import RandomSampler
+from io import BytesIO
+import imageio.v2 as imageio
+import numpy as np
+
+from torchvision import transforms
+from torchvision.utils import flow_to_image
+import cv2
+import torch
+import os
+
+def process_points(points, frames):
+
+    if len(points) >= frames:
+
+        frames_interval = np.linspace(0, len(points) - 1, frames, dtype=int)
+        points = [points[i] for i in frames_interval]
+        return points
+
+    else:
+        insert_num = frames - len(points)
+        insert_num_dict = {}
+        interval = len(points) - 1
+        n = insert_num // interval
+        for i in range(interval):
+            insert_num_dict[i] = n
+
+        m = insert_num % interval
+        if m > 0:
+            frames_interval = np.linspace(0, len(points)-1, m, dtype=int)
+            if frames_interval[-1] > 0:
+                frames_interval[-1] -= 1
+            for i in range(interval):
+                if i in frames_interval:
+                    insert_num_dict[i] += 1
+
+        res = []
+        for i in range(interval):
+            insert_points = []
+            x0, y0 = points[i]
+            x1, y1 = points[i + 1]
+
+            delta_x = x1 - x0
+            delta_y = y1 - y0
+
+            for j in range(insert_num_dict[i]):
+                x = x0 + (j + 1) / (insert_num_dict[i] + 1) * delta_x
+                y = y0 + (j + 1) / (insert_num_dict[i] + 1) * delta_y
+                insert_points.append([int(x), int(y)])
+
+            res += points[i : i + 1] + insert_points
+        res += points[-1:]
+        
+        return res
+
+
+def get_flow(points, optical_flow, video_len):
+    for i in range(video_len - 1):
+        p = points[i]
+        p1 = points[i + 1]
+        optical_flow[i + 1, p[1], p[0], 0] = p1[0] - p[0]
+        optical_flow[i + 1, p[1], p[0], 1] = p1[1] - p[1]
+
+    return optical_flow
+
+
+def sigma_matrix2(sig_x, sig_y, theta):
+    """Calculate the rotated sigma matrix (two dimensional matrix).
+    Args:
+        sig_x (float):
+        sig_y (float):
+        theta (float): Radian measurement.
+    Returns:
+        ndarray: Rotated sigma matrix.
+    """
+    d_matrix = np.array([[sig_x**2, 0], [0, sig_y**2]])
+    u_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
+    return np.dot(u_matrix, np.dot(d_matrix, u_matrix.T))
+
+
+def mesh_grid(kernel_size):
+    """Generate the mesh grid, centering at zero.
+    Args:
+        kernel_size (int):
+    Returns:
+        xy (ndarray): with the shape (kernel_size, kernel_size, 2)
+        xx (ndarray): with the shape (kernel_size, kernel_size)
+        yy (ndarray): with the shape (kernel_size, kernel_size)
+    """
+    ax = np.arange(-kernel_size // 2 + 1.0, kernel_size // 2 + 1.0)
+    xx, yy = np.meshgrid(ax, ax)
+    xy = np.hstack(
+        (
+            xx.reshape((kernel_size * kernel_size, 1)),
+            yy.reshape(kernel_size * kernel_size, 1),
+        )
+    ).reshape(kernel_size, kernel_size, 2)
+    return xy, xx, yy
+
+
+def pdf2(sigma_matrix, grid):
+    """Calculate PDF of the bivariate Gaussian distribution.
+    Args:
+        sigma_matrix (ndarray): with the shape (2, 2)
+        grid (ndarray): generated by :func:`mesh_grid`,
+            with the shape (K, K, 2), K is the kernel size.
+    Returns:
+        kernel (ndarrray): un-normalized kernel.
+    """
+    inverse_sigma = np.linalg.inv(sigma_matrix)
+    kernel = np.exp(-0.5 * np.sum(np.dot(grid, inverse_sigma) * grid, 2))
+    return kernel
+
+
+def bivariate_Gaussian(kernel_size, sig_x, sig_y, theta, grid=None, isotropic=True):
+    """Generate a bivariate isotropic or anisotropic Gaussian kernel.
+    In the isotropic mode, only `sig_x` is used. `sig_y` and `theta` is ignored.
+    Args:
+        kernel_size (int):
+        sig_x (float):
+        sig_y (float):
+        theta (float): Radian measurement.
+        grid (ndarray, optional): generated by :func:`mesh_grid`,
+            with the shape (K, K, 2), K is the kernel size. Default: None
+        isotropic (bool):
+    Returns:
+        kernel (ndarray): normalized kernel.
+    """
+    if grid is None:
+        grid, _, _ = mesh_grid(kernel_size)
+    if isotropic:
+        sigma_matrix = np.array([[sig_x**2, 0], [0, sig_x**2]])
+    else:
+        sigma_matrix = sigma_matrix2(sig_x, sig_y, theta)
+    kernel = pdf2(sigma_matrix, grid)
+    kernel = kernel / np.sum(kernel)
+    return kernel
+
+def read_points(file, video_len=16, reverse=False):
+    with open(file, "r") as f:
+        lines = f.readlines()
+    points = []
+    for line in lines:
+        x, y = line.strip().split(",")
+        points.append((int(x), int(y)))
+    if reverse:
+        points = points[::-1]
+
+    if len(points) > video_len:
+        skip = len(points) // video_len
+        points = points[::skip]
+    points = points[:video_len]
+
+    return points
+
+def process_traj(point_path, num_frames, video_size, device="cpu"):
+    
+    processed_points = []
+    points = np.load(point_path)
+
+    points = [tuple(x) for x in points.tolist()]
+    h, w = video_size
+    points = process_points(points, num_frames)
+    xy_range = [640, 480]
+    points = [[int(w * x / xy_range[0]), int(h * y / xy_range[1])] for x, y in points]
+    points_resized = [] 
+    for point in points:
+        if point[0] >= xy_range[0]:
+            point[0] = xy_range[0] - 1
+        elif point[0] < 0:
+            point[0] = 0
+        elif point[1] >= xy_range[1]:
+            point[1] = xy_range[1] - 1
+        elif point[1] < 0:
+            point[1] = 0
+        points_resized.append(point)
+    processed_points.append(points_resized)
+
+    return processed_points
+
+def process_traj_v2(point_path, num_frames, video_size, device="cpu"):
+    optical_flow = np.zeros((num_frames, video_size[0], video_size[1], 2), dtype=np.float32)
+    processed_points = []
+    
+    points = np.load(point_path)
+    points = [tuple(x) for x in points.tolist()]
+    h, w = video_size
+    points = process_points(points, num_frames)
+    xy_range = [640, 480]
+    points = [[int(w * x / xy_range[0]), int(h * y / xy_range[1])] for x, y in points]
+    points_resized = [] 
+    for point in points:
+        if point[0] >= xy_range[0]:
+            point[0] = xy_range[0] - 1
+        elif point[0] < 0:
+            point[0] = 0
+        elif point[1] >= xy_range[1]:
+            point[1] = xy_range[1] - 1
+        elif point[1] < 0:
+            point[1] = 0
+        points_resized.append(point)
+    optical_flow = get_flow(points_resized, optical_flow, video_len=num_frames)
+    processed_points.append(points_resized)
+    
+    size = 99
+    sigma = 10
+    blur_kernel = bivariate_Gaussian(size, sigma, sigma, 0, grid=None, isotropic=True)
+    blur_kernel = blur_kernel / blur_kernel[size // 2, size // 2]
+    
+    assert len(optical_flow) == num_frames
+    for i in range(1, num_frames):
+        optical_flow[i] = cv2.filter2D(optical_flow[i], -1, blur_kernel)
+    optical_flow = torch.tensor(optical_flow).to(device)
+
+    return optical_flow, processed_points
+
+def draw_circle(rgb, coord, radius, color=(255, 0, 0), visible=True, color_alpha=None):
+    # Create a draw object
+    draw = ImageDraw.Draw(rgb)
+    # Calculate the bounding box of the circle
+    left_up_point = (coord[0] - radius, coord[1] - radius)
+    right_down_point = (coord[0] + radius, coord[1] + radius)
+    # Draw the circle
+    color = tuple(list(color) + [color_alpha if color_alpha is not None else 255])
+    draw.ellipse(
+        [left_up_point, right_down_point],
+        fill=tuple(color) if visible else None,
+        outline=tuple(color),
+    )
+    return rgb
+
+def save_images2video(images, video_name, fps):
+    format = "mp4"
+    codec = "libx264" 
+    ffmpeg_params = ["-crf", str(12)]
+    pixelformat = "yuv420p" 
+    video_stream = BytesIO()
+
+    with imageio.get_writer(
+        video_stream,
+        fps=fps,
+        format=format,
+        codec=codec,
+        ffmpeg_params=ffmpeg_params,
+        pixelformat=pixelformat,
+    ) as writer:
+        for idx in range(len(images)):
+            writer.append_data(images[idx])
+    
+    video_data = video_stream.getvalue()
+    output_path = os.path.join(video_name + ".mp4")
+    with open(output_path, "wb") as f:
+        f.write(video_data)
+
+def sample_flowlatents(latents, flow_latents, mask, points, diameter, transit_start, transit_end):
+
+    points = points[:,::4,:]
+    radius = diameter // 2
+    channels = latents.shape[1]
+
+    for channel in range(channels):
+        latent_value = latents[:, channel, :].unsqueeze(2)[mask>0.].mean()
+        for frame in range(transit_start, transit_end):
+            if frame > 0:
+                flow_latents[0,:,frame,:,:] = flow_latents[0,:,frame-1,:,:]
+            centroid_x, centroid_y = points[0,frame]
+            centroid_x, centroid_y = int(centroid_x), int(centroid_y)
+            for i in range(centroid_y - radius, centroid_y + radius + 1):
+                for j in range(centroid_x - radius, centroid_x + radius + 1):
+                    if 0 <= i < flow_latents.shape[-2] and 0 <= j < flow_latents.shape[-1]: 
+                        if (i - centroid_y) ** 2 + (j - centroid_x) ** 2 <= radius ** 2:
+                            flow_latents[0,channel,frame,i,j] = latent_value + 1e-4
+
+    return flow_latents