| import datetime
|
| import pytz
|
| import traceback
|
| from torchvision.utils import make_grid
|
| from PIL import Image, ImageDraw, ImageFont
|
| import numpy as np
|
| import torch
|
| import json
|
| import os
|
| from tqdm import tqdm
|
| import cv2
|
| import imageio
|
| def get_time_for_log():
|
| return datetime.datetime.now(pytz.timezone('Asia/Shanghai')).strftime(
|
| "%Y%m%d %H:%M:%S")
|
|
|
|
|
| def get_trace_for_log():
|
| return str(traceback.format_exc())
|
|
|
| def make_grid_(imgs, save_file, nrow=10, pad_value=1):
|
| if isinstance(imgs, list):
|
| if isinstance(imgs[0], Image.Image):
|
| imgs = [torch.from_numpy(np.array(img)/255.) for img in imgs]
|
| elif isinstance(imgs[0], np.ndarray):
|
| imgs = [torch.from_numpy(img/255.) for img in imgs]
|
| imgs = torch.stack(imgs, 0).permute(0, 3, 1, 2)
|
| if isinstance(imgs, np.ndarray):
|
| imgs = torch.from_numpy(imgs)
|
|
|
| img_grid = make_grid(imgs, nrow=nrow, padding=2, pad_value=pad_value)
|
| img_grid = img_grid.permute(1, 2, 0).numpy()
|
| img_grid = (img_grid * 255).astype(np.uint8)
|
| img_grid = Image.fromarray(img_grid)
|
| img_grid.save(save_file)
|
|
|
| def draw_caption(img, text, pos, size=100, color=(128, 128, 128)):
|
| draw = ImageDraw.Draw(img)
|
|
|
| font = ImageFont.load_default()
|
| font = font.font_variant(size=size)
|
| draw.text(pos, text, color, font=font)
|
| return img
|
|
|
|
|
| def txt2json(txt_file, json_file):
|
| with open(txt_file, 'r') as f:
|
| items = f.readlines()
|
| items = [x.strip() for x in items]
|
|
|
| with open(json_file, 'w') as f:
|
| json.dump(items.tolist(), f)
|
|
|
| def process_thuman_texture():
|
| path = '/aifs4su/mmcode/lipeng/Thuman2.0'
|
| cases = os.listdir(path)
|
| for case in tqdm(cases):
|
| mtl = os.path.join(path, case, 'material0.mtl')
|
| with open(mtl, 'r') as f:
|
| lines = f.read()
|
| lines = lines.replace('png', 'jpeg')
|
| with open(mtl, 'w') as f:
|
| f.write(lines)
|
|
|
|
|
|
|
| os.environ["OPENCV_IO_ENABLE_OPENEXR"] = "1"
|
|
|
|
|
| def get_intrinsic_from_fov(fov, H, W, bs=-1):
|
| focal_length = 0.5 * H / np.tan(0.5 * fov)
|
| intrinsic = np.identity(3, dtype=np.float32)
|
| intrinsic[0, 0] = focal_length
|
| intrinsic[1, 1] = focal_length
|
| intrinsic[0, 2] = W / 2.0
|
| intrinsic[1, 2] = H / 2.0
|
|
|
| if bs > 0:
|
| intrinsic = intrinsic[None].repeat(bs, axis=0)
|
|
|
| return torch.from_numpy(intrinsic)
|
|
|
| def read_data(data_dir, i):
|
| """
|
| Return:
|
| rgb: (H, W, 3) torch.float32
|
| depth: (H, W, 1) torch.float32
|
| mask: (H, W, 1) torch.float32
|
| c2w: (4, 4) torch.float32
|
| intrinsic: (3, 3) torch.float32
|
| """
|
| background_color = torch.tensor([0.0, 0.0, 0.0])
|
|
|
| rgb_name = os.path.join(data_dir, f'render_%04d.webp' % i)
|
| depth_name = os.path.join(data_dir, f'depth_%04d.exr' % i)
|
|
|
| img = torch.from_numpy(
|
| np.asarray(
|
| Image.fromarray(imageio.v2.imread(rgb_name))
|
| .convert("RGBA")
|
| )
|
| / 255.0
|
| ).float()
|
| mask = img[:, :, -1:]
|
| rgb = img[:, :, :3] * mask + background_color[
|
| None, None, :
|
| ] * (1 - mask)
|
|
|
| depth = torch.from_numpy(
|
| cv2.imread(depth_name, cv2.IMREAD_UNCHANGED)[..., 0, None]
|
| )
|
| mask[depth > 100.0] = 0.0
|
| depth[~(mask > 0.5)] = 0.0
|
|
|
| meta_path = os.path.join(data_dir, 'meta.json')
|
| with open(meta_path, 'r') as f:
|
| meta = json.load(f)
|
|
|
| c2w = torch.as_tensor(
|
| meta['locations'][i]["transform_matrix"],
|
| dtype=torch.float32,
|
| )
|
|
|
| H, W = rgb.shape[:2]
|
| fovy = meta["camera_angle_x"]
|
| intrinsic = get_intrinsic_from_fov(fovy, H=H, W=W)
|
|
|
| return rgb, depth, mask, c2w, intrinsic
|
|
|
