conquer3d 0.4.2__tar.gz → 0.4.5__tar.gz

{conquer3d-0.4.2/conquer3d.egg-info → conquer3d-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.4.2
+Version: 0.4.5
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -88,14 +88,7 @@ twine upload dist/* --verbose
     author = {Karras, Tero},
     title = {Maximizing parallelism in the construction of BVHs, octrees, and k-d trees},
     year = {2012},
-    isbn = {9783905674415},
-    publisher = {Eurographics Association},
-    address = {Goslar, DEU},
     booktitle = {Proceedings of the Fourth ACM SIGGRAPH / Eurographics Conference on High-Performance Graphics},
-    pages = {33–37},
-    numpages = {5},
-    location = {Paris, France},
-    series = {EGGH-HPG'12}
 }
 ```
 
@@ -104,18 +97,7 @@ twine upload dist/* --verbose
     author = {M\"{o}ller, Tomas},
     title = {A fast triangle-triangle intersection test},
     year = {1997},
-    issue_date = {1997},
-    publisher = {A. K. Peters, Ltd.},
-    address = {USA},
-    volume = {2},
-    number = {2},
-    issn = {1086-7651},
-    url = {https://doi.org/10.1080/10867651.1997.10487472},
-    doi = {10.1080/10867651.1997.10487472},
     journal = {J. Graph. Tools},
-    month = nov,
-    pages = {25–30},
-    numpages = {6}
 }
 ```
 
@@ -124,36 +106,36 @@ twine upload dist/* --verbose
     author = {M\"{o}ller, Tomas and Trumbore, Ben},
     title = {Fast, minimum storage ray/triangle intersection},
     year = {2005},
-    isbn = {9781450378338},
-    publisher = {Association for Computing Machinery},
-    address = {New York, NY, USA},
-    url = {https://doi.org/10.1145/1198555.1198746},
-    doi = {10.1145/1198555.1198746},
-    pages = {7–es},
-    keywords = {base transformation, intersection, ray tracing, ray/triangle-intersection},
-    location = {Los Angeles, California},
-    series = {SIGGRAPH '05}
+    booktitle = {ACM SIGGRAPH 2005 Courses},
 }
 ```
 
 ```bibtex
-@InProceedings{10.1007/978-3-662-05105-4_2,
-    author="Meyer, Mark
-    and Desbrun, Mathieu
-    and Schr{\"o}der, Peter
-    and Barr, Alan H.",
-    editor="Hege, Hans-Christian
-    and Polthier, Konrad",
+@inproceedings{10.1007/978-3-662-05105-4_2,
+    author="Meyer, Mark and Desbrun, Mathieu and Schr{\"o}der, Peter and Barr, Alan H.",
     title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
     booktitle="Visualization and Mathematics III",
-    year="2003",
-    publisher="Springer Berlin Heidelberg",
-    address="Berlin, Heidelberg",
-    pages="35--57",
-    isbn="978-3-662-05105-4"
+    year="2003"
 }
 ```
 
+```bibtex
+@article{9167456,
+    author={Khan, Dawar and Plopski, Alexander and Fujimoto, Yuichiro and Kanbara, Masayuki and Jabeen, Gul and Zhang, Yongjie Jessica and Zhang, Xiaopeng and Kato, Hirokazu},
+    journal={IEEE Transactions on Visualization and Computer Graphics}, 
+    title={Surface Remeshing: A Systematic Literature Review of Methods and Research Directions}, 
+    year={2022}
+}
+```
+
+```bibtex
+@article{4487066,
+    author={Dietrich, Carlos A. and Scheidegger, Carlos E. and Schreiner, John and Comba, João L.D. and Nedel, Luciana P. and Silva, Cláudio T.},
+    journal={IEEE Transactions on Visualization and Computer Graphics}, 
+    title={Edge Transformations for Improving Mesh Quality of Marching Cubes}, 
+    year={2009}}
+```
+
 ## Blog Post
 - [Thinking Parallel, Part I: Collision Detection on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-i-collision-detection-gpu/)
 - [Thinking Parallel, Part II: Tree Traversal on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-ii-tree-traversal-gpu/)

{conquer3d-0.4.2 → conquer3d-0.4.5}/README.md

@@ -58,14 +58,7 @@ twine upload dist/* --verbose
     author = {Karras, Tero},
     title = {Maximizing parallelism in the construction of BVHs, octrees, and k-d trees},
     year = {2012},
-    isbn = {9783905674415},
-    publisher = {Eurographics Association},
-    address = {Goslar, DEU},
     booktitle = {Proceedings of the Fourth ACM SIGGRAPH / Eurographics Conference on High-Performance Graphics},
-    pages = {33–37},
-    numpages = {5},
-    location = {Paris, France},
-    series = {EGGH-HPG'12}
 }
 ```
 
@@ -74,18 +67,7 @@ twine upload dist/* --verbose
     author = {M\"{o}ller, Tomas},
     title = {A fast triangle-triangle intersection test},
     year = {1997},
-    issue_date = {1997},
-    publisher = {A. K. Peters, Ltd.},
-    address = {USA},
-    volume = {2},
-    number = {2},
-    issn = {1086-7651},
-    url = {https://doi.org/10.1080/10867651.1997.10487472},
-    doi = {10.1080/10867651.1997.10487472},
     journal = {J. Graph. Tools},
-    month = nov,
-    pages = {25–30},
-    numpages = {6}
 }
 ```
 
@@ -94,36 +76,36 @@ twine upload dist/* --verbose
     author = {M\"{o}ller, Tomas and Trumbore, Ben},
     title = {Fast, minimum storage ray/triangle intersection},
     year = {2005},
-    isbn = {9781450378338},
-    publisher = {Association for Computing Machinery},
-    address = {New York, NY, USA},
-    url = {https://doi.org/10.1145/1198555.1198746},
-    doi = {10.1145/1198555.1198746},
-    pages = {7–es},
-    keywords = {base transformation, intersection, ray tracing, ray/triangle-intersection},
-    location = {Los Angeles, California},
-    series = {SIGGRAPH '05}
+    booktitle = {ACM SIGGRAPH 2005 Courses},
 }
 ```
 
 ```bibtex
-@InProceedings{10.1007/978-3-662-05105-4_2,
-    author="Meyer, Mark
-    and Desbrun, Mathieu
-    and Schr{\"o}der, Peter
-    and Barr, Alan H.",
-    editor="Hege, Hans-Christian
-    and Polthier, Konrad",
+@inproceedings{10.1007/978-3-662-05105-4_2,
+    author="Meyer, Mark and Desbrun, Mathieu and Schr{\"o}der, Peter and Barr, Alan H.",
     title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
     booktitle="Visualization and Mathematics III",
-    year="2003",
-    publisher="Springer Berlin Heidelberg",
-    address="Berlin, Heidelberg",
-    pages="35--57",
-    isbn="978-3-662-05105-4"
+    year="2003"
 }
 ```
 
+```bibtex
+@article{9167456,
+    author={Khan, Dawar and Plopski, Alexander and Fujimoto, Yuichiro and Kanbara, Masayuki and Jabeen, Gul and Zhang, Yongjie Jessica and Zhang, Xiaopeng and Kato, Hirokazu},
+    journal={IEEE Transactions on Visualization and Computer Graphics}, 
+    title={Surface Remeshing: A Systematic Literature Review of Methods and Research Directions}, 
+    year={2022}
+}
+```
+
+```bibtex
+@article{4487066,
+    author={Dietrich, Carlos A. and Scheidegger, Carlos E. and Schreiner, John and Comba, João L.D. and Nedel, Luciana P. and Silva, Cláudio T.},
+    journal={IEEE Transactions on Visualization and Computer Graphics}, 
+    title={Edge Transformations for Improving Mesh Quality of Marching Cubes}, 
+    year={2009}}
+```
+
 ## Blog Post
 - [Thinking Parallel, Part I: Collision Detection on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-i-collision-detection-gpu/)
 - [Thinking Parallel, Part II: Tree Traversal on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-ii-tree-traversal-gpu/)

{conquer3d-0.4.2 → conquer3d-0.4.5}/conquer3d/csrc/binds/data_structure/triangle_mesh.cpp

@@ -104,6 +104,16 @@ torch::Tensor TriangleMesh::get_vertex_degrees()
     return this->vertex_degrees;
 }
 
+float TriangleMesh::get_valence_567_percentage()
+{
+    torch::Tensor degrees = this->get_vertex_degrees();
+    if (degrees.numel() == 0) return 0.0f;
+
+    torch::Tensor mask = (degrees == 5).logical_or(degrees == 6).logical_or(degrees == 7);
+    float count = mask.sum().item<float>();
+    return (count / degrees.numel()) * 100.0f;
+}
+
 void TriangleMesh::compute_vertex_lb_uniform()
 {
     if (this->vertex_lb_uniform.defined()) return;
@@ -491,6 +501,106 @@ torch::Tensor TriangleMesh::get_surface_area()
     return this->surface_area;
 }
 
+std::tuple<float, float> TriangleMesh::get_quality() {
+    if (this->num_triangles == 0) return std::make_tuple(0.0f, 0.0f);
+
+    auto options = torch::TensorOptions().dtype(torch::kFloat32).device(this->vertices.device());
+    torch::Tensor qualities = torch::empty({static_cast<int64_t>(this->num_triangles)}, options);
+
+    triangle_mesh::compute_quality(
+        this->num_triangles,
+        reinterpret_cast<const float3*>(this->vertices.data_ptr<float>()),
+        reinterpret_cast<const int3*>(this->triangles.data_ptr<int>()),
+        reinterpret_cast<float*>(qualities.data_ptr<float>())
+    );
+    
+    float min_q = qualities.min().item<float>();
+    float avg_q = qualities.mean().item<float>();
+    
+    return std::make_tuple(min_q, avg_q);
+}
+
+torch::Tensor TriangleMesh::get_aspect_ratio(int mode) {
+    auto options = torch::TensorOptions().dtype(torch::kFloat32).device(this->vertices.device());
+    torch::Tensor ar = torch::empty({static_cast<int64_t>(this->num_triangles)}, options);
+    
+    if (this->num_triangles == 0) return ar;
+
+    triangle_mesh::compute_aspect_ratio(
+        this->num_triangles,
+        reinterpret_cast<const float3*>(this->vertices.data_ptr<float>()),
+        reinterpret_cast<const int3*>(this->triangles.data_ptr<int>()),
+        mode,
+        reinterpret_cast<float*>(ar.data_ptr<float>())
+    );
+    
+    return ar;
+}
+
+torch::Tensor TriangleMesh::get_radii_ratio() {
+    auto options = torch::TensorOptions().dtype(torch::kFloat32).device(this->vertices.device());
+    torch::Tensor ratios = torch::empty({static_cast<int64_t>(this->num_triangles)}, options);
+    
+    if (this->num_triangles == 0) return ratios;
+
+    triangle_mesh::compute_radii_ratio(
+        this->num_triangles,
+        reinterpret_cast<const float3*>(this->vertices.data_ptr<float>()),
+        reinterpret_cast<const int3*>(this->triangles.data_ptr<int>()),
+        reinterpret_cast<float*>(ratios.data_ptr<float>())
+    );
+    
+    return ratios;
+}
+
+torch::Tensor TriangleMesh::get_triangle_regularity() {
+    auto options = torch::TensorOptions().dtype(torch::kFloat32).device(this->vertices.device());
+    torch::Tensor regularities = torch::empty({static_cast<int64_t>(this->num_triangles)}, options);
+    
+    if (this->num_triangles == 0) return regularities;
+
+    triangle_mesh::compute_triangle_regularity(
+        this->num_triangles,
+        reinterpret_cast<const float3*>(this->vertices.data_ptr<float>()),
+        reinterpret_cast<const int3*>(this->triangles.data_ptr<int>()),
+        reinterpret_cast<float*>(regularities.data_ptr<float>())
+    );
+    
+    return regularities;
+}
+
+torch::Tensor TriangleMesh::get_radius_edge_ratio() {
+    auto options = torch::TensorOptions().dtype(torch::kFloat32).device(this->vertices.device());
+    torch::Tensor ratios = torch::empty({static_cast<int64_t>(this->num_triangles)}, options);
+    
+    if (this->num_triangles == 0) return ratios;
+
+    triangle_mesh::compute_radius_edge_ratio(
+        this->num_triangles,
+        reinterpret_cast<const float3*>(this->vertices.data_ptr<float>()),
+        reinterpret_cast<const int3*>(this->triangles.data_ptr<int>()),
+        reinterpret_cast<float*>(ratios.data_ptr<float>())
+    );
+    
+    return ratios;
+}
+
+torch::Tensor TriangleMesh::get_angle_deviation() {
+    auto options = torch::TensorOptions().dtype(torch::kFloat32).device(this->vertices.device());
+    torch::Tensor deviations = torch::empty({static_cast<int64_t>(this->num_triangles)}, options);
+    
+    if (this->num_triangles == 0) return deviations;
+
+    triangle_mesh::compute_angle_deviation(
+        this->num_triangles,
+        reinterpret_cast<const float3*>(this->vertices.data_ptr<float>()),
+        reinterpret_cast<const int3*>(this->triangles.data_ptr<int>()),
+        reinterpret_cast<float*>(deviations.data_ptr<float>())
+    );
+    
+    return deviations;
+}
+
 void TriangleMesh::compute_edges_to_triangle_map()
 {
     if (this->num_triangles == 0)
@@ -763,6 +873,12 @@ void bind_ds_triangle_mesh(py::module_ &m)
         Returns:
             torch.Tensor - Shape (N,) int32 tensor of vertex degrees.
         )doc")
+        .def_property_readonly("valence_567_percentage", &TriangleMesh::get_valence_567_percentage, R"doc(
+        Percentage of vertices whose degrees (valences) are 5, 6, or 7.
+
+        Returns:
+            float - Percentage in range [0, 100].
+        )doc")
         .def_property_readonly("vertex_lb_uniform", &TriangleMesh::get_vertex_lb_uniform, R"doc(
         Uniform Laplace-Beltrami operator evaluated at each vertex.
 
@@ -793,6 +909,45 @@ void bind_ds_triangle_mesh(py::module_ &m)
         Returns:
             torch.Tensor - Total surface area of the mesh.
         )doc")
+        .def("get_quality", &TriangleMesh::get_quality, R"doc(
+        Compute the global quality of the mesh.
+
+        Returns:
+            Tuple[float, float] - Minimum and average triangle quality.
+        )doc")
+        .def("get_aspect_ratio", &TriangleMesh::get_aspect_ratio, py::arg("mode"), R"doc(
+        Compute aspect ratio for all triangles.
+
+        Args:
+            mode (int): The formula mode to use.
+
+        Returns:
+            torch.Tensor - Shape (M,) float32 tensor of triangle aspect ratios.
+        )doc")
+        .def("get_radii_ratio", &TriangleMesh::get_radii_ratio, R"doc(
+        Compute the radii ratio (incircle / circumcircle) for all triangles.
+
+        Returns:
+            torch.Tensor - Shape (M,) float32 tensor of triangle radii ratios.
+        )doc")
+        .def("get_triangle_regularity", &TriangleMesh::get_triangle_regularity, R"doc(
+        Compute the triangle regularity (2 * sqrt(3) * r / l) for all triangles.
+
+        Returns:
+            torch.Tensor - Shape (M,) float32 tensor of triangle regularities.
+        )doc")
+        .def("get_radius_edge_ratio", &TriangleMesh::get_radius_edge_ratio, R"doc(
+        Compute the radius edge ratio (R / e) for all triangles.
+
+        Returns:
+            torch.Tensor - Shape (M,) float32 tensor of triangle radius edge ratios.
+        )doc")
+        .def("get_angle_deviation", &TriangleMesh::get_angle_deviation, R"doc(
+        Compute the mean angle deviation from 60 degrees for all triangles.
+
+        Returns:
+            torch.Tensor - Shape (M,) float32 tensor of triangle angle deviations.
+        )doc")
         .def_property_readonly("bvh", &TriangleMesh::build_bvh, R"doc(
         The Bounding Volume Hierarchy built for this mesh.
 

{conquer3d-0.4.2 → conquer3d-0.4.5}/conquer3d/csrc/data_structure/triangle_mesh.cu

@@ -46,6 +46,97 @@ namespace triangle_mesh
         }
     }
 
+    __global__ void compute_quality_kernel(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ qualities)
+    {
+        uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx < num_triangles)
+        {
+            int3 tri = triangles[idx];
+            Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
+            qualities[idx] = T.compute_quality();
+        }
+    }
+
+    __global__ void compute_aspect_ratio_kernel(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        int mode,
+        float *__restrict__ aspect_ratios)
+    {
+        uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx < num_triangles)
+        {
+            int3 tri = triangles[idx];
+            Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
+            aspect_ratios[idx] = T.compute_ar(mode);
+        }
+    }
+
+    __global__ void compute_radii_ratio_kernel(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ ratios)
+    {
+        uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx < num_triangles)
+        {
+            int3 tri = triangles[idx];
+            Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
+            ratios[idx] = T.compute_radii_ratio();
+        }
+    }
+
+    __global__ void compute_triangle_regularity_kernel(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ regularities)
+    {
+        uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx < num_triangles)
+        {
+            int3 tri = triangles[idx];
+            Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
+            regularities[idx] = T.compute_triangle_regularity();
+        }
+    }
+
+    __global__ void compute_radius_edge_ratio_kernel(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ ratios)
+    {
+        uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx < num_triangles)
+        {
+            int3 tri = triangles[idx];
+            Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
+            ratios[idx] = T.compute_radius_edge_ratio();
+        }
+    }
+
+    __global__ void compute_angle_deviation_kernel(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ deviations)
+    {
+        uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (idx < num_triangles)
+        {
+            int3 tri = triangles[idx];
+            Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
+            deviations[idx] = T.compute_angle_deviation();
+        }
+    }
+
     __global__ void compute_triangle_aabbs_kernel(
         const uint32_t num_triangles,
         const float3 *__restrict__ vertices,
@@ -95,6 +186,97 @@ namespace triangle_mesh
             num_triangles, vertices, triangles, triangle_areas);
     }
 
+    __host__ void compute_quality(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ qualities)
+    {
+        if (num_triangles == 0) return;
+        
+        int threads = NTHREADS;
+        int blocks = (num_triangles + threads - 1) / threads;
+        
+        compute_quality_kernel<<<blocks, threads>>>(
+            num_triangles, vertices, triangles, qualities);
+    }
+
+    __host__ void compute_aspect_ratio(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        int mode,
+        float *__restrict__ aspect_ratios)
+    {
+        if (num_triangles == 0) return;
+        
+        int threads = NTHREADS;
+        int blocks = (num_triangles + threads - 1) / threads;
+        
+        compute_aspect_ratio_kernel<<<blocks, threads>>>(
+            num_triangles, vertices, triangles, mode, aspect_ratios);
+    }
+
+    __host__ void compute_radii_ratio(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ ratios)
+    {
+        if (num_triangles == 0) return;
+        
+        int threads = NTHREADS;
+        int blocks = (num_triangles + threads - 1) / threads;
+        
+        compute_radii_ratio_kernel<<<blocks, threads>>>(
+            num_triangles, vertices, triangles, ratios);
+    }
+
+    __host__ void compute_triangle_regularity(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ regularities)
+    {
+        if (num_triangles == 0) return;
+        
+        int threads = NTHREADS;
+        int blocks = (num_triangles + threads - 1) / threads;
+        
+        compute_triangle_regularity_kernel<<<blocks, threads>>>(
+            num_triangles, vertices, triangles, regularities);
+    }
+
+    __host__ void compute_radius_edge_ratio(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ ratios)
+    {
+        if (num_triangles == 0) return;
+        
+        int threads = NTHREADS;
+        int blocks = (num_triangles + threads - 1) / threads;
+        
+        compute_radius_edge_ratio_kernel<<<blocks, threads>>>(
+            num_triangles, vertices, triangles, ratios);
+    }
+
+    __host__ void compute_angle_deviation(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ deviations)
+    {
+        if (num_triangles == 0) return;
+        
+        int threads = NTHREADS;
+        int blocks = (num_triangles + threads - 1) / threads;
+        
+        compute_angle_deviation_kernel<<<blocks, threads>>>(
+            num_triangles, vertices, triangles, deviations);
+    }
+
     __host__ void compute_triangle_aabbs(
         const uint32_t num_triangles,
         const float3 *__restrict__ vertices,

{conquer3d-0.4.2 → conquer3d-0.4.5}/conquer3d/csrc/data_structure/triangle_mesh.h

@@ -70,6 +70,7 @@ public:
     
     void compute_vertex_degrees();
     torch::Tensor get_vertex_degrees();
+    float get_valence_567_percentage();
     
     void compute_vertex_lb_uniform();
     torch::Tensor get_vertex_lb_uniform();
@@ -140,6 +141,13 @@ public:
 
     int32_t get_euler_characteristic();
     int32_t get_genus();
+
+    std::tuple<float, float> get_quality();
+    torch::Tensor get_aspect_ratio(int mode);
+    torch::Tensor get_radii_ratio();
+    torch::Tensor get_triangle_regularity();
+    torch::Tensor get_radius_edge_ratio();
+    torch::Tensor get_angle_deviation();
 };
 
 namespace triangle_mesh
@@ -163,6 +171,43 @@ namespace triangle_mesh
         const int3 *__restrict__ triangles,
         float *__restrict__ triangle_areas);
 
+    __host__ void compute_quality(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ qualities);
+
+    __host__ void compute_aspect_ratio(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        int mode,
+        float *__restrict__ aspect_ratios);
+
+    __host__ void compute_radii_ratio(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ ratios);
+
+    __host__ void compute_triangle_regularity(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ regularities);
+
+    __host__ void compute_radius_edge_ratio(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ ratios);
+
+    __host__ void compute_angle_deviation(
+        const uint32_t num_triangles,
+        const float3 *__restrict__ vertices,
+        const int3 *__restrict__ triangles,
+        float *__restrict__ deviations);
+
     __host__ void compute_triangle_aabbs(
         const uint32_t num_triangles,
         const float3 *__restrict__ vertices,

{conquer3d-0.4.2 → conquer3d-0.4.5}/conquer3d/csrc/primitive/triangle.h

@@ -199,6 +199,97 @@ struct Triangle {
         return circumcenter;
     }
 
+    __host__ __device__ __forceinline__ float compute_quality() const {
+        float area = compute_area();
+        float3 e1 = v1 - v0;
+        float3 e2 = v2 - v1;
+        float3 e3 = v0 - v2;
+        float l1 = maths::norm(e1);
+        float l2 = maths::norm(e2);
+        float l3 = maths::norm(e3);
+        float l = fmaxf(fmaxf(l1, l2), l3);
+        float s = (l1 + l2 + l3) * 0.5f;
+        float q = (6 / sqrtf(3.0f)) * (area / (s * l));
+        return q;
+    }
+
+    __host__ __device__ __forceinline__ float compute_triangle_regularity() const {
+        float area = compute_area();
+        if (area <= 1e-8f) return 0.0f;
+        float3 e1 = v1 - v0;
+        float3 e2 = v2 - v1;
+        float3 e3 = v0 - v2;
+        float l1 = maths::norm(e1);
+        float l2 = maths::norm(e2);
+        float l3 = maths::norm(e3);
+        float s = (l1 + l2 + l3) * 0.5f;
+        float r = area / s;
+        float l = fmaxf(fmaxf(l1, l2), l3);
+        return (2.0f * sqrtf(3.0f) * r) / l;
+    }
+
+    __host__ __device__ __forceinline__ float compute_radius_edge_ratio() const {
+        float area = compute_area();
+        if (area <= 1e-8f) return 0.0f;
+        float3 e1 = v1 - v0;
+        float3 e2 = v2 - v1;
+        float3 e3 = v0 - v2;
+        float l1 = maths::norm(e1);
+        float l2 = maths::norm(e2);
+        float l3 = maths::norm(e3);
+        float R = (l1 * l2 * l3) / (4.0f * area);
+        float e = fminf(fminf(l1, l2), l3);
+        if (e <= 1e-8f) return 0.0f;
+        return R / e;
+    }
+
+    __host__ __device__ __forceinline__ float compute_angle_deviation() const {
+        float a0, a1, a2;
+        compute_angles(a0, a1, a2);
+        float opt = 1.0471975511965977f; // 60 degrees in radians (PI / 3)
+        return (fabsf(a0 - opt) + fabsf(a1 - opt) + fabsf(a2 - opt)) / 3.0f;
+    }
+
+    __host__ __device__ __forceinline__ float compute_radii_ratio() const {
+        float area = compute_area();
+        if (area <= 1e-8f) return 0.0f;
+        float3 e1 = v1 - v0;
+        float3 e2 = v2 - v1;
+        float3 e3 = v0 - v2;
+        float l1 = maths::norm(e1);
+        float l2 = maths::norm(e2);
+        float l3 = maths::norm(e3);
+        float s = (l1 + l2 + l3) * 0.5f;
+        float r = area / s;
+        float R = (l1 * l2 * l3) / (4.0f * area);
+        return r / R;
+    }
+
+    __host__ __device__ __forceinline__ float compute_ar(int mode) const {
+        float3 e1 = v1 - v0;
+        float3 e2 = v2 - v1;
+        float3 e3 = v0 - v2;
+        float l1 = maths::norm(e1);
+        float l2 = maths::norm(e2);
+        float l3 = maths::norm(e3);
+
+        if (mode == 0){
+            float area = compute_area();
+            float l = fmaxf(fmaxf(l1, l2), l3);
+            return (sqrtf(3.0f) * l * l) / (4.0f * area);
+        } else if (mode == 1){
+            float s = (l1 + l2 + l3) * 0.5f;
+            return (l1 * l2 * l3) / (8.0f * (s - l1) * (s - l2) * (s - l3));
+        } else if (mode == 2){
+            float area = compute_area();
+            return (l1 + l2 + l3) / (4.0f * area);
+        } else {
+            return 0.0f;
+        }
+    }
+
+    
+
     __host__ __device__ __forceinline__ bool test_point_on_tria_plane(const float3& p, float eps = 1e-5f) const {
         float3 n = compute_normal();
         float dist = fabsf(maths::dot(n, p - v0));

{conquer3d-0.4.2 → conquer3d-0.4.5/conquer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.4.2
+Version: 0.4.5
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -88,14 +88,7 @@ twine upload dist/* --verbose
     author = {Karras, Tero},
     title = {Maximizing parallelism in the construction of BVHs, octrees, and k-d trees},
     year = {2012},
-    isbn = {9783905674415},
-    publisher = {Eurographics Association},
-    address = {Goslar, DEU},
     booktitle = {Proceedings of the Fourth ACM SIGGRAPH / Eurographics Conference on High-Performance Graphics},
-    pages = {33–37},
-    numpages = {5},
-    location = {Paris, France},
-    series = {EGGH-HPG'12}
 }
 ```
 
@@ -104,18 +97,7 @@ twine upload dist/* --verbose
     author = {M\"{o}ller, Tomas},
     title = {A fast triangle-triangle intersection test},
     year = {1997},
-    issue_date = {1997},
-    publisher = {A. K. Peters, Ltd.},
-    address = {USA},
-    volume = {2},
-    number = {2},
-    issn = {1086-7651},
-    url = {https://doi.org/10.1080/10867651.1997.10487472},
-    doi = {10.1080/10867651.1997.10487472},
     journal = {J. Graph. Tools},
-    month = nov,
-    pages = {25–30},
-    numpages = {6}
 }
 ```
 
@@ -124,36 +106,36 @@ twine upload dist/* --verbose
     author = {M\"{o}ller, Tomas and Trumbore, Ben},
     title = {Fast, minimum storage ray/triangle intersection},
     year = {2005},
-    isbn = {9781450378338},
-    publisher = {Association for Computing Machinery},
-    address = {New York, NY, USA},
-    url = {https://doi.org/10.1145/1198555.1198746},
-    doi = {10.1145/1198555.1198746},
-    pages = {7–es},
-    keywords = {base transformation, intersection, ray tracing, ray/triangle-intersection},
-    location = {Los Angeles, California},
-    series = {SIGGRAPH '05}
+    booktitle = {ACM SIGGRAPH 2005 Courses},
 }
 ```
 
 ```bibtex
-@InProceedings{10.1007/978-3-662-05105-4_2,
-    author="Meyer, Mark
-    and Desbrun, Mathieu
-    and Schr{\"o}der, Peter
-    and Barr, Alan H.",
-    editor="Hege, Hans-Christian
-    and Polthier, Konrad",
+@inproceedings{10.1007/978-3-662-05105-4_2,
+    author="Meyer, Mark and Desbrun, Mathieu and Schr{\"o}der, Peter and Barr, Alan H.",
     title="Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
     booktitle="Visualization and Mathematics III",
-    year="2003",
-    publisher="Springer Berlin Heidelberg",
-    address="Berlin, Heidelberg",
-    pages="35--57",
-    isbn="978-3-662-05105-4"
+    year="2003"
 }
 ```
 
+```bibtex
+@article{9167456,
+    author={Khan, Dawar and Plopski, Alexander and Fujimoto, Yuichiro and Kanbara, Masayuki and Jabeen, Gul and Zhang, Yongjie Jessica and Zhang, Xiaopeng and Kato, Hirokazu},
+    journal={IEEE Transactions on Visualization and Computer Graphics}, 
+    title={Surface Remeshing: A Systematic Literature Review of Methods and Research Directions}, 
+    year={2022}
+}
+```
+
+```bibtex
+@article{4487066,
+    author={Dietrich, Carlos A. and Scheidegger, Carlos E. and Schreiner, John and Comba, João L.D. and Nedel, Luciana P. and Silva, Cláudio T.},
+    journal={IEEE Transactions on Visualization and Computer Graphics}, 
+    title={Edge Transformations for Improving Mesh Quality of Marching Cubes}, 
+    year={2009}}
+```
+
 ## Blog Post
 - [Thinking Parallel, Part I: Collision Detection on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-i-collision-detection-gpu/)
 - [Thinking Parallel, Part II: Tree Traversal on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-ii-tree-traversal-gpu/)

{conquer3d-0.4.2 → conquer3d-0.4.5}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conquer3d"
-version = "0.4.2"
+version = "0.4.5"
 description = "Geometric Cuda Tool Box"
 readme = "README.md"
 license = "MIT"