initial fix for mzd files with duplicated faces

losanc · losanc · commit 8109b98be5ed · 2022-04-11T15:42:13.000+02:00
diff --git a/additional_file_formats/__init__.py b/additional_file_formats/__init__.py
@@ -1,7 +1,8 @@
-from .mzd import readMZD_to_bpymesh,readMZD_to_meshio
+from .mzd import readMZD_to_bpymesh, readMZD_to_meshio,readMZD_to_meshio_with_split_norm
 from .bgeo import readbgeo_to_meshio
 
-additional_format_loader  ={'.bgeo':readbgeo_to_meshio, '.mzd':readMZD_to_meshio}
-
-__all__ = [readMZD_to_bpymesh,readMZD_to_meshio,readbgeo_to_meshio,additional_format_loader]
+additional_format_loader = {'.bgeo': readbgeo_to_meshio, '.mzd': readMZD_to_meshio}
 
+__all__ = [
+    readMZD_to_bpymesh, readMZD_to_meshio, readbgeo_to_meshio, readMZD_to_meshio_with_split_norm, additional_format_loader
+]
diff --git a/additional_file_formats/mzd.py b/additional_file_formats/mzd.py
@@ -1,5 +1,8 @@
+## TODO: use dictionary as cells is going to be deprecated, should use list instead
+
 head = b"    MZD-File-Format    \x00"  # c string has \x00 as end
 end = b"   >> END OF FILE <<   \x00"  # c string has \x00 as end
+import bpy
 import numpy as np
 import meshio
 from .table import table
@@ -85,6 +88,168 @@ def readMZD_to_meshio(filepath):
                     start_polyVIndices = end_polyVIndices
                     start_polyVIndicesNum = b
 
+                faces_copy = np.copy(cells['triangle'])
+                faces_copy.sort(axis=1)
+                _, indxs, count = np.unique(faces_copy, axis=0, return_index=True, return_counts=True)
+                faces = cells['triangle'][indxs]
+                cells['triangle'] = faces
+
+                faces_copy = np.copy(cells['quad'])
+                faces_copy.sort(axis=1)
+                _, indxs, count = np.unique(faces_copy, axis=0, return_index=True, return_counts=True)
+                faces = cells['quad'][indxs]
+                cells['quad'] = faces
+
+            elif chunkID == 0xDA7A0001:  # vertex normals.
+                byte = file.read(4)
+                out_numVerticeAttributes = int.from_bytes(byte, byteorder='little')
+                if out_numVerticeAttributes != out_numVertices:
+                    return -127
+
+                byte = file.read(out_numVerticeAttributes * 6)
+                out_vertAttribute = np.frombuffer(byte, dtype=np.uint16)
+                out_vertAttribute = table[out_vertAttribute]
+                point_data['normal'] = out_vertAttribute.reshape((out_numVerticeAttributes, 3))
+
+            elif chunkID == 0xDA7A0002:  # vertex motions
+                byte = file.read(4)
+                out_numVerticeAttributes = int.from_bytes(byte, byteorder='little')
+                if out_numVerticeAttributes != out_numVertices:
+                    return -127
+
+                byte = file.read(out_numVerticeAttributes * 6)
+                out_vertAttribute = np.frombuffer(byte, dtype=np.uint16)
+                out_vertAttribute = table[out_vertAttribute]
+                point_data['velocity'] = out_vertAttribute.reshape((out_numVerticeAttributes, 3))
+
+            elif chunkID == 0xDA7A0003:  # vertex colors
+                byte = file.read(4)
+                out_numVerticeAttributes = int.from_bytes(byte, byteorder='little')
+                if out_numVerticeAttributes != out_numVertices:
+                    return -127
+
+                byte = file.read(out_numVerticeAttributes * 8)
+                out_vertAttribute = np.frombuffer(byte, dtype=np.uint16)
+                out_vertAttribute = table[out_vertAttribute]
+                point_data['color'] = out_vertAttribute.reshape((out_numVerticeAttributes, 3))
+
+            elif chunkID == 0xDA7A0004:  # vertex UVWs.
+                byte = file.read(4)
+                out_numVerticeAttributes = int.from_bytes(byte, byteorder='little')
+                if out_numVerticeAttributes != out_numVertices:
+                    return -127
+
+                byte = file.read(out_numVerticeAttributes * 12)
+                out_vertAttribute = np.frombuffer(byte, dtype=np.float32)
+                point_data['uvw_map'] = out_vertAttribute.reshape((out_numVerticeAttributes, 3))
+
+            # For the rest of attributes, because meshio doest not support attributes on nodes, (equivalent to face cornder in blender)
+            # So the attributes data will be skipped
+            elif chunkID == 0xDA7A0011:  # node normals.
+                file.seek(size, 1)
+                pass
+            elif chunkID == 0xDA7A0013:  # node colors.
+                file.seek(size, 1)
+                pass
+            elif chunkID == 0xDA7A0014:  # node UVWs.
+                file.seek(size, 1)
+                pass
+            else:
+                file.seek(size, 1)
+                pass
+    return meshio.Mesh(out_vertPositions.reshape((out_numVertices, 3)), cells, point_data)
+
+
+def readMZD_to_meshio_with_split_norm(filepath):
+    out_numVertices = None
+    out_numPolygons = None
+    out_vertPositions = None
+    out_numNodes = None  # number of loops
+    out_polyVIndicesNum = None  # faces_loop_total
+    out_polyVIndices = None  #loops_vert_idx
+    cells = {}
+    point_data = {}
+
+    with open(filepath, 'rb') as file:
+        byte = file.read(24)
+        if byte != head:
+            return -4
+        while 1:
+            # check if it reach the end
+            byte = file.read(24)
+            if byte == end:
+                break
+            else:
+                # if not reach the end, rewind the pointer back 24 bytes
+                file.seek(-24, 1)
+
+            byte = file.read(4)
+            chunkID = int.from_bytes(byte, byteorder='little')
+
+            byte = file.read(24)
+            name = byte
+
+            byte = file.read(4)
+            size = int.from_bytes(byte, byteorder='little')
+
+            if chunkID == 0x0ABC0001:  # vertices and polygons.
+
+                byte = file.read(4)
+                out_numVertices = int.from_bytes(byte, byteorder='little')
+                if out_numVertices < 0:
+                    return -127
+                if out_numVertices == 0:
+                    break
+
+                byte = file.read(12 * out_numVertices)
+                out_vertPositions = np.frombuffer(byte, dtype=np.float32)
+
+                byte = file.read(4)
+                out_numPolygons = int.from_bytes(byte, byteorder='little')
+
+                byte = file.read(out_numPolygons)
+                out_polyVIndicesNum = np.frombuffer(byte, dtype=np.uint8)
+                out_numNodes = out_polyVIndicesNum.sum(dtype=np.int32)
+
+                byte = file.read(4)
+                numBytesPerPolyVInd = int.from_bytes(byte, byteorder='little')
+
+                if numBytesPerPolyVInd == 4:
+                    #  int
+                    byte = file.read(out_numNodes * numBytesPerPolyVInd)
+                    out_polyVIndices = np.frombuffer(byte, dtype=np.int32)
+                elif numBytesPerPolyVInd == 2:
+                    #  unsigned short
+                    byte = file.read(out_numNodes * numBytesPerPolyVInd)
+                    # WARNING: not sure if it's correct
+                    # uncovered branch from test data
+                    out_polyVIndices = np.frombuffer(byte, dtype=np.uint16)
+                else:
+                    return -127
+                start_polyVIndicesNum = 0
+                start_polyVIndices = 0
+                breaks = np.where(out_polyVIndicesNum[:-1] != out_polyVIndicesNum[1:])[0] + 1
+                breaks = np.append(breaks, len(out_polyVIndicesNum))
+                for b in breaks:
+                    poly_nodes_num = out_polyVIndicesNum[start_polyVIndices]  # 3(triangle) or 4 (quad)
+                    end_polyVIndices = start_polyVIndices + poly_nodes_num * (b - start_polyVIndicesNum)
+                    cells[num_nodes_to_name[poly_nodes_num]] = out_polyVIndices[start_polyVIndices:end_polyVIndices].reshape(
+                        ((b - start_polyVIndicesNum), poly_nodes_num))
+                    start_polyVIndices = end_polyVIndices
+                    start_polyVIndicesNum = b
+
+                faces_copy = np.copy(cells['triangle'])
+                faces_copy.sort(axis=1)
+                _, indxs = np.unique(faces_copy, axis=0, return_index=True)
+                faces = cells['triangle'][indxs]
+                cells['triangle'] = faces
+
+                faces_copy = np.copy(cells['quad'])
+                faces_copy.sort(axis=1)
+                _, indxs = np.unique(faces_copy, axis=0, return_index=True)
+                faces = cells['quad'][indxs]
+                cells['quad'] = faces
+
             elif chunkID == 0xDA7A0001:  # vertex normals.
                 byte = file.read(4)
                 out_numVerticeAttributes = int.from_bytes(byte, byteorder='little')
@@ -129,7 +294,7 @@ def readMZD_to_meshio(filepath):
                 point_data['uvw_map'] = out_vertAttribute.reshape((out_numVerticeAttributes, 3))
 
             # For the rest of attributes, because meshio doest not support attributes on nodes, (equivalent to face cornder in blender)
-            # So the attributes data will be skipped 
+            # So the attributes data will be skipped
             elif chunkID == 0xDA7A0011:  # node normals.
                 file.seek(size, 1)
                 pass
@@ -144,12 +309,13 @@ def readMZD_to_meshio(filepath):
                 pass
     return meshio.Mesh(out_vertPositions.reshape((out_numVertices, 3)), cells, point_data)
 
+
 def readMZD_to_bpymesh(filepath, mesh):
     shade_scheme = False
     if mesh.polygons:
         shade_scheme = mesh.polygons[0].use_smooth
 
-    if len(mesh.vertices)>0:
+    if len(mesh.vertices) > 0:
         mesh.clear_geometry()
 
     out_numVertices = None
@@ -217,20 +383,20 @@ def readMZD_to_bpymesh(filepath, mesh):
                     return -127
 
                 mesh.vertices.add(out_numVertices)
-                mesh.vertices.foreach_set('co',out_vertPositions)
+                mesh.vertices.foreach_set('co', out_vertPositions)
 
                 mesh.loops.add(out_numNodes)
-                mesh.loops.foreach_set('vertex_index',out_polyVIndices)
+                mesh.loops.foreach_set('vertex_index', out_polyVIndices)
 
                 mesh.polygons.add(out_numPolygons)
-                mesh.polygons.foreach_set('loop_total',out_polyVIndicesNum)
+                mesh.polygons.foreach_set('loop_total', out_polyVIndicesNum)
                 faces_loop_start = None
 
                 if out_polyVIndicesNum.size > 0:
                     faces_loop_start = np.cumsum(out_polyVIndicesNum)
                     faces_loop_start = np.roll(faces_loop_start, 1)
                     faces_loop_start[0] = 0
-                mesh.polygons.foreach_set('loop_start',faces_loop_start)
+                mesh.polygons.foreach_set('loop_start', faces_loop_start)
                 mesh.polygons.foreach_set("use_smooth", [shade_scheme] * out_numPolygons)
                 mesh.update()
                 mesh.validate()
diff --git a/template/mzd_template.py b/template/mzd_template.py
@@ -7,6 +7,7 @@
 import fileseq
 import bpy
 import additional_file_formats
+import numpy as np
 
 
 # In general we suggest to directly use process for performance and compatibility reason, 
@@ -15,11 +16,87 @@
 
 def process(fileseq: fileseq.FileSequence, frame_number: int, mesh:bpy.types.Mesh):
     frame_number = frame_number % len(fileseq)
-    additional_file_formats.readMZD_to_bpymesh(fileseq[frame_number],mesh)
-
-# this will be ignored
-def preprocess(fileseq: fileseq.FileSequence, frame_number: int) -> meshio.Mesh:    
-    # this is current implementation, will be slightly different from `process`
-   frame_number = frame_number % len(fileseq)
-   mesh = additional_file_formats.readMZD_to_meshio(fileseq[frame_number])
-   return mesh
+    meshio_mesh = additional_file_formats.readMZD_to_meshio_with_split_norm(fileseq[frame_number])
+    
+    mesh_vertices = meshio_mesh.points
+
+    n_poly = 0
+    n_loop = 0
+    n_verts = len(mesh_vertices)
+
+    faces_loop_start = np.array([], dtype=np.uint64)
+    faces_loop_total = np.array([], dtype=np.uint64)
+    loops_vert_idx = np.array([], dtype=np.uint64)
+    shade_scheme = False
+    if mesh.polygons:
+        shade_scheme = mesh.polygons[0].use_smooth
+    for cell in meshio_mesh.cells:
+        data = extract_faces(cell)
+        # np array can't be simply written as `if not data:`,
+        if not data.any():
+            continue
+        n_poly += len(data)
+        n_loop += data.shape[0] * data.shape[1]
+        loops_vert_idx = np.append(loops_vert_idx, data.ravel())
+        faces_loop_total = np.append(faces_loop_total, np.ones((len(data)), dtype=np.uint64) * data.shape[1])
+    if faces_loop_total.size > 0:
+        faces_loop_start = np.cumsum(faces_loop_total)
+        # Add a zero as first entry
+        faces_loop_start = np.roll(faces_loop_start, 1)
+        faces_loop_start[0] = 0
+
+    if len(mesh.vertices) == n_verts and len(mesh.polygons) == n_poly and len(mesh.loops) == n_loop:
+        pass
+    else:
+        mesh.clear_geometry()
+        mesh.vertices.add(n_verts)
+        mesh.loops.add(n_loop)
+        mesh.polygons.add(n_poly)
+
+    mesh.vertices.foreach_set("co", mesh_vertices.ravel())
+    mesh.loops.foreach_set("vertex_index", loops_vert_idx)
+    mesh.polygons.foreach_set("loop_start", faces_loop_start)
+    mesh.polygons.foreach_set("loop_total", faces_loop_total)
+    mesh.polygons.foreach_set("use_smooth", [shade_scheme] * len(faces_loop_total))
+
+    mesh.update()
+    mesh.validate()
+
+    #  copy attributes
+    attributes = mesh.attributes
+    for k, v in meshio_mesh.point_data.items():
+        if k == 'normal':
+            # mesh.vertices.foreach_set("normal", v.ravel())
+            mesh.use_auto_smooth = True
+            mesh.normals_split_custom_set_from_vertices(v)
+            
+            continue
+        k = reserved_word_check(k)
+        attribute = None
+        if k not in attributes:
+            if len(v.shape) == 1:
+                # one dimensional attribute
+                attribute = mesh.attributes.new(k, "FLOAT", "POINT")
+            if len(v.shape) == 2:
+                dim = v.shape[1]
+                if dim > 3:
+                    show_message_box('higher than 3 dimensional attribue, ignored')
+                    continue
+                if dim == 1:
+                    attribute = mesh.attributes.new(k, "FLOAT", "POINT")
+                if dim == 2:
+                    attribute = mesh.attributes.new(k, "FLOAT2", "POINT")
+                if dim == 3:
+                    attribute = mesh.attributes.new(k, "FLOAT_VECTOR", "POINT")
+            if len(v.shape) > 2:
+                show_message_box('more than 2 dimensional tensor, ignored')
+                continue
+        else:
+            attribute = attributes[k]
+        name_string = None
+        if attribute.data_type == "FLOAT":
+            name_string = "value"
+        else:
+            name_string = 'vector'
+
+        attribute.data.foreach_set(name_string, v.ravel())
