polyscope 1.3.4__tar.gz → 2.1.0__tar.gz

polyscope-2.1.0/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.1.0)
+project(polyscope-py)
+
+# Gather dependencies
+set(EIGEN3_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/deps/eigen/")
+
+# Recurse in to pybind
+add_subdirectory(deps/pybind11)
+
+# We need polyscope
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+add_subdirectory(deps/polyscope)
+
+pybind11_add_module(polyscope_bindings 
+  src/cpp/core.cpp
+  src/cpp/surface_mesh.cpp
+  src/cpp/point_cloud.cpp
+  src/cpp/curve_network.cpp
+  src/cpp/volume_mesh.cpp
+  src/cpp/volume_grid.cpp
+  src/cpp/camera_view.cpp
+  src/cpp/floating_quantities.cpp
+  src/cpp/implicit_helpers.cpp
+  src/cpp/managed_buffer.cpp
+  src/cpp/imgui.cpp
+)
+set_target_properties(polyscope_bindings PROPERTIES CXX_VISIBILITY_PRESET "default")
+
+target_include_directories(polyscope_bindings PUBLIC "${EIGEN3_INCLUDE_DIR}")
+target_link_libraries(polyscope_bindings PRIVATE polyscope)
+
+# make the resulting target actually be called polyscope, without the py
+# set_target_properties(polyscope_py PROPERTIES OUTPUT_NAME polyscope)

polyscope-2.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: polyscope
+Version: 2.1.0
+Summary: Polyscope: A viewer and user interface for 3D data.
+Home-page: https://polyscope.run
+Author: Nicholas Sharp
+Author-email: nmwsharp@gmail.com
+License: MIT
+Platform: UNKNOWN
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Polyscope's documentation is hosted at [polyscope.run](http://polyscope.run)
+
+To contribute, check out the [instructions here](https://polyscope.run/about/contributing/).
+
+![Polyscope](http://polyscope.run/media/teaser.svg)
+
+[![actions status linux](https://github.com/nmwsharp/polyscope/workflows/linux/badge.svg)](https://github.com/nmwsharp/polyscope/actions)
+[![actions status macOS](https://github.com/nmwsharp/polyscope/workflows/macOS/badge.svg)](https://github.com/nmwsharp/polyscope/actions)
+[![actions status windows](https://github.com/nmwsharp/polyscope/workflows/windows/badge.svg)](https://github.com/nmwsharp/polyscope/actions)
+![PyPI](https://img.shields.io/pypi/v/polyscope?style=flat-square)
+
+Polyscope is a C++/Python viewer and user interface for 3D data such as meshes and point clouds. It allows you to register your data and quickly generate informative and beautiful visualizations, either programmatically or via a dynamic GUI. Polyscope is designed to be lightweight---it does not "take ownership" over your entire program, and it is easy to integrate with existing codebases and popular libraries. The lofty objective of Polyscope is to offer a useful visual interface to your data via a single line of code.
+
+Polyscope uses a paradigm of *structures* and *quantities*. A **structure** is a geometric object in the scene, such as a surface mesh or point cloud. A **quantity** is data associated with a structure, such as a scalar function or a vector field.
+
+When any of these structures and quantities are registered, Polyscope displays them in an interactive 3D scene, handling boilerplate concerns such as toggling visibility, color-mapping data and adjusting maps, "picking" to click in the scene and query numerical quantities, etc.
+
+C++:
+
+``` C++
+#include "polyscope/polyscope.h"
+#include "polyscope/surface_mesh.h"
+
+// Initialize polyscope
+polyscope::init();
+
+// Register a point cloud
+// `points` is a Nx3 array-like container of points
+polyscope::registerPointCloud("my points", points)
+
+// Register a surface mesh structure
+// `meshVerts` is a Vx3 array-like container of vertex positions
+// `meshFaces` is a Fx3 array-like container of face indices  
+polyscope::registerSurfaceMesh("my mesh", meshVerts, meshFaces);
+
+// Add a scalar and a vector function defined on the mesh
+// `scalarQuantity` is a length V array-like container of values
+// `vectorQuantity` is an Fx3 array-like container of vectors per face
+polyscope::getSurfaceMesh("my mesh")->addVertexScalarQuantity("my_scalar", scalarQuantity);
+polyscope::getSurfaceMesh("my mesh")->addFaceVectorQuantity("my_vector", vectorQuantity);
+
+// View the point cloud and mesh we just registered in the 3D UI
+polyscope::show();
+```
+
+Python:
+``` python
+import polyscope as ps
+
+# Initialize polyscope
+ps.init()
+
+### Register a point cloud
+# `my_points` is a Nx3 numpy array
+ps.register_point_cloud("my points", my_points)
+
+### Register a mesh
+# `verts` is a Nx3 numpy array of vertex positions
+# `faces` is a Fx3 array of indices, or a nested list
+ps.register_surface_mesh("my mesh", verts, faces, smooth_shade=True)
+
+# Add a scalar function and a vector function defined on the mesh
+# vertex_scalar is a length V numpy array of values
+# face_vectors is an Fx3 array of vectors per face
+ps.get_surface_mesh("my mesh").add_scalar_quantity("my_scalar", 
+        vertex_scalar, defined_on='vertices', cmap='blues')
+ps.get_surface_mesh("my mesh").add_vector_quantity("my_vector", 
+        face_vectors, defined_on='faces', color=(0.2, 0.5, 0.5))
+
+# View the point cloud and mesh we just registered in the 3D UI
+ps.show()
+```
+
+Polyscope is designed to make your life easier. It is simple to build, and fewer than 10 lines of code should be sufficient to start visualizing. In C++, some [template magic](https://polyscope.run/data_adaptors/) means Polyscope can probably accept the data types you're already using!
+
+---
+Author: [Nicholas Sharp](http://www.nmwsharp.com)
+
+If Polyscope contributes to an academic publication, cite it as:
+```bib
+@misc{polyscope,
+  title = {Polyscope},
+  author = {Nicholas Sharp and others},
+  note = {www.polyscope.run},
+  year = {2019}
+}
+```
+
+Development of this software was funded in part by NSF Award 1717320, an NSF graduate research fellowship, and gifts from Adobe Research and Autodesk, Inc.
+
+

polyscope-2.1.0/README.md

@@ -0,0 +1,43 @@
+# polyscope-py
+Python bindings for Polyscope. https://polyscope.run/py
+
+[![Linux](https://github.com/nmwsharp/polyscope-py/workflows/Test%20Linux/badge.svg)](https://github.com/nmwsharp/polyscope-py/actions)
+[![macOS](https://github.com/nmwsharp/polyscope-py/workflows/Test%20macOS/badge.svg)](https://github.com/nmwsharp/polyscope-py/actions)
+[![Windows](https://github.com/nmwsharp/polyscope-py/workflows/Test%20Windows/badge.svg)](https://github.com/nmwsharp/polyscope-py/actions)
+[![PyPI](https://img.shields.io/pypi/v/polyscope?style=plastic)](https://pypi.org/project/polyscope/)
+[![Conda](https://img.shields.io/conda/v/conda-forge/polyscope)](https://anaconda.org/conda-forge/polyscope)
+
+This library is a python wrapper and deployment system. The core library lives at https://github.com/nmwsharp/polyscope. See documentation at https://polyscope.run/py.
+
+To contribute, check out the [instructions here](https://polyscope.run/about/contributing/).
+
+### Installation
+
+```
+python -m pip install polyscope
+```
+
+or
+
+```
+conda install -c conda-forge polyscope
+```
+
+polyscope-py should work out-of-the-box on any combination of Python 3.5-3.12 and Linux/macOS/Windows. Your graphics hardware must support OpenGL >= 3.3 core profile.
+
+## For developers
+
+This repo is configured with CI on github actions. 
+
+- By default, all commits to the main branch build & run tests. Use `[ci skip]` to skip this.
+- Tagging a commit with `[ci build]` causes it to also build all precompiled wheels and upload them as artifacts.
+- Creating a tagged version like `v1.2.3` will build wheels as above, and ALSO automatically upload them to pypi as described below.
+
+### Deploy a new version
+
+- Commit the desired version to the `master` branch, be sure the version string in `setup.py` corresponds to the new version number. Use the `[ci build]` tag in the commit message to trigger builds, which should take about an hour.
+- Watch the github actions builds to ensure all wheels build successfully. The resulting binaries will be saved as artifacts if you want try test with them.
+- While you're waiting, update the docs, including the changelog.
+- Tag the commit with a tag like `v1.2.3`, matching the version in `setup.py`. This will kick off a new github actions build which deploys the wheels to PyPI after compilation.
+- If we are still doing builds with multiple rounds of actions, it may be necessary to manually upload some of the generated wheels. Download from the github actions `Summary/Artifacs` pane, then upload with `twine upload * --skip-existing`
+- Update the conda builds by committing to the [feedstock repository](https://github.com/conda-forge/polyscope-feedstock). This generally just requires bumping the version number and updating the hash in `meta.yml`. Since `meta.yml` is configured to pull source from PyPi, you can't do this until after the source build has been uploaded from the github action.

polyscope-2.1.0/deps/polyscope/.github/workflows/linux.yml

@@ -0,0 +1,54 @@
+name: linux
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    if: "! contains(toJSON(github.event.commits.*.message), '[ci skip]')"
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        submodules: true
+
+    - name: install packages
+      run: sudo apt-get update && sudo apt-get install -y xorg-dev libglu1-mesa-dev xpra xserver-xorg-video-dummy freeglut3-dev
+
+    - name: configure
+      run: cd test && mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Debug -DPOLYSCOPE_BACKEND_OPENGL3_GLFW=ON -DPOLYSCOPE_BACKEND_OPENGL_MOCK=ON ..
+
+    - name: build
+      run: cd test/build && make
+
+    - name: run test
+      run: cd test/build && ./bin/polyscope-test --gtest_catch_exceptions=0 backend=openGL_mock
+  
+  build_shared:
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    if: "! contains(toJSON(github.event.commits.*.message), '[ci skip]')"
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        submodules: true
+
+    - name: install packages
+      run: sudo apt-get update && sudo apt-get install -y xorg-dev libglu1-mesa-dev xpra xserver-xorg-video-dummy freeglut3-dev
+
+    - name: configure
+      run: cd test && mkdir build && cd build && cmake -DBUILD_SHARED_LIBS=TRUE -DCMAKE_BUILD_TYPE=Debug -DPOLYSCOPE_BACKEND_OPENGL3_GLFW=ON -DPOLYSCOPE_BACKEND_OPENGL_MOCK=ON ..
+
+    - name: build
+      run: cd test/build && make
+
+    - name: run test
+      run: cd test/build && ./bin/polyscope-test --gtest_catch_exceptions=0 backend=openGL_mock

polyscope-2.1.0/deps/polyscope/.gitignore

@@ -0,0 +1,47 @@
+# Build directories
+build/
+build_debug/
+misc/file2c/file2cpp
+
+# Editor and OS things
+imgui.ini
+.DS_Store
+.vscode
+*.swp
+tags
+*.blend1
+.cache
+compile_commands.json
+
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app

polyscope-2.1.0/deps/polyscope/deps/CMakeLists.txt

@@ -0,0 +1,23 @@
+if("${POLYSCOPE_BACKEND_OPENGL3_GLFW}")
+
+  ## Glad
+  add_subdirectory(glad)
+
+  ## GLFW
+  set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
+  set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+  set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+  set(GLFW_INSTALL OFF CACHE BOOL "" FORCE)
+  add_subdirectory(glfw)
+endif()
+
+if("${POLYSCOPE_BACKEND_OPENGL_MOCK}")
+endif()
+
+## Imgui
+add_subdirectory(imgui)
+
+## Argparse
+
+## Other dependencies
+add_subdirectory(stb)

polyscope-2.1.0/deps/polyscope/deps/MarchingCubeCpp/README.md

@@ -0,0 +1,51 @@
+From: https://github.com/aparis69/MarchingCubeCpp
+
+nsharp: made small changes to use glm vector class and expose an isolevel argument
+
+## Marching Cube C++
+A public domain header-only marching cube implementation in C/C++ without anything fancy. Only dependencies are cmath 
+and vector headers. I could get rid of vector and just use plain arrays, but it is more convenient for my personal 
+projects to keep that way, though one could easily modify the implementation.
+
+This work was motivated by this public domain implementation of the marching cube: https://github.com/nsf/mc which gives 
+a fully runnable example in OpenGL. I thought it could be simplified and could make a good header-only library.
+
+## Behaviour
+Calling MC::marching_cube will create an indexed mesh with vertices and normals defined in their own std::vector's.
+By default, data is allocated for vertices, normals and triangle indices. You can change the default allocated 
+space using the function MC::setDefaultArraySizes.
+
+The output mesh represents the zero-isosurface of the input scalar field. Coordinates of the vertices will follow
+the grid discretization: a 128x128x128 grid will create a mesh embedded in the axis-aligned box from Vec3(0) to Vec3(128).
+
+You can optionally enable double precision by defining MC_CPP_USE_DOUBLE_PRECISION before including the header.
+
+## Use
+First define MC_CPP_ENABLE and then include MC.h in your project. Example:
+```cpp
+#define MC_IMPLEM_ENABLE
+#include "MC.h"
+
+int main()
+{
+	// First compute a scalar field
+	const int n = 100;
+	MC::MC_FLOAT* field = new MC::MC_FLOAT[n * n * n];
+	// [...]
+	
+	// Compute isosurface using marching cube
+	MC::mcMesh mesh;
+	MC::marching_cube(field, n, n, n, mesh);
+
+	// Dot whatever you want with the mesh
+	// [...]
+
+	return 0;
+}
+```
+
+You may find a complete example in main.cpp file. Running the program in the repository will output an obj file showing 
+the isosurface of a single perlin noise octave.
+
+## Licence
+Double Licence, whatever fits you best: Public domain or MIT License.

polyscope-2.1.0/deps/polyscope/deps/MarchingCubeCpp/include/MarchingCube/MC.h

@@ -0,0 +1,319 @@
+#ifndef MC_CPP_INCLUDED
+#define MC_CPP_INCLUDED
+
+#include <vector>
+#include <cmath>
+
+// Added by nsharp: use glm instead of internal vector class
+#include <glm/glm.hpp>
+#include <glm/gtx/norm.hpp>
+
+namespace MC
+{
+	// Optionally define double precision
+#ifdef MC_CPP_USE_DOUBLE_PRECISION
+	typedef double MC_FLOAT;
+#else
+	typedef float MC_FLOAT;
+#endif
+
+	typedef unsigned int muint;   
+
+
+	static inline MC_FLOAT mc_internalLength2(const glm::vec3& v)
+	{
+		return glm::length2(v);
+	}
+	static inline MC_FLOAT mc_internalLength(const glm::vec3& v)
+	{
+		return glm::length(v);
+	}
+	static inline glm::vec3 mc_internalNormalize(const glm::vec3& v)
+	{
+    return glm::normalize(v);
+	}
+	static inline glm::vec3 mc_internalCross(const glm::vec3& v1, const glm::vec3& v2)
+	{
+		return glm::cross(v1, v2);
+	}
+
+	typedef struct mcVec3i
+	{
+	public:
+		union 
+		{
+			muint v[3];
+			struct 
+			{
+				muint x, y, z;
+			};
+		};
+		inline muint& operator[](int i) { return v[i]; }
+	} mcVec3i;
+
+	typedef struct mcMesh
+	{
+	public:
+		std::vector<glm::vec3> vertices;
+		std::vector<glm::vec3> normals;
+		std::vector<muint> indices;
+	} mcMesh;
+
+	void marching_cube(MC_FLOAT* field, MC_FLOAT isoval, muint nx, muint ny, muint nz, mcMesh& outputMesh);
+	void setDefaultArraySizes(muint vertSize, muint normSize, muint triSize);
+}
+
+
+#endif
+
+namespace MC
+{
+#ifdef MC_IMPLEM_ENABLE
+	static muint defaultVerticeArraySize	= 100000;
+	static muint defaultNormalArraySize		= 100000;
+	static muint defaultTriangleArraySize	= 400000;
+
+	static inline muint mc_internalToIndex1D(muint i, muint j, muint k, const mcVec3i& size)
+	{
+		//return (k * size.y + j) * size.x + i;
+		return (i * size.y + j) * size.z + k;
+	}
+
+	static inline muint mc_internalToIndex1DSlab(muint i, muint j, muint k, const mcVec3i& size)
+	{
+    return size.x * size.y * (k % 2) + j * size.x + i;
+		//return size.z * size.y * (i % 2) + j * size.z + k;
+	}
+
+	// Look-up table for triangle configurations
+	static const unsigned long long mc_internalMarching_cube_tris[256] = 
+	{
+		0ULL, 33793ULL, 36945ULL, 159668546ULL,
+		18961ULL, 144771090ULL, 5851666ULL, 595283255635ULL,
+		20913ULL, 67640146ULL, 193993474ULL, 655980856339ULL,
+		88782242ULL, 736732689667ULL, 797430812739ULL, 194554754ULL,
+		26657ULL, 104867330ULL, 136709522ULL, 298069416227ULL,
+		109224258ULL, 8877909667ULL, 318136408323ULL, 1567994331701604ULL,
+		189884450ULL, 350847647843ULL, 559958167731ULL, 3256298596865604ULL,
+		447393122899ULL, 651646838401572ULL, 2538311371089956ULL, 737032694307ULL,
+		29329ULL, 43484162ULL, 91358498ULL, 374810899075ULL,
+		158485010ULL, 178117478419ULL, 88675058979ULL, 433581536604804ULL,
+		158486962ULL, 649105605635ULL, 4866906995ULL, 3220959471609924ULL,
+		649165714851ULL, 3184943915608436ULL, 570691368417972ULL, 595804498035ULL,
+		124295042ULL, 431498018963ULL, 508238522371ULL, 91518530ULL,
+		318240155763ULL, 291789778348404ULL, 1830001131721892ULL, 375363605923ULL,
+		777781811075ULL, 1136111028516116ULL, 3097834205243396ULL, 508001629971ULL,
+		2663607373704004ULL, 680242583802939237ULL, 333380770766129845ULL, 179746658ULL,
+		42545ULL, 138437538ULL, 93365810ULL, 713842853011ULL,
+		73602098ULL, 69575510115ULL, 23964357683ULL, 868078761575828ULL,
+		28681778ULL, 713778574611ULL, 250912709379ULL, 2323825233181284ULL,
+		302080811955ULL, 3184439127991172ULL, 1694042660682596ULL, 796909779811ULL,
+		176306722ULL, 150327278147ULL, 619854856867ULL, 1005252473234484ULL,
+		211025400963ULL, 36712706ULL, 360743481544788ULL, 150627258963ULL,
+		117482600995ULL, 1024968212107700ULL, 2535169275963444ULL, 4734473194086550421ULL,
+		628107696687956ULL, 9399128243ULL, 5198438490361643573ULL, 194220594ULL,
+		104474994ULL, 566996932387ULL, 427920028243ULL, 2014821863433780ULL,
+		492093858627ULL, 147361150235284ULL, 2005882975110676ULL, 9671606099636618005ULL,
+		777701008947ULL, 3185463219618820ULL, 482784926917540ULL, 2900953068249785909ULL,
+		1754182023747364ULL, 4274848857537943333ULL, 13198752741767688709ULL, 2015093490989156ULL,
+		591272318771ULL, 2659758091419812ULL, 1531044293118596ULL, 298306479155ULL,
+		408509245114388ULL, 210504348563ULL, 9248164405801223541ULL, 91321106ULL,
+		2660352816454484ULL, 680170263324308757ULL, 8333659837799955077ULL, 482966828984116ULL,
+		4274926723105633605ULL, 3184439197724820ULL, 192104450ULL, 15217ULL,
+		45937ULL, 129205250ULL, 129208402ULL, 529245952323ULL,
+		169097138ULL, 770695537027ULL, 382310500883ULL, 2838550742137652ULL,
+		122763026ULL, 277045793139ULL, 81608128403ULL, 1991870397907988ULL,
+		362778151475ULL, 2059003085103236ULL, 2132572377842852ULL, 655681091891ULL,
+		58419234ULL, 239280858627ULL, 529092143139ULL, 1568257451898804ULL,
+		447235128115ULL, 679678845236084ULL, 2167161349491220ULL, 1554184567314086709ULL,
+		165479003923ULL, 1428768988226596ULL, 977710670185060ULL, 10550024711307499077ULL,
+		1305410032576132ULL, 11779770265620358997ULL, 333446212255967269ULL, 978168444447012ULL,
+		162736434ULL, 35596216627ULL, 138295313843ULL, 891861543990356ULL,
+		692616541075ULL, 3151866750863876ULL, 100103641866564ULL, 6572336607016932133ULL,
+		215036012883ULL, 726936420696196ULL, 52433666ULL, 82160664963ULL,
+		2588613720361524ULL, 5802089162353039525ULL, 214799000387ULL, 144876322ULL,
+		668013605731ULL, 110616894681956ULL, 1601657732871812ULL, 430945547955ULL,
+		3156382366321172ULL, 7644494644932993285ULL, 3928124806469601813ULL, 3155990846772900ULL,
+		339991010498708ULL, 10743689387941597493ULL, 5103845475ULL, 105070898ULL,
+		3928064910068824213ULL, 156265010ULL, 1305138421793636ULL, 27185ULL,
+		195459938ULL, 567044449971ULL, 382447549283ULL, 2175279159592324ULL,
+		443529919251ULL, 195059004769796ULL, 2165424908404116ULL, 1554158691063110021ULL,
+		504228368803ULL, 1436350466655236ULL, 27584723588724ULL, 1900945754488837749ULL,
+		122971970ULL, 443829749251ULL, 302601798803ULL, 108558722ULL,
+		724700725875ULL, 43570095105972ULL, 2295263717447940ULL, 2860446751369014181ULL,
+		2165106202149444ULL, 69275726195ULL, 2860543885641537797ULL, 2165106320445780ULL,
+		2280890014640004ULL, 11820349930268368933ULL, 8721082628082003989ULL, 127050770ULL,
+		503707084675ULL, 122834978ULL, 2538193642857604ULL, 10129ULL,
+		801441490467ULL, 2923200302876740ULL, 1443359556281892ULL, 2901063790822564949ULL,
+		2728339631923524ULL, 7103874718248233397ULL, 12775311047932294245ULL, 95520290ULL,
+		2623783208098404ULL, 1900908618382410757ULL, 137742672547ULL, 2323440239468964ULL,
+		362478212387ULL, 727199575803140ULL, 73425410ULL, 34337ULL,
+		163101314ULL, 668566030659ULL, 801204361987ULL, 73030562ULL,
+		591509145619ULL, 162574594ULL, 100608342969108ULL, 5553ULL,
+		724147968595ULL, 1436604830452292ULL, 176259090ULL, 42001ULL,
+		143955266ULL, 2385ULL, 18433ULL, 0ULL,
+	};
+
+	/*!
+	\brief Approximates the vertex position of the mesh from the scalar values along an edge (va, vb).
+	\param slab_inds slab indices global array
+	\param mesh the mesh
+	\param va, vb edges values
+	\param axis axis index 0/1/2
+	\param x, y, z current slab index
+	\param size slab indices array size
+	*/
+	static void mc_internalComputeEdge(mcVec3i* slab_inds, mcMesh& mesh, float va, float vb, int axis, muint x, muint y, muint z, const mcVec3i& size)
+	{
+		if ((va < 0.0) == (vb < 0.0))
+			return;
+    glm::vec3 v = { MC_FLOAT(x), MC_FLOAT(y), MC_FLOAT(z) };
+		v[axis] += va / (va - vb);
+		slab_inds[mc_internalToIndex1DSlab(x, y, z, size)][axis] = muint(mesh.vertices.size());
+		mesh.vertices.push_back(v);
+		mesh.normals.push_back(glm::vec3({ 0, 0, 0 }));
+	}
+
+	/*!
+	\brief Computes and acumulates the geometric normal of triangle formed by vertices (a, b, c).
+	\param mesh the mesh
+	\param a, b, c vertex indices
+	*/
+	static inline void mc_internalAccumulateNormal(mcMesh& mesh, muint a, muint b, muint c)
+	{
+    glm::vec3& va = mesh.vertices[a];
+    glm::vec3& vb = mesh.vertices[b];
+    glm::vec3& vc = mesh.vertices[c];
+    glm::vec3 ab = va - vb;
+    glm::vec3 cb = vc - vb;
+    glm::vec3 n = mc_internalCross(cb, ab);
+		mesh.normals[a] += n;
+		mesh.normals[b] += n;
+		mesh.normals[c] += n;
+	}
+
+
+	/*
+	\brief Stores the default array sizes for the indexed mesh computed
+	by the marching cubes. Useful for speeding-up the marching cubes.
+	\param vertSize vertex array size
+	\param normSize normal array size
+	\param triSize triangle index array size
+	*/
+	inline void setDefaultArraySizes(muint vertSize, muint normSize, muint triSize)
+	{
+		defaultVerticeArraySize		= vertSize;
+		defaultNormalArraySize		= normSize;
+		defaultTriangleArraySize	= triSize;
+	}
+
+	/*!
+	\brief Computes the mesh representing the zero isosurface of a 3D scalarfield and
+	 outputs it to an indexed mesh.
+	\param field scalarfield of real values in C-contiguous order: the value for grid point
+	 (ix, iy, iz) is stored at index (iz*ny + iy)*nx + ix
+	\param nx, ny, nz grid dimension
+	\param outputMesh indexed mesh returned.
+	*/
+	void marching_cube(MC_FLOAT* field, MC_FLOAT isoval, muint nx, muint ny, muint nz, mcMesh& outputMesh)
+	{
+		outputMesh.vertices.reserve(defaultVerticeArraySize);
+		outputMesh.normals.reserve(defaultNormalArraySize);
+		outputMesh.indices.reserve(defaultTriangleArraySize);
+
+		const mcVec3i size = { nx, ny, nz };
+		mcVec3i* slab_inds = new mcVec3i[nx * ny * 2];
+		MC_FLOAT vs[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+		muint edge_indices[12];
+		for (muint z = 0; z < nz - 1; z++)
+		{
+			for (muint y = 0; y < ny - 1; y++)
+			{
+				for (muint x = 0; x < nx - 1; x++)
+				{
+					vs[0] = -isoval + field[mc_internalToIndex1D(x, y, z, size)];
+					vs[1] = -isoval + field[mc_internalToIndex1D(x + 1, y, z, size)];
+					vs[2] = -isoval + field[mc_internalToIndex1D(x, y + 1, z, size)];
+					vs[3] = -isoval + field[mc_internalToIndex1D(x + 1, y + 1, z, size)];
+					vs[4] = -isoval + field[mc_internalToIndex1D(x, y, z + 1, size)];
+					vs[5] = -isoval + field[mc_internalToIndex1D(x + 1, y, z + 1, size)];
+					vs[6] = -isoval + field[mc_internalToIndex1D(x, y + 1, z + 1, size)];
+					vs[7] = -isoval + field[mc_internalToIndex1D(x + 1, y + 1, z + 1, size)];
+
+					const int config_n =
+						((vs[0] < 0) << 0) |
+						((vs[1] < 0) << 1) |
+						((vs[2] < 0) << 2) |
+						((vs[3] < 0) << 3) |
+						((vs[4] < 0) << 4) |
+						((vs[5] < 0) << 5) |
+						((vs[6] < 0) << 6) |
+						((vs[7] < 0) << 7);
+					if (config_n == 0 || config_n == 255)
+						continue;
+
+					if (y == 0 && z == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[0], vs[1], 0, x, y, z, size);
+					if (z == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[2], vs[3], 0, x, y + 1, z, size);
+					if (y == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[4], vs[5], 0, x, y, z + 1, size);
+					mc_internalComputeEdge(slab_inds, outputMesh, vs[6], vs[7], 0, x, y + 1, z + 1, size);
+
+					if (x == 0 && z == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[0], vs[2], 1, x, y, z, size);
+					if (z == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[1], vs[3], 1,x + 1, y, z, size);
+					if (x == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[4], vs[6], 1, x, y, z + 1, size);
+					mc_internalComputeEdge(slab_inds, outputMesh, vs[5], vs[7], 1, x + 1, y, z + 1, size);
+
+					if (x == 0 && y == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[0], vs[4], 2, x, y, z, size);
+					if (y == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[1], vs[5], 2, x + 1, y, z, size);
+					if (x == 0)
+						mc_internalComputeEdge(slab_inds, outputMesh, vs[2], vs[6], 2, x, y + 1, z, size);
+					mc_internalComputeEdge(slab_inds, outputMesh, vs[3], vs[7], 2, x + 1, y + 1, z, size);
+
+					edge_indices[0] = slab_inds[mc_internalToIndex1DSlab(x, y, z, size)].x;
+					edge_indices[1] = slab_inds[mc_internalToIndex1DSlab(x, y + 1, z, size)].x;
+					edge_indices[2] = slab_inds[mc_internalToIndex1DSlab(x, y, z + 1, size)].x;
+					edge_indices[3] = slab_inds[mc_internalToIndex1DSlab(x, y + 1, z + 1, size)].x;
+					edge_indices[4] = slab_inds[mc_internalToIndex1DSlab(x, y, z, size)].y;
+					edge_indices[5] = slab_inds[mc_internalToIndex1DSlab(x + 1, y, z, size)].y;
+					edge_indices[6] = slab_inds[mc_internalToIndex1DSlab(x, y, z + 1, size)].y;
+					edge_indices[7] = slab_inds[mc_internalToIndex1DSlab(x + 1, y, z + 1, size)].y;
+					edge_indices[8] = slab_inds[mc_internalToIndex1DSlab(x, y, z, size)].z;
+					edge_indices[9] = slab_inds[mc_internalToIndex1DSlab(x + 1, y, z, size)].z;
+					edge_indices[10] = slab_inds[mc_internalToIndex1DSlab(x, y + 1, z, size)].z;
+					edge_indices[11] = slab_inds[mc_internalToIndex1DSlab(x + 1, y + 1, z, size)].z;
+
+					const uint64_t& config = mc_internalMarching_cube_tris[config_n];
+					const size_t n_triangles = config & 0xF;
+					const size_t n_indices = n_triangles * 3;
+					const size_t& indexBase = outputMesh.indices.size();
+					int offset = 4;
+					for (size_t i = 0; i < n_indices; i++)
+					{
+						const int edge = (config >> offset) & 0xF;
+						outputMesh.indices.push_back(edge_indices[edge]);
+						offset += 4;
+					}
+					for (size_t i = 0; i < n_triangles; i++)
+					{
+						mc_internalAccumulateNormal(outputMesh,
+							outputMesh.indices[indexBase + i * 3 + 0],
+							outputMesh.indices[indexBase + i * 3 + 1],
+							outputMesh.indices[indexBase + i * 3 + 2]);
+					}
+				}
+			}
+		}
+		for (size_t i = 0; i < outputMesh.normals.size(); i++)
+			outputMesh.normals[i] = mc_internalNormalize(outputMesh.normals[i]);
+		delete[] slab_inds;
+	}
+
+#endif
+}