mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-05-14 09:02:06 +00:00
dc5897d7b5
* Update eigen from v3.3.7 to v5.0.1. This updates eigen from v3.3.7 released on December 11, 2018-12-11 to v5.0.1 released on 2025-11-11. There have be a large number of bug-fixes, optimizations, and improvements between these releases. See the details at; https://gitlab.com/libeigen/eigen/-/releases It retains the previous custom minimal `CMakeLists.txt`, and adds a README-OrcaSlicer.md that explains what version and parts of the upstream eigen release have been included, and where the full release can be found. * Update libigl from v2.0.0 (or older) to v2.6.0. This updates libigl from what was probably v2.0.0 released on 2018-10-16 to v2.6.0 released on 2025-05-15. It's possible the old version was even older than that but there is no version indicators in the code and I ran out of patience identifying missing changes and only went back as far as v2.0.0. There have been a large number of bug-fixes, optimizations, and improvements between these versions. See the following for details; https://github.com/libigl/libigl/releases I retained the minimal custom `CMakeLists.txt`, added `README.md` from the libigl distribution which identifies the version, and added a README-OrcaSlicer.md that details the version and parts that have been included. * Update libslic3r for libigl v2.6.0 changes. This updates libslic3r for all changes moving to eigen v5.0.1 and libigl v2.6.0. Despite the large number of updates to both dependencies, no changes were required for the eigen update, and only one change was required for the libigl update. For libigl, `igl::Hit` was changed to a template taking the Scalar type to use. Previously it was hard-coded to `float`, so to minimize possible impact I've updated all places it is used from `igl::Hit` to `igl::Hit<float>`. * Add compiler option `-DNOMINMAX` for libigl with MSVC. MSVC by default defines `min(()` and `max()` macros that break `std::numeric_limits<>::max()`. The upstream cmake that we don't include adds `-DNOMINMAX` for the libigl module when compiling with MSVC, so we need to add the same thing here. * Fix src/libslic3r/TriangleMeshDeal.cpp for the unmodified upstream libigl. This fixes `TriangleMeshDeal.cpp` to work with the unmodified upstream libigl v2.6.0. loop.{h,cpp} implementation. This file and feature was added in PR "BBS Port: Mesh Subdivision" (#12150) which included changes to `loop.{h,cpp}` in the old version of libigl. This PR avoids modifying the included dependencies, and uses the updated upstream versions of those files without any modifications, which requires fixing TriangleMeshDeal.cpp to work with them. In particular, the modifications made to `loop.{h,cpp}` included changing the return type from void to bool, adding additional validation checking of the input meshes, and returning false if they failed validation. These added checks looked unnecessary and would only have caught problems if the input mesh was very corrupt. To make `TriangleMeshDeal.cpp` work without this built-in checking functionality, I removed checking/handling of any `false` return value. There was also a hell of a lot of redundant copying and casting back and forth between float and double, so I cleaned that up. The input and output meshs use floats for the vertexes, and there would be no accuracy benefits from casting to and from doubles for the simple weighted average operations done by igl::loop(). So this just uses `Eigen:Map` to use the original input mesh vertex data directly without requiring any copy or casting. * Move eigen from included `deps_src` to externaly fetched `deps`. This copys what PrusaSlicer did and moved it from an included dependency under `deps_src` to an externaly fetched dependency under `deps`. This requires updating some `CMakeList.txt` configs and removing the old and obsolete `cmake/modules/FindEigen3.cmake`. The details of when this was done in PrusaSlicer and the followup fixes are at; *21116995d7* https://github.com/prusa3d/PrusaSlicer/issues/13608 * https://github.com/prusa3d/PrusaSlicer/pull/13609 *e3c277b9eeFor some reason I don't fully understand this also required fixing `src/slic3r/GUI/GUI_App.cpp` by adding `#include <boost/nowide/cstdio.hpp>` to fix an `error: ‘remove’ is not a member of ‘boost::nowide'`. The main thing I don't understand is how it worked before. Note that this include is in the PrusaSlicer version of this file, but it also significantly deviates from what is currently in OrcaSlicer in many other ways. * Whups... I missed adding the deps/Eigen/Eigen.cmake file... * Tidy some whitespace indenting in CMakeLists.txt. * Ugh... tabs indenting needing fixes. * Change the include order of deps/Eigen. It turns out that although Boost includes some references to Eigen, Eigen also includes some references to Boost for supporting some of it's additional numeric types. I don't think it matters much since we are not using these features, but I think technically its more correct to say Eigen depends on Boost than the other way around, so I've re-ordered them. * Add source for Eigen 5.0.1 download to flatpak yml config. * Add explicit `DEPENDS dep_Boost to deps/Eigen. I missed this before. This ensures we don't rely on include orders to make sure Boost is installed before we configure Eigen. * Add `DEPENDS dep_Boost dep_GMP dep_MPFR` to deps/Eigen. It turns out Eigen can also use GMP and MPFR for multi-precision and multi-precision-rounded numeric types if they are available. Again, I don't think we are using these so it doesn't really matter, but it is technically correct and ensures they are there if we ever do need them. * Fix deps DEPENDENCY ordering for GMP, MPFR, Eigen, and CGAL. I think this is finally correct. Apparently CGAL also optionally depends on Eigen, so the correct dependency order from lowest to highest is GMP, MPFR, Eigen, and CGAL. --------- Co-authored-by: Donovan Baarda <dbaarda@google.com> Co-authored-by: Noisyfox <timemanager.rick@gmail.com>
552 lines
29 KiB
C++
552 lines
29 KiB
C++
/*===========================================================================*\
|
|
* *
|
|
* IsoEx *
|
|
* Copyright (C) 2002 by Computer Graphics Group, RWTH Aachen *
|
|
* www.rwth-graphics.de *
|
|
* *
|
|
*---------------------------------------------------------------------------*
|
|
* *
|
|
* License *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or modify it *
|
|
* under the terms of the GNU Library General Public License as published *
|
|
* by the Free Software Foundation, version 2. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, but *
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
|
|
* Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; if not, write to the Free Software *
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
|
|
* *
|
|
\*===========================================================================*/
|
|
|
|
#include "marching_cubes.h"
|
|
#include "marching_cubes_tables.h"
|
|
|
|
#include <unordered_map>
|
|
|
|
|
|
extern const int edgeTable[256];
|
|
extern const int triTable[256][2][17];
|
|
extern const int polyTable[8][16];
|
|
|
|
|
|
template <typename DerivedValues, typename DerivedPoints, typename DerivedVertices, typename DerivedIndices, typename DerivedFaces>
|
|
class MarchingCubes
|
|
{
|
|
struct EdgeKey
|
|
{
|
|
EdgeKey(unsigned i0, unsigned i1) : i0_(i0), i1_(i1) {}
|
|
|
|
bool operator==(const EdgeKey& _rhs) const
|
|
{
|
|
return i0_ == _rhs.i0_ && i1_ == _rhs.i1_;
|
|
}
|
|
|
|
unsigned i0_, i1_;
|
|
};
|
|
|
|
struct EdgeHash
|
|
{
|
|
std::size_t operator()(const EdgeKey& key) const {
|
|
std::size_t seed = 0;
|
|
seed ^= key.i0_ + 0x9e3779b9 + (seed<<6) + (seed>>2); // Copied from boost::hash_combine
|
|
seed ^= key.i1_ + 0x9e3779b9 + (seed<<6) + (seed>>2);
|
|
return std::hash<std::size_t>()(seed);
|
|
}
|
|
};
|
|
|
|
typedef std::unordered_map<EdgeKey, unsigned, EdgeHash> MyMap;
|
|
typedef typename MyMap::const_iterator MyMapIterator;
|
|
|
|
public:
|
|
// Dense index grid version
|
|
MarchingCubes(const Eigen::MatrixBase<DerivedValues> &values,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const unsigned x_res,
|
|
const unsigned y_res,
|
|
const unsigned z_res,
|
|
const double isovalue,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces)
|
|
{
|
|
assert(values.cols() == 1);
|
|
assert(points.cols() == 3);
|
|
|
|
if(x_res <2 || y_res<2 ||z_res<2)
|
|
return;
|
|
faces.resize(10000,3);
|
|
int num_faces = 0;
|
|
|
|
vertices.resize(10000,3);
|
|
int num_vertices = 0;
|
|
|
|
unsigned n_cubes = (x_res-1) * (y_res-1) * (z_res-1);
|
|
assert(unsigned(points.rows()) == x_res * y_res * z_res);
|
|
|
|
unsigned int offsets_[8];
|
|
offsets_[0] = 0;
|
|
offsets_[1] = 1;
|
|
offsets_[2] = 1 + x_res;
|
|
offsets_[3] = x_res;
|
|
offsets_[4] = x_res*y_res;
|
|
offsets_[5] = 1 + x_res*y_res;
|
|
offsets_[6] = 1 + x_res + x_res*y_res;
|
|
offsets_[7] = x_res + x_res*y_res;
|
|
|
|
for (unsigned cube_it =0 ; cube_it < n_cubes; ++cube_it)
|
|
{
|
|
unsigned corner[8];
|
|
// get point indices of corner vertices
|
|
for (int i=0; i<8; ++i)
|
|
{
|
|
// get cube coordinates
|
|
unsigned int _idx = cube_it;
|
|
unsigned int X(x_res-1), Y(y_res-1);
|
|
unsigned int x = _idx % X; _idx /= X;
|
|
unsigned int y = _idx % Y; _idx /= Y;
|
|
unsigned int z = _idx;
|
|
// transform to point coordinates
|
|
_idx = x + y*x_res + z*x_res*y_res;
|
|
// add offset
|
|
corner[i] = _idx + offsets_[i];
|
|
}
|
|
add_cube(values,points,isovalue,corner,vertices,num_vertices,faces,num_faces,edge2vertex);
|
|
}
|
|
vertices.conservativeResize(num_vertices, Eigen::NoChange);
|
|
faces.conservativeResize(num_faces, Eigen::NoChange);
|
|
}
|
|
|
|
// Sparse index grid version
|
|
MarchingCubes(const Eigen::MatrixBase<DerivedValues> &values,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const Eigen::MatrixBase<DerivedIndices> &cubes,
|
|
const double isovalue,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces)
|
|
{
|
|
assert(values.cols() == 1);
|
|
assert(points.cols() == 3);
|
|
assert(cubes.cols() == 8);
|
|
|
|
if(cubes.rows() == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
faces.resize(10000,3);
|
|
int num_faces = 0;
|
|
|
|
vertices.resize(10000,3);
|
|
int num_vertices = 0;
|
|
|
|
|
|
unsigned n_cubes = cubes.rows();
|
|
|
|
for (unsigned cube_it =0 ; cube_it < n_cubes; ++cube_it)
|
|
{
|
|
typedef Eigen::Matrix<typename DerivedIndices::Scalar, 1, 8> CubeIndexVector;
|
|
|
|
CubeIndexVector corner = cubes.row(cube_it);
|
|
add_cube(values,points,isovalue,corner.data(),vertices,num_vertices,faces,num_faces,edge2vertex);
|
|
}
|
|
vertices.conservativeResize(num_vertices, Eigen::NoChange);
|
|
faces.conservativeResize(num_faces, Eigen::NoChange);
|
|
}
|
|
|
|
// Dense index grid function version
|
|
template <typename DerivedValue, typename DerivedPoint>
|
|
MarchingCubes(
|
|
const std::function< DerivedValue(const DerivedPoint & ) > & value_fun,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const unsigned x_res,
|
|
const unsigned y_res,
|
|
const unsigned z_res,
|
|
const double isovalue,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces)
|
|
{
|
|
assert(points.cols() == 3);
|
|
|
|
if(x_res <2 || y_res<2 ||z_res<2)
|
|
return;
|
|
faces.resize(10000,3);
|
|
int num_faces = 0;
|
|
|
|
vertices.resize(10000,3);
|
|
int num_vertices = 0;
|
|
|
|
unsigned n_cubes = (x_res-1) * (y_res-1) * (z_res-1);
|
|
assert(unsigned(points.rows()) == x_res * y_res * z_res);
|
|
|
|
unsigned int offsets_[8];
|
|
offsets_[0] = 0;
|
|
offsets_[1] = 1;
|
|
offsets_[2] = 1 + x_res;
|
|
offsets_[3] = x_res;
|
|
offsets_[4] = x_res*y_res;
|
|
offsets_[5] = 1 + x_res*y_res;
|
|
offsets_[6] = 1 + x_res + x_res*y_res;
|
|
offsets_[7] = x_res + x_res*y_res;
|
|
|
|
for (unsigned cube_it =0 ; cube_it < n_cubes; ++cube_it)
|
|
{
|
|
unsigned corner[8];
|
|
// get point indices of corner vertices
|
|
for (int i=0; i<8; ++i)
|
|
{
|
|
// get cube coordinates
|
|
unsigned int _idx = cube_it;
|
|
unsigned int X(x_res-1), Y(y_res-1);
|
|
unsigned int x = _idx % X; _idx /= X;
|
|
unsigned int y = _idx % Y; _idx /= Y;
|
|
unsigned int z = _idx;
|
|
// transform to point coordinates
|
|
_idx = x + y*x_res + z*x_res*y_res;
|
|
// add offset
|
|
corner[i] = _idx + offsets_[i];
|
|
}
|
|
add_cube(value_fun,points,isovalue,corner,vertices,num_vertices,faces,num_faces,edge2vertex);
|
|
}
|
|
vertices.conservativeResize(num_vertices, Eigen::NoChange);
|
|
faces.conservativeResize(num_faces, Eigen::NoChange);
|
|
}
|
|
|
|
template <typename CubeIndexType>
|
|
static void add_cube(
|
|
const Eigen::MatrixBase<DerivedValues> &values,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const double isovalue,
|
|
const CubeIndexType corner[],
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
int &num_vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces,
|
|
int & num_faces,
|
|
MyMap &edge2vertex)
|
|
{
|
|
typedef typename DerivedFaces::Scalar SampleScalar;
|
|
SampleScalar samples[12];
|
|
unsigned char cubetype(0);
|
|
|
|
// determine cube type
|
|
for (int i=0; i<8; ++i)
|
|
{
|
|
if (values(corner[i]) > isovalue)
|
|
{
|
|
cubetype |= (1<<i);
|
|
}
|
|
}
|
|
|
|
// trivial reject ?
|
|
if (cubetype == 0 || cubetype == 255)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// compute samples on cube's edges
|
|
if (edgeTable[cubetype]&1)
|
|
samples[0] = add_vertex(values, points, isovalue, corner[0], corner[1], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&2)
|
|
samples[1] = add_vertex(values, points, isovalue, corner[1], corner[2], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&4)
|
|
samples[2] = add_vertex(values, points, isovalue, corner[3], corner[2], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&8)
|
|
samples[3] = add_vertex(values, points, isovalue, corner[0], corner[3], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&16)
|
|
samples[4] = add_vertex(values, points, isovalue, corner[4], corner[5], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&32)
|
|
samples[5] = add_vertex(values, points, isovalue, corner[5], corner[6], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&64)
|
|
samples[6] = add_vertex(values, points, isovalue, corner[7], corner[6], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&128)
|
|
samples[7] = add_vertex(values, points, isovalue, corner[4], corner[7], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&256)
|
|
samples[8] = add_vertex(values, points, isovalue, corner[0], corner[4], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&512)
|
|
samples[9] = add_vertex(values, points, isovalue, corner[1], corner[5], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&1024)
|
|
samples[10] = add_vertex(values, points, isovalue, corner[2], corner[6], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&2048)
|
|
samples[11] = add_vertex(values, points, isovalue, corner[3], corner[7], vertices, num_vertices, edge2vertex);
|
|
|
|
// connect samples by triangles
|
|
for (int i=0; triTable[cubetype][0][i] != -1; i+=3 )
|
|
{
|
|
num_faces++;
|
|
if (num_faces > faces.rows())
|
|
{
|
|
faces.conservativeResize(faces.rows()+10000, Eigen::NoChange);
|
|
}
|
|
faces.row(num_faces-1) <<
|
|
samples[triTable[cubetype][0][i ]],
|
|
samples[triTable[cubetype][0][i+1]],
|
|
samples[triTable[cubetype][0][i+2]];
|
|
}
|
|
};
|
|
|
|
template <typename DerivedValue, typename DerivedPoint, typename CubeIndexType>
|
|
static void add_cube(
|
|
const std::function< DerivedValue(const DerivedPoint & ) > & value_fun,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const double isovalue,
|
|
const CubeIndexType corner[],
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
int &num_vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces,
|
|
int & num_faces,
|
|
MyMap &edge2vertex)
|
|
{
|
|
typedef typename DerivedFaces::Scalar SampleScalar;
|
|
SampleScalar samples[12];
|
|
unsigned char cubetype(0);
|
|
|
|
// determine cube type
|
|
for (int i=0; i<8; ++i)
|
|
{
|
|
if (value_fun(points.row(corner[i])) > isovalue)
|
|
{
|
|
cubetype |= (1<<i);
|
|
}
|
|
}
|
|
|
|
// trivial reject ?
|
|
if (cubetype == 0 || cubetype == 255)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// compute samples on cube's edges
|
|
if (edgeTable[cubetype]&1)
|
|
samples[0] = add_vertex(value_fun, points, isovalue, corner[0], corner[1], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&2)
|
|
samples[1] = add_vertex(value_fun, points, isovalue, corner[1], corner[2], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&4)
|
|
samples[2] = add_vertex(value_fun, points, isovalue, corner[3], corner[2], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&8)
|
|
samples[3] = add_vertex(value_fun, points, isovalue, corner[0], corner[3], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&16)
|
|
samples[4] = add_vertex(value_fun, points, isovalue, corner[4], corner[5], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&32)
|
|
samples[5] = add_vertex(value_fun, points, isovalue, corner[5], corner[6], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&64)
|
|
samples[6] = add_vertex(value_fun, points, isovalue, corner[7], corner[6], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&128)
|
|
samples[7] = add_vertex(value_fun, points, isovalue, corner[4], corner[7], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&256)
|
|
samples[8] = add_vertex(value_fun, points, isovalue, corner[0], corner[4], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&512)
|
|
samples[9] = add_vertex(value_fun, points, isovalue, corner[1], corner[5], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&1024)
|
|
samples[10] = add_vertex(value_fun, points, isovalue, corner[2], corner[6], vertices, num_vertices, edge2vertex);
|
|
if (edgeTable[cubetype]&2048)
|
|
samples[11] = add_vertex(value_fun, points, isovalue, corner[3], corner[7], vertices, num_vertices, edge2vertex);
|
|
|
|
// connect samples by triangles
|
|
for (int i=0; triTable[cubetype][0][i] != -1; i+=3 )
|
|
{
|
|
num_faces++;
|
|
if (num_faces > faces.rows())
|
|
{
|
|
faces.conservativeResize(faces.rows()+10000, Eigen::NoChange);
|
|
}
|
|
faces.row(num_faces-1) <<
|
|
samples[triTable[cubetype][0][i ]],
|
|
samples[triTable[cubetype][0][i+1]],
|
|
samples[triTable[cubetype][0][i+2]];
|
|
}
|
|
};
|
|
|
|
static typename DerivedFaces::Scalar add_vertex(
|
|
const Eigen::MatrixBase<DerivedValues> &values,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const double isovalue,
|
|
unsigned int i0,
|
|
unsigned int i1,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
int &num_vertices,
|
|
MyMap &edge2vertex)
|
|
{
|
|
// find vertex if it has been computed already
|
|
MyMapIterator it = edge2vertex.find(EdgeKey(i0, i1));
|
|
if (it != edge2vertex.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
|
|
// generate new vertex
|
|
const Eigen::Matrix<typename DerivedPoints::Scalar, 1, 3> & p0 = points.row(i0);
|
|
const Eigen::Matrix<typename DerivedPoints::Scalar, 1, 3> & p1 = points.row(i1);
|
|
typename DerivedValues::Scalar s0 = fabs(values(i0)-isovalue);
|
|
typename DerivedValues::Scalar s1 = fabs(values(i1)-isovalue);
|
|
typename DerivedValues::Scalar t = s0 / (s0+s1);
|
|
num_vertices++;
|
|
if (num_vertices > vertices.rows())
|
|
{
|
|
vertices.conservativeResize(vertices.rows()+10000, Eigen::NoChange);
|
|
}
|
|
//
|
|
// Linear interpolation based on linearly interpolating values
|
|
vertices.row(num_vertices-1) = ((1.0f-t)*p0 + t*p1).template cast<typename DerivedVertices::Scalar>();
|
|
edge2vertex[EdgeKey(i0, i1)] = num_vertices-1;
|
|
return num_vertices-1;
|
|
}
|
|
|
|
template <typename DerivedValue, typename DerivedPoint>
|
|
static typename DerivedFaces::Scalar add_vertex(
|
|
const std::function< DerivedValue(const DerivedPoint & ) > & value_fun,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const double isovalue,
|
|
unsigned int i0,
|
|
unsigned int i1,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
int &num_vertices,
|
|
MyMap &edge2vertex)
|
|
{
|
|
// find vertex if it has been computed already
|
|
MyMapIterator it = edge2vertex.find(EdgeKey(i0, i1));
|
|
if (it != edge2vertex.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
num_vertices++;
|
|
if (num_vertices > vertices.rows())
|
|
{
|
|
vertices.conservativeResize(vertices.rows()+10000, Eigen::NoChange);
|
|
}
|
|
|
|
// generate new vertex
|
|
typedef Eigen::Matrix<typename DerivedPoints::Scalar, 1, 3> RowVector3S;
|
|
const RowVector3S & p0 = points.row(i0);
|
|
const RowVector3S & p1 = points.row(i1);
|
|
// Linear interpolation based on linearly interpolating values
|
|
//typename DerivedValues::Scalar s0 = fabs(value_fun(points.row(i0))-isovalue);
|
|
//typename DerivedValues::Scalar s1 = fabs(value_fun(points.row(i1))-isovalue);
|
|
//typename DerivedValues::Scalar t = s0 / (s0+s1);
|
|
const DerivedValue v1 = value_fun(p1);
|
|
double t0 = (v1>isovalue)?0:1;
|
|
double t1 = (v1>isovalue)?1:0;
|
|
double t;
|
|
for(int j = 0;j<10;j++)
|
|
{
|
|
t = 0.5*(t0+t1);
|
|
const double val = value_fun( ((1.0f-t)*p0 + t*p1) );
|
|
if( val > isovalue )
|
|
{
|
|
t1 = t;
|
|
}else
|
|
{
|
|
t0 = t;
|
|
}
|
|
}
|
|
vertices.row(num_vertices-1) = ((1.0f-t)*p0 + t*p1).template cast<typename DerivedVertices::Scalar>();
|
|
|
|
edge2vertex[EdgeKey(i0, i1)] = num_vertices-1;
|
|
return num_vertices-1;
|
|
}
|
|
|
|
// maps an edge to the sample vertex generated on it
|
|
MyMap edge2vertex;
|
|
};
|
|
|
|
|
|
template <typename DerivedValues, typename DerivedPoints, typename DerivedVertices, typename DerivedFaces>
|
|
IGL_INLINE void igl::copyleft::marching_cubes(
|
|
const Eigen::MatrixBase<DerivedValues> &values,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const unsigned x_res,
|
|
const unsigned y_res,
|
|
const unsigned z_res,
|
|
const double isovalue,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces)
|
|
{
|
|
typedef Eigen::MatrixXi Shim; /* DerivedIndices shim type is unused in this instantiation*/
|
|
MarchingCubes<DerivedValues, DerivedPoints, DerivedVertices, Shim, DerivedFaces>
|
|
mc(values, points, x_res, y_res, z_res, isovalue, vertices, faces);
|
|
}
|
|
|
|
template <
|
|
typename DerivedValue,
|
|
typename DerivedPoint,
|
|
typename DerivedPoints,
|
|
typename DerivedVertices,
|
|
typename DerivedFaces>
|
|
IGL_INLINE void igl::copyleft::marching_cubes(
|
|
const std::function< DerivedValue(const DerivedPoint & ) > & value_fun,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const unsigned x_res,
|
|
const unsigned y_res,
|
|
const unsigned z_res,
|
|
const double isovalue,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces)
|
|
{
|
|
MarchingCubes<
|
|
Eigen::Matrix<DerivedValue,Eigen::Dynamic,1>, /* unnecessary */
|
|
DerivedPoints, DerivedVertices,
|
|
Eigen::Matrix<int,Eigen::Dynamic,1>, /* unnecessary */
|
|
DerivedFaces> mc(value_fun, points, x_res, y_res, z_res, isovalue, vertices, faces);
|
|
}
|
|
|
|
template <typename DerivedValues, typename DerivedPoints, typename DerivedVertices, typename DerivedFaces>
|
|
IGL_INLINE void igl::copyleft::marching_cubes(
|
|
const Eigen::MatrixBase<DerivedValues> &values,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const unsigned x_res,
|
|
const unsigned y_res,
|
|
const unsigned z_res,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces)
|
|
{
|
|
typedef Eigen::MatrixXi Shim; /* DerivedIndices shim type is unused in this instantiation*/
|
|
MarchingCubes<DerivedValues, DerivedPoints, DerivedVertices, Shim, DerivedFaces>
|
|
mc(values, points, x_res, y_res, z_res, 0.0 /*isovalue*/, vertices, faces);
|
|
}
|
|
|
|
template <typename DerivedValues, typename DerivedPoints, typename DerivedVertices, typename DerivedIndices, typename DerivedFaces>
|
|
IGL_INLINE void igl::copyleft::marching_cubes(
|
|
const Eigen::MatrixBase<DerivedValues>& values,
|
|
const Eigen::MatrixBase<DerivedPoints>& points,
|
|
const Eigen::MatrixBase<DerivedIndices>& indices,
|
|
const double isovalue,
|
|
Eigen::PlainObjectBase<DerivedVertices>& vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces)
|
|
{
|
|
MarchingCubes<DerivedValues, DerivedPoints, DerivedVertices, DerivedIndices, DerivedFaces> mc(values, points, indices, isovalue, vertices, faces);
|
|
}
|
|
|
|
template <typename DerivedValues, typename DerivedPoints, typename DerivedVertices, typename DerivedIndices, typename DerivedFaces>
|
|
IGL_INLINE void igl::copyleft::marching_cubes(
|
|
const Eigen::MatrixBase<DerivedValues> &values,
|
|
const Eigen::MatrixBase<DerivedPoints> &points,
|
|
const Eigen::MatrixBase<DerivedIndices> & indices,
|
|
Eigen::PlainObjectBase<DerivedVertices> &vertices,
|
|
Eigen::PlainObjectBase<DerivedFaces> &faces)
|
|
{
|
|
MarchingCubes<DerivedValues, DerivedPoints, DerivedVertices, DerivedIndices, DerivedFaces> mc(values, points, indices, 0.0 /*isovalue*/, vertices, faces);
|
|
}
|
|
|
|
#ifdef IGL_STATIC_LIBRARY
|
|
// Explicit template instantiation
|
|
// generated by autoexplicit.sh
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, unsigned int, unsigned int, unsigned int, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<float, -1, 1, 0, -1, 1>, Eigen::Matrix<float, -1, 3, 0, -1, 3>, Eigen::Matrix<float, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<float, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 0, -1, 3> > const&, unsigned int, unsigned int, unsigned int, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<float, -1, 1, 0, -1, 1>, Eigen::Matrix<float, -1, 3, 1, -1, 3>, Eigen::Matrix<float, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<float, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> > const&, unsigned int, unsigned int, unsigned int, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<float, -1, 1, 0, -1, 1>, Eigen::Matrix<float, -1, -1, 0, -1, -1>, Eigen::Matrix<float, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<float, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<float, -1, -1, 0, -1, -1> > const&, unsigned int, unsigned int, unsigned int, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<float, -1, 3, 1, -1, 3>, Eigen::Matrix<int, -1, 3, 1, -1, 3> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, unsigned int, unsigned int, unsigned int, Eigen::PlainObjectBase<Eigen::Matrix<float, -1, 3, 1, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 1, -1, 3> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, unsigned int, unsigned int, unsigned int, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(const Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, const Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, const Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(const Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, const Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&, const Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(const Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, const Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, const Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(const Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, const Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&, const Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 8, 0, -1, 8>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(const Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&, const Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, const Eigen::MatrixBase<Eigen::Matrix<int, -1, 8, 0, -1, 8> >&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>,Eigen::Matrix<double, -1, -1, 0, -1, -1>,Eigen::Matrix<double, -1, -1, 0, -1, -1>,Eigen::Matrix<int, -1, -1, 0, -1, -1>,Eigen::Matrix<int, -1, 3, 0, -1, 3> >(const Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&,const Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&,const Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&,Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&,Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>,Eigen::Matrix<double, -1, -1, 0, -1, -1>,Eigen::Matrix<double, -1, -1, 0, -1, -1>,Eigen::Matrix<int, -1, 8, 0, -1, 8>,Eigen::Matrix<int, -1, 3, 0, -1, 3> >(const Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&,const Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&,const Eigen::MatrixBase<Eigen::Matrix<int, -1, 8, 0, -1, 8> >&,Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&,Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>,Eigen::Matrix<double, -1, 3, 0, -1, 3>,Eigen::Matrix<double, -1, 3, 0, -1, 3>,Eigen::Matrix<int, -1, 8, 0, -1, 8>,Eigen::Matrix<int, -1, 3, 0, -1, 3> >(const Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >&,const Eigen::MatrixBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&,const Eigen::MatrixBase<Eigen::Matrix<int, -1, 8, 0, -1, 8> >&,Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> >&,Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::MatrixBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
|
template void igl::copyleft::marching_cubes<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1> >(Eigen::MatrixBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> > const&, Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, unsigned int, unsigned int, unsigned int, double, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&);
|
|
#endif
|