mesh2sdf2 2.2.0__tar.gz → 2.3.0__tar.gz

mesh2sdf2-2.3.0/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: mesh2sdf2
+Version: 2.3.0
+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
+
+[![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/)
+
+# mesh2sdf2
+
+Repository: <https://github.com/LuckJMG/mesh2sdf2>. Maintainer: Lucas Mosquera.
+
+mesh2sdf2 is a community-maintained fork of [mesh2sdf](https://github.com/wang-ps/mesh2sdf) by Peng-Shuai Wang. The fork keeps the algorithm and the public API of the original project, so the import name is still `mesh2sdf`.
+
+## Project description
+
+With mesh2sdf2 you can convert a triangle mesh to a signed distance field (SDF) on a regular grid. The library also works with **non-watertight** meshes, such as the meshes of ShapeNet, since it repairs the surface before it computes the sign.
+
+Compared with the original project, mesh2sdf2 supports Python 3.10 to 3.14, builds with current versions of setuptools and pybind11, and computes the SDF about 26 times faster on a 12-thread CPU.
+
+![Example of a mesh from ShapeNet](https://raw.githubusercontent.com/wang-ps/mesh2sdf/master/example/data/result.png)
+
+## Who this project is for
+
+This project is for researchers and developers who need signed distance fields from 3D meshes, for example to generate training data for 3D deep learning. The original mesh2sdf generated the training data of the paper [Dual Octree Graph Networks (SIGGRAPH 2022)](https://wang-ps.github.io/dualocnn).
+
+## Project dependencies
+
+Before you use mesh2sdf2, make sure that you have:
+
+- Python 3.10 or later.
+- A C++ compiler that [pybind11 supports](https://github.com/pybind/pybind11#supported-compilers), if no wheel exists for your platform or you install from source.
+
+pip installs the Python dependencies (NumPy, trimesh, and scikit-image) automatically.
+
+## Instructions for using mesh2sdf2
+
+Get started with mesh2sdf2 by installing it from PyPI.
+
+### Install mesh2sdf2
+
+1. Install the package from PyPI.
+
+    ```shell
+    pip install mesh2sdf2
+    ```
+
+2. Alternatively, install it from the source code.
+
+    ```shell
+    git clone https://github.com/LuckJMG/mesh2sdf2.git
+    cd mesh2sdf2
+    pip install .
+    ```
+
+### Run mesh2sdf2
+
+1. Scale the vertices of your mesh to the range `[-1, 1]` and call `mesh2sdf.compute`.
+
+    ```python
+    import trimesh
+    import mesh2sdf
+
+    mesh = trimesh.creation.icosphere(radius=0.8)
+    size = 128
+    sdf = mesh2sdf.compute(mesh.vertices, mesh.faces, size, fix=True, level=2 / size)
+    print(sdf.shape)  # (128, 128, 128)
+    ```
+
+2. To process the example mesh of the repository, run the demo script from the repository root.
+
+    ```shell
+    python example/demo.py
+    ```
+
+    The script writes `example/data/plane.fixed.obj` with the repaired mesh and `example/data/plane.npy` with the SDF. To process another mesh, pass its path, for example `python example/demo.py path/to/mesh.obj`.
+
+The signature of the function is `mesh2sdf.compute(vertices, faces, size=128, fix=False, level=0.015, return_mesh=False)`.
+
+| Parameter | Description |
+|---|---|
+| `vertices` | Array of shape `(N, 3)`. The values must be in the range `[-1, 1]`. |
+| `faces` | Array of shape `(M, 3)` with the vertex indices of each triangle. |
+| `size` | Resolution of the grid. The grid has `size` samples per axis and spans `[-1, 1]`, both ends included. |
+| `fix` | If `True`, repairs the mesh before it computes the sign. Use it for non-watertight meshes. |
+| `level` | Level-set value for the repair. The recommended value is `2 / size`. |
+| `return_mesh` | If `True`, also returns the repaired mesh as a `trimesh.Trimesh`. |
+
+The function returns a `float32` array of shape `(size, size, size)`.
+
+### Troubleshoot mesh2sdf2
+
+| Issue | Solution |
+|---|---|
+| The SDF has wrong values and no error appears. | Scale the vertices to the range `[-1, 1]`, since the function does not check the range. |
+| The sign of the SDF is wrong on an open mesh. | Call `compute` with `fix=True`. |
+| `compute` raises `ValueError`. | Use a `size` of 2 or more. |
+| `pip install` fails while it builds the extension. | Install a C++ compiler that pybind11 supports. |
+
+## Performance
+
+mesh2sdf2 2.3.0 computes the SDF about **26x faster** than the original mesh2sdf 1.1.0 on a 12-thread CPU, and about 5.6x faster on one thread. Both numbers are the geometric mean over five workloads, which are the four in the next table and a cube with `size=64`. Each time is the median of 3 runs with Python 3.14.
+
+| Workload | mesh2sdf 1.1.0 | 2.3.0, 12 threads | 2.3.0, 1 thread |
+|---|---|---|---|
+| cube | 6066 ms | 116 ms (52.5x) | 402 ms (15.1x) |
+| plane | 7245 ms | 277 ms (26.2x) | 1195 ms (6.1x) |
+| icosphere, 5k triangles | 7442 ms | 405 ms (18.4x) | 2815 ms (2.6x) |
+| icosphere, 20k triangles | 9040 ms | 634 ms (14.3x) | 4626 ms (2.0x) |
+
+The next table gives the cumulative gain of each improvement on the cube, with `size=128` and 12 threads.
+
+| Stage | Time | Speedup |
+|---|---|---|
+| mesh2sdf 1.1.0 | 6066 ms | 1.00x |
+| cache triangle distance data | 4011 ms | 1.51x |
+| wavefront parallel sweep | 1321 ms | 4.59x |
+| Orthodox C++ port | 1167 ms | 5.20x |
+| geometry and parallel split (2.2.0) | 1077 ms | 5.63x |
+| skip repeated distances, row wavefront (2.3.0) | 116 ms | 52.5x |
+
+The C++ core releases the Python global interpreter lock (GIL), so several Python threads can call `compute` at the same time. With `OMP_NUM_THREADS=1`, four Python threads that each process the cube finish 57x faster than with the original project, from 24.3 s to 0.43 s. The release of the GIL gives 4x of that gain. In 2.2.0, the sweep took almost all the time, so the parallel sign, memcpy, and parallel init steps gave no measurable gain on these meshes.
+
+To reproduce the numbers, run `just bench-versions`. The run takes about 30 minutes, and the speedup depends on the number of CPU cores.
+
+## How it works
+
+1. mesh2sdf2 computes the **unsigned** distance field with the fast sweeping algorithm of [SDFGen](https://github.com/christopherbatty/SDFGen) by Christopher Batty. This step is accurate even for non-watertight meshes, since the unsigned distance does not depend on the inside or the outside of the surface.
+2. If `fix=True`, the marching cubes algorithm extracts the level set at the small value `level`. The result is a manifold triangle mesh.
+3. The extracted mesh can have several connected components, so mesh2sdf2 keeps the component with the largest bounding box.
+4. mesh2sdf2 computes the signed distance field again on the kept mesh and returns it as the final output.
+
+## Contributing guidelines
+
+To report a bug or propose a change, open an issue or a pull request in the [GitHub repository](https://github.com/LuckJMG/mesh2sdf2).
+
+## Additional documentation
+
+For more information:
+
+- [Original mesh2sdf repository](https://github.com/wang-ps/mesh2sdf), with the paper and the algorithm.
+- [Dual Octree Graph Networks](https://wang-ps.github.io/dualocnn), the project page of the paper that uses mesh2sdf.
+- [SDFGen](https://github.com/christopherbatty/SDFGen), the source of the fast sweeping algorithm.
+
+## How to get help
+
+- [GitHub issues](https://github.com/LuckJMG/mesh2sdf2/issues), for bugs and questions about the fork.
+
+## Citation
+
+If you use the code in your research, please cite the paper of the original authors.
+
+```bibtex
+@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},
+}
+```
+
+## Terms of use
+
+mesh2sdf2 is licensed under the MIT License. See [LICENSE](LICENSE).

mesh2sdf2-2.3.0/README.md

@@ -0,0 +1,161 @@
+[![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/)
+
+# mesh2sdf2
+
+Repository: <https://github.com/LuckJMG/mesh2sdf2>. Maintainer: Lucas Mosquera.
+
+mesh2sdf2 is a community-maintained fork of [mesh2sdf](https://github.com/wang-ps/mesh2sdf) by Peng-Shuai Wang. The fork keeps the algorithm and the public API of the original project, so the import name is still `mesh2sdf`.
+
+## Project description
+
+With mesh2sdf2 you can convert a triangle mesh to a signed distance field (SDF) on a regular grid. The library also works with **non-watertight** meshes, such as the meshes of ShapeNet, since it repairs the surface before it computes the sign.
+
+Compared with the original project, mesh2sdf2 supports Python 3.10 to 3.14, builds with current versions of setuptools and pybind11, and computes the SDF about 26 times faster on a 12-thread CPU.
+
+![Example of a mesh from ShapeNet](https://raw.githubusercontent.com/wang-ps/mesh2sdf/master/example/data/result.png)
+
+## Who this project is for
+
+This project is for researchers and developers who need signed distance fields from 3D meshes, for example to generate training data for 3D deep learning. The original mesh2sdf generated the training data of the paper [Dual Octree Graph Networks (SIGGRAPH 2022)](https://wang-ps.github.io/dualocnn).
+
+## Project dependencies
+
+Before you use mesh2sdf2, make sure that you have:
+
+- Python 3.10 or later.
+- A C++ compiler that [pybind11 supports](https://github.com/pybind/pybind11#supported-compilers), if no wheel exists for your platform or you install from source.
+
+pip installs the Python dependencies (NumPy, trimesh, and scikit-image) automatically.
+
+## Instructions for using mesh2sdf2
+
+Get started with mesh2sdf2 by installing it from PyPI.
+
+### Install mesh2sdf2
+
+1. Install the package from PyPI.
+
+    ```shell
+    pip install mesh2sdf2
+    ```
+
+2. Alternatively, install it from the source code.
+
+    ```shell
+    git clone https://github.com/LuckJMG/mesh2sdf2.git
+    cd mesh2sdf2
+    pip install .
+    ```
+
+### Run mesh2sdf2
+
+1. Scale the vertices of your mesh to the range `[-1, 1]` and call `mesh2sdf.compute`.
+
+    ```python
+    import trimesh
+    import mesh2sdf
+
+    mesh = trimesh.creation.icosphere(radius=0.8)
+    size = 128
+    sdf = mesh2sdf.compute(mesh.vertices, mesh.faces, size, fix=True, level=2 / size)
+    print(sdf.shape)  # (128, 128, 128)
+    ```
+
+2. To process the example mesh of the repository, run the demo script from the repository root.
+
+    ```shell
+    python example/demo.py
+    ```
+
+    The script writes `example/data/plane.fixed.obj` with the repaired mesh and `example/data/plane.npy` with the SDF. To process another mesh, pass its path, for example `python example/demo.py path/to/mesh.obj`.
+
+The signature of the function is `mesh2sdf.compute(vertices, faces, size=128, fix=False, level=0.015, return_mesh=False)`.
+
+| Parameter | Description |
+|---|---|
+| `vertices` | Array of shape `(N, 3)`. The values must be in the range `[-1, 1]`. |
+| `faces` | Array of shape `(M, 3)` with the vertex indices of each triangle. |
+| `size` | Resolution of the grid. The grid has `size` samples per axis and spans `[-1, 1]`, both ends included. |
+| `fix` | If `True`, repairs the mesh before it computes the sign. Use it for non-watertight meshes. |
+| `level` | Level-set value for the repair. The recommended value is `2 / size`. |
+| `return_mesh` | If `True`, also returns the repaired mesh as a `trimesh.Trimesh`. |
+
+The function returns a `float32` array of shape `(size, size, size)`.
+
+### Troubleshoot mesh2sdf2
+
+| Issue | Solution |
+|---|---|
+| The SDF has wrong values and no error appears. | Scale the vertices to the range `[-1, 1]`, since the function does not check the range. |
+| The sign of the SDF is wrong on an open mesh. | Call `compute` with `fix=True`. |
+| `compute` raises `ValueError`. | Use a `size` of 2 or more. |
+| `pip install` fails while it builds the extension. | Install a C++ compiler that pybind11 supports. |
+
+## Performance
+
+mesh2sdf2 2.3.0 computes the SDF about **26x faster** than the original mesh2sdf 1.1.0 on a 12-thread CPU, and about 5.6x faster on one thread. Both numbers are the geometric mean over five workloads, which are the four in the next table and a cube with `size=64`. Each time is the median of 3 runs with Python 3.14.
+
+| Workload | mesh2sdf 1.1.0 | 2.3.0, 12 threads | 2.3.0, 1 thread |
+|---|---|---|---|
+| cube | 6066 ms | 116 ms (52.5x) | 402 ms (15.1x) |
+| plane | 7245 ms | 277 ms (26.2x) | 1195 ms (6.1x) |
+| icosphere, 5k triangles | 7442 ms | 405 ms (18.4x) | 2815 ms (2.6x) |
+| icosphere, 20k triangles | 9040 ms | 634 ms (14.3x) | 4626 ms (2.0x) |
+
+The next table gives the cumulative gain of each improvement on the cube, with `size=128` and 12 threads.
+
+| Stage | Time | Speedup |
+|---|---|---|
+| mesh2sdf 1.1.0 | 6066 ms | 1.00x |
+| cache triangle distance data | 4011 ms | 1.51x |
+| wavefront parallel sweep | 1321 ms | 4.59x |
+| Orthodox C++ port | 1167 ms | 5.20x |
+| geometry and parallel split (2.2.0) | 1077 ms | 5.63x |
+| skip repeated distances, row wavefront (2.3.0) | 116 ms | 52.5x |
+
+The C++ core releases the Python global interpreter lock (GIL), so several Python threads can call `compute` at the same time. With `OMP_NUM_THREADS=1`, four Python threads that each process the cube finish 57x faster than with the original project, from 24.3 s to 0.43 s. The release of the GIL gives 4x of that gain. In 2.2.0, the sweep took almost all the time, so the parallel sign, memcpy, and parallel init steps gave no measurable gain on these meshes.
+
+To reproduce the numbers, run `just bench-versions`. The run takes about 30 minutes, and the speedup depends on the number of CPU cores.
+
+## How it works
+
+1. mesh2sdf2 computes the **unsigned** distance field with the fast sweeping algorithm of [SDFGen](https://github.com/christopherbatty/SDFGen) by Christopher Batty. This step is accurate even for non-watertight meshes, since the unsigned distance does not depend on the inside or the outside of the surface.
+2. If `fix=True`, the marching cubes algorithm extracts the level set at the small value `level`. The result is a manifold triangle mesh.
+3. The extracted mesh can have several connected components, so mesh2sdf2 keeps the component with the largest bounding box.
+4. mesh2sdf2 computes the signed distance field again on the kept mesh and returns it as the final output.
+
+## Contributing guidelines
+
+To report a bug or propose a change, open an issue or a pull request in the [GitHub repository](https://github.com/LuckJMG/mesh2sdf2).
+
+## Additional documentation
+
+For more information:
+
+- [Original mesh2sdf repository](https://github.com/wang-ps/mesh2sdf), with the paper and the algorithm.
+- [Dual Octree Graph Networks](https://wang-ps.github.io/dualocnn), the project page of the paper that uses mesh2sdf.
+- [SDFGen](https://github.com/christopherbatty/SDFGen), the source of the fast sweeping algorithm.
+
+## How to get help
+
+- [GitHub issues](https://github.com/LuckJMG/mesh2sdf2/issues), for bugs and questions about the fork.
+
+## Citation
+
+If you use the code in your research, please cite the paper of the original authors.
+
+```bibtex
+@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},
+}
+```
+
+## Terms of use
+
+mesh2sdf2 is licensed under the MIT License. See [LICENSE](LICENSE).

{mesh2sdf2-2.2.0 → mesh2sdf2-2.3.0}/csrc/array3.h

@@ -16,21 +16,6 @@ template <class T> struct Array3 {
 		storage = NULL;
 	}
 
-	Array3(int ni_, int nj_, int nk_) {
-		assert(ni_ >= 0 && nj_ >= 0 && nk_ >= 0);
-
-		ni = ni_;
-		nj = nj_;
-		nk = nk_;
-		storage = NULL;
-
-		size_t n = (size_t)ni_ * nj_ * nk_;
-		if (n > 0) {
-			storage = (T *)malloc(n * sizeof(T));
-			assert(storage != NULL);
-		}
-	}
-
 	Array3(int ni_, int nj_, int nk_, const T &value) {
 		assert(ni_ >= 0 && nj_ >= 0 && nk_ >= 0);
 
@@ -54,49 +39,19 @@ template <class T> struct Array3 {
 	Array3(const Array3 &) = delete;
 	Array3 &operator=(const Array3 &) = delete;
 
-	Array3(Array3 &&o) noexcept {
-		ni = o.ni;
-		nj = o.nj;
-		nk = o.nk;
-		storage = o.storage;
-
-		o.ni = 0;
-		o.nj = 0;
-		o.nk = 0;
-		o.storage = NULL;
-	}
-
-	Array3 &operator=(Array3 &&o) noexcept {
-		if (this != &o) {
-			free(storage);
-
-			ni = o.ni;
-			nj = o.nj;
-			nk = o.nk;
-			storage = o.storage;
-
-			o.ni = 0;
-			o.nj = 0;
-			o.nk = 0;
-			o.storage = NULL;
-		}
-
-		return *this;
-	}
-
 	inline size_t index(int i, int j, int k) const {
 		return (size_t)i + (size_t)ni * ((size_t)j + (size_t)nj * (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);
-		// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+		// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-security.ArrayBound)
 		return storage[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);
-		// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+		// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn,clang-analyzer-security.ArrayBound)
 		return storage[index(i, j, k)];
 	}
 

{mesh2sdf2-2.2.0 → mesh2sdf2-2.3.0}/csrc/geometry.h

@@ -2,7 +2,6 @@
 #define GEOMETRY_H
 
 #include <assert.h>
-#include <math.h>
 
 #include "vec.h"
 
@@ -18,6 +17,14 @@ struct TriangleData {
 	SegmentData edge12, edge13, edge23;
 };
 
+struct Grid {
+	Vec3f origin;
+	float dx;
+	int ni, nj, nk;
+};
+
+static constexpr int exact_band = 1;
+
 static inline int clamp_int(int v, int lo, int hi) {
 	if (v < lo) {
 		return lo;
@@ -28,8 +35,6 @@ static inline int clamp_int(int v, int lo, int hi) {
 	return v;
 }
 
-static inline float min_f(float a, float b) { return a < b ? a : b; }
-
 static inline double min3(double a, double b, double c) {
 	double m = a;
 	if (b < m) {
@@ -52,6 +57,25 @@ static inline double max3(double a, double b, double c) {
 	return m;
 }
 
+struct IndexRange {
+	int lo, hi;
+};
+
+// grid cells within exact_band of a triangle's extent [min(p,q,r), max(p,q,r)]
+static inline IndexRange band_range(double p, double q, double r, int n) {
+	IndexRange range = {
+		clamp_int((int)min3(p, q, r) - exact_band, 0, n - 1),
+		clamp_int((int)max3(p, q, r) + exact_band + 1, 0, n - 1)};
+	return range;
+}
+
+// grid rows inside a triangle's extent [min(p,q,r), max(p,q,r)]
+static inline IndexRange row_range(double p, double q, double r, int n) {
+	IndexRange range = {clamp_int((int)ceil(min3(p, q, r)), 0, n - 1),
+						clamp_int((int)floor(max3(p, q, r)), 0, n - 1)};
+	return range;
+}
+
 // find distance x0 is from segment x1-x2
 static inline float point_segment_distance(const Vec3f &x0, const Vec3f &x1,
 										   const Vec3f &x2,
@@ -172,15 +196,15 @@ struct TriSetup {
 	double r_i, r_j, r_k;
 };
 
-static inline TriSetup setup_triangle(const Vec3ui &t, const Vec3f *x,
+static inline TriSetup setup_triangle(const Vec3ui &t, const Vec3f *vertices,
 									  const Vec3f &origin, float dx) {
 	unsigned int p = t.x, q = t.y, r = t.z;
 	TriSetup s;
 
 	TriangleData &triangle = s.triangle;
-	triangle.x1 = x[p];
-	triangle.x2 = x[q];
-	triangle.x3 = x[r];
+	triangle.x1 = vertices[p];
+	triangle.x2 = vertices[q];
+	triangle.x3 = vertices[r];
 	triangle.x13 = triangle.x1 - triangle.x3;
 	triangle.x23 = triangle.x2 - triangle.x3;
 	triangle.m13 = mag2(triangle.x13);
@@ -199,15 +223,15 @@ static inline TriSetup setup_triangle(const Vec3ui &t, const Vec3f *x,
 	triangle.edge23 = {triangle.x3 - triangle.x2,
 					   (double)mag2(triangle.x3 - triangle.x2)};
 
-	s.p_i = ((double)x[p].x - origin.x) / dx;
-	s.p_j = ((double)x[p].y - origin.y) / dx;
-	s.p_k = ((double)x[p].z - origin.z) / dx;
-	s.q_i = ((double)x[q].x - origin.x) / dx;
-	s.q_j = ((double)x[q].y - origin.y) / dx;
-	s.q_k = ((double)x[q].z - origin.z) / dx;
-	s.r_i = ((double)x[r].x - origin.x) / dx;
-	s.r_j = ((double)x[r].y - origin.y) / dx;
-	s.r_k = ((double)x[r].z - origin.z) / dx;
+	s.p_i = ((double)vertices[p].x - origin.x) / dx;
+	s.p_j = ((double)vertices[p].y - origin.y) / dx;
+	s.p_k = ((double)vertices[p].z - origin.z) / dx;
+	s.q_i = ((double)vertices[q].x - origin.x) / dx;
+	s.q_j = ((double)vertices[q].y - origin.y) / dx;
+	s.q_k = ((double)vertices[q].z - origin.z) / dx;
+	s.r_i = ((double)vertices[r].x - origin.x) / dx;
+	s.r_j = ((double)vertices[r].y - origin.y) / dx;
+	s.r_k = ((double)vertices[r].z - origin.z) / dx;
 	return s;
 }