File size: 10,793 Bytes
8e29a6e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 | import os
import json
import numpy as np
import logging
import subprocess
import torch
import re
from pathlib import Path
from PIL import Image, ImageSequence
# from decord import VideoReader # will make cv2.imread NONE!!
from torchvision import transforms
from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize, ToPILImage
try:
from torchvision.transforms import InterpolationMode
BICUBIC = InterpolationMode.BICUBIC
BILINEAR = InterpolationMode.BILINEAR
except ImportError:
BICUBIC = Image.BICUBIC
BILINEAR = Image.BILINEAR
CACHE_DIR = os.environ.get('EDITBOARD_CACHE_DIR')
if CACHE_DIR is None:
CACHE_DIR = os.path.join(os.path.expanduser('~'), '.cache', 'editboard')
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
def clip_transform(n_px):
return Compose([
Resize(n_px, interpolation=BICUBIC, antialias=False),
CenterCrop(n_px),
transforms.Lambda(lambda x: x.float().div(255.0)),
Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),
])
def clip_transform_Image(n_px):
return Compose([
Resize(n_px, interpolation=BICUBIC, antialias=False),
CenterCrop(n_px),
ToTensor(),
Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),
])
def dino_transform(n_px):
return Compose([
Resize(size=n_px, antialias=False),
transforms.Lambda(lambda x: x.float().div(255.0)),
Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
def dino_transform_Image(n_px):
return Compose([
Resize(size=n_px, antialias=False),
ToTensor(),
Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
def tag2text_transform(n_px):
normalize = Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
return Compose([ToPILImage(),Resize((n_px, n_px), antialias=False),ToTensor(),normalize])
def get_frame_indices(num_frames, vlen, sample='rand', fix_start=None, input_fps=1, max_num_frames=-1):
if sample in ["rand", "middle"]: # uniform sampling
acc_samples = min(num_frames, vlen)
# split the video into `acc_samples` intervals, and sample from each interval.
intervals = np.linspace(start=0, stop=vlen, num=acc_samples + 1).astype(int)
ranges = []
for idx, interv in enumerate(intervals[:-1]):
ranges.append((interv, intervals[idx + 1] - 1))
if sample == 'rand':
try:
frame_indices = [random.choice(range(x[0], x[1])) for x in ranges]
except:
frame_indices = np.random.permutation(vlen)[:acc_samples]
frame_indices.sort()
frame_indices = list(frame_indices)
elif fix_start is not None:
frame_indices = [x[0] + fix_start for x in ranges]
elif sample == 'middle':
frame_indices = [(x[0] + x[1]) // 2 for x in ranges]
else:
raise NotImplementedError
if len(frame_indices) < num_frames: # padded with last frame
padded_frame_indices = [frame_indices[-1]] * num_frames
padded_frame_indices[:len(frame_indices)] = frame_indices
frame_indices = padded_frame_indices
elif "fps" in sample: # fps0.5, sequentially sample frames at 0.5 fps
output_fps = float(sample[3:])
duration = float(vlen) / input_fps
delta = 1 / output_fps # gap between frames, this is also the clip length each frame represents
frame_seconds = np.arange(0 + delta / 2, duration + delta / 2, delta)
frame_indices = np.around(frame_seconds * input_fps).astype(int)
frame_indices = [e for e in frame_indices if e < vlen]
if max_num_frames > 0 and len(frame_indices) > max_num_frames:
frame_indices = frame_indices[:max_num_frames]
# frame_indices = np.linspace(0 + delta / 2, duration + delta / 2, endpoint=False, num=max_num_frames)
else:
raise ValueError
return frame_indices
def load_video(video_path, data_transform=None, num_frames=None, return_tensor=True, width=None, height=None):
"""
Load a video from a given path and apply optional data transformations.
The function supports loading video in GIF (.gif), PNG (.png), and MP4 (.mp4) formats.
Depending on the format, it processes and extracts frames accordingly.
Parameters:
- video_path (str): The file path to the video or image to be loaded.
- data_transform (callable, optional): A function that applies transformations to the video data.
Returns:
- frames (torch.Tensor): A tensor containing the video frames with shape (T, C, H, W),
where T is the number of frames, C is the number of channels, H is the height, and W is the width.
Raises:
- NotImplementedError: If the video format is not supported.
The function first determines the format of the video file by its extension.
For GIFs, it iterates over each frame and converts them to RGB.
For PNGs, it reads the single frame, converts it to RGB.
For MP4s, it reads the frames using the VideoReader class and converts them to NumPy arrays.
If a data_transform is provided, it is applied to the buffer before converting it to a tensor.
Finally, the tensor is permuted to match the expected (T, C, H, W) format.
"""
if video_path.endswith('.gif'):
frame_ls = []
img = Image.open(video_path)
for frame in ImageSequence.Iterator(img):
frame = frame.convert('RGB')
frame = np.array(frame).astype(np.uint8)
frame_ls.append(frame)
buffer = np.array(frame_ls).astype(np.uint8)
elif video_path.endswith('.png'):
frame = Image.open(video_path)
frame = frame.convert('RGB')
frame = np.array(frame).astype(np.uint8)
frame_ls = [frame]
buffer = np.array(frame_ls)
# elif video_path.endswith('.mp4'):
# import decord
# decord.bridge.set_bridge('native')
# if width:
# video_reader = VideoReader(video_path, width=width, height=height, num_threads=1)
# else:
# video_reader = VideoReader(video_path, num_threads=1)
# frame_indices = range(len(video_reader))
# if num_frames:
# frame_indices = get_frame_indices(
# num_frames, len(video_reader), sample="middle"
# )
# frames = video_reader.get_batch(frame_indices) # (T, H, W, C), torch.uint8
# buffer = frames.asnumpy().astype(np.uint8)
else:
raise NotImplementedError
frames = buffer
if num_frames and not video_path.endswith('.mp4'):
frame_indices = get_frame_indices(
num_frames, len(frames), sample="middle"
)
frames = frames[frame_indices]
if data_transform:
frames = data_transform(frames)
elif return_tensor:
frames = torch.Tensor(frames)
frames = frames.permute(0, 3, 1, 2) # (T, C, H, W), torch.uint8
return frames
def load_dimension_info(json_dir, dimension):
"""
Load video list and prompt information based on a specified dimension and language from a JSON file.
Parameters:
- json_dir (str): The directory path where the JSON file is located.
- dimension (str): The dimension for evaluation to filter the video prompts.
Returns:
- video_list (list): A list of video file paths that match the specified dimension.
- prompt_dict_ls (list): A list of dictionaries, each containing a prompt and its corresponding video list.
The function reads the JSON file to extract video information. It filters the prompts based on the specified
dimension and compiles a list of video paths and associated prompts in the specified language.
Notes:
- The JSON file is expected to contain a list of dictionaries with keys 'dimension', "edited_video_path", and language-based prompts.
- The function assumes that the "edited_video_path" key in the JSON can either be a list or a single string value.
"""
video_list = []
full_prompt_list = load_json(json_dir)
for each_item in full_prompt_list:
if dimension in each_item['dimension'] and "edited_video_path" in each_item:
source_folder = each_item["edited_video_path"]
output_folder = os.path.join(source_folder, "tempt_dir")
folder_name = os.path.basename(source_folder)
gif_path = os.path.join(output_folder, f"{folder_name}.gif")
video_list.append(gif_path)
return video_list
def init_submodules(dimension_list, read_frame=False):
submodules_dict = {}
for dimension in dimension_list:
os.makedirs(CACHE_DIR, exist_ok=True)
if dimension == 'background_consistency':
# read_frame = False
vit_b_path = 'ViT-B/32'
submodules_dict[dimension] = [vit_b_path, read_frame]
# Assign the DINO model path for subject consistency dimension
elif dimension == 'subject_consistency':
submodules_dict[dimension] = {
'repo_or_dir':'facebookresearch/dino:main',
'source':'github',
'model': 'dino_vitb16',
'read_frame': read_frame
}
elif dimension == 'aesthetic_quality':
aes_path = f'{CACHE_DIR}/aesthetic_model/emb_reader'
vit_l_path = 'ViT-L/14'
submodules_dict[dimension] = [vit_l_path, aes_path]
elif dimension == 'imaging_quality':
musiq_spaq_path = f'{CACHE_DIR}/pyiqa_model/musiq_spaq_ckpt-358bb6af.pth'
if not os.path.isfile(musiq_spaq_path):
wget_command = ['wget', 'https://github.com/chaofengc/IQA-PyTorch/releases/download/v0.1-weights/musiq_spaq_ckpt-358bb6af.pth', '-P', os.path.dirname(musiq_spaq_path)]
subprocess.run(wget_command, check=True)
submodules_dict[dimension] = {'model_path': musiq_spaq_path}
else:
submodules_dict[dimension] = None
return submodules_dict
def save_json(data, path, indent=4):
with open(path, 'w', encoding='utf-8') as f:
json.dump(data, f, indent=indent)
def load_json(path):
"""
Load a JSON file from the given file path.
Parameters:
- file_path (str): The path to the JSON file.
Returns:
- data (dict or list): The data loaded from the JSON file, which could be a dictionary or a list.
"""
with open(path, 'r', encoding='utf-8') as f:
return json.load(f)
|