mesh2sdf2 2.1.1__tar.gz

mesh2sdf2-2.1.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2022 Peng-Shuai Wang <wangps@hotmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

mesh2sdf2-2.1.1/MANIFEST.in

@@ -0,0 +1 @@
+graft csrc

mesh2sdf2-2.1.1/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: mesh2sdf2
+Version: 2.1.1
+Summary: Compute the signed distance field from an input mesh
+Author-email: Lucas Mosquera <25126199+LuckJMG@users.noreply.github.com>, Peng-Shuai Wang <wangps@hotmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/LuckJMG/mesh2sdf2
+Project-URL: Source, https://github.com/LuckJMG/mesh2sdf2
+Project-URL: Issues, https://github.com/LuckJMG/mesh2sdf2/issues
+Project-URL: Upstream, https://github.com/wang-ps/mesh2sdf
+Keywords: sdf,mesh,signed-distance-field,pybind11,3d
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: trimesh
+Requires-Dist: scikit-image
+Dynamic: license-file
+
+# Mesh2SDF2
+
+[![Downloads](https://static.pepy.tech/badge/mesh2sdf2)](https://pepy.tech/project/mesh2sdf2)
+[![Downloads](https://static.pepy.tech/badge/mesh2sdf2/month)](https://pepy.tech/project/mesh2sdf2/month)
+[![PyPI](https://img.shields.io/pypi/v/mesh2sdf2)](https://pypi.org/project/mesh2sdf2/)
+
+
+> **This is a community-maintained fork** of
+> [mesh2sdf](https://github.com/wang-ps/mesh2sdf) by Peng-Shuai Wang. It adds
+> Python 3.10–3.14 support, modernizes the build (setuptools ≥68,
+> pybind11 ≥2.13), and improve the compute speed. Original project, paper, and algorithm: see the
+> [upstream repo](https://github.com/wang-ps/mesh2sdf). License: MIT.
+
+Converts an input mesh to a signed distance field. It can work with arbitrary
+meshes, even **non-watertight** meshes from ShapeNet.
+
+`mesh2sdf` is used in their paper
+[Dual Octree Graph Networks (SIGGRAPH 2022)](https://wang-ps.github.io/dualocnn)
+to generate the training data.
+Please cite their paper if you find the code useful for your research.
+
+
+## Installation
+
+`mesh2sdf2` depends on [pybind11](https://github.com/pybind/pybind11), and C++
+compilers are needed to build the code. Supported compilers are listed
+[here](https://github.com/pybind/pybind11#supported-compilers).
+
+- Install via the following command:
+    ``` shell
+    pip install mesh2sdf2
+    ```
+
+- Alternatively, install from the source code via the following commands.
+    ``` shell
+    git clone https://github.com/LuckJMG/mesh2sdf2.git
+    cd mesh2sdf2
+    pip install .
+    ```
+
+- Alternatively, install from the source code via the following commands.
+    ``` shell
+    git clone https://github.com/wang-ps/mesh2sdf.git
+    pip install ./mesh2sdf
+    ```
+
+## Example
+
+After installing `mesh2sdf`, run the following command to process an input mesh
+from ShapeNet:
+
+```shell
+python example/demo.py
+```
+
+![Example of a mesh from ShapeNet](https://raw.githubusercontent.com/wang-ps/mesh2sdf/master/example/data/result.png)
+
+
+## How does it work?
+
+- Given an input mesh, we first compute the **unsigned** distance field with the
+  fast sweeping algorithm implemented by
+  [Christopher Batty (SDFGen)](https://github.com/christopherbatty/SDFGen).
+  Note that the unsigned distance field can always be reliably and accurately
+  computed even though the input mesh is non-watertight.
+
+- Then we extract the level sets with a small value **d** with the marching cube
+  algorithm. The extracted level sets are represented with triangle meshes and
+  are guaranteed to be manifold.
+
+- There exist multiple connected components in the extracted meshes, and we only
+  keep the mesh with the largest bounding box.
+
+- Compute the signed distance field again with the kept triangle mesh as the
+  final output. In this way, the signed distance field (SDF) is computed for a
+  non-watertight input mesh.
+
+
+## Citation
+
+```
+@article {Wang-Sig2022,
+  title      = {Dual Octree Graph Networks for Learning Adaptive Volumetric
+                Shape Representations},
+  author     = {Wang, Peng-Shuai and Liu, Yang and Tong, Xin},
+  journal    = {ACM Transactions on Graphics (SIGGRAPH)},
+  volume     = {41},
+  number     = {4},
+  year       = {2022},
+}
+
+```

mesh2sdf2-2.1.1/README.md

@@ -0,0 +1,92 @@
+# Mesh2SDF2
+
+[![Downloads](https://static.pepy.tech/badge/mesh2sdf2)](https://pepy.tech/project/mesh2sdf2)
+[![Downloads](https://static.pepy.tech/badge/mesh2sdf2/month)](https://pepy.tech/project/mesh2sdf2/month)
+[![PyPI](https://img.shields.io/pypi/v/mesh2sdf2)](https://pypi.org/project/mesh2sdf2/)
+
+
+> **This is a community-maintained fork** of
+> [mesh2sdf](https://github.com/wang-ps/mesh2sdf) by Peng-Shuai Wang. It adds
+> Python 3.10–3.14 support, modernizes the build (setuptools ≥68,
+> pybind11 ≥2.13), and improve the compute speed. Original project, paper, and algorithm: see the
+> [upstream repo](https://github.com/wang-ps/mesh2sdf). License: MIT.
+
+Converts an input mesh to a signed distance field. It can work with arbitrary
+meshes, even **non-watertight** meshes from ShapeNet.
+
+`mesh2sdf` is used in their paper
+[Dual Octree Graph Networks (SIGGRAPH 2022)](https://wang-ps.github.io/dualocnn)
+to generate the training data.
+Please cite their paper if you find the code useful for your research.
+
+
+## Installation
+
+`mesh2sdf2` depends on [pybind11](https://github.com/pybind/pybind11), and C++
+compilers are needed to build the code. Supported compilers are listed
+[here](https://github.com/pybind/pybind11#supported-compilers).
+
+- Install via the following command:
+    ``` shell
+    pip install mesh2sdf2
+    ```
+
+- Alternatively, install from the source code via the following commands.
+    ``` shell
+    git clone https://github.com/LuckJMG/mesh2sdf2.git
+    cd mesh2sdf2
+    pip install .
+    ```
+
+- Alternatively, install from the source code via the following commands.
+    ``` shell
+    git clone https://github.com/wang-ps/mesh2sdf.git
+    pip install ./mesh2sdf
+    ```
+
+## Example
+
+After installing `mesh2sdf`, run the following command to process an input mesh
+from ShapeNet:
+
+```shell
+python example/demo.py
+```
+
+![Example of a mesh from ShapeNet](https://raw.githubusercontent.com/wang-ps/mesh2sdf/master/example/data/result.png)
+
+
+## How does it work?
+
+- Given an input mesh, we first compute the **unsigned** distance field with the
+  fast sweeping algorithm implemented by
+  [Christopher Batty (SDFGen)](https://github.com/christopherbatty/SDFGen).
+  Note that the unsigned distance field can always be reliably and accurately
+  computed even though the input mesh is non-watertight.
+
+- Then we extract the level sets with a small value **d** with the marching cube
+  algorithm. The extracted level sets are represented with triangle meshes and
+  are guaranteed to be manifold.
+
+- There exist multiple connected components in the extracted meshes, and we only
+  keep the mesh with the largest bounding box.
+
+- Compute the signed distance field again with the kept triangle mesh as the
+  final output. In this way, the signed distance field (SDF) is computed for a
+  non-watertight input mesh.
+
+
+## Citation
+
+```
+@article {Wang-Sig2022,
+  title      = {Dual Octree Graph Networks for Learning Adaptive Volumetric
+                Shape Representations},
+  author     = {Wang, Peng-Shuai and Liu, Yang and Tong, Xin},
+  journal    = {ACM Transactions on Graphics (SIGGRAPH)},
+  volume     = {41},
+  number     = {4},
+  year       = {2022},
+}
+
+```

mesh2sdf2-2.1.1/csrc/array3.h

@@ -0,0 +1,67 @@
+#ifndef ARRAY3_H
+#define ARRAY3_H
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <vector>
+
+template <class T> struct Array3 {
+	int ni, nj, nk;
+	std::vector<T> a;
+
+	Array3(void) : ni(0), nj(0), nk(0) {}
+
+	Array3(int ni_, int nj_, int nk_)
+		: ni(ni_), nj(nj_), nk(nk_), a(static_cast<size_t>(ni_) * nj_ * nk_) {
+		assert(ni_ >= 0 && nj_ >= 0 && nk_ >= 0);
+	}
+
+	Array3(int ni_, int nj_, int nk_, const T &value)
+		: ni(ni_), nj(nj_), nk(nk_),
+		  a(static_cast<size_t>(ni_) * nj_ * nk_, value) {
+		assert(ni_ >= 0 && nj_ >= 0 && nk_ >= 0);
+	}
+
+	inline size_t index(int i, int j, int k) const {
+		return static_cast<size_t>(i) +
+			   static_cast<size_t>(ni) *
+				   (static_cast<size_t>(j) +
+					static_cast<size_t>(nj) * static_cast<size_t>(k));
+	}
+
+	const T &operator()(int i, int j, int k) const {
+		assert(i >= 0 && i < ni && j >= 0 && j < nj && k >= 0 && k < nk);
+		return a[index(i, j, k)];
+	}
+
+	T &operator()(int i, int j, int k) {
+		assert(i >= 0 && i < ni && j >= 0 && j < nj && k >= 0 && k < nk);
+		return a[index(i, j, k)];
+	}
+
+	void assign(const T &value) { std::fill(a.begin(), a.end(), value); }
+
+	void resize(int ni_, int nj_, int nk_) {
+		assert(ni_ >= 0 && nj_ >= 0 && nk_ >= 0);
+		ni = ni_;
+		nj = nj_;
+		nk = nk_;
+		a.resize(static_cast<size_t>(ni) * nj * nk);
+	}
+
+	void resize(int ni_, int nj_, int nk_, const T &value) {
+		assert(ni_ >= 0 && nj_ >= 0 && nk_ >= 0);
+		ni = ni_;
+		nj = nj_;
+		nk = nk_;
+		a.assign(static_cast<size_t>(ni) * nj * nk, value);
+	}
+
+	size_t size(void) const { return a.size(); }
+};
+
+typedef Array3<float> Array3f;
+typedef Array3<int> Array3i;
+
+#endif