{"id":2563,"date":"2024-09-13T14:42:49","date_gmt":"2024-09-13T14:42:49","guid":{"rendered":"https:\/\/summergeometry.org\/sgi2024\/?p=2563"},"modified":"2024-09-13T14:42:50","modified_gmt":"2024-09-13T14:42:50","slug":"adaptive-isotropic-remeshing-for-tetsphere-splatting","status":"publish","type":"post","link":"https:\/\/summergeometry.org\/sgi2024\/adaptive-isotropic-remeshing-for-tetsphere-splatting\/","title":{"rendered":"Adaptive Isotropic Remeshing for TetSphere Splatting"},"content":{"rendered":"\n<p class=\"wp-block-paragraph\">Primary mentor: Minghao Guo<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Volunteer assistant: Shanthika Naik<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Student: Dianlun (Jennifer) Luo<\/p>\n\n\n\n<h4 class=\"wp-block-heading\">1. Introduction<\/h4>\n\n\n\n<p><strong>TetSphere Splatting<\/strong>, introduced by Guo et al. (2024), is a cutting-edge method for reconstructing 3D shapes with high-quality geometry. It employs an explicit, Lagrangian geometry representation to efficiently create high-quality meshes. Unlike conventional object reconstruction techniques, which typically use Eulerian representations and face challenges with high computational demands and suboptimal mesh quality, TetSphere Splatting leverages tetrahedral meshes, providing superior results without the need for neural networks or post-processing. This method is robust and versatile, making it suitable for a wide range of applications, including single-view 3D reconstruction and image-\/text-to-3D content generation.<\/p>\n\n\n\n<p>The primary objective of this project was to explore volumetric geometry reconstruction through the implementation of two key enhancements:<\/p>\n    <ol>\n        <li><strong>Geometry Optimization via Subdivision\/Remeshing:<\/strong> This involved integrating subdivision and remeshing techniques to refine the geometry optimization process in TetSphere Splatting, allowing for the capture of finer details and improving overall tessellation quality.<\/li>\n        <li><strong>Adaptive TetSphere Modification:<\/strong> Mechanisms were developed to adaptively split and merge tetrahedral spheres during the optimization phase, enhancing the flexibility of the method and improving geometric detail capture.<\/li>\n    <\/ol>\n\n\n\n<p>In this project, I implemented <strong>Adaptive Isotropic Remeshing<\/strong> from scratch. The algorithm was tested on two models:<\/p>\n    <ul>\n        <li><strong>final_surface_mesh.obj<\/strong> generated by TetSphere Splatting in the TetSphere Splatting codebase.<\/li>\n        <li>The <strong>Stanford Bunny<\/strong> mesh (bun_zipper_res2.ply).<\/li>\n    <\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">2. Adaptive Isotropic Remeshing Algorithm<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">The remeshing procedure can be broken down into four major steps:<\/p>\n\n\n\n<ol>\n  <li>Split all edges at their midpoint that are longer than \\( \\frac{4}{3} l \\), where \\( l \\) is the local sizing field.<\/li>\n  <li>Collapse all edges shorter than \\( \\frac{4}{5} l \\) into their midpoint.<\/li>\n  <li>Flip edges in order to minimize the deviation from the ideal vertex valence of 6 (or 4 on boundaries).<\/li>\n  <li>Relocate vertices on the surface by applying tangential smoothing.<\/li>\n<\/ol>\n\n\n\n<figure class=\"wp-block-image size-large\"><a href=\"https:\/\/graphics.stanford.edu\/courses\/cs468-12-spring\/LectureSlides\/13_Remeshing1.pdf\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"663\" src=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/local_remeshing_operators-1024x663.jpg\" alt=\"\" class=\"wp-image-2988\" srcset=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/local_remeshing_operators-1024x663.jpg 1024w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/local_remeshing_operators-300x194.jpg 300w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/local_remeshing_operators-768x497.jpg 768w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/local_remeshing_operators-1536x995.jpg 1536w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/local_remeshing_operators-2048x1326.jpg 2048w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/local_remeshing_operators-1200x777.jpg 1200w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/local_remeshing_operators-1980x1282.jpg 1980w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/a><\/figure>\n\n\n\n<h5 class=\"wp-block-heading\">2.1 Adaptive Sizing Field<\/h5>\n\n\n\n<p>Instead of using a uniform target edge length, an <strong>adaptive sizing field<\/strong> was computed using the <code>trimesh<\/code> package. The constant target edge length \\( L \\) was replaced by an adaptive sizing field \\( L(x) \\), which is intuitive to control, simple to implement, and efficient to compute.<\/p>\n\n<p>Splitting edges based on their length and the angle of their endpoint normals can lead to anisotropically stretched triangles, requiring an additional threshold parameter to control the allowed deviation of endpoint normals. The remeshing approach is based on a single, highly intuitive parameter: the <strong>approximation tolerance<\/strong> \\( \\epsilon \\). This parameter controls the maximum allowed geometric deviation between the triangle mesh and the underlying smooth surface geometry.<\/p>\n\n<p>The method first computes the curvature field of the input mesh and then derives the optimal local edge lengths (the sizing field \\( L(x) \\)) from the maximum curvature and the approximation tolerance. The process is as follows:<\/p>\n\n\n\n<pre class=\"wp-block-code\" style=\"font-size:16px\"><code>Algorithm: Compute Adaptive Sizing Field\n\nInput: Mesh M, Points P, Parameter \u03b5\nOutput: Sizing Field Values S\n\nStep 1: Compute Mean Curvature\n    H \u2190 discrete_mean_curvature_measure(M, P, radius = 1.0)\n\nStep 2: Compute Gaussian Curvature\n    K \u2190 discrete_gaussian_curvature_measure(M, P, radius = 1.0)\n\nStep 3: Compute Maximum Curvature\n    C_max \u2190 |H| + sqrt(|H\u00b2 - K|)\n\nStep 4: Ensure Minimum Curvature Threshold\n    C_max \u2190 max(C_max, 1e-6)\n\nStep 5: Compute Sizing Field Values\n    S \u2190 sqrt(max((6\u03b5 \/ C_max) - 3\u03b5\u00b2, 0))\n\nStep 6: Return Sizing Field Values\n    Return S<\/code><\/pre>\n\n\n\n<h5 class=\"wp-block-heading\">2.2 Edge Splitting<\/h5>\n\n\n\n<p class=\"wp-block-paragraph\">Edge splitting is a process where edges that exceed a certain length threshold are split at their midpoint. This step helps maintain consistent element sizes across the mesh and prevent the occurrence of overly stretched or irregular elements. By splitting longer edges, we can achieve better mesh quality, improve computational efficiency, and optimize the mesh for various applications.<\/p>\n\n\n\n<pre class=\"wp-block-code\" style=\"font-size:16px\"><code>Algorithm: Split Edges of a Mesh\n\nInput: Mesh M, Parameter \u03b5\nOutput: Modified Mesh with Split Edges\n\nStep 1: Initialize new vertex and face lists\n    new_vertices \u2190 M.vertices\n    new_faces \u2190 M.faces\n\nStep 2: Iterate over each edge in the mesh\n    For each edge e = (v\u2080, v\u2081) in M.edges:\n        - Compute edge length: l_edge \u2190 ||M.vertices&#091;v\u2080] - M.vertices&#091;v\u2081]||\n        - Compute sizing field for edge vertices: sizing_values \u2190 sizing_field(M, &#091;v\u2080, v\u2081], \u03b5)\n        - Calculate target length: l_target \u2190 (sizing_values&#091;0] + sizing_values&#091;1]) \/ 2\n\n        If l_edge &gt; (4\/3) * l_target:\n            Step 3: Split the edge\n                - Compute midpoint: midpoint \u2190 (M.vertices&#091;v\u2080] + M.vertices&#091;v\u2081]) \/ 2\n                - Add the new vertex to new_vertices\n                - Find adjacent faces containing edge (v\u2080, v\u2081)\n                - For each adjacent face f = (v\u2080, v\u2081, v\u2082):\n                    - Remove face f from new_faces\n                    - Add new faces &#091;v\u2080, new_vertex, v\u2082] and &#091;v\u2081, new_vertex, v\u2082] to new_faces\n\nStep 4: Create and return new mesh\n    Return M \u2190 trimesh.Trimesh(vertices=new_vertices, faces=new_faces)<\/code><\/pre>\n\n\n\n<h5 class=\"wp-block-heading\">2.3 Edge Collapse<\/h5>\n\n\n\n<p class=\"wp-block-paragraph\">Edge collapse simplifies the mesh by merging the vertices of short edges. This step is particularly useful for eliminating unnecessary small elements that may introduce inefficiencies in the mesh. By collapsing short edges, the mesh is coarsened in areas where high detail is not needed. <\/p>\n\n\n\n<pre class=\"wp-block-code\" style=\"font-size:16px\"><code>Algorithm: Collapse Edges of a Mesh\n\nInput: Mesh M, Parameter \u03b5\nOutput: Modified Mesh with Collapsed Edges\n\nStep 1: Initialize face list and sets\n    new_faces \u2190 M.faces\n    vertices_to_remove \u2190 &#091;]\n    collapsed_vertices \u2190 {}\n\nStep 2: Iterate over each edge in the mesh\n    For each edge e = (v\u2080, v\u2081) in M.edges:\n        - Compute edge length: l_edge \u2190 ||M.vertices&#091;v\u2080] - M.vertices&#091;v\u2081]||\n        - Compute sizing field for edge vertices: sizing_values \u2190 sizing_field(M, &#091;v\u2080, v\u2081], \u03b5)\n        - Calculate target length: l_target \u2190 (sizing_values&#091;0] + sizing_values&#091;1]) \/ 2\n\n        If l_edge &lt; (4\/5) * l_target and v\u2080, v\u2081 not in collapsed_vertices:\n            Step 3: Collapse the edge\n                - Compute midpoint: midpoint \u2190 (M.vertices&#091;v\u2080] + M.vertices&#091;v\u2081]) \/ 2\n                - Set M.vertices&#091;v\u2080] \u2190 midpoint\n                - Mark v\u2081 for removal: vertices_to_remove \u2190 vertices_to_remove \u222a {v\u2081}\n                - Mark v\u2080, v\u2081 as collapsed: collapsed_vertices \u2190 collapsed_vertices \u222a {v\u2080, v\u2081}\n\n                Find adjacent faces containing v\u2081 but not v\u2080:\n                For each adjacent face f = (v\u2081, v\u2082, v\u2083):\n                    - Remove face f from new_faces\n                    - Add new face &#091;v\u2080, v\u2082, v\u2083] to new_faces\n                    - Mark v\u2082, v\u2083 as collapsed\n\nStep 4: Update the mesh\n    - Create index_map to remap vertex indices for remaining vertices\n    - Remove vertices in vertices_to_remove from M.vertices\n    - Remap the faces in new_faces based on index_map\n\nStep 5: Create and return new mesh\n    Return M \u2190 trimesh.Trimesh(vertices=new_vertices, faces=new_faces)\n    <\/code><\/pre>\n\n\n\n<h5 class=\"wp-block-heading\">2.4 Edge Flipping<\/h5>\n\n\n\n<p class=\"wp-block-paragraph\">Edge flipping is performed when it reduces the squared difference between the actual valence of the four vertices in the two adjacent triangles and their optimal values. For <strong>interior vertices<\/strong>, the ideal valence is 6, while for <strong>boundary vertices<\/strong>, it is 4.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">To preserve key features of the mesh, <strong>sharp edges<\/strong> and <strong>material boundaries<\/strong> should not be flipped.<\/p>\n\n\n\n<pre class=\"wp-block-code\" style=\"font-size:16px\"><code>Algorithm: Check Edge Flip Condition\n\nInput: Vertices V, Edges E, Faces F, Edge e = (v\u2081, v\u2082)\nOutput: Flip Condition, New Vertices v\u2083, v\u2084, Adjacent Faces f\u2081, f\u2082\n\nStep 1: Find adjacent faces of edge e\n    adjacent_faces \u2190 &#091;f \u2208 F : v\u2081 \u2208 f and v\u2082 \u2208 f]\n\n    If len(adjacent_faces) \u2260 2:\n        Return False, None, None, None, None\n\nStep 2: Identify third vertices of adjacent faces\n    f\u2081, f\u2082 \u2190 adjacent_faces\n    v\u2083 \u2190 &#091;v \u2208 f\u2081 : v \u2260 v\u2081 and v \u2260 v\u2082]\n    v\u2084 \u2190 &#091;v \u2208 f\u2082 : v \u2260 v\u2081 and v \u2260 v\u2082]\n\n    If len(v\u2083) \u2260 1 or len(v\u2084) \u2260 1 or v\u2083&#091;0] = v\u2084&#091;0]:\n        Return False, None, None, None, None\n\nStep 3: Check edge conditions\n    v\u2083, v\u2084 \u2190 v\u2083&#091;0], v\u2084&#091;0]\n    \n    If &#091;v\u2083, v\u2084] \u2208 E:\n        Return False, None, None, None, None\n\nStep 4: Check normal vector alignment\n    Compute normal\u2081 \u2190 normal(f\u2081), normal\u2082 \u2190 normal(f\u2082)\n    Normalize both normal\u2081 and normal\u2082\n    Compute dot product dot_product \u2190 dot(normal\u2081, normal\u2082)\n\n    If dot_product &lt; 0.9:\n        Return False, None, None, None, None\n\nStep 5: Compute valence difference before and after edge flip\n    valence \u2190 compute_valence(V, E)\n    Compute valence difference before and after the flip\n\nReturn difference_after &lt; difference_before, v\u2083, v\u2084, f\u2081, f\u2082<\/code><\/pre>\n\n\n\n<pre class=\"wp-block-code\" style=\"font-size:16px\"><code>Algorithm: Flip Edge of a Mesh\n\nInput: Mesh M, Edge e = (v\u2081, v\u2082)\nOutput: Modified Mesh M\n\nStep 1: Check if edge flip condition is satisfied\n    condition, v\u2083, v\u2084, f\u2081, f\u2082 \u2190 flip_edge_condition(M.vertices, M.edges_unique, M.faces, e)\n\n    If condition = False:\n        Return M\n\nStep 2: Update the faces\n    Remove f\u2081 and f\u2082 from the mesh faces\n    Add new faces &#091;v\u2081, v\u2083, v\u2084] and &#091;v\u2082, v\u2083, v\u2084] to the mesh\n\nStep 3: Create and return the updated mesh\n    Return new_mesh \u2190 trimesh.Trimesh(vertices=M.vertices, faces=new_faces)<\/code><\/pre>\n\n\n\n<h5 class=\"wp-block-heading\">2.5 Tangential Relaxation<\/h5>\n\n\n\n<p class=\"wp-block-paragraph\">Tangential smoothing relocates vertices to create a smoother surface without significantly altering the mesh geometry. The process averages the positions of the neighboring vertices, constrained to the surface, which maintains the mesh&#8217;s adherence to the original geometry while improving its smoothness.<\/p>\n\n\n\n<pre class=\"wp-block-code\" style=\"font-size:16px\"><code>Algorithm: Tangential Relaxation\n\nInput: Mesh M, Sizing Field L\nOutput: Relaxed Mesh\n\nStep 1: Initialize variables\n    vertices \u2190 M.vertices\n    faces \u2190 M.faces\n    relaxed_vertices \u2190 zeros_like(vertices)\n\nStep 2: For each vertex i in vertices:\n    Find incident faces for vertex i\n        incident_faces \u2190 where(faces == i)\n        weighted_barycenter_sum \u2190 zeros(3)\n        weight_sum \u2190 0\n\n    Step 3: For each face f in incident_faces:\n        Compute barycenter and area\n            face_vertices \u2190 faces&#091;f]\n            triangle_vertices \u2190 vertices&#091;face_vertices]\n            barycenter \u2190 mean(triangle_vertices)\n            \n            v\u2080, v\u2081, v\u2082 \u2190 triangle_vertices\n            area \u2190 ||cross(v\u2081 - v\u2080, v\u2082 - v\u2080)|| \/ 2\n\n        Step 4: Compute weight based on sizing field\n            sizing_at_barycenter \u2190 mean(&#091;L&#091;v] for v in face_vertices])\n            weight \u2190 area \u00d7 sizing_at_barycenter\n\n        Step 5: Accumulate weighted barycenter sum\n            weighted_barycenter_sum \u2190 weighted_barycenter_sum + weight \u00d7 barycenter\n            weight_sum \u2190 weight_sum + weight\n\n    Step 6: Compute relaxed vertex position\n        relaxed_vertices&#091;i] \u2190 weighted_barycenter_sum \/ weight_sum if weight_sum \u2260 0 else vertices&#091;i]\n\nStep 7: Create and return relaxed mesh\n    Return relaxed_mesh \u2190 trimesh.Trimesh(vertices=relaxed_vertices, faces=faces)<\/code><\/pre>\n\n\n\n<h5 class=\"wp-block-heading\">2.6 Adaptive Remeshing<\/h5>\n\n\n\n<p class=\"wp-block-paragraph\">The adaptive remeshing algorithm iterates through the above steps to refine the mesh over multiple iterations. <\/p>\n\n\n\n<pre class=\"wp-block-code\" style=\"font-size:16px\"><code>Algorithm: Adaptive Remeshing\n\nInput: Mesh M, Parameter \u03b5, Number of Iterations: iteration\nOutput: Remeshed and Smoothed Mesh\n\nFor i = 1 to iteration:\n\n    Step 1: Split edges\n        M \u2190 split_edges(M, \u03b5)  \n\n    Step 2: Collapse edges\n        M \u2190 collapse_edges(M, \u03b5)\n\n    Step 3: Flip edges\n        For each edge e in M.edges_unique:\n            M \u2190 flip_edge(M, e)\n\n    Step 4: Tangential relaxation\n        Recalculate sizing values based on the updated mesh\n        sizing_values \u2190 sizing_field(M, M.vertices, \u03b5)\n        M \u2190 tangential_relaxation(M, sizing_values)\n\nReturn M<\/code><\/pre>\n\n\n\n<h4>3. Results<\/h4>\n\n<h5>3.1 final_surface_mesh.obj<\/h5>\n<p>The TetSphere Splatting output (<code>final_surface_mesh.obj<\/code>) and its corresponding remeshed version (<code>dog_remeshed_iter1.obj<\/code>) were evaluated to assess the effectiveness of the remeshing algorithm.<\/p>\n<ul>\n    <li><strong>final_surface_mesh.obj:<\/strong>  \n        <ul>\n            <li>Vertices: 16,675<\/li>\n            <li>Faces: 33,266<\/li>\n        <\/ul>\n    <\/li>\n    <li><strong>dog_remeshed_iter1.obj:<\/strong>  \n        <ul>\n            <li>Vertices: 26,603<\/li>\n            <li>Faces: 53,122<\/li>\n        <\/ul>\n    <\/li>\n<\/ul>\n\n<p><strong>Comparison:<\/strong><br>\nThe remeshing process results in a significant increase in both vertices and faces, which produces a more refined and detailed mesh. This is clear in the comparison image below. The <code>dog_remeshed_iter1.obj<\/code> (right) shows a denser mesh structure compared to the <code>final_surface_mesh.obj<\/code> (left). The Adaptive Isotropic Remeshing algorithm enhances resolution and captures finer geometric details.<\/p>\n\n\n\n<div class=\"wp-block-columns alignwide is-layout-flex wp-container-core-columns-is-layout-8f761849 wp-block-columns-is-layout-flex\">\n<div class=\"wp-block-column is-layout-flow wp-block-column-is-layout-flow\">\n<figure class=\"wp-block-image alignfull size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"793\" src=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_init-1024x793.png\" alt=\"\" class=\"wp-image-3004\" srcset=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_init-1024x793.png 1024w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_init-300x232.png 300w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_init-768x594.png 768w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_init-1536x1189.png 1536w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_init-1200x929.png 1200w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_init.png 1938w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><figcaption class=\"wp-element-caption\">final_surface_mesh.obj<\/figcaption><\/figure>\n<\/div>\n\n\n\n<div class=\"wp-block-column is-layout-flow wp-block-column-is-layout-flow\">\n<figure class=\"wp-block-image alignfull size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"793\" src=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_final1-1024x793.png\" alt=\"\" class=\"wp-image-3006\" srcset=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_final1-1024x793.png 1024w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_final1-300x232.png 300w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_final1-768x594.png 768w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_final1-1536x1189.png 1536w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_final1-1200x929.png 1200w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/dog_final1.png 1938w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><figcaption class=\"wp-element-caption\">dog_remeshed_iter1.obj<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n<h5>3.2 bun_zipper_res2.ply<\/h5>\n<p>The Stanford Bunny mesh (<code>bun_zipper_res2.ply<\/code>) was similarly processed through multiple iterations of remeshing to evaluate the progressive refinement of the mesh.<\/p>\n<ul>\n    <li><strong>bun_zipper_res2.ply:<\/strong>  \n        <ul>\n            <li>Vertices: 8,171<\/li>\n            <li>Faces: 16,301<\/li>\n        <\/ul>\n    <\/li>\n    <li><strong>bunny_remeshed_iter1.obj:<\/strong>  \n        <ul>\n            <li>Vertices: 6,476<\/li>\n            <li>Faces: 12,962<\/li>\n        <\/ul>\n    <\/li>\n    <li><strong>bunny_remeshed_iter2.obj:<\/strong>  \n        <ul>\n            <li>Vertices: 5,196<\/li>\n            <li>Faces: 10,381<\/li>\n        <\/ul>\n    <\/li>\n    <li><strong>bunny_remeshed_iter3.obj:<\/strong>  \n        <ul>\n            <li>Vertices: 4,159<\/li>\n            <li>Faces: 8,300<\/li>\n        <\/ul>\n    <\/li>\n<\/ul>\n\n<p><strong>Comparison:<\/strong><br>\nThe progressive reduction in vertices and faces over the iterations demonstrates the remeshing algorithm\u2019s ability to simplify the mesh while retaining the overall geometry. The remeshed iterations display a higher number of equilateral triangles, which creates a more uniform and well-proportioned mesh. This improvement is obvious when comparing the final iteration (<code>bunny_remeshed_iter3.obj<\/code>) with the original model (<code>bun_zipper_res2.ply<\/code>). The triangles become more equilateral and evenly distributed, resulting in a smoother and more consistent surface.<\/p>\n\n\n\n<div class=\"wp-block-columns alignwide is-layout-flex wp-container-core-columns-is-layout-8f761849 wp-block-columns-is-layout-flex\">\n<div class=\"wp-block-column is-layout-flow wp-block-column-is-layout-flow\">\n<figure class=\"wp-block-image alignfull size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"889\" src=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_res200-2-1024x889.png\" alt=\"\" class=\"wp-image-3037\" srcset=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_res200-2-1024x889.png 1024w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_res200-2-300x260.png 300w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_res200-2-768x667.png 768w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_res200-2-1536x1333.png 1536w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_res200-2-1200x1042.png 1200w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_res200-2.png 1728w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><figcaption class=\"wp-element-caption\">bun_zipper_res2.ply<\/figcaption><\/figure>\n<\/div>\n\n\n\n<div class=\"wp-block-column is-layout-flow wp-block-column-is-layout-flow\">\n<figure class=\"wp-block-image alignfull size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"889\" src=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter01-1024x889.png\" alt=\"\" class=\"wp-image-3038\" srcset=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter01-1024x889.png 1024w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter01-300x260.png 300w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter01-768x667.png 768w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter01-1536x1333.png 1536w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter01-1200x1042.png 1200w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter01.png 1728w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><figcaption class=\"wp-element-caption\">bunny_remeshed_iter1.obj<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n<div class=\"wp-block-columns alignwide is-layout-flex wp-container-core-columns-is-layout-8f761849 wp-block-columns-is-layout-flex\">\n<div class=\"wp-block-column is-layout-flow wp-block-column-is-layout-flow\">\n<figure class=\"wp-block-image alignfull size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"889\" src=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter02-1024x889.png\" alt=\"\" class=\"wp-image-3039\" srcset=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter02-1024x889.png 1024w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter02-300x260.png 300w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter02-768x667.png 768w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter02-1536x1333.png 1536w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter02-1200x1042.png 1200w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter02.png 1728w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><figcaption class=\"wp-element-caption\">bunny_remeshed_iter2.obj<\/figcaption><\/figure>\n<\/div>\n\n\n\n<div class=\"wp-block-column is-layout-flow wp-block-column-is-layout-flow\">\n<figure class=\"wp-block-image alignfull size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"889\" src=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter03-1024x889.png\" alt=\"\" class=\"wp-image-3040\" srcset=\"https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter03-1024x889.png 1024w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter03-300x260.png 300w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter03-768x667.png 768w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter03-1536x1333.png 1536w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter03-1200x1042.png 1200w, https:\/\/summergeometry.org\/sgi2024\/wp-content\/uploads\/2024\/09\/bunny_iter03.png 1728w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><figcaption class=\"wp-element-caption\">bunny_remeshed_iter3.obj<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n<h3> 4. Performance Analysis<\/h3>\n\n<p>The current implementation of the remeshing algorithm was developed in Python, utilizing the <code>trimesh<\/code> library. While Python is easy to use, performance limitations may arise when handling large-scale meshes or real-time rendering. <\/p>\n\n<p>A potential solution to improve performance is to transition the core remeshing algorithms to C++.<\/p>\n\n<h5>Benefits of Using C++:<\/h5>\n<ul>\n    <li><strong>Speed<\/strong>: C++ allows for significantly faster execution times due to its lower-level memory management and optimization capabilities.<\/li>\n    <li><strong>Parallelization<\/strong>: Advanced threading and parallel computing techniques in C++ can accelerate the remeshing process.<\/li>\n    <li><strong>Memory Efficiency<\/strong>: C++ provides better control over memory allocation, which is crucial when working with large datasets.<\/li>\n<\/ul>\n\n\n\n<h4 class=\"wp-block-heading\">5. References<\/h4>\n\n\n\n<p class=\"wp-block-paragraph\">M. Botsch and L. Kobbelt, &#8220;<a href=\"https:\/\/www.graphics.rwth-aachen.de\/media\/papers\/remeshing1.pdf\">A remeshing approach to multiresolution modeling<\/a>,&#8221; <em>Proceedings of the 2004 Eurographics\/ACM SIGGRAPH Symposium on Geometry Processing<\/em>, Nice, France, 2004, pp. 185\u2013192. doi: 10.1145\/1057432.1057457.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">M. Dunyach, D. Vanderhaeghe, L. Barthe, and M. Botsch, &#8220;<a href=\"https:\/\/diglib.eg.org\/server\/api\/core\/bitstreams\/c4d5096e-de41-466e-9e74-83a28da64d67\/content\">Adaptive remeshing for real-time mesh deformation<\/a>,&#8221; in <em>Eurographics 2013 &#8211; Short Papers<\/em>, M.-A. Otaduy and O. Sorkine, Eds. The Eurographics Association, 2013, pp. 29\u201332. doi: 10.2312\/conf\/EG2013\/short\/029-032.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">&#8220;Remeshing,&#8221; <em>Lecture Slides for CS468<\/em>, Stanford University, 2012. [Online]. Available: <a href=\"https:\/\/graphics.stanford.edu\/courses\/cs468-12-spring\/LectureSlides\/13_Remeshing1.pdf\">https:\/\/graphics.stanford.edu\/courses\/cs468-12-spring\/LectureSlides\/13_Remeshing1.pdf<\/a>. [Accessed: Sep. 12, 2024].<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">M. Guo, B. Wang, K. He, and W. Matusik, &#8220;TetSphere Splatting: Representing high-quality geometry with Lagrangian volumetric meshes,&#8221; <em>arXiv<\/em>, 2024. [Online]. Available: <a href=\"https:\/\/arxiv.org\/abs\/2405.20283\">https:\/\/arxiv.org\/abs\/2405.20283<\/a>. [Accessed: Sep. 12, 2024].<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">B. Kerbl, G. Kopanas, T. Leimkuehler, and G. Drettakis, &#8220;<a href=\"https:\/\/repo-sam.inria.fr\/fungraph\/3d-gaussian-splatting\/\">3D Gaussian splatting for real-time radiance field rendering<\/a>,&#8221; <em>ACM Trans. Graph.<\/em>, vol. 42, no. 4, Art. no. 139, Jul. 2023. doi: 10.1145\/3592433.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Primary mentor: Minghao Guo Volunteer assistant: Shanthika Naik Student: Dianlun (Jennifer) Luo 1. Introduction TetSphere Splatting, introduced by Guo et al. (2024), is a cutting-edge method for reconstructing 3D shapes with high-quality geometry. It employs an explicit, Lagrangian geometry representation to efficiently create high-quality meshes. Unlike conventional object reconstruction techniques, which typically use Eulerian representations [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[37],"tags":[],"ppma_author":[20],"class_list":["post-2563","post","type-post","status-publish","format-standard","hentry","category-research"],"authors":[{"term_id":20,"user_id":0,"is_guest":1,"slug":"cap-dl3572","display_name":"dl3572","avatar_url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=mm&r=g","author_category":"","first_name":"","last_name":"","user_url":"","job_title":"","description":""}],"_links":{"self":[{"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/posts\/2563","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/comments?post=2563"}],"version-history":[{"count":9,"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/posts\/2563\/revisions"}],"predecessor-version":[{"id":3108,"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/posts\/2563\/revisions\/3108"}],"wp:attachment":[{"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/media?parent=2563"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/categories?post=2563"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/tags?post=2563"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/summergeometry.org\/sgi2024\/wp-json\/wp\/v2\/ppma_author?post=2563"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}