Upload 9 files

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+scripts/body_to_render.blend filter=lfs diff=lfs merge=lfs -text
+scripts/face_ict_to_render.blend filter=lfs diff=lfs merge=lfs -text

scripts/_obj.py

@@ -0,0 +1,284 @@
+import os
+import numpy as np
+
+
+class MeshData(object):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name")
+        self.vertex_format = [
+            ('v_pos', 3, 'float'),
+            ('v_normal', 3, 'float'),
+            ('v_tc0', 2, 'float'),
+            ('v_ambient', 3, 'float'),
+            ('v_diffuse', 3, 'float'),
+            ('v_specular', 3, 'float')
+        ]
+        self.vertices = []
+        self.indices = []
+        # Default basic material of mesh object
+        self.diffuse_color = np.array([1.0, 1.0, 1.0])
+        self.ambient_color = np.array([1.0, 1.0, 1.0])
+        self.specular_color = np.array([1.0, 1.0, 1.0])
+        self.specular_coefficent = 16.0
+        self.transparency = 1.0
+
+    def set_materials(self, mtl_dict):
+        self.diffuse_color = mtl_dict.get('Kd', self.diffuse_color)
+        self.diffuse_color = np.array([float(v) for v in self.diffuse_color])
+        self.ambient_color = mtl_dict.get('Ka', self.ambient_color)
+        self.ambient_color = np.array([float(v) for v in self.ambient_color])
+        self.specular_color = mtl_dict.get('Ks', self.specular_color)
+        self.specular_color = np.array([float(v) for v in self.specular_color])
+        self.specular_coefficent = float(
+            mtl_dict.get('Ns', self.specular_coefficent))
+        transparency = mtl_dict.get('d')
+        if not transparency:
+            transparency = 1.0 - float(mtl_dict.get('Tr', 0))
+        self.transparency = float(transparency)
+
+
+class MTL(object):
+    def __init__(self, filename):
+        self.contents = {}
+        self.filename = filename
+        if not os.path.exists(filename):
+            return
+        for line in open(filename, "r"):
+            if line.startswith('#'):
+                continue
+            values = line.split()
+            if not values:
+                continue
+            if values[0] == 'newmtl':
+                mtl = self.contents[values[1]] = {}
+            elif mtl is None:
+                raise ValueError("mtl file doesn't start with newmtl stmt")
+            if len(values[1:]) > 1:
+                mtl[values[0]] = values[1:]
+            else:
+                mtl[values[0]] = values[1]
+
+    def __getitem__(self, key):
+        return self.contents[key]
+
+    def get(self, key, default=None):
+        return self.contents.get(key, default)
+
+
+class ObjHandle(object):
+    """  """
+
+    def __init__(self, filename=None, swapyz=False, delimiter=None,
+                 vertices=None, normals=None, texcoords=None, faces=None, face_norms=None, face_texs=None,
+                 obj_material=None, mtl=None, triangulate=False):
+        if filename is not None:
+            self.load(filename, swapyz, delimiter, triangulate=triangulate)
+        else:
+            self.vertices = np.array(vertices) if vertices is not None else np.array([])
+            self.normals = np.array(normals) if normals is not None else np.array([])
+            self.texcoords = np.array(texcoords) if texcoords is not None else np.array([])
+            self.faces = np.array(faces) if faces is not None else np.array([[]])
+            self.face_norms = np.array(face_norms) if face_norms is not None else np.empty((self.faces.shape[0], 0))
+            self.face_texs = np.array(face_texs) if face_texs is not None else np.empty((self.faces.shape[0], 0))
+            if swapyz:
+                self.vertices = self.vertices[: [0, 2, 1]]
+                self.normals = self.normals[: [0, 2, 1]]
+
+            self.objects = {}
+            self._current_object = None
+            self.obj_material = obj_material
+            self.mtl = mtl
+
+    def load(self, filename, swapyz=False, delimiter=None, triangulate=False):
+        """Loads a Wavefront OBJ file. """
+        self.objects = {}
+        self.vertices = []
+        self.normals = []
+        self.texcoords = []
+        self.faces = []
+        self.face_norms = []
+        self.face_texs = []
+
+        self._current_object = None
+        self.mtl = None
+        self.obj_material = None
+
+        for line in open(filename, "r", encoding="utf8"):
+            if delimiter is not None and delimiter == "# object" and "# object" in line:
+                if self._current_object:
+                    self.finish_object()
+                self._current_object = line.split()[2]
+            if line.startswith('#'):
+                continue
+            if line.startswith('s'):
+                continue
+            values = line.split()
+            if not values:
+                continue
+            if values[0] == 'o' and len(self.vertices) != 0:
+                self.finish_object()
+                self._current_object = values[1]
+            elif values[0] == 'mtllib':
+                # load materials file here
+                self.mtl = MTL(values[1])
+            elif values[0] in ('usemtl', 'usemat'):
+                self.obj_material = values[1]
+            if values[0] == 'v':
+                v = list(map(float, values[1:4]))
+                if swapyz:
+                    v = [v[0], v[2], v[1]]
+                    #v = [v[1], v[2], v[0]]
+                self.vertices.append(v)
+            elif values[0] == 'vn':
+                v = list(map(float, values[1:4]))
+                if swapyz:
+                    v = [v[0], v[2], v[1]]
+                    #v = [v[1], v[2], v[0]]
+                self.normals.append(v)
+            elif values[0] == 'vt':
+                self.texcoords.append(list(map(float, values[1:3])))
+            elif values[0] == 'f':
+                if not triangulate or len(values) == 4:
+                    face = []
+                    texcoords = []
+                    norms = []
+                    for v in values[1:]:
+                        w = v.split('/')
+                        face.append(int(w[0]) - 1)
+                        if len(w) >= 2 and len(w[1]) > 0:
+                            if '//' not in v:
+                                texcoords.append(int(w[1]) - 1)
+                            else:
+                                norms.append(int(w[1]) - 1)
+                        if len(w) >= 3 and len(w[2]) > 0:
+                            norms.append(int(w[2]) - 1)
+                    self.faces.append(face)
+                    self.face_norms.append(norms)
+                    self.face_texs.append(texcoords)
+                else:
+
+                    face = []
+                    texcoords = []
+                    norms = []
+                    for v in values[1:4]:
+                        w = v.split('/')
+                        face.append(int(w[0]) - 1)
+                        if len(w) >= 2 and len(w[1]) > 0:
+                            if '//' not in v:
+                                texcoords.append(int(w[1]) - 1)
+                            else:
+                                norms.append(int(w[1]) - 1)
+                        if len(w) >= 3 and len(w[2]) > 0:
+                            norms.append(int(w[2]) - 1)
+                    self.faces.append(face)
+                    self.face_norms.append(norms)
+                    self.face_texs.append(texcoords)
+
+                    face = []
+                    texcoords = []
+                    norms = []
+                    for v in [values[1], values[3], values[4]]:
+                        w = v.split('/')
+                        face.append(int(w[0]) - 1)
+                        if len(w) >= 2 and len(w[1]) > 0:
+                            if '//' not in v:
+                                texcoords.append(int(w[1]) - 1)
+                            else:
+                                norms.append(int(w[1]) - 1)
+                        if len(w) >= 3 and len(w[2]) > 0:
+                            norms.append(int(w[2]) - 1)
+                    self.faces.append(face)
+                    self.face_norms.append(norms)
+                    self.face_texs.append(texcoords)
+
+        self.finish_object()
+
+    def finish_object(self):
+        self.vertices = np.array(self.vertices)
+        self.normals = np.array(self.normals)
+        self.texcoords = np.array(self.texcoords)
+        self.faces = np.array(self.faces)
+        self.face_norms = np.array(self.face_norms)
+        self.face_texs = np.array(self.face_texs)
+        if self._current_object is None:
+            return
+
+        mesh = MeshData()
+        idx = 0
+        material = self.mtl.get(self.obj_material)
+        if material:
+            mesh.set_materials(material)
+        for verts, norms, tcs in zip(self.faces, self.face_norms, self.face_texs):
+            # verts = f[0]
+            # norms = f[1]
+            # tcs = f[2]
+            for i in range(3):
+                # get normal components
+                n = np.array([0.0, 0.0, 0.0])
+                if norms is not None:
+                    n = self.normals[norms[i] - 1]
+
+                # get texture coordinate components
+                t = np.array([0.0, 0.0])
+                if tcs is not None:
+                    t = self.texcoords[tcs[i] - 1]
+
+                # get vertex components
+                v = self.vertices[verts[i] - 1]
+
+                data = [v[0], v[1], v[2], n[0], n[1], n[2], t[0], t[1]]
+                mesh.vertices.extend(data)
+
+                # add material info in the vertice
+                mesh.vertices.extend(
+                    mesh.ambient_color +
+                    mesh.diffuse_color +
+                    mesh.specular_color
+                )
+
+            tri = [idx, idx + 1, idx + 2]
+            mesh.indices.extend(tri)
+            idx += 3
+
+        mesh.vertices = np.array(mesh.vertices)
+        mesh.indices = np.array(mesh.indices)
+
+        self.objects[self._current_object] = mesh
+        # mesh.calculate_normals()
+        self.faces = []
+
+    def write(self, filename, swapyz=False):
+        # NOTE: NO CONSIDERATION FOR DELIMITER NOW
+        with open(filename, 'w') as f:
+            if self.mtl is not None:
+                f.write(f"mtllib {self.mtl.filename}\n")
+            for v in self.vertices:
+                if swapyz:
+                    v = v[0], v[2], v[1]
+                f.write(f"v {v[0]:.6f} {v[1]:.6f} {v[2]:.6f}\n")
+
+            if self.texcoords.size != 0:
+                for vt in self.texcoords:
+                    f.write(f"vt {vt[0]:.6f} {vt[1]:.6f}\n")
+            if self.normals.size != 0:
+                for vn in self.normals:
+                    if swapyz:
+                        vn = vn[0], vn[2], vn[1]
+                    f.write(f"vn {vn[0]:.6f} {vn[1]:.6f} {vn[2]:.6f}\n")
+            if self.obj_material is not None:
+                f.write(f"usemtl {self.obj_material}\n")
+            for verts, norms, tcs in zip(self.faces, self.face_norms, self.face_texs):
+                f.write("f ")
+                for i in range(verts.shape[0]):
+                    f.write(f"{verts[i] + 1}")
+
+                    if tcs.size != 0:
+                        f.write(f"/{tcs[i] + 1}")
+                    elif norms.size != 0:
+                        f.write("/")
+                    if norms.size != 0:
+                        f.write(f"/{norms[i] + 1}")
+
+                    if i != verts.shape[0] - 1:
+                        f.write(" ")
+                f.write("\n")

scripts/blendshape_ict.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba480e86edf38515942b4ece28e9d834b6dc15871e4a8f5180d91935609fe810
+size 9281048

scripts/body_to_render.blend

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4bad6154d30cd059ba5effb4d92cf544128bb1fad94c8dbb240f6da1f5be505a
+size 1524579665

scripts/example_body_render_job.txt

@@ -0,0 +1,2 @@
+20231119_051
+20231126_319

scripts/example_face_render_job.txt

@@ -0,0 +1,2 @@
+20231119_001_051
+20231126_003_319

scripts/face_ict_to_arkit.py

@@ -0,0 +1,35 @@
+# This script converts the .npy which currently contains 55 blendshapes
+# to ARKit space which has 51 blendshapes. It removes the 10 and 11th index
+# and merges the 2nd and 3rd index together, and 6th and 7th index together.
+
+import os
+import numpy as np
+import argparse
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input', '-i', type=str, default=os.path.join('..', 'face_ict'), help='Path to arkit npy file or folder')
+    parser.add_argument('--output', '-o', type=str, default=os.path.join('..', 'face_arkit_copy'), help='Folder path to store output npy sequence file')
+    args = parser.parse_args()
+
+    os.makedirs(args.output, exist_ok=True)
+
+    input_files = []
+    if os.path.isdir(args.input):
+        input_files = [os.path.join(args.input, f) for f in sorted(os.listdir(args.input)) if f.endswith('.npy')]
+    else:
+        input_files = [args.input]
+
+    for file_path in input_files:
+        vert_seq = np.load(file_path) # (N, 55)
+        part_1 = vert_seq[:, :2] # (N, 2)
+        merge_1 = vert_seq[:, 2:4].mean(axis=1).reshape(-1, 1) # (N, 1)
+        part_2 = vert_seq[:, 4:6] # (N, 2)
+        merge_2 = vert_seq[:, 6:8].mean(axis=1).reshape(-1, 1) # (N, 1)
+        part_3 = vert_seq[:, 8:10] # (N, 2)
+        part_4 = vert_seq[:, 12:] # (N, 43)
+        new_vert_seq = np.concatenate([part_1, merge_1, part_2, merge_2, part_3, part_4], axis=1) # (N, 51)
+        output_path = os.path.join(args.output, os.path.basename(file_path))
+        np.save(output_path, new_vert_seq)
+        print("Saving to", output_path)

scripts/face_ict_to_render.blend

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bddb3a6e5ac6c11e03f27442ed03533ffd7b5300492086c85d62587c0a2e603
+size 2327017712

scripts/face_ict_to_vertices.py

@@ -0,0 +1,73 @@
+import os
+import numpy as np
+import argparse
+from scripts._obj import ObjHandle
+from multiprocessing import Pool, cpu_count
+
+
+def process_file(args_tuple):
+    """Process a single input file."""
+    input_file, bs, vert_neutrals, output_dir = args_tuple
+
+    arkit_seq = np.load(input_file)
+    print(f"Processing: {input_file}")
+
+    template_key = os.path.basename(input_file).split('_')[1]
+
+    vert_seq = []
+
+    for frame_arkit in arkit_seq:
+        vert_offset = bs.T @ frame_arkit
+        vert_seq.append(vert_offset)
+
+    vert_seq = np.stack(vert_seq, axis=0)
+    vert_neutral = vert_neutrals.get(template_key, vert_neutrals.get('default', next(iter(vert_neutrals.values()))))
+    vert_seq = vert_seq + vert_neutral
+
+    print(f"Output: {vert_seq.shape}")
+
+    output_file = os.path.join(output_dir, os.path.basename(input_file))
+    np.save(output_file, vert_seq)
+
+    return output_file
+
+
+if __name__ == '__main__':
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input', '-i', type=str, default=os.path.join('..', 'face_ict'), help='Path to arkit npy file or folder')
+    parser.add_argument('--templates', '-t', type=str, default=os.path.join('..', 'face_ict_templates'), help='Path to template obj file or folder')
+    parser.add_argument('--output', '-o', type=str, default=os.path.join('..', 'face_vertices'), help='Folder path to store output npy sequence file')
+    parser.add_argument('--bs', '-p', type=str, default='blendshape_ict.npy', help='Path to PCA model')
+    parser.add_argument('--workers', '-w', type=int, default=cpu_count(), help='Number of parallel workers')
+    args = parser.parse_args()
+
+    os.makedirs(args.output, exist_ok=True)
+    bs = np.load(args.bs)
+
+    vert_neutrals = {}
+    if os.path.isdir(args.templates):
+        for f in sorted(os.listdir(args.templates)):
+            if f.endswith('.obj'):
+                template_path = os.path.join(args.templates, f)
+                obj = ObjHandle(template_path, triangulate=True)
+                vert_neutrals[f[:-4]] = obj.vertices.reshape(-1)[None]
+    else:
+        obj = ObjHandle(args.templates, triangulate=True)
+        vert_neutrals['default'] = obj.vertices.reshape(-1)[None]
+
+    if os.path.isdir(args.input):
+        input_files = [os.path.join(args.input, f) for f in sorted(os.listdir(args.input)) if f.endswith('.npy')]
+    else:
+        input_files = [args.input]
+
+    print(f"Processing {len(input_files)} files using {args.workers} workers...")
+
+    # Prepare arguments for each file
+    process_args = [(input_file, bs, vert_neutrals, args.output) for input_file in input_files]
+
+    # Process files in parallel
+    with Pool(args.workers) as pool:
+        results = pool.map(process_file, process_args)
+
+    print(f"Done! Processed {len(results)} files.")

scripts/render_add_audio.py

@@ -0,0 +1,110 @@
+import os
+import argparse
+import re
+import tempfile
+
+FRAME_RATE = 30
+
+def natural_sort_key(s):
+    """Key function for natural sorting (handles numbers in strings correctly)."""
+    return [int(text) if text.isdigit() else text.lower()
+            for text in re.split(r'(\d+)', s)]
+
+
+def add_audio_to_face_renders(input_path, wav_path, output_path):
+    is_meta_render_dir = all(os.path.isdir(os.path.join(input_path, f)) for f in os.listdir(input_path))
+    if is_meta_render_dir:
+        input_dirs = [os.path.join(input_path, f) for f in sorted(os.listdir(input_path))]
+    else:
+        input_dirs = [input_path]
+
+    for dir_path in input_dirs:
+        audio_file_path = os.path.join(wav_path, os.path.basename(dir_path) + '.wav')
+        output_file_path = os.path.join(output_path, os.path.basename(dir_path) + '.mp4')
+
+        # Find and sort PNG files
+        png_files = [f for f in os.listdir(dir_path) if f.lower().endswith('.png')]
+        if not png_files:
+            print(f"No PNG files found in {dir_path}. Skipping.")
+            continue
+        png_files.sort(key=natural_sort_key)
+
+        # Create temporary file list for ffmpeg concat demuxer
+        list_file_content = ""
+        for png_file in png_files:
+            abs_path = os.path.abspath(os.path.join(dir_path, png_file)).replace('\\', '/')
+            list_file_content += f"file '{abs_path}'\n"
+            list_file_content += f"duration {1/FRAME_RATE}\n"
+
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False, encoding='utf-8') as tf:
+            tf.write(list_file_content)
+            temp_list_file = tf.name
+
+        temp_list_file_escaped = temp_list_file.replace('\\', '/')
+
+        print(f"Processing: {dir_path}")
+        os.system(f'ffmpeg -f concat -safe 0 -i "{temp_list_file_escaped}" '
+                  f'-i "{audio_file_path}" '
+                  f'-c:v libx264 -pix_fmt yuv420p -r {FRAME_RATE} '
+                  f'-c:a aac -shortest '
+                  f'-y "{output_file_path}"')
+
+        os.remove(temp_list_file)
+
+
+def find_audio_files(wav_path, date, scenario):
+    audio_files = []
+    for file in os.listdir(os.path.join(wav_path)):
+        if not file.endswith('.wav'):
+            continue
+        parts = file.split('_')
+        if parts[0] == date and parts[2].split('.')[0] == scenario:
+            audio_files.append(os.path.join(wav_path, file))
+    assert len(audio_files) == 2
+    return audio_files
+
+
+def add_audio_to_body_renders(input_path, wav_path, output_path):
+    input_files = []
+    if os.path.isdir(input_path):
+        input_files = [os.path.join(input_path, f) for f in sorted(os.listdir(input_path)) if f.endswith('.mkv')]
+    else:
+        input_files = [input_path]
+    
+    for file_path in input_files:
+        filename = os.path.basename(file_path)
+        date, scenario = filename.split('.')[0].split('_')
+        audio_file_paths = find_audio_files(wav_path, date, scenario)
+        output_file_path = os.path.join(output_path, filename.replace('.mkv', '.mp4'))
+        
+        print('Processing:', file_path)
+        os.system(f"ffmpeg -i {file_path} \
+            -i {audio_file_paths[0]} \
+            -i {audio_file_paths[1]} \
+            -filter_complex \"[1:a][2:a]amix=inputs=2:duration=longest[aout]\" \
+            -map 0:v \
+            -map \"[aout]\" \
+            -c:v copy \
+            -c:a aac \
+            {output_file_path}")
+
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input_type', '-it', type=str, default='face', help='Type of input to process: face or body')
+    parser.add_argument('--input_face', '-if', type=str, default=os.path.join('..', 'face_renders_noaudio'), help='Path to single-instance face render folder or multi-instance folder without audio')
+    parser.add_argument('--output_face', '-of', type=str, default=os.path.join('..', 'face_renders_withaudio'), help='Folder path to store output face render folder with audio')
+    parser.add_argument('--input_body', '-ib', type=str, default=os.path.join('..', 'body_renders_noaudio'), help='Path to single-instance body render folder or multi-instance folder without audio')
+    parser.add_argument('--output_body', '-ob', type=str, default=os.path.join('..', 'body_renders_withaudio'), help='Folder path to store output body render folder with audio')
+    parser.add_argument('--wav_path', '-w', type=str, default=os.path.join('..', 'wav'), help='Path to folder containing wav files')
+    args = parser.parse_args()
+
+    if args.input_type == 'face':
+        os.makedirs(args.output_face, exist_ok=True)
+        add_audio_to_face_renders(args.input_face, args.wav_path, args.output_face)
+    elif args.input_type == 'body':
+        os.makedirs(args.output_body, exist_ok=True)
+        add_audio_to_body_renders(args.input_body, args.wav_path, args.output_body)
+    else:
+        raise ValueError("Invalid input type. Choose 'face' or 'body'.")