├── src
    ├── read_obj.h
    ├── trimesh.h
    ├── make_signed_distance.h
    ├── optimize_tet_mesh.h
    ├── sdf.h
    ├── match_features.h
    ├── make_tet_mesh.h
    ├── geometry_queries.h
    ├── tet_quality.h
    ├── trimesh.cpp
    ├── tet_quality.cpp
    ├── read_obj.cpp
    ├── tet_mesh.h
    ├── sdf.cpp
    ├── geometry_queries.cpp
    ├── feature.h
    ├── gluvi.h
    ├── array3.h
    ├── make_signed_distance.cpp
    ├── main.cpp
    ├── util.h
    ├── vec.h
    ├── optimize_tet_mesh.cpp
    └── view_tet.cpp
├── meshes
    ├── cube.obj
    ├── cube.feat
    ├── joint.feat
    ├── sphere.obj
    ├── joint.obj
    ├── block.feat
    └── fandisk.feat
├── .gitignore
├── LICENSE
├── Makefile.defs
├── TODO
├── Makefile
└── README


/src/read_obj.h:
--------------------------------------------------------------------------------
 1 | #ifndef READ_OBJ_H
 2 | #define READ_OBJ_H
 3 | 
 4 | #include <vector>
 5 | #include "vec.h"
 6 | 
 7 | bool
 8 | read_objfile(std::vector<Vec3f>& x,
 9 |              std::vector<Vec3i>& tri,
10 |              const char *filename_format, ...);
11 | 
12 | bool
13 | write_objfile(const std::vector<Vec3f>& x,
14 |               const std::vector<Vec3i>& tri,
15 |               const char *filename_format, ...);
16 | 
17 | #endif
18 | 


--------------------------------------------------------------------------------
/meshes/cube.obj:
--------------------------------------------------------------------------------
 1 | v 0 0 0
 2 | v 0 0 1
 3 | v 0 1 0
 4 | v 0 1 1
 5 | v 1 0 0
 6 | v 1 0 1
 7 | v 1 1 0
 8 | v 1 1 1
 9 | vt 0 0
10 | vt 0 0
11 | vt 0 0
12 | vt 0 0
13 | vt 0 0
14 | vt 0 0
15 | vt 0 0
16 | vt 0 0
17 | f 3/1 4/2 8/3 
18 | f 3/1 1/4 2/5 
19 | f 4/2 2/5 6/6 
20 | f 8/3 6/6 5/7 
21 | f 2/5 1/4 5/7 
22 | f 1/4 3/1 7/8 
23 | f 8/3 7/8 3/1 
24 | f 2/5 4/2 3/1 
25 | f 6/6 8/3 4/2 
26 | f 5/7 7/8 8/3 
27 | f 5/7 6/6 2/5 
28 | f 7/8 5/7 1/4 
29 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | #*.obj
 6 | obj/*
 7 | obj_debug/*
 8 | 
 9 | # Precompiled Headers
10 | *.gch
11 | *.pch
12 | 
13 | # Compiled Dynamic libraries
14 | *.so
15 | *.dylib
16 | *.dll
17 | 
18 | # Fortran module files
19 | *.mod
20 | 
21 | # Compiled Static libraries
22 | *.lai
23 | *.la
24 | *.a
25 | *.lib
26 | 
27 | # Executables
28 | *.exe
29 | *.out
30 | *.app
31 | quartet
32 | quartet_release
33 | view_tet
34 | view_tet_release
35 | 
36 | 


--------------------------------------------------------------------------------
/src/trimesh.h:
--------------------------------------------------------------------------------
 1 | #ifndef TRIMESH_H
 2 | #define TRIMESH_H
 3 | 
 4 | #include "vec.h"
 5 | #include <vector>
 6 | 
 7 | 
 8 | class TriMesh
 9 | {
10 | public:
11 |     struct HalfEdge;
12 | 
13 |     struct Vertex
14 |     {
15 |         Vec3f p;
16 |         HalfEdge* e;
17 |     };
18 | 
19 |     struct Face
20 |     {
21 |         HalfEdge* e;
22 |     };
23 | 
24 |     struct HalfEdge
25 |     {
26 |         Vertex* v;
27 |         Face* f;
28 |         HalfEdge* prev, *next;
29 |         HalfEdge* sym;
30 |     };
31 | 
32 |     std::vector<Vertex> vertices;
33 |     std::vector<Face> faces;
34 |     std::vector<HalfEdge> edges;
35 | 
36 |     TriMesh(const std::vector<Vec3f>& x,
37 |             const std::vector<Vec3i>& tri);
38 | };
39 | 
40 | #endif
41 | 
42 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2014, crawforddoran <>
 2 | 
 3 | Permission to use, copy, modify, and/or distribute this software for any
 4 | purpose with or without fee is hereby granted, provided that the above
 5 | copyright notice and this permission notice appear in all copies.
 6 | 
 7 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 8 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 9 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
10 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
12 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
13 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
14 | 
15 | 


--------------------------------------------------------------------------------
/src/make_signed_distance.h:
--------------------------------------------------------------------------------
 1 | #ifndef MAKE_SIGNED_DISTANCE_H
 2 | #define MAKE_SIGNED_DISTANCE_H
 3 | 
 4 | #include "sdf.h"
 5 | #include "vec.h"
 6 | 
 7 | // Create a signed distance field for a water-tight triangle mesh (absolute
 8 | // distances will be pretty good even for arbitrary triangle soup, but
 9 | // correct signs rely on having a closed mesh).
10 | // Input tri is a list of triangles in the mesh, and x is the positions of the
11 | // vertices;
12 | // Variable sdf should already be initialized with the desired origin, grid
13 | // size and grid dimensions.  
14 | // Its values will be set up with the signed distance field.
15 | void
16 | make_signed_distance(const std::vector<Vec3i> &tri,
17 |                      const std::vector<Vec3f> &x,
18 |                      SDF &sdf);
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/meshes/cube.feat:
--------------------------------------------------------------------------------
 1 | feat 12
 2 | 2
 3 | 0.000000 0.000000 0.000000
 4 | 1.000000 0.000000 0.000000
 5 | 2
 6 | 0.000000 0.000000 0.000000
 7 | 0.000000 0.000000 1.000000
 8 | 2
 9 | 0.000000 0.000000 0.000000
10 | 0.000000 1.000000 0.000000
11 | 2
12 | 0.000000 0.000000 1.000000
13 | 1.000000 0.000000 1.000000
14 | 2
15 | 0.000000 0.000000 1.000000
16 | 0.000000 1.000000 1.000000
17 | 2
18 | 0.000000 1.000000 0.000000
19 | 0.000000 1.000000 1.000000
20 | 2
21 | 0.000000 1.000000 0.000000
22 | 1.000000 1.000000 0.000000
23 | 2
24 | 0.000000 1.000000 1.000000
25 | 1.000000 1.000000 1.000000
26 | 2
27 | 1.000000 0.000000 0.000000
28 | 1.000000 1.000000 0.000000
29 | 2
30 | 1.000000 0.000000 0.000000
31 | 1.000000 0.000000 1.000000
32 | 2
33 | 1.000000 0.000000 1.000000
34 | 1.000000 1.000000 1.000000
35 | 2
36 | 1.000000 1.000000 0.000000
37 | 1.000000 1.000000 1.000000
38 | 


--------------------------------------------------------------------------------
/Makefile.defs:
--------------------------------------------------------------------------------
 1 | # This file is included into the main Makefile, providing it with
 2 | # local machine settings.
 3 | # Most of it is platform-specific compilers, flags, and libraries.
 4 | # See below examples for which variables should be defined.
 5 | 
 6 | # For example, on a Linux PC this will likely work:
 7 | DEPEND = g++
 8 | CC = g++ -Wall
 9 | RELEASE_FLAGS = -O3 -DNDEBUG -funroll-loops
10 | DEBUG_FLAGS = -g
11 | LINK = g++
12 | LINK_LIBS = -lm
13 | VIEWER_LIBS = -lGL -lGLU -lglut
14 | 
15 | # Should work for Mingw (with freeglut installed)
16 | #DEPEND = g++
17 | #CC = g++ -Wall
18 | #RELEASE_FLAGS = -O3 -DNDEBUG -funroll-loops
19 | #DEBUG_FLAGS = -g
20 | #LINK = g++
21 | #LINK_LIBS = -lm
22 | #VIEWER_LIBS = -lopengl32 -lglu32 -lfreeglut
23 | 
24 | # On Mac OS X (on a G5), this probably will work:
25 | #DEPEND = g++
26 | #CC = g++ -Wall
27 | #RELEASE_FLAGS = -DNDEBUG -fast # add -mcpu=7450 for a G4, or -mcpu=750 for a G3 since -fast enables 970(G5) instructions by default
28 | #DEBUG_FLAGS = -g
29 | #LINK = g++
30 | #LINK_LIBS = -lm -lobjc
31 | #VIEWER_LIBS = -framework OpenGL -framework GLUT
32 | 


--------------------------------------------------------------------------------
/src/optimize_tet_mesh.h:
--------------------------------------------------------------------------------
 1 | #ifndef OPTIMIZE_TET_MESH_H
 2 | #define OPTIMIZE_TET_MESH_H
 3 | 
 4 | #include "tet_mesh.h"
 5 | #include "sdf.h"
 6 | #include "feature.h"
 7 | #include <vector>
 8 | #include <map>
 9 | 
10 | 
11 | // Optimize tetrahedral mesh to improve tet quality.
12 | //  mesh - the tetrahedral mesh to optimize
13 | //  sdf - the signed distance field representing the object the tet mesh
14 | //        should reproduce
15 | //  boundary_verts - the indices of the vertices on the boundary of the
16 | //                   tet mesh
17 | //  featureSet - The set of features that the tet mesh is constrained to match
18 | //  feature_endpoints - the indices of the vertices constrained to feature
19 | //                      endpoints. These vertices will not be moved.
20 | //  feature_edge_verts - maps vertex indices to the feature to which they  
21 | //                       they should be constrained
22 | float
23 | optimize_tet_mesh(TetMesh& mesh,
24 |                   const SDF& sdf,
25 |                   const std::vector<int>& boundary_verts,
26 |                   const FeatureSet& featureSet,
27 |                   const std::vector<int>& feature_endpoints,
28 |                   const std::map<int, int>& vertex_feature_map);
29 | 
30 | #endif
31 | 


--------------------------------------------------------------------------------
/src/sdf.h:
--------------------------------------------------------------------------------
 1 | #ifndef SDF_H
 2 | #define SDF_H
 3 | 
 4 | #include "array3.h"
 5 | #include "vec.h"
 6 | 
 7 | 
 8 | //
 9 | // Signed Distance Field
10 | //
11 | // Scalar field storing the shortest distance to an implicit surface
12 | // (which is therefore found at the zero-isosurface).
13 | // The field has a negative sign inside the surface and positive sign outside.
14 | // The scalar field phi is stored as a 3-dimensional array of values, and
15 | // trilinear interpolation is provided for arbitrary spatial lookups.
16 | //
17 | struct SDF
18 | {
19 |     Array3f phi;
20 |     const Vec3f origin;
21 |     const float dx;
22 | 
23 |     // Constructor
24 |     // origin is the origin of the 3D array.
25 |     // dx is the grid spacing in 3D space
26 |     // ni*nj*nk are the dimensions of the grid.
27 |     SDF(const Vec3f& origin,
28 |         const float dx,
29 |         int ni, int nj, int nk);
30 | 
31 |     // Evaluate the scalar field at the given point using 
32 |     // trilinear interpolation.
33 |     float operator() (const Vec3f& x) const;
34 | 
35 |     // Compute the gradient vector of the field at the given point.
36 |     Vec3f gradient(const Vec3f& x) const;
37 | 
38 |     // Compute the "normal" vector of the field at the given point.
39 |     // This is equivalent to the normalized gradient vector.
40 |     Vec3f normal(const Vec3f& x) const;
41 | 
42 |     // Project the given point x onto the zero-isosurface of the field.
43 |     // Note that this is only accurate if x is already near the isosurface.
44 |     Vec3f projectToIsosurface(const Vec3f& x) const;
45 | 
46 | private:
47 |     const float over_dx; // 1/dx
48 | };
49 | 
50 | #endif
51 | 


--------------------------------------------------------------------------------
/src/match_features.h:
--------------------------------------------------------------------------------
 1 | #ifndef MATCH_FEATURES_H
 2 | #define MATCH_FEATURES_H
 3 | 
 4 | #include "tet_mesh.h"
 5 | #include "feature.h"
 6 | #include "vec.h"
 7 | #include <vector>
 8 | #include <map>
 9 | 
10 | 
11 | // Modify the given TetMesh to match the features in the given FeatureSet.
12 | //  mesh - the TetMesh to be modified
13 | //  featureSet - the set of features to be matched by the mesh
14 | //  dx - the resolution of the mesh.  Features below this resolution are not
15 | //       guaranteed to be matched accurately.
16 | //  boundary_verts - indices of the boundary vertices of the mesh
17 | //  boundary_tris - triangles of the boundary mesh, stored as indices into the
18 | //                  vertices of the mesh
19 | //  feature_endpoints - on exit, stores the indices of the mesh vertices that
20 | //                      are now constrained to feature endpoints.
21 | //  vertex_feature_map - on exit, stores a mapping of vertex indices to the
22 | //                       indices of the features to which they are now 
23 | //                       constrained
24 | //  unsafe - if true, allow feature matching operations that might invert
25 | //           tetrahedra
26 | // Returns false iff the endpoints of the features could not be resolved,
27 | // indicating algorithm failure.
28 | bool
29 | match_features(TetMesh& mesh,
30 |                FeatureSet& featureSet,
31 |                float dx,
32 |                const std::vector<int>& boundary_verts,
33 |                const std::vector<Vec3i>& boundary_tris,
34 |                std::vector<int>& feature_endpoints,
35 |                std::map<int, int>& vertex_feature_map,
36 |                bool unsafe = false);
37 | 
38 | #endif
39 | 


--------------------------------------------------------------------------------
/src/make_tet_mesh.h:
--------------------------------------------------------------------------------
 1 | #ifndef MAKE_TET_MESH_H
 2 | #define MAKE_TET_MESH_H
 3 | 
 4 | #include "sdf.h"
 5 | #include "tet_mesh.h"
 6 | #include "feature.h"
 7 | 
 8 | // From a signed distance function sdf, create a tetrahedral mesh of 
 9 | // its interior.
10 | // We use an isosurface stuffing approach starting from an acute lattice.
11 | //  mesh - The tetrahedral mesh to be constructed.
12 | //  sdf - The signed distance field from which the mesh will be built
13 | //  optimize - if true, the mesh will be optimized after construction
14 | //  outputIntermediateMeshes - if true, the mesh will be output at various 
15 | //                             intermediate stages of the mesh generation 
16 | //                             process.
17 | void
18 | make_tet_mesh(TetMesh& mesh,
19 |               const SDF& sdf,
20 |               bool optimize = true,
21 |               bool outputIntermediateMeshes = false,
22 |               bool unsafeFeatureMatching = false);
23 | 
24 | 
25 | // Create tetrahedral mesh as above that also incorporates the 
26 | // sharp features found in the given featureSet.
27 | //  sdf - The signed distance field from which the mesh will be built
28 | //  mesh - The tetrahedral mesh to be constructed.
29 | //  featureSet - A set of features (points and edges) that will be
30 | //               matched as closely as possible by the constructed tet mesh.
31 | //  optimize - if true, the mesh will be optimized after construction
32 | //  outputIntermediateMeshes - if true, the mesh will be output at various 
33 | //                             intermediate stages of the mesh generation 
34 | //                             process.
35 | void 
36 | make_tet_mesh(TetMesh& mesh,
37 |               const SDF& sdf,
38 |               FeatureSet& featureSet,
39 |               bool optimize = true,
40 |               bool outputIntermediateMeshes = false,
41 |               bool unsafeFeatureMatching = false);
42 | 
43 | #endif
44 | 


--------------------------------------------------------------------------------
/src/geometry_queries.h:
--------------------------------------------------------------------------------
 1 | #ifndef GEOMETRY_QUERIES_H
 2 | #define GEOMETRY_QUERIES_H
 3 | 
 4 | #include "vec.h"
 5 | 
 6 | 
 7 | // Initializes values needed for exact arithmetic.
 8 | // Call this before calling orientation predicates!
 9 | double initialize_exact();
10 | 
11 | // find distance x0 is from segment x1-x2
12 | float
13 | point_segment_distance(const Vec3f &x0,
14 |                        const Vec3f &x1,
15 |                        const Vec3f &x2);
16 | 
17 | // find distance x0 is from triangle x1-x2-x3
18 | float
19 | point_triangle_distance(const Vec3f &x0,
20 |                         const Vec3f &x1,
21 |                         const Vec3f &x2,
22 |                         const Vec3f &x3);
23 | 
24 | // Calculate twice signed area of triangle (0,0)-(x1,y1)-(x2,y2) and return an
25 | // SOS-determined sign (-1, +1, or 0 only if it's a truly degenerate triangle)
26 | int
27 | orientation(double x1, double y1,
28 |             double x2, double y2,
29 |             double &twice_signed_area);
30 | 
31 | // Robust test of (x0,y0) in the triangle (x1,y1)-(x2,y2)-(x3,y3), with SOS
32 | // determination of edge and corner cases.
33 | // If true is returned, the barycentric coordinates are set in a,b,c;
34 | // if false is returned, they could be partially overwritten - do not trust.
35 | bool point_in_triangle_2d(double x0, double y0, 
36 |                           double x1, double y1,
37 |                           double x2, double y2,
38 |                           double x3, double y3,
39 |                           double& a, double& b, double& c);
40 | 
41 | 
42 | // Calculate six times the signed area of the tetrahedron
43 | // (a_x,a_y,a_z)-(b_x,b_y,b_z)-(c_x,c_y,c_z)-(0,0,0)
44 | // and return an SOS-determined sign
45 | // (-1, +1, or 0 only if the tet is truly degenerate).
46 | int orientation3D(double a_x, double a_y, double a_z,
47 |                   double b_x, double b_y, double b_z,
48 |                   double c_x, double c_y, double c_z,
49 |                   double d_x, double d_y, double d_z,
50 |                   double &six_signed_volume);
51 | 
52 | #endif
53 | 


--------------------------------------------------------------------------------
/src/tet_quality.h:
--------------------------------------------------------------------------------
 1 | #ifndef TET_QUALITY_H
 2 | #define TET_QUALITY_H
 3 | 
 4 | #include "tet_mesh.h"
 5 | 
 6 | //
 7 | // Implementations of different quality metric for tetrahedra.
 8 | // All quality metrics should conform to the following:
 9 | //  - Equilateral tetrahedra should have a quality measure of 1.0, which is 
10 | //    the maximum (ie: quality measure should be normalized).
11 | //  - Degenerate tetrahedra should have a quality measure of zero
12 | //  - Inverted tetrahedra should have a negative quality measure.
13 | //
14 | // Ideally these measures should also be scale-invariant.
15 | //
16 | // This gets its own file (ie: is not part of the Tet or TetMesh classes)
17 | // because we want to be able to use these quality metrics interchangeably.
18 | // One user might want to optimize based on max dihedral angle, whereas
19 | // another might want to use aspect ratio.
20 | //
21 | // So ideally, client code should be able to choose which quality function
22 | // (or maybe function object/functor in the future) they want to use.
23 | // Then any code that calls compute_tet_quality will use the chosen 
24 | // quality function without needing to know about it.
25 | //
26 | 
27 | //
28 | // Quality metrics
29 | //
30 | 
31 | // Largest dihedral angle
32 | float
33 | max_dihedral_angle(const Tet& tet);
34 | 
35 | // Minimum sine of dihedral angle
36 | float
37 | min_sine_dihedral_angle(const Tet& tet);
38 | 
39 | // Smallest face angle
40 | float
41 | min_face_angle(const Tet& tet);
42 | 
43 | // Aspect ratio is the longest edge length divided by the shortest altitude
44 | float
45 | aspect_ratio(const Tet& tet);
46 | 
47 | 
48 | //
49 | // Abstract quality metric function.
50 | //
51 | 
52 | // Compute a quality metric for the given tetrahedron.
53 | // The quality metric has an optimal (normalized) value of 1.0.
54 | // Degenerate tets have a quality value of 0.0, and inverted tets have 
55 | // a negative quality value.
56 | inline float
57 | compute_tet_quality(const Tet& tet) {
58 |     return aspect_ratio(tet);
59 | 
60 |     // TODO: Appropriate design pattern to allow plugging in 
61 |     // different metrics as desired.
62 | }
63 | 
64 | #endif
65 | 


--------------------------------------------------------------------------------
/src/trimesh.cpp:
--------------------------------------------------------------------------------
 1 | #include "trimesh.h"
 2 | 
 3 | #include <map>
 4 | 
 5 | 
 6 | TriMesh::TriMesh(const std::vector<Vec3f>& x,
 7 |                  const std::vector<Vec3i>& tri)
 8 |     : vertices(x.size()), faces(tri.size()), edges(tri.size()*3)
 9 | {
10 |     for (size_t v = 0; v < vertices.size(); ++v)
11 |     {
12 |         vertices[v].p = x[v];
13 |     }
14 | 
15 |     // For keeping track of edges that we haven't paired off yet.
16 |     std::map<std::pair<int,int>,int> unmatchedEdges;
17 |     std::map<std::pair<int,int>,int>::iterator edgeItr;
18 | 
19 |     for (size_t f = 0; f < faces.size(); ++f)
20 |     {
21 |         const Vec3i& t = tri[f];
22 |         HalfEdge* e = &(edges[3*f]);
23 | 
24 |         for (int i = 0; i < 3; ++i)
25 |         {
26 |             // Associate vertex and edge.
27 |             e[i].v = &(vertices[t[i]]);
28 |             e[i].v->e = &(e[i]);
29 | 
30 |             // Associate edge with face.
31 |             e[i].f = &(faces[f]);
32 | 
33 |             // Link up edges.
34 |             e[i].prev = &(e[(i+2)%3]);
35 |             e[i].next = &(e[(i+1)%3]);
36 | 
37 |             // Match symmetric edges
38 |             std::pair<int,int> tempEdge(t[i], t[(i+1)%3]);
39 |             if (tempEdge.first > tempEdge.second)
40 |             {
41 |                 // Lower vertex index always comes first.
42 |                 tempEdge.first = tempEdge.second;
43 |                 tempEdge.second = t[i];
44 |             }
45 |             edgeItr = unmatchedEdges.find(tempEdge);
46 |             if (edgeItr == unmatchedEdges.end())
47 |             {
48 |                 // The pair to this edge has not been found yet.
49 |                 // Save the index of the current half-edge for later.
50 |                 unmatchedEdges[tempEdge] = 3*f+i;
51 |             }
52 |             else
53 |             {
54 |                 // The pair was already found, pair it with the current edge.
55 |                 e[i].sym = &(edges[edgeItr->second]);
56 |                 e[i].sym->sym = &(e[i]);
57 |                 unmatchedEdges.erase(edgeItr);
58 |             }
59 |         }
60 | 
61 |         // Associate face with the first edge.
62 |         e[0].f->e = &(e[0]);
63 |     }
64 | }
65 | 
66 | 
67 | 


--------------------------------------------------------------------------------
/TODO:
--------------------------------------------------------------------------------
 1 | - A better build setup (eg: cmake)
 2 | 
 3 | - Iteratively alternate between optimization and progressive feature matching
 4 | 
 5 | - Alternative feature matching strategies
 6 |     - Move neighbors when snapping vertex (ie: energy/spring model, 
 7 |         displacement kernel).
 8 |     - Snap lattice vertices to features before doing isosurface stuffing.
 9 |     - OR Snap lattice vertices to feature endpoints (not full features) 
10 |         before doing isosurface stuffing.
11 | 
12 | - Ensure optimality of path search
13 |     - Right now not guaranteed to be optimal because the tet inversion test
14 |       depends on the path taken to a particular vertex, not just the edges
15 |       and weights of the graph.
16 | 
17 | - Use tet quality metrics to choose optimal paths during edge snapping
18 |     (instead of just minimizing the distance that vertices are moved).
19 |     - This may require Bellman-Ford (for negative edge weights), because
20 |         it's possible that snapping a vertex could actually improve the 
21 |         tet that it's a part of (our distance-minimizing algorithm
22 |         assumes that moving a vertex will always make the tet worse).
23 | 
24 | - Improve mesh data structure efficiency
25 |     - ie: adjacency list for triangle mesh, O(1) neighbor lookup, improve 
26 |         efficiency of graph search in match_features
27 |           - Efficient TriMesh class created (half-edge data structures),
28 |             but it isn't applicable to the mesh we've been using that 
29 |             indexes into the vertices of a TetMesh.
30 | 
31 | 
32 | Less important stuff:
33 | - Better tet-mesh data structures
34 |     - More efficient traversal of edges, triangles.
35 | 
36 | - Tet Quality measures
37 |     - Design pattern for plugging in arbitrary quality measure?
38 | 
39 | - FeatureSet::consolidate()
40 | 
41 | - Allow topology changes when matching features.
42 |     - If unable to find path between two vertices separated by two boundary
43 |         triangles, do an "edge split" or "edge flip" on the edge separating 
44 |         them.
45 | 
46 | - Curvature for automatic feature detection to detect feature points.
47 | 
48 | - Additional misc optimizations
49 | 
50 | - Handle more mesh file formats
51 |     - .OFF (input, triangles)
52 |     - .ELE (output, tets)
53 | 
54 | 


--------------------------------------------------------------------------------
/src/tet_quality.cpp:
--------------------------------------------------------------------------------
  1 | #include "tet_quality.h"
  2 | 
  3 | 
  4 | static const float SQRT2 = sqrt(2.0);
  5 | static const float PI_3_INV = 3.0/M_PI;
  6 | static const float OPT_DIHEDRAL = asin(2.0*sqrt(2.0)/3.0);
  7 | 
  8 | 
  9 | float
 10 | max_dihedral_angle(const Tet& tet)
 11 | {
 12 |     int orient = tet.orientation();
 13 | 
 14 |     if (orient == 0)
 15 |     {
 16 |         return 0.0;
 17 |     }
 18 | 
 19 |     std::vector<float> angles;
 20 |     tet.dihedralAngles(angles);
 21 |     float maxAngle = angles[0];
 22 |     for (size_t i = 1; i < angles.size(); ++i)
 23 |     {
 24 |         if (angles[i] > maxAngle)
 25 |         {
 26 |             maxAngle = angles[i];
 27 |         }
 28 |     }
 29 | 
 30 |     // maxAngle will be between OPT_DIHEDRAL and M_PI.
 31 |     // Normalize to the range (0,1) and flip so that 0 corresponds to M_PI
 32 |     // and 1 corresponds to OPT_DIHEDRAL.
 33 |     float quality = 1.0 - (maxAngle-OPT_DIHEDRAL)/(M_PI-OPT_DIHEDRAL);
 34 | 
 35 |     if (orient < 0)
 36 |     {
 37 |         quality *= -1.0;
 38 |     }
 39 | 
 40 | 	return quality;
 41 | }
 42 | 
 43 | 
 44 | float
 45 | min_sine_dihedral_angle(const Tet& tet)
 46 | {
 47 |     int orient = tet.orientation();
 48 |     if (orient == 0)
 49 |     {
 50 |         return 0.0;
 51 |     }
 52 | 
 53 |     std::vector<float> angles;
 54 |     tet.dihedralAngles(angles);
 55 |     float minSin = sin(angles[0]);
 56 |     for (size_t i = 1; i < angles.size(); ++i)
 57 |     {
 58 |         float sinAngle = sin(angles[i]);
 59 |         if (minSin > sinAngle)
 60 |         {
 61 |             minSin = sinAngle;
 62 |         }
 63 |     }
 64 | 
 65 |     if (orient < 0)
 66 |     {
 67 |         minSin *= -1.0;
 68 |     }
 69 | 
 70 |     return minSin;
 71 | }
 72 | 
 73 | 
 74 | float
 75 | min_face_angle(const Tet& tet)
 76 | {
 77 |     int orient = tet.orientation();
 78 |     if (orient == 0)
 79 |     {
 80 |         return 0.0;
 81 |     }
 82 | 
 83 |     std::vector<float> angles;
 84 |     tet.faceAngles(angles);
 85 |     float minAngle = angles[0];
 86 |     for (size_t i = 1; i < angles.size(); ++i)
 87 |     {
 88 |         if (angles[i] < minAngle)
 89 |         {
 90 |             minAngle = angles[i];
 91 |         }
 92 |     }
 93 | 
 94 |     // Normalize
 95 |     minAngle *= PI_3_INV;
 96 | 
 97 |     // Compute orientation to determine sign of result.
 98 |     if (orient < 0)
 99 |     {
100 |         minAngle *= -1.0;
101 |     }
102 | 
103 |     return minAngle;
104 | }
105 | 
106 | 
107 | float
108 | aspect_ratio(const Tet& tet)
109 | {
110 |     // Want to minimize aspect ratio, so invert.
111 |     // Normalize by sqrt(2).
112 |     return SQRT2 / tet.aspectRatio();
113 | }
114 | 
115 | 
116 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
  1 | # Makefile for quartet
  2 | #
  3 | # This Makefile depends on a file called "Makefile.defs" which contains
  4 | # platform-specific definitions.
  5 | #
  6 | # To build quartet, first run "make depend" (which relies on g++ version 3.1 or
  7 | # higher) and then either "make" (equivalent to "make debug") or "make release".
  8 | #
  9 | # This is for GNU make; other versions of make may not run correctly.
 10 | 
 11 | MAIN_PROGRAM = quartet
 12 | SRC = predicates.cpp           \
 13 |       geometry_queries.cpp     \
 14 |       sdf.cpp                  \
 15 |       trimesh.cpp              \
 16 |       tet_mesh.cpp             \
 17 |       feature.cpp              \
 18 |       read_obj.cpp             \
 19 |       tet_quality.cpp          \
 20 |       match_features.cpp       \
 21 |       optimize_tet_mesh.cpp    \
 22 |       make_signed_distance.cpp \
 23 |       make_tet_mesh.cpp        \
 24 |       main.cpp
 25 | 
 26 | VIEWER_PROGRAM = view_tet
 27 | VIEWER_SRC = gluvi.cpp             \
 28 |              view_tet.cpp          \
 29 |              feature.cpp           \
 30 |              read_obj.cpp          \
 31 |              predicates.cpp        \
 32 |              geometry_queries.cpp  \
 33 |              tet_mesh.cpp          \
 34 |              tet_quality.cpp
 35 | 
 36 | 
 37 | SRC_ALL = $(SRC) $(VIEWER_SRC)
 38 | 
 39 | include Makefile.defs
 40 | 
 41 | # object files
 42 | RELEASE_OBJ = $(patsubst %.cpp,obj/%.o,$(notdir $(SRC)))
 43 | VIEWER_RELEASE_OBJ = $(patsubst %.cpp,obj/%.o,$(notdir $(VIEWER_SRC)))
 44 | DEBUG_OBJ = $(patsubst %.cpp,obj_debug/%.o,$(notdir $(SRC)))
 45 | VIEWER_DEBUG_OBJ = $(patsubst %.cpp,obj_debug/%.o,$(notdir $(VIEWER_SRC)))
 46 | 
 47 | .PHONY: all
 48 | all: debug
 49 | 
 50 | # how to make the main target (debug mode, the default)
 51 | $(MAIN_PROGRAM): $(DEBUG_OBJ)
 52 | 	$(LINK) $(DEBUG_LINKFLAGS) -o $@ $^ $(LINK_LIBS)
 53 | 
 54 | # how to make the main target (release mode)
 55 | $(MAIN_PROGRAM)_release: $(RELEASE_OBJ)
 56 | 	$(LINK) $(RELEASE_LINKFLAGS) -o $@ $^ $(LINK_LIBS)
 57 | 
 58 | # how to make the viewer application (debug mode, the default)
 59 | $(VIEWER_PROGRAM): $(VIEWER_DEBUG_OBJ)
 60 | 	$(LINK) $(DEBUG_LINKFLAGS) -o $@ $^ $(LINK_LIBS) $(VIEWER_LIBS)
 61 | 
 62 | # how to make the viewer application (release mode)
 63 | $(VIEWER_PROGRAM)_release: $(VIEWER_RELEASE_OBJ)
 64 | 	$(LINK) $(RELEASE_LINKFLAGS) -o $@ $^ $(LINK_LIBS) $(VIEWER_LIBS)
 65 | 
 66 | # how to compile the predicates.cpp source file
 67 | # This is different because optimization must be disabled 
 68 | # (at least, according to the TetGen source... not sure if it's true or not)
 69 | obj/predicates.o: src/predicates.cpp
 70 | 	$(CC) -c $(RELEASE_FLAGS) -O0 -o $@ $^
 71 | obj_debug/predicates.o: src/predicates.cpp
 72 | 	$(CC) -c $(DEBUG_FLAGS) -O0 -o $@ $^ 
 73 | 
 74 | 
 75 | .PHONY: release
 76 | release: $(MAIN_PROGRAM)_release $(VIEWER_PROGRAM)_release
 77 | 
 78 | .PHONY: debug
 79 | debug: $(MAIN_PROGRAM) $(VIEWER_PROGRAM)
 80 | 
 81 | # how to compile each file
 82 | .SUFFIXES:
 83 | obj/%.o:
 84 | 	$(CC) -c $(RELEASE_FLAGS) -o $@ $<
 85 | obj_debug/%.o:
 86 | 	$(CC) -c $(DEBUG_FLAGS) -o $@ $<
 87 | 
 88 | # cleaning up
 89 | .PHONY: clean
 90 | clean:
 91 | 	-rm -f obj/*.o $(MAIN_PROGRAM) $(VIEWER_PROGRAM) obj_debug/*.o $(MAIN_PROGRAM)_release $(VIEWER_PROGRAM)_release *core
 92 | 
 93 | # dependencies are automatically generated
 94 | .PHONY: depend
 95 | depend:
 96 | 	-mkdir obj
 97 | 	-rm -f obj/depend
 98 | 	$(foreach srcfile,$(SRC_ALL),$(DEPEND) -MM src/$(srcfile) -MT $(patsubst %.cpp,obj/%.o,$(notdir $(srcfile))) >> obj/depend;)
 99 | 	-mkdir obj_debug
100 | 	-rm -f obj_debug/depend
101 | 	$(foreach srcfile,$(SRC_ALL),$(DEPEND) -MM src/$(srcfile) -MT $(patsubst %.cpp,obj_debug/%.o,$(notdir $(srcfile))) >> obj_debug/depend;)
102 | 
103 | -include obj/depend
104 | -include obj_debug/depend
105 | 


--------------------------------------------------------------------------------
/src/read_obj.cpp:
--------------------------------------------------------------------------------
  1 | #include "read_obj.h"
  2 | #include <fstream>
  3 | #include <cmath>
  4 | #include <cstdarg>
  5 | #include <cstdlib>
  6 | 
  7 | #define LINESIZE 1024 // maximum line size when reading .OBJ files
  8 | 
  9 | static bool
 10 | read_int(const char *s,
 11 |          int &value,
 12 |          bool &leading_slash,
 13 |          int &position)
 14 | {
 15 |     leading_slash=false;
 16 |     for(position=0; s[position]!=0; ++position){
 17 |         switch(s[position]){
 18 |             case '/':
 19 |                 leading_slash=true;
 20 |                 break;
 21 |             case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
 22 |                 goto found_int;
 23 |         }
 24 |     }
 25 |     return false;
 26 | 
 27 | found_int:
 28 |     value=0;
 29 |     for(;; ++position){
 30 |         switch(s[position]){
 31 |             case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
 32 |                 value=10*value+s[position]-'0';
 33 |                 break;
 34 |             default:
 35 |                 return true;
 36 |         }
 37 |     }
 38 |     return true; // should never get here, but keeps compiler happy
 39 | }
 40 | 
 41 | static void
 42 | read_face_list(const char *s,
 43 |                std::vector<int> &vertex_list)
 44 | {
 45 |     vertex_list.clear();
 46 |     int v, skip;
 47 |     bool leading_slash;
 48 |     for(int i=0;;){
 49 |         if(read_int(s+i, v, leading_slash, skip)){
 50 |             if(!leading_slash)
 51 |                 vertex_list.push_back(v-1); // correct for 1-based index
 52 |             //          vertex_list.push_back(v); // correct for 0-based index
 53 |             i+=skip;
 54 |         }else
 55 |             break;
 56 |     }
 57 | }
 58 | 
 59 | bool
 60 | read_objfile(std::vector<Vec3f>& x,
 61 |              std::vector<Vec3i>& tri,
 62 |              const char *filename_format, ...)
 63 | {
 64 |     va_list ap;
 65 |     va_start(ap, filename_format);
 66 | #ifdef WIN32
 67 | #define FILENAMELENGTH 256
 68 |    char filename[FILENAMELENGTH];
 69 |    _vsnprintf(filename, FILENAMELENGTH, filename_format, ap);
 70 |    std::ifstream input(filename, std::ifstream::binary);
 71 | #else
 72 |    char *filename;
 73 |    if (vasprintf(&filename, filename_format, ap) == -1) {
 74 |         return false;
 75 |    }
 76 |    std::ifstream input(filename, std::ifstream::binary);
 77 |    std::free(filename);
 78 | #endif
 79 |     va_end(ap);
 80 | 
 81 |     if(!input.good()) return false;
 82 | 
 83 |     x.clear();
 84 |     tri.clear();
 85 | 
 86 |     char line[LINESIZE];
 87 |     std::vector<int> vertex_list;
 88 |     while(input.good()){
 89 |         input.getline(line, LINESIZE);
 90 |         switch(line[0]){
 91 |             case 'v': // vertex data
 92 |                 if(line[1]==' '){
 93 |                     Vec3f new_vertex;
 94 |                     std::sscanf(line+2, "%f %f %f", &new_vertex[0],
 95 |                                                     &new_vertex[1],
 96 |                                                     &new_vertex[2]);
 97 |                     x.push_back(new_vertex);
 98 |                 }
 99 |                 break;
100 |             case 'f': // face data
101 |                 if(line[1]==' '){
102 |                     read_face_list(line+2, vertex_list);
103 |                     for(int j=0; j<(int)vertex_list.size()-2; ++j)
104 |                         tri.push_back(Vec3i(vertex_list[0],
105 |                                             vertex_list[j+1],
106 |                                             vertex_list[j+2]));
107 |                 }
108 |                 break;
109 |         }
110 |     }
111 |     return true;
112 | }
113 | 
114 | 
115 | bool
116 | write_objfile(const std::vector<Vec3f>& x,
117 |               const std::vector<Vec3i>& tri,
118 |               const char *filename_format, ...)
119 | {
120 |     va_list ap;
121 |     va_start(ap, filename_format);
122 | #ifdef WIN32
123 | #define FILENAMELENGTH 256
124 |    char filename[FILENAMELENGTH];
125 |    _vsnprintf(filename, FILENAMELENGTH, filename_format, ap);
126 |    std::ofstream output(filename);
127 | #else
128 |    char *filename;
129 |    if (vasprintf(&filename, filename_format, ap) == -1) {
130 |        return false;
131 |    }
132 |    std::ofstream output(filename);
133 |    std::free(filename);
134 | #endif
135 |     va_end(ap);
136 |     
137 |     if(!output.good()) return false;
138 | 
139 |     for (size_t v = 0; v < x.size(); ++v)
140 |     {
141 |         output << "v " << x[v][0] << " " << x[v][1] << " " << x[v][2] 
142 |                << std::endl;
143 |     }
144 |     for (size_t f = 0; f < tri.size(); ++f)
145 |     {
146 |         output << "f " << tri[f][0]+1 << " " 
147 |                        << tri[f][1]+1 << " " 
148 |                        << tri[f][2]+1
149 |                << std::endl;
150 |     }
151 |     
152 |     return true;
153 | }
154 | 
155 | 


--------------------------------------------------------------------------------
/src/tet_mesh.h:
--------------------------------------------------------------------------------
  1 | #ifndef TET_MESH_H
  2 | #define TET_MESH_H
  3 | 
  4 | #include "vec.h"
  5 | #include <vector>
  6 | 
  7 | //
  8 | // Data structure representing a single tetrahedron.
  9 | //
 10 | struct Tet
 11 | {
 12 |     Vec3f v[4]; // The four vertices of the tetrahedron.
 13 | 
 14 |     Tet() { }
 15 |     Tet(const Vec3f& v0, const Vec3f& v1, const Vec3f& v2, const Vec3f& v3);
 16 | 
 17 |     Vec3f& operator[] (int i) { return v[i]; }
 18 |     const Vec3f& operator[] (int i) const { return v[i]; }
 19 | 
 20 |     int orientation(double &sixSignedVolume) const;
 21 |     int orientation() const;
 22 | 
 23 |     float volume() const;
 24 |     float aspectRatio() const;
 25 | 
 26 |     void dihedralAngles(std::vector<float>& angles) const;
 27 |     void faceAngles(std::vector<float>& angles) const;
 28 | 
 29 |     float maxEdgeLength() const;
 30 | };
 31 | 
 32 | 
 33 | //
 34 | // Data structure representing a tetrahedral mesh.
 35 | //
 36 | struct TetMesh
 37 | {
 38 |     // Default constructor
 39 |     TetMesh() : dirty(false) {}
 40 |     // Copy constructor
 41 |     TetMesh(const TetMesh& mesh) : v(mesh.v), t(mesh.t), dirty(true) {}
 42 |     // Construct from vertices and tet indices
 43 |     TetMesh(const std::vector<Vec3f>& verts, 
 44 |             const std::vector<Vec4i>& tets) :
 45 |         v(verts), t(tets), dirty(true) {}
 46 | 
 47 |     // Returns the position of the vertex stored at index i.
 48 |     Vec3f& V(int i) { return v[i]; }
 49 |     const Vec3f& V(int i) const { return v[i]; }
 50 | 
 51 |     // Returns the indices of the tetrahedron stored at index i.
 52 |     Vec4i& T(int i) { dirty = true; return t[i]; }
 53 |     const Vec4i& T(int i) const { return t[i]; }
 54 | 
 55 |     // Returns the list of this tet mesh's vertices.
 56 |     std::vector<Vec3f>& verts() { dirty = true; return v; }
 57 |     const std::vector<Vec3f>& verts() const { return v; }
 58 | 
 59 |     // Returns the list of this tet mesh's tetrahedron indices.
 60 |     std::vector<Vec4i>& tets() { dirty = true; return t; }
 61 |     const std::vector<Vec4i>& tets() const { return t; }
 62 | 
 63 |     // Returns the number of vertices in the tet mesh.
 64 |     size_t vSize() const { return v.size(); }
 65 | 
 66 |     // Returns the number of tetrahedra in the mesh.
 67 |     size_t tSize() const { return t.size(); }
 68 | 
 69 |     // Returns the tetrahedron stored at index t.
 70 |     Tet getTet(int t) const;
 71 | 
 72 |     // Fills the given list with all indices of all the vertices 
 73 |     // that are adjacent to the given vertex.
 74 |     void getAdjacentVertices(int vertex, std::vector<int>& vertices) const;
 75 |     // Fills the given list with all the tets incident to the given vertex.
 76 |     void getIncidentTets(int vertex, std::vector<Tet>& tets) const;
 77 |     // Fills the given list with the indices of tets incident to vertex.
 78 |     void getIncidentTetIndices(int vertex, std::vector<int>& tetIndices) const;
 79 | 
 80 |     // Clean up the mesh, getting rid of unused vertices.
 81 |     // Tetrahedral indices adjusted accordingly.
 82 |     void compactMesh();
 83 | 
 84 |     // Extract boundary vertices and triangles from the tet mesh.
 85 |     // Vertices will be returned in boundary_verts as indices into the 
 86 |     // tet mesh vertex list v.
 87 |     // Triangles are stored in boundary_tris.  These are also indices into v, 
 88 |     // NOT as indices into boundary_verts!!!
 89 |     // Assumes that the tet mesh is well-formed and closed...
 90 |     void getBoundary(std::vector<int>& boundary_verts,
 91 |                      std::vector<Vec3i>& boundary_tris) const;
 92 | 
 93 |     // Extract boundary vertices and triangles from the tet mesh.
 94 |     // Vertices will be copied into boundary_verts.
 95 |     // Triangles are stored in boundary_tris.  These are indices into 
 96 |     // boundary_verts. 
 97 |     // Assumes that the tet mesh is well-formed and closed...
 98 |     void getBoundary(std::vector<Vec3f>& boundary_verts,
 99 |                      std::vector<Vec3i>& boundary_tris) const;
100 | 
101 |     // Write this TetMesh to file with the given name.
102 |     // The output file will be of the .TET format.
103 |     bool writeToFile(const char* filename) const;
104 | 
105 |     // Compute information about this TetMesh (dihedral angles, tet volumes,
106 |     // etc.) and write it to the file with the given name.
107 |     bool writeInfoToFile(const char* filename) const;
108 | 
109 | private:
110 |     std::vector<Vec3f> v;
111 |     std::vector<Vec4i> t;
112 | 
113 |     // Stores the indices of the tetrahedra incident to each vertex.
114 |     mutable std::vector< std::vector<int> > incidenceMap;
115 |     // Indicates whether the incidence map may need to be rebuilt.
116 |     mutable bool dirty; 
117 | 
118 |     // Re-create the incidence map from the current v and t lists.
119 |     // This is const because we need to be able to call it from 
120 |     // getIncidentTets(), which is const.  
121 |     // incidenceMap and dirty are mutable as a result.
122 |     void buildIncidenceMap() const;
123 | };
124 | 
125 | #endif
126 | 


--------------------------------------------------------------------------------
/src/sdf.cpp:
--------------------------------------------------------------------------------
  1 | #include "sdf.h"
  2 | 
  3 | 
  4 | SDF::SDF(const Vec3f &origin_,
  5 |          const float dx_,
  6 |          int ni, int nj, int nk)
  7 |     : origin(origin_), dx(dx_), over_dx(1.0f/dx_)
  8 | {
  9 |     assert(ni >= 2 && nj >= 2 && nk >= 2);
 10 | 
 11 |     // Initialize phi to be upper bound on distance.
 12 |     phi.assign(ni, nj, nk, (ni+nj+nk)*dx);
 13 | }
 14 | 
 15 | 
 16 | float
 17 | SDF::operator()(const Vec3f& x) const
 18 | {
 19 |     float fi = (x[0] - origin[0])*over_dx,
 20 |           fj = (x[1] - origin[1])*over_dx,
 21 |           fk = (x[2] - origin[2])*over_dx;
 22 | 
 23 |     float u = fi - std::floor(fi),
 24 |           v = fj - std::floor(fj),
 25 |           w = fk - std::floor(fk);
 26 | 
 27 |     int i = static_cast<int>(fi), 
 28 |         j = static_cast<int>(fj), 
 29 |         k = static_cast<int>(fk);
 30 | 
 31 |     if (i < 0) { i = 0; u = 0; } else if (i > phi.ni-2) { i = phi.ni-2; u=1; }
 32 |     if (j < 0) { j = 0; v = 0; } else if (j > phi.nj-2) { j = phi.nj-2; v=1; }
 33 |     if (k < 0) { k = 0; w = 0; } else if (k > phi.nk-2) { k = phi.nk-2; w=1; }
 34 | 
 35 |     return (1-u)*( (1-v)*( (1-w)*phi(i,j,k)     + w*phi(i,j,k+1) )
 36 |                      + v*( (1-w)*phi(i,j+1,k)   + w*phi(i,j+1,k+1) ) )
 37 |              + u*( (1-v)*( (1-w)*phi(i+1,j,k)   + w*phi(i+1,j,k+1) )
 38 |                      + v*( (1-w)*phi(i+1,j+1,k) + w*phi(i+1,j+1,k+1) ) );
 39 | }
 40 | 
 41 | 
 42 | Vec3f
 43 | SDF::gradient(const Vec3f& x) const
 44 | {
 45 |     float fi = (x[0] - origin[0])*over_dx,
 46 |           fj = (x[1] - origin[1])*over_dx,
 47 |           fk = (x[2] - origin[2])*over_dx;
 48 | 
 49 |     float u = fi - std::floor(fi),
 50 |           v = fj - std::floor(fj),
 51 |           w = fk - std::floor(fk);
 52 | 
 53 |     int i = static_cast<int>(fi), 
 54 |         j = static_cast<int>(fj), 
 55 |         k = static_cast<int>(fk);
 56 | 
 57 |     if (i < 0) { i = 0; u = 0; } else if (i > phi.ni-2) { i = phi.ni-2; u=1; }
 58 |     if (j < 0) { j = 0; v = 0; } else if (j > phi.nj-2) { j = phi.nj-2; v=1; }
 59 |     if (k < 0) { k = 0; w = 0; } else if (k > phi.nk-2) { k = phi.nk-2; w=1; }
 60 | 
 61 |     // Compute interpolated finite differences in each dimension.
 62 |     Vec3f diff;
 63 | 
 64 |     diff[0] = -(1-v) * ( (1-w)*phi(i,j,k)     + w*phi(i,j,k+1) )
 65 |                  - v * ( (1-w)*phi(i,j+1,k)   + w*phi(i,j+1,k+1) )
 66 |               +(1-v) * ( (1-w)*phi(i+1,j,k)   + w*phi(i+1,j,k+1) )
 67 |                  + v * ( (1-w)*phi(i+1,j+1,k) + w*phi(i+1,j+1,k+1) );
 68 |     diff[1] = (1-u) *( -((1-w)*phi(i,j,k)     + w*phi(i,j,k+1))
 69 |                       + ((1-w)*phi(i,j+1,k)   + w*phi(i,j+1,k+1)) )
 70 |                 + u *( -((1-w)*phi(i+1,j,k)   + w*phi(i+1,j,k+1)) 
 71 |                       + ((1-w)*phi(i+1,j+1,k) + w*phi(i+1,j+1,k+1)) );
 72 |     diff[2] = (1-u) * ( (1-v)*(phi(i,j,k+1)     - phi(i,j,k)) 
 73 |                         + v * (phi(i,j+1,k+1)   - phi(i,j+1,k)) )
 74 |                 + u * ( (1-v)*(phi(i+1,j,k+1)   - phi(i+1,j,k))
 75 |                         + v * (phi(i+1,j+1,k+1) - phi(i+1,j+1,k)) );
 76 | 
 77 |     return diff * over_dx;
 78 | }
 79 | 
 80 | 
 81 | Vec3f
 82 | SDF::normal(const Vec3f& x) const
 83 | {
 84 |     Vec3f g = gradient(x);
 85 |     return g / (mag(g) + 1e-30); // Avoid divide-by-zero
 86 | }
 87 | 
 88 | 
 89 | Vec3f
 90 | SDF::projectToIsosurface(const Vec3f& x) const
 91 | {
 92 |     float s0 = 0, // zero'th step
 93 |           d0 = (*this)(x); // zero'th value
 94 |     if (d0 == 0)
 95 |         return x; // Already on the isosurface.
 96 | 
 97 |     Vec3f g = gradient(x); // Search direction
 98 |     float g2 = mag2(g);
 99 |     if (g2 == 0)
100 |         return x; // Give up if we're stuck.
101 | 
102 |     float tol = 1e-3*std::fabs(d0);
103 | 
104 |     float s = clamp(-d0/g2, -dx, dx); // first step
105 |     float d = (*this)(x+s*g); // first value
106 | 
107 |     // Search outward until a sign change is found
108 |     for (int steps = 0; steps < 5; ++steps) {
109 |         if (std::fabs(d) <= tol) // converged?
110 |             return x+s*g;
111 |         if (d0 < 0 && d > 0) // found sign change?
112 |             goto refine_projection;
113 |         if (d0 > 0 && d < 0) // found sign change?
114 |             goto refine_projection;
115 |         // otherwise search forward
116 |         d0 = d;
117 |         s0 = s;
118 |         s *= 1.25; // expand outwards a bit
119 |         d = (*this)(x+s*g);
120 |     }
121 |     // If we make it here, we failed to find a sign change...
122 |     if (std::fabs(d0) < std::fabs(d))
123 |         return x;
124 |     else
125 |         return x+s*g;
126 | 
127 | refine_projection:
128 |     // Secant guess at step size
129 |     s = (d*s0 - d0*s) / (d-d0);
130 | #ifndef NDEBUG
131 |     float d_new = (*this)(x+s*g);
132 |     if (std::fabs(d_new) > 100.0*tol && tol > 1e-5) {
133 |         std::cerr << "projectToIsosurface failed? sdf=" << d_new
134 |                   << ", tol=" << tol << ", ratio=" 
135 |                   << std::fabs(d_new)/tol << std::endl
136 |                   << "x={" << x << "}, gradient={" << g << "}" << std::endl;
137 |     }
138 | #endif
139 |     return x+s*g;
140 | }
141 | 
142 | 
143 | 


--------------------------------------------------------------------------------
/src/geometry_queries.cpp:
--------------------------------------------------------------------------------
  1 | #include <cfloat>
  2 | #include "geometry_queries.h"
  3 | 
  4 | // External functions defined in predicates.cpp
  5 | extern double exactinit();
  6 | extern double orient3d(double* pa, double* pb, double* pc, double* pd);
  7 | 
  8 | 
  9 | double
 10 | initialize_exact()
 11 | {
 12 |     return exactinit();
 13 | }
 14 | 
 15 | float
 16 | point_segment_distance(const Vec3f &x0,
 17 |                        const Vec3f &x1,
 18 |                        const Vec3f &x2)
 19 | {
 20 |     Vec3f dx(x2-x1);
 21 |     double m2=mag2(dx);
 22 |     // find parameter value of closest point on segment
 23 |     float s12=(float)(dot(x2-x0, dx)/m2);
 24 |     if(s12<0){
 25 |         s12=0;
 26 |     }else if(s12>1){
 27 |         s12=1;
 28 |     }
 29 |     // and find the distance
 30 |     return dist(x0, s12*x1+(1-s12)*x2);
 31 | }
 32 | 
 33 | float
 34 | point_triangle_distance(const Vec3f &x0,
 35 |                         const Vec3f &x1,
 36 |                         const Vec3f &x2,
 37 |                         const Vec3f &x3)
 38 | {
 39 |     // first find barycentric coordinates of closest point on infinite plane
 40 |     Vec3f x13(x1-x3), x23(x2-x3), x03(x0-x3);
 41 |     float m13=mag2(x13), m23=mag2(x23), d=dot(x13,x23);
 42 |     float invdet=1.f/max(m13*m23-d*d,1e-30f);
 43 |     float a=dot(x13,x03), b=dot(x23,x03);
 44 |     // the barycentric coordinates themselves
 45 |     float w23=invdet*(m23*a-d*b);
 46 |     float w31=invdet*(m13*b-d*a);
 47 |     float w12=1-w23-w31;
 48 |     if(w23>=0 && w31>=0 && w12>=0){ // if we're inside the triangle
 49 |         return dist(x0, w23*x1+w31*x2+w12*x3); 
 50 |     }else{ // we have to clamp to one of the edges
 51 |         if(w23>0) // this rules out edge 2-3 for us
 52 |             return min(point_segment_distance(x0,x1,x2),
 53 |                        point_segment_distance(x0,x1,x3));
 54 |         else if(w31>0) // this rules out edge 1-3
 55 |             return min(point_segment_distance(x0,x1,x2),
 56 |                        point_segment_distance(x0,x2,x3));
 57 |         else // w12 must be >0, ruling out edge 1-2
 58 |             return min(point_segment_distance(x0,x1,x3),
 59 |                        point_segment_distance(x0,x2,x3));
 60 |     }
 61 | }
 62 | 
 63 | // Find x+y=a+b, but with |x|>|y| (or both zero) non-overlapping in bits.
 64 | static void
 65 | two_sum(double a, double b, double& x, double& y)
 66 | {
 67 |     x=a+b;
 68 |     double z=x-a;
 69 |     y=(a-(x-z))+(b-z);
 70 | }
 71 | 
 72 | // Find x+y=a with x and y using only half the mantissa bits.
 73 | static void
 74 | split(double a, double& x, double& y)
 75 | {
 76 |     double c=134217729*a;
 77 |     x=c-(c-a);
 78 |     y=a-x;
 79 | }
 80 | 
 81 | // Find x+y=a*b (exactly) with |x|>|y| (or both zero) nonoverlapping in bits.
 82 | static void
 83 | two_product(double a,
 84 |             double b,
 85 |             double& x,
 86 |             double& y)
 87 | {
 88 |     x=a*b;
 89 |     double a1, a2, b1, b2;
 90 |     split(a, a1, a2);
 91 |     split(b, b1, b2);
 92 |     y=a2*b2-(((x-a1*b1)-a2*b1)-a1*b2);
 93 | }
 94 | 
 95 | int
 96 | orientation(double x1, double y1,
 97 |             double x2, double y2,
 98 |             double &twice_signed_area)
 99 | {
100 |     twice_signed_area=y1*x2-x1*y2;
101 |     double bound=5*DBL_EPSILON*(std::fabs(y1*x2)+std::fabs(x1*y2));
102 |     if(std::fabs(twice_signed_area)<bound){ // rounding error alert!
103 |         // We'll do the exact version instead with floating point expansions.
104 |         // This could be faster, but not a critical thing to optimize.
105 |         // First find a+b=y1*x2 and c+d=-x1*y2
106 |         double a, b, c, d;
107 |         two_product(y1, x2, a, b);
108 |         two_product(-x1, y2, c, d);
109 |         // Then add c+(a+b) to get f+g+h
110 |         double e, f, g, h;
111 |         two_sum(c, b, e, h);
112 |         two_sum(e, a, f, g);
113 |         // And finally add d+(f+g+h) to get i+j+l+n
114 |         double i, j, k, l, m, n;
115 |         two_sum(d, h, m, n);
116 |         two_sum(m, g, k, l);
117 |         two_sum(k, f, i, j);
118 |         twice_signed_area=i+(j+(l+n));
119 |     }
120 |     if(twice_signed_area>0) return 1;
121 |     else if(twice_signed_area<0) return -1;
122 |     else if(y2>y1) return 1;
123 |     else if(y2<y1) return -1;
124 |     else if(x1>x2) return 1;
125 |     else if(x1<x2) return -1;
126 |     else return 0; // only true when x1==x2 and y1==y2
127 | }
128 | 
129 | bool point_in_triangle_2d(double x0, double y0, 
130 |                           double x1, double y1,
131 |                           double x2, double y2,
132 |                           double x3, double y3,
133 |                           double& a, double& b, double& c)
134 | {
135 |     x1-=x0; x2-=x0; x3-=x0;
136 |     y1-=y0; y2-=y0; y3-=y0;
137 |     int signa=orientation(x2, y2, x3, y3, a);
138 |     if(signa==0) return false;
139 |     int signb=orientation(x3, y3, x1, y1, b);
140 |     if(signb!=signa) return false;
141 |     int signc=orientation(x1, y1, x2, y2, c);
142 |     if(signc!=signa) return false;
143 |     double sum=a+b+c;
144 |     assert(sum!=0);
145 |     a/=sum;
146 |     b/=sum;
147 |     c/=sum;
148 |     return true;
149 | }
150 | 
151 | 
152 | int orientation3D(double a_x, double a_y, double a_z,
153 |                   double b_x, double b_y, double b_z,
154 |                   double c_x, double c_y, double c_z,
155 |                   double d_x, double d_y, double d_z,
156 |                   double &six_signed_volume)
157 | {
158 |     double a[3], b[3], c[3], d[3];
159 |     a[0] = a_x; a[1] = a_y; a[2] = a_z;
160 |     b[0] = b_x; b[1] = b_y; b[2] = b_z;
161 |     c[0] = c_x; c[1] = c_y; c[2] = c_z;
162 |     d[0] = d_x; d[1] = d_y; d[2] = d_z;
163 |     six_signed_volume = orient3d(a, b, c, d);
164 | 
165 |     // For now our tets have the opposite orientation from Shewchuk's,
166 |     // so we'll flip the sign of the volume.
167 |     six_signed_volume *= -1.0;
168 | 
169 |     if (six_signed_volume < 0.0) return -1;
170 |     else if (six_signed_volume > 0.0) return 1;
171 |     else return 0;
172 | }
173 | 
174 | 
175 | 


--------------------------------------------------------------------------------
/src/feature.h:
--------------------------------------------------------------------------------
  1 | #ifndef FEATURE_H
  2 | #define FEATURE_H
  3 | 
  4 | #include "trimesh.h"
  5 | #include "vec.h"
  6 | #include <vector>
  7 | #include <map>
  8 | 
  9 | //
 10 | // A Feature is a point or connected sequence of edges that we wish to 
 11 | // preserve when meshing a 3D model.
 12 | //
 13 | struct Feature 
 14 | {
 15 |     // The vertices that define the feature when connected by line segments.
 16 |     std::vector<Vec3f> vertices;
 17 | 
 18 |     // Returns true iff this feature is a single point.
 19 |     bool isPoint() const { return vertices.size() == 1; }
 20 | 
 21 |     // Return the endpoints of the feature.
 22 |     Vec3f getEndpoint1() const { return vertices[0]; }
 23 |     Vec3f getEndpoint2() const { return vertices[vertices.size()-1]; }
 24 | 
 25 |     // Returns the point on the feature closest to the given point p.
 26 |     Vec3f projectToFeature(const Vec3f &p) const;
 27 | 
 28 |     // Project the given point p onto the feature and return the tangent 
 29 |     // to the feature at that point.
 30 |     Vec3f getTangent(const Vec3f &p) const;
 31 | };
 32 | 
 33 | 
 34 | //
 35 | // FeatureSet stores and maintains a set of features.
 36 | //
 37 | // The following invariant is enforced at all times:
 38 | //   - No two features share the same vertex on their interiors.
 39 | // In other words, features may only share vertices if those vertices are 
 40 | // their endpoints.
 41 | //
 42 | // The FeatureSet can consolidate its features by combining vertices that
 43 | // are within a given distance threshold.
 44 | //
 45 | // The FeatureSet can be initialized by passing in Features and lists of 
 46 | // Features, or it can be initialized by reading a .FEAT file.
 47 | //
 48 | // Features can be retrieved from the set by numerical index.
 49 | // Note that modifying the FeatureSet in any way can invalidate previous
 50 | // indices into the FeatureSet.
 51 | //
 52 | // In addition, the FeatureSet can provide the set of all endpoints of its 
 53 | // features.  These vertices are returned with no duplicates.
 54 | //
 55 | class FeatureSet
 56 | {
 57 | public:
 58 |     // Default constructor
 59 |     FeatureSet() {}
 60 | 
 61 |     // Constructor
 62 |     // f is a list of Features to add to the set.
 63 |     FeatureSet(const std::vector<Feature>& f);
 64 | 
 65 |     // Add the given list of features to the set.
 66 |     void addFeatures(const std::vector<Feature>& features);
 67 | 
 68 |     // Add the given feature to the set.
 69 |     void addFeature(const Feature& feature);
 70 | 
 71 |     // Initialize this FeatureSet based on the given file.
 72 |     // The file should be of the .FEAT format,
 73 |     // ie: it should contain lists of vertices each prefaced by an
 74 |     // integer indicating the number of vertices in the current feature.
 75 |     // Returns true iff the file was read successfully.
 76 |     bool readFromFile(const char *filename_format, ...);
 77 | 
 78 |     // Write this FeatureSet to a file with the given name.
 79 |     // Ideally, this should be a .FEAT file.
 80 |     // The output format will match the description above.
 81 |     bool writeToFile(const char *filename_format, ...);
 82 | 
 83 |     // Combine vertices that are within the given distance threshold apart.
 84 |     // If this causes any features to share vertices, split those features
 85 |     // at those vertices.
 86 |     void consolidate(float dist = 0.0f);
 87 | 
 88 |     // Returns the number of features in the set.
 89 |     unsigned int numFeatures() const { return indices.size(); }
 90 | 
 91 |     // Copies the feature at index i in to the given feature parameter.
 92 |     void getFeature(unsigned int i, Feature& feature) const;
 93 | 
 94 |     // Copies the features in the set into the given features parameter.
 95 |     void getFeatures(std::vector<Feature>& features) const;
 96 | 
 97 |     // Copies a list of feature endpoints into the given endpoints parameter.
 98 |     // The endpoints will not be duplicated; if a vertex is the endpoint of
 99 |     // multiple features it will only be returned once.
100 |     void getFeatureEndpoints(std::vector<Vec3f>& endpoints) const;
101 | 
102 |     // Merges the two given feature endpoints by moving endpoint2 to endpoint1
103 |     // and replacing all references to endpoint2 with references to endpoint1.
104 |     // The given endpoints must be valid endpoints in the FeatureSet. 
105 |     // Ideally they should come from a call to getFeatureEndpoints, 
106 |     // and should not be modified before being passed to this function.
107 |     void mergeEndpoints(const Vec3f& endpoint1, const Vec3f& endpoint2,
108 |                         std::vector<Vec3f>& newEndpoints);
109 | 
110 |     // Process the given triangle mesh to find sharp features and add them to
111 |     // this FeatureSet.
112 |     // Uses the given angle_threshold to determine which edges and vertices are
113 |     // "sharp".
114 |     void autoDetectFeatures(const TriMesh& mesh, 
115 |                             float angle_threshold_degrees);
116 | 
117 | private:
118 |     // The set of vertices in the features of the FeatureSet.
119 |     std::vector<Vec3f> vertices;
120 | 
121 |     // List of features as indices into the vertex list (vertices).
122 |     // indices[f][v] gives the index of the v'th vertex of the f'th feature.
123 |     std::vector< std::vector<int> > indices;
124 | 
125 |     // Map of vertex positions to their index in vertices.
126 |     std::map<Vec3f, int> vertexMap;
127 | 
128 |     // Examine the feature at the given index and check if it forms a loop.
129 |     // A loop is a feature that starts and ends at the same vertex.
130 |     // If the feature is degenerate (ie all vertices are the same), 
131 |     // convert it into a point.
132 |     // If the is a loop and the entire feature lies within the given
133 |     // collapseRadius, collapse the feature to a point.
134 |     // If the feature is a loop and extends outside the collapseRadius,
135 |     // split it in half.
136 |     // Returns true iff the feature is split and a new feature is added.
137 |     bool checkForLoop(int fIndex, float collapseRadiusSquared = 0.0f);
138 | 
139 |     // Find the features in the set containing the given index in its interior.
140 |     // Split that feature in two at that index.
141 |     // Repeat until the given index is only found at the endpoints of features.
142 |     // This may increase the number of features in the FeatureSet, 
143 |     // but the number of vertices remains the same.
144 |     void splitFeatures(int vIndex);
145 | };
146 | 
147 | #endif
148 | 


--------------------------------------------------------------------------------
/src/gluvi.h:
--------------------------------------------------------------------------------
  1 | #ifndef GLUVI_H
  2 | #define GLUVI_H
  3 | 
  4 | #include <iostream>
  5 | #include <vector>
  6 | 
  7 | #ifdef __APPLE__
  8 | #include <GLUT/glut.h> // why does Apple have to put glut.h here...
  9 | #else
 10 | #include <GL/glut.h> // ...when everyone else puts it here?
 11 | #endif
 12 | 
 13 | #include "vec.h"
 14 | 
 15 | namespace Gluvi{
 16 | 
 17 | /*
 18 | For portions of the code which export RIB commands (e.g. from cameras):
 19 | 
 20 | The RenderMan (R) Interface Procedures and Protocol are:
 21 | Copyright 1988, 1989, Pixar
 22 | All Rights Reserved
 23 | */
 24 | 
 25 | // the camera capability for Gluvi
 26 | struct Camera
 27 | {
 28 |    virtual ~Camera(void) {}
 29 |    virtual void click(int button, int state, int x, int y) = 0;
 30 |    virtual void drag(int x, int y) = 0;
 31 |    virtual void return_to_default(void) = 0;
 32 |    //@@@ add these to be called by a user glutKeyboardFunc() thing so that
 33 |    //@@@ cameras can easily add keyboard shortcuts for e.g. return_to_default, transformation, etc.
 34 |    //virtual void navigation_keyboard_handler(unsigned char key, int x, int y) = 0;
 35 |    //virtual void navigation_special_key_handler(int key, int x, int y) = 0;
 36 |    virtual void gl_transform(void) = 0;
 37 |    virtual void export_rib(std::ostream &output) = 0;
 38 |    virtual void display_screen(void) {} // in case the camera needs to show anything on screen
 39 | };
 40 | 
 41 | struct Target3D : public Camera
 42 | {
 43 |    float target[3], dist;
 44 |    float heading, pitch;
 45 |    float default_target[3], default_dist;
 46 |    float default_heading, default_pitch;
 47 |    float fovy;
 48 |    float near_clip_factor, far_clip_factor;
 49 |    enum {INACTIVE, ROTATE, TRUCK, DOLLY} action_mode;
 50 |    int oldmousex, oldmousey;
 51 | 
 52 |    Target3D(float target_[3]=0, float dist_=1, float heading_=0, float pitch_=0, float fovy_=45,
 53 |             float near_clip_factor_=0.01, float far_clip_factor_=100);
 54 |    void click(int button, int state, int x, int y);
 55 |    void drag(int x, int y);
 56 |    void return_to_default(void);
 57 |    void transform_mouse(int x, int y, float ray_origin[3], float ray_direction[3]);
 58 |    void get_viewing_direction(float direction[3]);
 59 |    void gl_transform(void);
 60 |    void export_rib(std::ostream &output);
 61 | };
 62 | 
 63 | // same as above, but with orthographic projection
 64 | struct TargetOrtho3D : public Camera
 65 | {
 66 |    float target[3], dist;
 67 |    float heading, pitch;
 68 |    float default_target[3], default_dist;
 69 |    float default_heading, default_pitch;
 70 |    float height_factor;
 71 |    float near_clip_factor, far_clip_factor;
 72 |    enum {INACTIVE, ROTATE, TRUCK, DOLLY} action_mode;   // @@@@ WHAT ABOUT ZOOMING??? IS WIDTH ALWAYS A FUNCTION OF DIST?
 73 |    int oldmousex, oldmousey;
 74 | 
 75 |    TargetOrtho3D(float target_[3]=0, float dist_=1, float heading_=0, float pitch_=0, float height_factor_=1,
 76 |                  float near_clip_factor_=0.01, float far_clip_factor_=100);
 77 |    void click(int button, int state, int x, int y);
 78 |    void drag(int x, int y);
 79 |    void return_to_default(void);
 80 |    void transform_mouse(int x, int y, float ray_origin[3], float ray_direction[3]);
 81 |    void get_viewing_direction(float direction[3]);
 82 |    void gl_transform(void);
 83 |    void export_rib(std::ostream &output);
 84 | };
 85 | 
 86 | struct PanZoom2D : public Camera
 87 | {
 88 |    float bottom, left, height;
 89 |    float default_bottom, default_left, default_height;
 90 |    enum {INACTIVE, PAN, ZOOM_IN, ZOOM_OUT} action_mode;
 91 |    int oldmousex, oldmousey;
 92 |    bool moved_since_mouse_down; // to distinuish simple clicks from drags
 93 |    int clickx, clicky;
 94 | 
 95 |    PanZoom2D(float bottom_=0, float left_=0, float height_=1);
 96 |    void click(int button, int state, int x, int y);
 97 |    void drag(int x, int y);
 98 |    void return_to_default(void);
 99 |    void transform_mouse(int x, int y, float coords[2]);
100 |    void gl_transform(void);
101 |    void export_rib(std::ostream &output);
102 |    void display_screen(void);
103 | };
104 | 
105 | // overlaid user-interface widgets
106 | struct Widget
107 | {
108 |    int dispx, dispy, width, height; // set in display()
109 | 
110 |    virtual ~Widget() {}
111 |    virtual void display(int x, int y) = 0;
112 |    virtual bool click(int state, int x, int y) { return false; } // returns true if click handled by widget
113 |    virtual void drag(int x, int y) {}
114 | };
115 | 
116 | struct StaticText : public Widget
117 | {
118 |    const char *text;
119 | 
120 |    StaticText(const char *text_);
121 |    void display(int x, int y);
122 | };
123 | 
124 | struct Button : public Widget
125 | {
126 |    enum {UNINVOLVED, SELECTED, HIGHLIGHTED} status;
127 |    const char *text;
128 |    int minwidth;
129 | 
130 |    Button(const char *text_, int minwidth_=0);
131 |    void display(int x, int y);
132 |    bool click(int state, int x, int y);
133 |    void drag(int x, int y);
134 |    virtual void action() {}
135 | };
136 | 
137 | struct Slider : public Widget
138 | {
139 |    enum {UNINVOLVED, SELECTED} status;
140 |    const char *text;
141 |    int length, justify;
142 |    int position;
143 |    int scrollxmin, scrollxmax, scrollymin, scrollymax;
144 |    int clickx;
145 | 
146 |    Slider(const char *text_, int length_=100, int position_=0, int justify_=0);
147 |    void display(int x, int y);
148 |    bool click(int state, int x, int y);
149 |    void drag(int x, int y);
150 |    virtual void action() {}
151 | };
152 | 
153 | struct WidgetList : public Widget
154 | {
155 |    int indent;
156 |    bool hidden;
157 |    std::vector<Widget*> list;
158 |    int downclicked_member;
159 | 
160 |    WidgetList(int listindent_=12, bool hidden_=false);
161 |    void display(int x, int y);
162 |    bool click(int state, int x, int y);
163 |    void drag(int x, int y);
164 | };
165 | 
166 | // display callback
167 | extern void (*userDisplayFunc)(void); 
168 | 
169 | // mouse callbacks for events that Gluvi ignores (control not pressed, or mouse not on an active widget)
170 | extern void (*userMouseFunc)(int button, int state, int x, int y);
171 | extern void (*userDragFunc)(int x, int y);
172 | 
173 | // user is free to do their own callbacks for everything else except glutReshape()
174 | 
175 | // additional helpful functions
176 | void ppm_screenshot(const char *filename_format, ...);
177 | void sgi_screenshot(const char *filename_format, ...);
178 | void set_generic_lights(void);
179 | void set_generic_material(float r, float g, float b, GLenum face=GL_FRONT_AND_BACK);
180 | void set_matte_material(float r, float g, float b, GLenum face=GL_FRONT_AND_BACK);
181 | //@@@@@@@ USEFUL FUNCTIONALITY:
182 | void draw_3d_arrow(const float base[3], const float point[3], float arrow_head_length=0);
183 | void draw_2d_arrow(const Vec2f base, const Vec2f point, float arrow_head_length);
184 | void draw_coordinate_grid(float size=1, int spacing=10);
185 | void draw_text(const float point[3], const char *text, int fontsize=12);
186 | 
187 | // call init first thing
188 | void init(const char *windowtitle, int *argc, char **argv);
189 | 
190 | // the Gluvi state
191 | extern Camera *camera;
192 | extern WidgetList root;
193 | extern int winwidth, winheight;
194 | 
195 | // then after setting the Gluvi state and doing any of your own set-up, call run()
196 | void run(void);
197 | 
198 | }; // end of namespace
199 | 
200 | #endif
201 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | Quartet
  2 | *******
  3 | 
  4 | A tetrahedral mesh generator based on Jonathon Shewchuk's isosurface stuffing 
  5 | algorithm in combination with the A15 acute tetrahedral tile.
  6 | 
  7 | written by:
  8 | Robert Bridson (www.cs.ubc.ca/~rbridson)
  9 | Crawford Doran (www.crawforddoran.com)
 10 | --------------------------------------
 11 | 
 12 | 
 13 | Overview
 14 | ==========
 15 | 
 16 | Quartet converts a watertight triangle mesh into a high-quality uniform 
 17 | tetrahedral mesh that closely approximates the geometry, up to the curvature 
 18 | implied by the specified grid sampling (dx). Optionally, the tetrahedral mesh 
 19 | can be warped to match sharp features on the input, and also improved by a 
 20 | quality optimization pass.
 21 | 
 22 | 
 23 | Building Quartet
 24 | =================
 25 | 
 26 | 1) It may be necessary to edit Makefile.defs in order to ensure that 
 27 |    platform-specific variables are set correctly. These include the compiler,
 28 |    linker, and all flags associated with them, including libraries.
 29 | 2) Run 'make depend'
 30 | 3) Run 'make' and/or 'make release' ('make' is equivalent to 'make debug')
 31 | 
 32 | 
 33 | Running Quartet
 34 | ==================
 35 | 
 36 | Quartet is run from the command line with the following syntax:
 37 | 
 38 | quartet <input.obj> <dx> <output.tet> [-f <feature.feat>] [-a <angle_threshold>]
 39 | [-s <surface.obj>] [-i] [-o]
 40 | 
 41 | - <input.obj> is the OBJ file containing the surface to be converted to a 
 42 |   tetrahedral mesh.
 43 | - <dx> is the grid spacing used in the isosurface stuffing algorithm. The 
 44 |   generated tetrahedra will be approximately this size.
 45 | - <output.tet> is a path to the file where the resulting tetrahedral mesh will 
 46 |   be saved.
 47 | 
 48 | The optional flags have the following effects:
 49 | -f <features.feat>   -- The given file <features.feat> contains lists of 
 50 |                         points and edges indicating sharp corners and ridges 
 51 |                         in the input. The output mesh will resolve these 
 52 |                         features as well as possible.
 53 | -a <angle_threshold> -- Auto-detects sharp features in the input.  Edges with
 54 |                         a dihedral angle smaller than <angle_threshold> degrees
 55 |                         will be resolved in the output as well as possible.
 56 |                         In addition, these features will be written to a file
 57 |                         called 'auto.feat' (which can then be fed to the -f 
 58 |                         option in future executions).
 59 | -s <surface.obj>     -- The boundary of the resulting tetrahedral mesh is
 60 |                         written to <surface.obj>.  This is largely for 
 61 |                         convenience of visualizing the result.
 62 | -i                   -- Intermediate stages of the mesh generation process are
 63 |                         saved to disk in files named 'N_*_.tet' where N is the 
 64 |                         numbering of the steps.
 65 | -o                   -- Perform quality optimization on the resulting 
 66 |                         tetrahedral mesh.
 67 | 
 68 | Example inputs can be found in the 'meshes' directory.  For the inputs with
 69 | sharp features, corresponding .feat files are provided.
 70 | 
 71 | Example usages:
 72 | quartet dragon.obj 0.01 dragon_01.tet -o -s dragon.obj
 73 | quartet fandisk.obj 0.1 fandisk_1.tet -f fandisk.feat
 74 | quartet block.obj 0.5 block_5.tet -a 110.0 -o
 75 | 
 76 | 
 77 | Running view_tet
 78 | ==================
 79 | 
 80 | We have included an OpenGL viewer application for visualizing resulting tet 
 81 | meshes.  The viewer is called view_tet, and can be called with the following 
 82 | syntax:
 83 | 
 84 | view_tet <input.tet> [-s] [-f <features.feat>] [-p (x|y|z)<cutting-plane-pos>]*
 85 | [-w <num_tets>]
 86 | 
 87 | Here, <input.tet> is the TET file produced by quartet containing the tet mesh.
 88 | 
 89 | The optional flags have the following effects:
 90 | -s                            -- Assume that <input.tet> is actually
 91 |                                  <input.obj> and read it in as a surface
 92 |                                  mesh from an OBJ file.
 93 | -f <features.feat>            -- Displays the sharp features in the file
 94 |                                  <features.feat> alongside the mesh.
 95 | -p (x|y|z)<cutting-plane-pos> -- Specifies a plane to cut the mesh so the
 96 |                                  viewer can see "inside" of it.  The plane is
 97 |                                  specified by which coordinate axis is its 
 98 |                                  normal and its position along that axis.
 99 |                                  Multiple planes can be specified with multiple
100 |                                  occurrences of this flag.
101 | -w num_tets                   -- Draw the mesh so that the <num_tets>
102 |                                  worst-quality tetrahedra are highlighted.
103 | 
104 | Example usages:
105 | view_tet block.tet -p x0.0
106 | view_tet dragon.obj -s
107 | view_tet fandisk.tet -f fandisk.feat -w 10
108 | 
109 | Once view_tet is running, the viewer can be controlled with the following 
110 | inputs:
111 | 
112 | Shift+LeftMouseButton   -- Rotate camera
113 | Shift+RightMouseButton  -- Zoom camera
114 | Shift+MiddleMouseButton -- Pan camera
115 | 
116 | 
117 | 
118 | Source Code overview
119 | ======================
120 | 
121 | The following files make up the quartet source:
122 | 
123 | Utilities / Data Structures:
124 | 
125 | util.h
126 |  - a bunch of small useful functions
127 | 
128 | vec.h
129 |  - a convenience wrapper around fixed-length arrays (for vectors in 3D etc.)
130 | 
131 | array3.h
132 |  - a convenience wrapper around STL vectors to get 3D arrays
133 | 
134 | sdf.h/cpp
135 |  - a signed-distance-field data structure for working with level sets
136 | 
137 | read_obj.h/cpp
138 |  - code to read in a Wavefront .OBJ file
139 | 
140 | trimesh.h/cpp
141 |  - a simple half-edge triangle mesh data structure
142 | 
143 | tet_mesh.h/cpp
144 |  - an index-based tetrahedral mesh data structure.  Maintains incidence 
145 |    relationships as necessary for fast adjacency queries.
146 | 
147 | features.h/cpp
148 |  - Data structures representing sharp features of a triangle mesh and 
149 |    aggregations of those features (called FeatureSets)
150 | 
151 | 
152 | Meshing Functions:
153 | 
154 | geometry_queries.h/cpp
155 |  - some simple and not-so-simple geometric operations needed for creating
156 |    signed distance functions from triangle meshes.
157 |    Uses Jonathan Shewchuk's robust geometric predicates code, found in 
158 |    predicates.cpp (http://www.cs.cmu.edu/~quake/robust.html).
159 | 
160 | make_signed_distance.h/cpp
161 |  - code for robustly creating a fairly accurate signed distance function
162 |    of a watertight triangle mesh, sampled on a regular 3D grid.
163 | 
164 | make_tet_mesh.h/cpp
165 |  - code to create a quality tetrahedral mesh of the interior of a level set
166 | 
167 | tet_quality.h/cpp
168 |  - functions for measuring quality of tetrahedra based on various metrics
169 | 
170 | match_features.h/cpp
171 |  - code to restore desired sharp features onto a tetrahedral mesh
172 | 
173 | optimize_tet_mesh.h/cpp
174 |  - code to improve the overall quality of a given tetrahedral mesh.  Uses as 
175 |    much data from the meshing step (ie: sdf, sharp features, etc.) as possible.
176 | 
177 | main.cpp
178 |  - quartet command-line program 
179 | 
180 | 
181 | Viewer Application:
182 | 
183 | gluvi.h/cpp
184 |  - code for creating a simple generic OpenGL viewer application
185 | 
186 | view_tet.cpp
187 |  - view_tet main code file for viewing tet meshes
188 | 
189 | 


--------------------------------------------------------------------------------
/src/array3.h:
--------------------------------------------------------------------------------
  1 | #ifndef ARRAY3_H
  2 | #define ARRAY3_H
  3 | 
  4 | #include <algorithm>
  5 | #include <cassert>
  6 | #include <vector>
  7 | 
  8 | template<class T, class ArrayT=std::vector<T> >
  9 | struct Array3
 10 | {
 11 |     // STL-friendly typedefs
 12 | 
 13 |     typedef typename ArrayT::iterator iterator;
 14 |     typedef typename ArrayT::const_iterator const_iterator;
 15 |     typedef typename ArrayT::size_type size_type;
 16 |     typedef long difference_type;
 17 |     typedef T& reference;
 18 |     typedef const T& const_reference;
 19 |     typedef T value_type;
 20 |     typedef T* pointer;
 21 |     typedef const T* const_pointer;
 22 |     typedef typename ArrayT::reverse_iterator reverse_iterator;
 23 |     typedef typename ArrayT::const_reverse_iterator const_reverse_iterator;
 24 | 
 25 |     // the actual representation
 26 | 
 27 |     int ni, nj, nk;
 28 |     ArrayT a;
 29 | 
 30 |     // the interface
 31 | 
 32 |     Array3(void)
 33 |         : ni(0), nj(0), nk(0)
 34 |     {}
 35 | 
 36 |     Array3(int ni_, int nj_, int nk_)
 37 |         : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_)
 38 |     { assert(ni_>=0 && nj_>=0 && nk_>=0); }
 39 | 
 40 |     Array3(int ni_, int nj_, int nk_, ArrayT& a_)
 41 |         : ni(ni_), nj(nj_), nk(nk_), a(a_)
 42 |     { assert(ni_>=0 && nj_>=0 && nk_>=0); }
 43 | 
 44 |     Array3(int ni_, int nj_, int nk_, const T& value)
 45 |         : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, value)
 46 |     { assert(ni_>=0 && nj_>=0 && nk_>=0); }
 47 | 
 48 |     Array3(int ni_, int nj_, int nk_, const T& value, size_type max_n_)
 49 |         : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, value, max_n_)
 50 |     { assert(ni_>=0 && nj_>=0 && nk_>=0); }
 51 | 
 52 |     Array3(int ni_, int nj_, int nk_, T* data_)
 53 |         : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, data_)
 54 |     { assert(ni_>=0 && nj_>=0 && nk_>=0); }
 55 | 
 56 |     Array3(int ni_, int nj_, int nk_, T* data_, size_type max_n_)
 57 |         : ni(ni_), nj(nj_), nk(nk_), a(ni_*nj_*nk_, data_, max_n_)
 58 |     { assert(ni_>=0 && nj_>=0 && nk_>=0); }
 59 | 
 60 |     ~Array3(void)
 61 |     {
 62 | #ifndef NDEBUG
 63 |         ni=nj=0;
 64 | #endif
 65 |     }
 66 | 
 67 |     const T& operator()(int i, int j, int k) const
 68 |     {
 69 |         assert(i>=0 && i<ni && j>=0 && j<nj && k>=0 && k<nk);
 70 |         return a[i+ni*(j+nj*k)];
 71 |     }
 72 | 
 73 |     T& operator()(int i, int j, int k)
 74 |     {
 75 |         assert(i>=0 && i<ni && j>=0 && j<nj && k>=0 && k<nk);
 76 |         return a[i+ni*(j+nj*k)];
 77 |     }
 78 | 
 79 |     bool operator==(const Array3<T>& x) const
 80 |     { return ni==x.ni && nj==x.nj && nk==x.nk && a==x.a; }
 81 | 
 82 |     bool operator!=(const Array3<T>& x) const
 83 |     { return ni!=x.ni || nj!=x.nj || nk!=x.nk || a!=x.a; }
 84 | 
 85 |     bool operator<(const Array3<T>& x) const
 86 |     {
 87 |         if(ni<x.ni) return true; else if(ni>x.ni) return false;
 88 |         if(nj<x.nj) return true; else if(nj>x.nj) return false;
 89 |         if(nk<x.nk) return true; else if(nk>x.nk) return false;
 90 |         return a<x.a;
 91 |     }
 92 | 
 93 |     bool operator>(const Array3<T>& x) const
 94 |     {
 95 |         if(ni>x.ni) return true; else if(ni<x.ni) return false;
 96 |         if(nj>x.nj) return true; else if(nj<x.nj) return false;
 97 |         if(nk>x.nk) return true; else if(nk<x.nk) return false;
 98 |         return a>x.a;
 99 |     }
100 | 
101 |     bool operator<=(const Array3<T>& x) const
102 |     {
103 |         if(ni<x.ni) return true; else if(ni>x.ni) return false;
104 |         if(nj<x.nj) return true; else if(nj>x.nj) return false;
105 |         if(nk<x.nk) return true; else if(nk>x.nk) return false;
106 |         return a<=x.a;
107 |     }
108 | 
109 |     bool operator>=(const Array3<T>& x) const
110 |     {
111 |         if(ni>x.ni) return true; else if(ni<x.ni) return false;
112 |         if(nj>x.nj) return true; else if(nj<x.nj) return false;
113 |         if(nk>x.nk) return true; else if(nk<x.nk) return false;
114 |         return a>=x.a;
115 |     }
116 | 
117 |     void assign(const T& value)
118 |     { a.assign(value); }
119 | 
120 |     void assign(int ni_, int nj_, int nk_, const T& value)
121 |     {
122 |         a.assign(ni_*nj_*nk_, value);
123 |         ni=ni_;
124 |         nj=nj_;
125 |         nk=nk_;
126 |     }
127 | 
128 |     void assign(int ni_, int nj_, int nk_, const T* copydata)
129 |     {
130 |         a.assign(ni_*nj_*nk_, copydata);
131 |         ni=ni_;
132 |         nj=nj_;
133 |         nk=nk_;
134 |     }
135 | 
136 |     const T& at(int i, int j, int k) const
137 |     {
138 |         assert(i>=0 && i<ni && j>=0 && j<nj && k>=0 && k<nk);
139 |         return a[i+ni*(j+nj*k)];
140 |     }
141 | 
142 |     T& at(int i, int j, int k)
143 |     {
144 |         assert(i>=0 && i<ni && j>=0 && j<nj && k>=0 && k<nk);
145 |         return a[i+ni*(j+nj*k)];
146 |     }
147 | 
148 |     const T& back(void) const
149 |     { 
150 |         assert(a.size());
151 |         return a.back();
152 |     }
153 | 
154 |     T& back(void)
155 |     {
156 |         assert(a.size());
157 |         return a.back();
158 |     }
159 | 
160 |     const_iterator begin(void) const
161 |     { return a.begin(); }
162 | 
163 |     iterator begin(void)
164 |     { return a.begin(); }
165 | 
166 |     size_type capacity(void) const
167 |     { return a.capacity(); }
168 | 
169 |     void clear(void)
170 |     {
171 |         a.clear();
172 |         ni=nj=nk=0;
173 |     }
174 | 
175 |     bool empty(void) const
176 |     { return a.empty(); }
177 | 
178 |     const_iterator end(void) const
179 |     { return a.end(); }
180 | 
181 |     iterator end(void)
182 |     { return a.end(); }
183 | 
184 |     void fill(int ni_, int nj_, int nk_, const T& value)
185 |     {
186 |         a.fill(ni_*nj_*nk_, value);
187 |         ni=ni_;
188 |         nj=nj_;
189 |         nk=nk_;
190 |     }
191 | 
192 |     const T& front(void) const
193 |     {
194 |         assert(a.size());
195 |         return a.front();
196 |     }
197 | 
198 |     T& front(void)
199 |     {
200 |         assert(a.size());
201 |         return a.front();
202 |     }
203 | 
204 |     size_type max_size(void) const
205 |     { return a.max_size(); }
206 | 
207 |     reverse_iterator rbegin(void)
208 |     { return reverse_iterator(end()); }
209 | 
210 |     const_reverse_iterator rbegin(void) const
211 |     { return const_reverse_iterator(end()); }
212 | 
213 |     reverse_iterator rend(void)
214 |     { return reverse_iterator(begin()); }
215 | 
216 |     const_reverse_iterator rend(void) const
217 |     { return const_reverse_iterator(begin()); }
218 | 
219 |     void reserve(int reserve_ni, int reserve_nj, int reserve_nk)
220 |     { a.reserve(reserve_ni*reserve_nj*reserve_nk); }
221 | 
222 |     void resize(int ni_, int nj_, int nk_)
223 |     {
224 |         assert(ni_>=0 && nj_>=0 && nk_>=0);
225 |         a.resize(ni_*nj_*nk_);
226 |         ni=ni_;
227 |         nj=nj_;
228 |         nk=nk_;
229 |     }
230 | 
231 |     void resize(int ni_, int nj_, int nk_, const T& value)
232 |     {
233 |         assert(ni_>=0 && nj_>=0 && nk_>=0);
234 |         a.resize(ni_*nj_*nk_, value);
235 |         ni=ni_;
236 |         nj=nj_;
237 |         nk=nk_;
238 |     }
239 | 
240 |     void set_zero(void)
241 |     { a.set_zero(); }
242 | 
243 |     size_type size(void) const
244 |     { return a.size(); }
245 | 
246 |     void swap(Array3<T>& x)
247 |     {
248 |         std::swap(ni, x.ni);
249 |         std::swap(nj, x.nj);
250 |         std::swap(nk, x.nk);
251 |         a.swap(x.a);
252 |     }
253 | 
254 |     void trim(void)
255 |     { a.trim(); }
256 | };
257 | 
258 | // some common arrays
259 | 
260 | typedef Array3<double> Array3d;
261 | typedef Array3<float> Array3f;
262 | typedef Array3<int> Array3i;
263 | 
264 | #endif
265 | 


--------------------------------------------------------------------------------
/src/make_signed_distance.cpp:
--------------------------------------------------------------------------------
  1 | #include "make_signed_distance.h"
  2 | #include "geometry_queries.h"
  3 | 
  4 | 
  5 | // Comment out to use a faster, less accurate point-tri distance measure.
  6 | #define EXACT_POINT_TRI_DISTANCE
  7 | 
  8 | 
  9 | static void
 10 | check_neighbour(const std::vector<Vec3i> &tri,
 11 |                 const std::vector<Vec3f> &x,
 12 |                 Array3f &phi,
 13 |                 Array3i &closest_tri,
 14 |                 const Vec3f &gx,
 15 |                 int i0, int j0, int k0,
 16 |                 int i1, int j1, int k1)
 17 | {
 18 |     if(closest_tri(i1,j1,k1) >= 0) {
 19 |         int p, q, r; assign(tri[closest_tri(i1,j1,k1)], p, q, r);
 20 | 	
 21 | #ifdef EXACT_POINT_TRI_DISTANCE
 22 | 		// This is the more accurate, exact distance-to-tri routine
 23 |         float d = point_triangle_distance(gx, x[p], x[q], x[r]);
 24 | #else
 25 | 		// This is a fast approximation, using the triangle centroid
 26 |         float d = dist(gx, 0.3333333333333333333f*(x[p]+x[q]+x[r]));
 27 | #endif
 28 | 		
 29 |         if(d < phi(i0,j0,k0)) {
 30 |             phi(i0,j0,k0) = d;
 31 |             closest_tri(i0,j0,k0) = closest_tri(i1,j1,k1);
 32 |         }
 33 |     }
 34 | }
 35 | 
 36 | 
 37 | static void
 38 | sweep(const std::vector<Vec3i> &tri,
 39 |       const std::vector<Vec3f> &x,
 40 |       SDF &sdf,
 41 |       Array3i &closest_tri,
 42 |       int di, int dj, int dk)
 43 | {
 44 |     // figure out loop bounds from direction (di,dj,dk)
 45 |     int i0, i1;
 46 |     if (di>0) { i0=1; i1=sdf.phi.ni; }
 47 |     else { i0=sdf.phi.ni-2; i1=-1; }
 48 |     int j0, j1;
 49 |     if (dj>0) { j0=1; j1=sdf.phi.nj; }
 50 |     else { j0=sdf.phi.nj-2; j1=-1; }
 51 |     int k0, k1;
 52 |     if (dk>0) { k0=1; k1=sdf.phi.nk; }
 53 |     else { k0=sdf.phi.nk-2; k1=-1; }
 54 |     // sweep through the grid propagating closest triangle information
 55 |     int i, j, k;
 56 |     for(k=k0; k!=k1; k+=dk) for(j=j0; j!=j1; j+=dj) for(i=i0; i!=i1; i+=di) {
 57 |         Vec3f gx(i*sdf.dx+sdf.origin[0], 
 58 |                  j*sdf.dx+sdf.origin[1], 
 59 |                  k*sdf.dx+sdf.origin[2]);
 60 |         check_neighbour(tri,x, sdf.phi, closest_tri, gx, i,j,k, i-di,j,   k);
 61 |         check_neighbour(tri,x, sdf.phi, closest_tri, gx, i,j,k, i,   j-dj,k);
 62 |         check_neighbour(tri,x, sdf.phi, closest_tri, gx, i,j,k, i-di,j-dj,k);
 63 |         check_neighbour(tri,x, sdf.phi, closest_tri, gx, i,j,k, i,   j,   k-dk);
 64 |         check_neighbour(tri,x, sdf.phi, closest_tri, gx, i,j,k, i-di,j,   k-dk);
 65 |         check_neighbour(tri,x, sdf.phi, closest_tri, gx, i,j,k, i,   j-dj,k-dk);
 66 |         check_neighbour(tri,x, sdf.phi, closest_tri, gx, i,j,k, i-di,j-dj,k-dk);
 67 |     }
 68 | }
 69 | 
 70 | 
 71 | void
 72 | make_signed_distance(const std::vector<Vec3i> &tri,
 73 |                      const std::vector<Vec3f> &x,
 74 |                      SDF &sdf)
 75 | {
 76 |     // prepare an array to store (approximate) closest triangle to grid points
 77 |     Array3i closest_tri(sdf.phi.ni, sdf.phi.nj, sdf.phi.nk, -1);
 78 |     // prepare an array to count intersections of triangles with grid edges:
 79 |     // intersection_count(i,j,k) is # of tri intersections in (i-1,i]x{j}x{k}
 80 |     Array3i intersection_count(sdf.phi.ni, sdf.phi.nj, sdf.phi.nk, 0);
 81 | 
 82 |     // Pre-compute double-precision dx and 1/dx.
 83 |     double Ddx = static_cast<double>(sdf.dx);
 84 |     double _Ddx = 1.0 / Ddx;
 85 |     float _dx = static_cast<float>(_Ddx);
 86 |     // Pre-compute double-precision origin.
 87 |     double o0 = static_cast<double>(sdf.origin[0]);
 88 |     double o1 = static_cast<double>(sdf.origin[1]);
 89 |     double o2 = static_cast<double>(sdf.origin[2]);
 90 | 
 91 |     // initialize correct distances near the mesh and count intersections
 92 |     std::cout<<"  rasterizing triangles"<<std::endl;
 93 |     int i, j, k;
 94 |     for(size_t t=0; t<tri.size(); ++t) {
 95 |         int p, q, r; assign(tri[t], p, q, r);
 96 |         // get padded bounding box of triangle in grid coordinates
 97 |         int i0=(int)((min(x[p][0],x[q][0],x[r][0]) - o0)*_Ddx - 0.5),
 98 |             i1=(int)((max(x[p][0],x[q][0],x[r][0]) - o0)*_Ddx + 1.5),
 99 |             j0=(int)((min(x[p][1],x[q][1],x[r][1]) - o1)*_Ddx - 0.5),
100 |             j1=(int)((max(x[p][1],x[q][1],x[r][1]) - o1)*_Ddx + 1.5),
101 |             k0=(int)((min(x[p][2],x[q][2],x[r][2]) - o2)*_Ddx - 0.5),
102 |             k1=(int)((max(x[p][2],x[q][2],x[r][2]) - o2)*_Ddx + 1.5);
103 |         // clamp appropriately to lie within the grid
104 |         if (i0<0) i0=0; else if (i0>sdf.phi.ni-1) i0=sdf.phi.ni-1;
105 |         if (i1<0) i1=0; else if (i1>sdf.phi.ni-1) i1=sdf.phi.ni-1;
106 |         if (j0<0) j0=0; else if (j0>sdf.phi.nj-1) j0=sdf.phi.nj-1;
107 |         if (j1<0) j1=0; else if (j1>sdf.phi.nj-1) j1=sdf.phi.nj-1;
108 |         if (k0<0) k0=0; else if (k0>sdf.phi.nk-1) k0=sdf.phi.nk-1;
109 |         if (k1<0) k1=0; else if (k1>sdf.phi.nk-1) k1=sdf.phi.nk-1;
110 |         // do distances and intersection counts in this chunk
111 |         for(k=k0; k<=k1; ++k) for(j=j0; j<=j1; ++j) for(i=i0; i<=i1; ++i) {
112 |             Vec3f gx(i*sdf.dx+sdf.origin[0], 
113 |                      j*sdf.dx+sdf.origin[1], 
114 |                      k*sdf.dx+sdf.origin[2]);
115 |             float d = point_triangle_distance(gx, x[p], x[q], x[r]);
116 |             if (d < sdf.phi(i,j,k)) {
117 |                 sdf.phi(i,j,k) = d;
118 |                 closest_tri(i,j,k) = t;
119 |             }
120 |         }
121 |         // and do intersection counts
122 |         for(int k=k0; k<=k1; ++k) for(int j=j0; j<=j1; ++j) {
123 |             double gy=j*Ddx+sdf.origin[1], gz=k*Ddx+sdf.origin[2];
124 |             double a, b, c;
125 |             if (point_in_triangle_2d(gy, gz,
126 |                                      x[p][1], x[p][2],
127 |                                      x[q][1], x[q][2],
128 |                                      x[r][1], x[r][2], a, b, c)) {
129 |                 // estimate x coordinate of intersection
130 |                 double xint = a*x[p][0] + b*x[q][0] + c*x[r][0];
131 |                 // convert to a grid coordinate
132 |                 int i_interval=(int)(std::ceil((xint-sdf.origin[0])*_dx));
133 |                 // intersection is in (i_interval-1,i_interval]
134 |                 if (i_interval < 0)
135 |                     ++intersection_count(0, j, k);
136 |                 else if (i_interval < sdf.phi.ni)
137 |                     ++intersection_count(i_interval, j, k);
138 |                 // ignore intersections beyond the +x side of the grid
139 |             }
140 |         }
141 |     }
142 | 
143 |     // fill in the rest of the distances with fast sweeping
144 |     // (a single sweep is adequate to get rough approximation everywhere)
145 |     std::cout<<"  sweeping to rest of grid"<<std::endl;
146 |     for (unsigned int pass=0; pass<1; ++pass){
147 |         sweep(tri, x, sdf, closest_tri, +1, +1, +1);
148 |         sweep(tri, x, sdf, closest_tri, -1, -1, -1);
149 |         sweep(tri, x, sdf, closest_tri, +1, +1, -1);
150 |         sweep(tri, x, sdf, closest_tri, -1, -1, +1);
151 |         sweep(tri, x, sdf, closest_tri, +1, -1, +1);
152 |         sweep(tri, x, sdf, closest_tri, -1, +1, -1);
153 |         sweep(tri, x, sdf, closest_tri, +1, -1, -1);
154 |         sweep(tri, x, sdf, closest_tri, -1, +1, +1);
155 |     }
156 | 
157 |     // figure out signs (inside/outside) from parity of intersection counts
158 |     std::cout<<"  calculating signs"<<std::endl;
159 |     for(int k=0; k<sdf.phi.nk; ++k) for(int j=0; j<sdf.phi.nj; ++j) {
160 |         int total_count = 0;
161 |         for (int i=0; i<sdf.phi.ni; ++i) {
162 |             total_count += intersection_count(i,j,k);
163 |             if (total_count%2 == 1) {                 
164 |                 // if parity of intersections so far is odd,
165 |                 sdf.phi(i,j,k) = -sdf.phi(i,j,k); // we are inside the mesh
166 |             }
167 |         }
168 |     }
169 | 	
170 | }
171 | 
172 | 


--------------------------------------------------------------------------------
/meshes/joint.feat:
--------------------------------------------------------------------------------
  1 | feat 26
  2 | 21
  3 | 0.309566 0.705673 -0.150798
  4 | 0.318546 0.705673 -0.188201
  5 | 0.321564 0.705673 -0.226548
  6 | 0.318546 0.705673 -0.264896
  7 | 0.309566 0.705673 -0.302299
  8 | 0.294846 0.705673 -0.337837
  9 | 0.274748 0.705673 -0.370634
 10 | 0.249765 0.705673 -0.399884
 11 | 0.220516 0.705673 -0.424866
 12 | 0.187718 0.705673 -0.444965
 13 | 0.15218 0.705673 -0.459685
 14 | 0.114777 0.705673 -0.468665
 15 | 0.07643 0.705673 -0.471682
 16 | 0.038082 0.705673 -0.468665
 17 | 0.000679 0.705673 -0.459685
 18 | -0.034859 0.705673 -0.444965
 19 | -0.067656 0.705673 -0.424866
 20 | -0.096906 0.705673 -0.399884
 21 | -0.121888 0.705673 -0.370634
 22 | -0.141987 0.705673 -0.337837
 23 | -0.156706 0.705673 -0.302299
 24 | 21
 25 | -0.156706 0.705673 -0.302299
 26 | -0.165687 0.705673 -0.264896
 27 | -0.168704 0.705673 -0.226548
 28 | -0.165687 0.705673 -0.188201
 29 | -0.156706 0.705673 -0.150798
 30 | -0.141987 0.705673 -0.11526
 31 | -0.121888 0.705673 -0.082463
 32 | -0.096906 0.705673 -0.053212
 33 | -0.067656 0.705673 -0.02823
 34 | -0.034859 0.705673 -0.008132
 35 | 0.000679 0.705673 0.006588
 36 | 0.038082 0.705673 0.015568
 37 | 0.07643 0.705673 0.018586
 38 | 0.114777 0.705673 0.015568
 39 | 0.152181 0.705673 0.006588
 40 | 0.187719 0.705673 -0.008132
 41 | 0.220516 0.705673 -0.02823
 42 | 0.249766 0.705673 -0.053213
 43 | 0.274748 0.705673 -0.082463
 44 | 0.294846 0.705673 -0.11526
 45 | 0.309566 0.705673 -0.150798
 46 | 21
 47 | 0.309566 -0.411409 -0.150798
 48 | 0.294846 -0.411409 -0.11526
 49 | 0.274748 -0.411409 -0.082463
 50 | 0.249766 -0.411409 -0.053213
 51 | 0.220516 -0.411409 -0.02823
 52 | 0.187719 -0.411409 -0.008132
 53 | 0.152181 -0.411409 0.006588
 54 | 0.114777 -0.411409 0.015568
 55 | 0.07643 -0.411409 0.018586
 56 | 0.038082 -0.411409 0.015568
 57 | 0.000679 -0.411409 0.006588
 58 | -0.034859 -0.411409 -0.008132
 59 | -0.067656 -0.411409 -0.02823
 60 | -0.096906 -0.411409 -0.053212
 61 | -0.121888 -0.411409 -0.082463
 62 | -0.141987 -0.411409 -0.11526
 63 | -0.156706 -0.411409 -0.150798
 64 | -0.165687 -0.411409 -0.188201
 65 | -0.168704 -0.411409 -0.226548
 66 | -0.165687 -0.411409 -0.264896
 67 | -0.156706 -0.411409 -0.302299
 68 | 21
 69 | -0.156706 -0.411409 -0.302299
 70 | -0.141987 -0.411409 -0.337837
 71 | -0.121888 -0.411409 -0.370634
 72 | -0.096906 -0.411409 -0.399884
 73 | -0.067656 -0.411409 -0.424866
 74 | -0.034859 -0.411409 -0.444965
 75 | 0.000679 -0.411409 -0.459685
 76 | 0.038082 -0.411409 -0.468665
 77 | 0.07643 -0.411409 -0.471682
 78 | 0.114777 -0.411409 -0.468665
 79 | 0.15218 -0.411409 -0.459685
 80 | 0.187718 -0.411409 -0.444965
 81 | 0.220516 -0.411409 -0.424866
 82 | 0.249765 -0.411409 -0.399884
 83 | 0.274748 -0.411409 -0.370634
 84 | 0.294846 -0.411409 -0.337837
 85 | 0.309566 -0.411409 -0.302299
 86 | 0.318546 -0.411409 -0.264896
 87 | 0.321564 -0.411409 -0.226548
 88 | 0.318546 -0.411409 -0.188201
 89 | 0.309566 -0.411409 -0.150798
 90 | 22
 91 | -0.410534 -0.411409 -0.577483
 92 | 0.07643 -0.411409 -0.577483
 93 | 0.131328 -0.411409 -0.573162
 94 | 0.184875 -0.411409 -0.560307
 95 | 0.23575 -0.411409 -0.539233
 96 | 0.282704 -0.411409 -0.51046
 97 | 0.324579 -0.411409 -0.474697
 98 | 0.360342 -0.411409 -0.432822
 99 | 0.389115 -0.411409 -0.385869
100 | 0.410188 -0.411409 -0.334993
101 | 0.423044 -0.411409 -0.281447
102 | 0.427365 -0.411409 -0.226548
103 | 0.423044 -0.411409 -0.17165
104 | 0.410188 -0.411409 -0.118104
105 | 0.389116 -0.411409 -0.067228
106 | 0.360342 -0.411409 -0.020274
107 | 0.324579 -0.411409 0.021601
108 | 0.282705 -0.411409 0.057364
109 | 0.235751 -0.411409 0.086137
110 | 0.184875 -0.411409 0.10721
111 | 0.131328 -0.411409 0.120066
112 | 0.07643 -0.411409 0.124386
113 | 4
114 | -0.410534 -0.411409 0.488458
115 | -0.410534 -0.411409 0.124386
116 | -0.410534 -0.411409 -0.226548
117 | -0.410534 -0.411409 -0.577483
118 | 23
119 | -0.410534 0.705673 -0.577483
120 | 0.07643 0.705673 -0.577483
121 | 0.131328 0.705673 -0.573162
122 | 0.184875 0.705673 -0.560307
123 | 0.23575 0.705673 -0.539233
124 | 0.282704 0.705673 -0.51046
125 | 0.324579 0.705673 -0.474697
126 | 0.360342 0.705673 -0.432822
127 | 0.389115 0.705673 -0.385869
128 | 0.410188 0.705673 -0.334993
129 | 0.423044 0.705673 -0.281447
130 | 0.427365 0.705673 -0.226548
131 | 0.423044 0.705673 -0.17165
132 | 0.410188 0.705673 -0.118104
133 | 0.389116 0.705673 -0.067228
134 | 0.360342 0.705673 -0.020273
135 | 0.324579 0.705673 0.021601
136 | 0.282705 0.705673 0.057364
137 | 0.235751 0.705673 0.086137
138 | 0.184875 0.705673 0.10721
139 | 0.131328 0.705673 0.120066
140 | 0.07643 0.705673 0.124386
141 | -0.167053 0.705673 0.124386
142 | 3
143 | -0.410534 0.705673 0.488458
144 | -0.410534 -0.060474 0.488458
145 | -0.410534 -0.411409 0.488458
146 | 2
147 | -0.167053 -0.060474 0.488458
148 | -0.167053 0.705673 0.488458
149 | 2
150 | -0.167053 0.705673 0.488458
151 | -0.410534 0.705673 0.488458
152 | 2
153 | -0.410534 -0.411409 -0.577483
154 | -0.410534 0.705673 -0.577483
155 | 4
156 | -0.410534 0.705673 0.488458
157 | -0.410534 0.705673 0.124386
158 | -0.410534 0.705673 -0.226548
159 | -0.410534 0.705673 -0.577483
160 | 3
161 | -0.410534 -0.411409 0.488458
162 | -0.167053 -0.411409 0.488458
163 | 0.07643 -0.411409 0.488458
164 | 2
165 | 0.07643 -0.411409 0.488458
166 | 0.07643 -0.060474 0.488458
167 | 2
168 | 0.07643 -0.060474 0.488458
169 | -0.167053 -0.060474 0.488458
170 | 2
171 | -0.167053 0.705673 0.124386
172 | -0.167053 -0.060474 0.124386
173 | 2
174 | -0.167053 -0.060474 0.488458
175 | -0.167053 -0.060474 0.124386
176 | 2
177 | -0.167053 0.705673 0.124386
178 | -0.167053 0.705673 0.488458
179 | 21
180 | -0.410534 -0.337995 0.32189
181 | -0.410534 -0.339257 0.305858
182 | -0.410534 -0.337995 0.289824
183 | -0.410534 -0.334241 0.274186
184 | -0.410534 -0.328086 0.259329
185 | -0.410534 -0.319683 0.245616
186 | -0.410534 -0.309238 0.233387
187 | -0.410534 -0.29701 0.222942
188 | -0.410534 -0.283298 0.214539
189 | -0.410534 -0.268439 0.208384
190 | -0.410534 -0.252801 0.204631
191 | -0.410534 -0.236768 0.203369
192 | -0.410534 -0.220735 0.204631
193 | -0.410534 -0.205097 0.208384
194 | -0.410534 -0.190239 0.214539
195 | -0.410534 -0.176527 0.222942
196 | -0.410534 -0.164298 0.233387
197 | -0.410534 -0.153853 0.245616
198 | -0.410534 -0.14545 0.259329
199 | -0.410534 -0.139296 0.274186
200 | -0.410534 -0.135541 0.289824
201 | 21
202 | -0.410534 -0.135541 0.289824
203 | -0.410534 -0.13428 0.305858
204 | -0.410534 -0.135541 0.32189
205 | -0.410534 -0.139296 0.337528
206 | -0.410534 -0.14545 0.352386
207 | -0.410534 -0.153853 0.366099
208 | -0.410534 -0.164298 0.378327
209 | -0.410534 -0.176527 0.388772
210 | -0.410534 -0.190239 0.397176
211 | -0.410534 -0.205097 0.40333
212 | -0.410534 -0.220735 0.407084
213 | -0.410534 -0.236768 0.408345
214 | -0.410534 -0.252801 0.407084
215 | -0.410534 -0.268439 0.40333
216 | -0.410534 -0.283298 0.397176
217 | -0.410534 -0.29701 0.388772
218 | -0.410534 -0.309238 0.378327
219 | -0.410534 -0.319683 0.366099
220 | -0.410534 -0.328086 0.352386
221 | -0.410534 -0.334241 0.337528
222 | -0.410534 -0.337995 0.32189
223 | 2
224 | 0.07643 -0.411409 0.124386
225 | 0.07643 -0.411409 0.488458
226 | 21
227 | 0.07643 -0.135541 0.32189
228 | 0.07643 -0.13428 0.305858
229 | 0.07643 -0.135541 0.289824
230 | 0.07643 -0.139296 0.274186
231 | 0.07643 -0.14545 0.259329
232 | 0.07643 -0.153853 0.245616
233 | 0.07643 -0.164298 0.233387
234 | 0.07643 -0.176527 0.222942
235 | 0.07643 -0.190239 0.214539
236 | 0.07643 -0.205097 0.208384
237 | 0.07643 -0.220735 0.204631
238 | 0.07643 -0.236768 0.203369
239 | 0.07643 -0.252801 0.204631
240 | 0.07643 -0.268439 0.208384
241 | 0.07643 -0.283298 0.214539
242 | 0.07643 -0.29701 0.222942
243 | 0.07643 -0.309238 0.233387
244 | 0.07643 -0.319683 0.245616
245 | 0.07643 -0.328086 0.259329
246 | 0.07643 -0.334241 0.274186
247 | 0.07643 -0.337995 0.289824
248 | 21
249 | 0.07643 -0.337995 0.289824
250 | 0.07643 -0.339257 0.305858
251 | 0.07643 -0.337995 0.32189
252 | 0.07643 -0.334241 0.337528
253 | 0.07643 -0.328086 0.352386
254 | 0.07643 -0.319683 0.366099
255 | 0.07643 -0.309238 0.378327
256 | 0.07643 -0.29701 0.388772
257 | 0.07643 -0.283298 0.397176
258 | 0.07643 -0.268439 0.40333
259 | 0.07643 -0.252801 0.407084
260 | 0.07643 -0.236768 0.408345
261 | 0.07643 -0.220735 0.407084
262 | 0.07643 -0.205097 0.40333
263 | 0.07643 -0.190239 0.397176
264 | 0.07643 -0.176527 0.388772
265 | 0.07643 -0.164298 0.378327
266 | 0.07643 -0.153853 0.366099
267 | 0.07643 -0.14545 0.352386
268 | 0.07643 -0.139296 0.337528
269 | 0.07643 -0.135541 0.32189
270 | 2
271 | 0.07643 -0.411409 0.124386
272 | 0.07643 -0.060474 0.124386
273 | 2
274 | 0.07643 -0.060474 0.124386
275 | 0.07643 -0.060474 0.488458
276 | 2
277 | 0.07643 -0.060474 0.124386
278 | -0.167053 -0.060474 0.124386
279 | 


--------------------------------------------------------------------------------
/meshes/sphere.obj:
--------------------------------------------------------------------------------
  1 | # 162
  2 | # 320
  3 | v 0.000000 -0.525731 0.850651
  4 | v 0.850651 0.000000 0.525731
  5 | v 0.850651 0.000000 -0.525731
  6 | v -0.850651 0.000000 -0.525731
  7 | v -0.850651 0.000000 0.525731
  8 | v -0.525731 0.850651 0.000000
  9 | v 0.525731 0.850651 0.000000
 10 | v 0.525731 -0.850651 0.000000
 11 | v -0.525731 -0.850651 0.000000
 12 | v 0.000000 -0.525731 -0.850651
 13 | v 0.000000 0.525731 -0.850651
 14 | v 0.000000 0.525731 0.850651
 15 | v 1.000000 0.000000 0.000000
 16 | v -1.000000 0.000000 0.000000
 17 | v 0.000000 1.000000 0.000000
 18 | v 0.000000 0.000000 -1.000000
 19 | v 0.000000 -1.000000 0.000000
 20 | v 0.000000 0.000000 1.000000
 21 | v 0.500000 0.309017 -0.809017
 22 | v 0.809017 0.500000 -0.309017
 23 | v 0.309017 0.809017 -0.500000
 24 | v 0.309017 0.809017 0.500000
 25 | v 0.809017 0.500000 0.309017
 26 | v 0.500000 0.309017 0.809017
 27 | v -0.309017 0.809017 -0.500000
 28 | v -0.809017 0.500000 -0.309017
 29 | v -0.500000 0.309017 -0.809017
 30 | v -0.500000 0.309017 0.809017
 31 | v -0.809017 0.500000 0.309017
 32 | v -0.309017 0.809017 0.500000
 33 | v 0.309017 -0.809017 -0.500000
 34 | v 0.809017 -0.500000 -0.309017
 35 | v 0.500000 -0.309017 -0.809017
 36 | v 0.500000 -0.309017 0.809017
 37 | v 0.809017 -0.500000 0.309017
 38 | v 0.309017 -0.809017 0.500000
 39 | v -0.309017 -0.809017 -0.500000
 40 | v -0.500000 -0.309017 -0.809017
 41 | v -0.809017 -0.500000 -0.309017
 42 | v -0.309017 -0.809017 0.500000
 43 | v -0.809017 -0.500000 0.309017
 44 | v -0.500000 -0.309017 0.809017
 45 | v -0.259892 -0.433888 0.862669
 46 | v 0.000000 -0.273266 0.961938
 47 | v 0.259892 -0.433888 0.862669
 48 | v 0.160622 -0.693780 0.702047
 49 | v -0.160622 -0.693780 0.702047
 50 | v 0.862669 -0.259892 0.433888
 51 | v 0.702047 -0.160622 0.693780
 52 | v 0.702047 0.160622 0.693780
 53 | v 0.862669 0.259892 0.433888
 54 | v 0.961938 0.000000 0.273266
 55 | v 0.702047 0.160622 -0.693780
 56 | v 0.702047 -0.160622 -0.693780
 57 | v 0.862669 -0.259892 -0.433888
 58 | v 0.961938 0.000000 -0.273266
 59 | v 0.862669 0.259892 -0.433888
 60 | v -0.862669 -0.259892 -0.433888
 61 | v -0.702047 -0.160622 -0.693780
 62 | v -0.702047 0.160622 -0.693780
 63 | v -0.862669 0.259892 -0.433888
 64 | v -0.961938 0.000000 -0.273266
 65 | v -0.702047 0.160622 0.693780
 66 | v -0.702047 -0.160622 0.693780
 67 | v -0.862669 -0.259892 0.433888
 68 | v -0.961938 0.000000 0.273266
 69 | v -0.862669 0.259892 0.433888
 70 | v -0.433888 0.862669 -0.259892
 71 | v -0.273266 0.961938 0.000000
 72 | v -0.433888 0.862669 0.259892
 73 | v -0.693780 0.702047 0.160622
 74 | v -0.693780 0.702047 -0.160622
 75 | v 0.433888 0.862669 0.259892
 76 | v 0.273266 0.961938 0.000000
 77 | v 0.433888 0.862669 -0.259892
 78 | v 0.693780 0.702047 -0.160622
 79 | v 0.693780 0.702047 0.160622
 80 | v 0.433888 -0.862669 -0.259892
 81 | v 0.273266 -0.961938 0.000000
 82 | v 0.433888 -0.862669 0.259892
 83 | v 0.693780 -0.702047 0.160622
 84 | v 0.693780 -0.702047 -0.160622
 85 | v -0.433888 -0.862669 0.259892
 86 | v -0.273266 -0.961938 0.000000
 87 | v -0.433888 -0.862669 -0.259892
 88 | v -0.693780 -0.702047 -0.160622
 89 | v -0.693780 -0.702047 0.160622
 90 | v -0.259892 -0.433888 -0.862669
 91 | v -0.160622 -0.693780 -0.702047
 92 | v 0.160622 -0.693780 -0.702047
 93 | v 0.259892 -0.433888 -0.862669
 94 | v 0.000000 -0.273266 -0.961938
 95 | v -0.259892 0.433888 -0.862669
 96 | v 0.000000 0.273266 -0.961938
 97 | v 0.259892 0.433888 -0.862669
 98 | v 0.160622 0.693780 -0.702047
 99 | v -0.160622 0.693780 -0.702047
100 | v 0.259892 0.433888 0.862669
101 | v 0.000000 0.273266 0.961938
102 | v -0.259892 0.433888 0.862669
103 | v -0.160622 0.693780 0.702047
104 | v 0.160622 0.693780 0.702047
105 | v 0.951057 0.262866 -0.162460
106 | v 0.951057 0.262866 0.162460
107 | v 0.850651 0.525731 0.000000
108 | v 0.850651 -0.525731 0.000000
109 | v 0.951057 -0.262866 0.162460
110 | v 0.951057 -0.262866 -0.162460
111 | v -0.951057 0.262866 0.162460
112 | v -0.951057 0.262866 -0.162460
113 | v -0.850651 0.525731 0.000000
114 | v -0.951057 -0.262866 -0.162460
115 | v -0.951057 -0.262866 0.162460
116 | v -0.850651 -0.525731 0.000000
117 | v -0.162460 0.951057 0.262866
118 | v 0.162460 0.951057 0.262866
119 | v 0.000000 0.850651 0.525731
120 | v 0.162460 0.951057 -0.262866
121 | v -0.162460 0.951057 -0.262866
122 | v 0.000000 0.850651 -0.525731
123 | v 0.262866 0.162460 -0.951057
124 | v 0.262866 -0.162460 -0.951057
125 | v 0.525731 0.000000 -0.850651
126 | v -0.262866 -0.162460 -0.951057
127 | v -0.262866 0.162460 -0.951057
128 | v -0.525731 0.000000 -0.850651
129 | v -0.162460 -0.951057 -0.262866
130 | v 0.162460 -0.951057 -0.262866
131 | v 0.000000 -0.850651 -0.525731
132 | v 0.162460 -0.951057 0.262866
133 | v -0.162460 -0.951057 0.262866
134 | v 0.000000 -0.850651 0.525731
135 | v 0.262866 -0.162460 0.951057
136 | v 0.262866 0.162460 0.951057
137 | v 0.525731 0.000000 0.850651
138 | v -0.262866 0.162460 0.951057
139 | v -0.262866 -0.162460 0.951057
140 | v -0.525731 0.000000 0.850651
141 | v 0.688191 0.425325 -0.587785
142 | v 0.587785 0.688191 -0.425325
143 | v 0.425325 0.587785 -0.688191
144 | v 0.587785 0.688191 0.425325
145 | v 0.688191 0.425325 0.587785
146 | v 0.425325 0.587785 0.688191
147 | v -0.587785 0.688191 -0.425325
148 | v -0.688191 0.425325 -0.587785
149 | v -0.425325 0.587785 -0.688191
150 | v -0.688191 0.425325 0.587785
151 | v -0.587785 0.688191 0.425325
152 | v -0.425325 0.587785 0.688191
153 | v 0.587785 -0.688191 -0.425325
154 | v 0.688191 -0.425325 -0.587785
155 | v 0.425325 -0.587785 -0.688191
156 | v 0.688191 -0.425325 0.587785
157 | v 0.587785 -0.688191 0.425325
158 | v 0.425325 -0.587785 0.688191
159 | v -0.425325 -0.587785 -0.688191
160 | v -0.688191 -0.425325 -0.587785
161 | v -0.587785 -0.688191 -0.425325
162 | v -0.587785 -0.688191 0.425325
163 | v -0.688191 -0.425325 0.587785
164 | v -0.425325 -0.587785 0.688191
165 | f 1 43 44
166 | f 1 44 45
167 | f 1 45 46
168 | f 1 46 47
169 | f 1 47 43
170 | f 2 48 49
171 | f 2 49 50
172 | f 2 50 51
173 | f 2 51 52
174 | f 2 52 48
175 | f 3 53 54
176 | f 3 54 55
177 | f 3 55 56
178 | f 3 56 57
179 | f 3 57 53
180 | f 4 58 59
181 | f 4 59 60
182 | f 4 60 61
183 | f 4 61 62
184 | f 4 62 58
185 | f 5 63 64
186 | f 5 64 65
187 | f 5 65 66
188 | f 5 66 67
189 | f 5 67 63
190 | f 6 68 69
191 | f 6 69 70
192 | f 6 70 71
193 | f 6 71 72
194 | f 6 72 68
195 | f 7 73 74
196 | f 7 74 75
197 | f 7 75 76
198 | f 7 76 77
199 | f 7 77 73
200 | f 8 78 79
201 | f 8 79 80
202 | f 8 80 81
203 | f 8 81 82
204 | f 8 82 78
205 | f 9 83 84
206 | f 9 84 85
207 | f 9 85 86
208 | f 9 86 87
209 | f 9 87 83
210 | f 10 88 89
211 | f 10 89 90
212 | f 10 90 91
213 | f 10 91 92
214 | f 10 92 88
215 | f 11 93 94
216 | f 11 94 95
217 | f 11 95 96
218 | f 11 96 97
219 | f 11 97 93
220 | f 12 98 99
221 | f 12 99 100
222 | f 12 100 101
223 | f 12 101 102
224 | f 12 102 98
225 | f 13 52 104
226 | f 13 104 103
227 | f 13 103 56
228 | f 13 56 108
229 | f 13 108 107
230 | f 13 107 52
231 | f 14 62 110
232 | f 14 110 109
233 | f 14 109 66
234 | f 14 66 113
235 | f 14 113 112
236 | f 14 112 62
237 | f 15 119 118
238 | f 15 118 74
239 | f 15 74 116
240 | f 15 116 115
241 | f 15 115 69
242 | f 15 69 119
243 | f 16 92 122
244 | f 16 122 121
245 | f 16 121 94
246 | f 16 94 125
247 | f 16 125 124
248 | f 16 124 92
249 | f 17 128 127
250 | f 17 127 84
251 | f 17 84 131
252 | f 17 131 130
253 | f 17 130 79
254 | f 17 79 128
255 | f 18 137 136
256 | f 18 136 99
257 | f 18 99 134
258 | f 18 134 133
259 | f 18 133 44
260 | f 18 44 137
261 | f 19 139 141
262 | f 19 141 95
263 | f 19 95 121
264 | f 19 121 123
265 | f 19 123 53
266 | f 19 53 139
267 | f 20 57 103
268 | f 20 103 105
269 | f 20 105 76
270 | f 20 76 140
271 | f 20 140 139
272 | f 20 139 57
273 | f 21 118 120
274 | f 21 120 96
275 | f 21 96 141
276 | f 21 141 140
277 | f 21 140 75
278 | f 21 75 118
279 | f 22 142 144
280 | f 22 144 102
281 | f 22 102 117
282 | f 22 117 116
283 | f 22 116 73
284 | f 22 73 142
285 | f 23 143 142
286 | f 23 142 77
287 | f 23 77 105
288 | f 23 105 104
289 | f 23 104 51
290 | f 23 51 143
291 | f 24 135 134
292 | f 24 134 98
293 | f 24 98 144
294 | f 24 144 143
295 | f 24 143 50
296 | f 24 50 135
297 | f 25 145 147
298 | f 25 147 97
299 | f 25 97 120
300 | f 25 120 119
301 | f 25 119 68
302 | f 25 68 145
303 | f 26 146 145
304 | f 26 145 72
305 | f 26 72 111
306 | f 26 111 110
307 | f 26 110 61
308 | f 26 61 146
309 | f 27 126 125
310 | f 27 125 93
311 | f 27 93 147
312 | f 27 147 146
313 | f 27 146 60
314 | f 27 60 126
315 | f 28 148 150
316 | f 28 150 100
317 | f 28 100 136
318 | f 28 136 138
319 | f 28 138 63
320 | f 28 63 148
321 | f 29 67 109
322 | f 29 109 111
323 | f 29 111 71
324 | f 29 71 149
325 | f 29 149 148
326 | f 29 148 67
327 | f 30 115 117
328 | f 30 117 101
329 | f 30 101 150
330 | f 30 150 149
331 | f 30 149 70
332 | f 30 70 115
333 | f 31 151 153
334 | f 31 153 90
335 | f 31 90 129
336 | f 31 129 128
337 | f 31 128 78
338 | f 31 78 151
339 | f 32 152 151
340 | f 32 151 82
341 | f 32 82 106
342 | f 32 106 108
343 | f 32 108 55
344 | f 32 55 152
345 | f 33 123 122
346 | f 33 122 91
347 | f 33 91 153
348 | f 33 153 152
349 | f 33 152 54
350 | f 33 54 123
351 | f 34 133 135
352 | f 34 135 49
353 | f 34 49 154
354 | f 34 154 156
355 | f 34 156 45
356 | f 34 45 133
357 | f 35 107 106
358 | f 35 106 81
359 | f 35 81 155
360 | f 35 155 154
361 | f 35 154 48
362 | f 35 48 107
363 | f 36 156 155
364 | f 36 155 80
365 | f 36 80 130
366 | f 36 130 132
367 | f 36 132 46
368 | f 36 46 156
369 | f 37 127 129
370 | f 37 129 89
371 | f 37 89 157
372 | f 37 157 159
373 | f 37 159 85
374 | f 37 85 127
375 | f 38 158 157
376 | f 38 157 88
377 | f 38 88 124
378 | f 38 124 126
379 | f 38 126 59
380 | f 38 59 158
381 | f 39 112 114
382 | f 39 114 86
383 | f 39 86 159
384 | f 39 159 158
385 | f 39 158 58
386 | f 39 58 112
387 | f 40 47 132
388 | f 40 132 131
389 | f 40 131 83
390 | f 40 83 160
391 | f 40 160 162
392 | f 40 162 47
393 | f 41 161 160
394 | f 41 160 87
395 | f 41 87 114
396 | f 41 114 113
397 | f 41 113 65
398 | f 41 65 161
399 | f 42 162 161
400 | f 42 161 64
401 | f 42 64 138
402 | f 42 138 137
403 | f 42 137 43
404 | f 42 43 162
405 | f 47 162 43
406 | f 43 137 44
407 | f 44 133 45
408 | f 45 156 46
409 | f 46 132 47
410 | f 52 107 48
411 | f 48 154 49
412 | f 49 135 50
413 | f 50 143 51
414 | f 51 104 52
415 | f 57 139 53
416 | f 53 123 54
417 | f 54 152 55
418 | f 55 108 56
419 | f 56 103 57
420 | f 62 112 58
421 | f 58 158 59
422 | f 59 126 60
423 | f 60 146 61
424 | f 61 110 62
425 | f 67 148 63
426 | f 63 138 64
427 | f 64 161 65
428 | f 65 113 66
429 | f 66 109 67
430 | f 72 145 68
431 | f 68 119 69
432 | f 69 115 70
433 | f 70 149 71
434 | f 71 111 72
435 | f 77 142 73
436 | f 73 116 74
437 | f 74 118 75
438 | f 75 140 76
439 | f 76 105 77
440 | f 82 151 78
441 | f 78 128 79
442 | f 79 130 80
443 | f 80 155 81
444 | f 81 106 82
445 | f 87 160 83
446 | f 83 131 84
447 | f 84 127 85
448 | f 85 159 86
449 | f 86 114 87
450 | f 92 124 88
451 | f 88 157 89
452 | f 89 129 90
453 | f 90 153 91
454 | f 91 122 92
455 | f 97 147 93
456 | f 93 125 94
457 | f 94 121 95
458 | f 95 141 96
459 | f 96 120 97
460 | f 102 144 98
461 | f 98 134 99
462 | f 99 136 100
463 | f 100 150 101
464 | f 101 117 102
465 | f 103 104 105
466 | f 106 107 108
467 | f 109 110 111
468 | f 112 113 114
469 | f 115 116 117
470 | f 118 119 120
471 | f 121 122 123
472 | f 124 125 126
473 | f 127 128 129
474 | f 130 131 132
475 | f 133 134 135
476 | f 136 137 138
477 | f 139 140 141
478 | f 142 143 144
479 | f 145 146 147
480 | f 148 149 150
481 | f 151 152 153
482 | f 154 155 156
483 | f 157 158 159
484 | f 160 161 162
485 | 


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
  1 | #include "make_tet_mesh.h"
  2 | #include "make_signed_distance.h"
  3 | #include "read_obj.h"
  4 | #include "feature.h"
  5 | #include "trimesh.h"
  6 | #include <sstream>
  7 | #include <fstream>
  8 | #include <cstdio>
  9 | #include <cstring>
 10 | #include <ctime>
 11 | 
 12 | int
 13 | main(int argc,
 14 |      char **argv)
 15 | {
 16 |     //
 17 |     // Parse input arguments
 18 |     //
 19 | 
 20 |     bool usage = false, failure = false;
 21 |     bool feature = false, automatic = false, surface = false,
 22 |          intermediate = false, optimize = false, unsafe = false;
 23 |     char* featureFile = NULL, *surfaceFile = NULL;
 24 |     float angleThreshold;
 25 | 
 26 |     if (argc < 4 || argc > 12) {
 27 |         usage = true;
 28 |         failure = true;
 29 |     }
 30 | 
 31 |     for (int arg = 4; arg < argc && !failure; ++arg) {
 32 |         if (strcmp(argv[arg], "-f") == 0) {
 33 |             if (feature) {
 34 |                 std::printf("Error: already specified feature file\n");
 35 |                 usage = true;
 36 |                 failure = true;
 37 |                 break;
 38 |             }
 39 |             ++arg;
 40 |             if (arg >= argc || argv[arg][0] == '-') {
 41 |                 std::printf("Error: Expected feature file after -f\n");
 42 |                 usage = true;
 43 |                 --arg;
 44 |             } else {
 45 |                 feature = true;
 46 |                 featureFile = argv[arg];
 47 |             }
 48 | 
 49 |         } else if (strcmp(argv[arg], "-a") == 0) {
 50 |             if (automatic) {
 51 |                 std::printf("Error: already specified automatic feature "
 52 |                             "generation\n");
 53 |                 usage = true;
 54 |                 failure = true;
 55 |                 break;
 56 |             }
 57 |             ++arg;
 58 |             if (arg >= argc || argv[arg][0] == '-') {
 59 |                 std::printf("Error: Expected angle threshold after -a\n");
 60 |                 usage = true;
 61 |                 --arg;
 62 |             } else {
 63 |                 if (sscanf(argv[arg], "%f", &angleThreshold)) {
 64 |                     automatic = true;
 65 |                 } else {
 66 |                     std::printf("Error interpreting [%s] as angle threshold\n",
 67 |                                 argv[arg]);
 68 |                     usage = true;
 69 |                     --arg;
 70 |                 }
 71 |             }
 72 | 
 73 |         } else if (strcmp(argv[arg], "-s") == 0) {
 74 |             if (surface) {
 75 |                 std::printf("Error: already specified surface output\n");
 76 |                 usage = true;
 77 |                 failure = true;
 78 |                 break;
 79 |             }
 80 |             ++arg;
 81 |             if (arg >= argc || argv[arg][0] == '-') {
 82 |                 std::printf("Error: Expected OBJ filename after -s\n");
 83 |                 usage = true;
 84 |                 --arg;
 85 |             } else {
 86 |                 surface = true;
 87 |                 surfaceFile = argv[arg];
 88 |             }
 89 | 
 90 |         } else if (strcmp(argv[arg], "-i") == 0) {
 91 |             if (intermediate) {
 92 |                 std::printf("Warning: Already specified intermediate "
 93 |                             "outputs\n");
 94 |                 usage = true;
 95 |             }
 96 |             intermediate = true;
 97 | 
 98 |         } else if (strcmp(argv[arg], "-o") == 0) {
 99 |             if (optimize) {
100 |                 std::printf("Warning: Already specified optimization\n");
101 |                 usage = true;
102 |             }
103 |             optimize = true;
104 | 
105 |         } else if (strcmp(argv[arg], "-u") == 0) {
106 |             if (unsafe) {
107 |                 std::printf("Warning: Already specified unsafe option\n");
108 |                 usage = true;
109 |             }
110 |             unsafe = true;
111 | 
112 |         } else {
113 |             std::printf("Error: Invalid input argument: %s\n", argv[arg]);
114 |             usage = true;
115 |             failure = true;
116 |         }
117 |     }
118 | 
119 |     if (feature && automatic) {
120 |         std::printf("Error: Feature file and automatic feature generation "
121 |                     "selected.  Disabling automatic feature generation "
122 |                     "and using the given feature file.\n");
123 |         automatic = false;
124 |     }
125 | 
126 |     if (usage) {
127 |         std::printf("usage: quartet <input.obj> <dx> <output.tet> "
128 |                     "[-f <feature.feat>] [-a <angle_threshold>] "
129 |                     "[-s <surface.obj>] [-i] [-o] \n"
130 |                     "  -f -- Match the features in the given "
131 |                     "<feature.feat> file\n"
132 |                     "  -a -- Do automatic feature detection and matching on "
133 |                     "the input triangle mesh. "
134 |                     "Use the given <angle_threshold>.\n"
135 |                     "  -s -- Output the surface of the tet mesh as an "
136 |                     "OBJ file\n"
137 |                     "  -i -- Output intermediate tet meshes from each "
138 |                     "stage of the mesh generation algorithm.\n"
139 |                     "  -o -- Enable mesh optimization.\n"
140 |                     "  -u -- Enable unsafe feature-matching operations.\n");
141 |     }
142 |     if (failure) {
143 |         return 1;
144 |     }
145 | 
146 | 
147 |     //
148 |     // Run quartet mesh generation
149 |     //
150 | 
151 |     // Get a surface mesh
152 |     std::vector<Vec3i> surf_tri;
153 |     std::vector<Vec3f> surf_x;
154 |     if (!read_objfile(surf_x, surf_tri, "%s", argv[1])) {
155 |         std::printf("error reading [%s] as a .obj mesh\n", argv[1]);
156 |         return 2;
157 |     }
158 |     if (surf_tri.size() < 4 || surf_x.size() < 4) {
159 |         std::printf("Surface mesh is too small to have an interior.\n");
160 |         return 3;
161 |     }
162 | 
163 |     // Get the grid spacing
164 |     float dx=1;
165 |     if (sscanf(argv[2], "%f", &dx) != 1) {
166 |         std::printf("error interpreting [%s] as a float grid spacing\n",
167 |                     argv[2]);
168 |         return 4;
169 |     }
170 | 
171 |     // Find bounding box
172 |     Vec3f xmin=surf_x[0], xmax=surf_x[0];
173 |     for (size_t i=1; i<surf_x.size(); ++i)
174 |         update_minmax(surf_x[i], xmin, xmax);
175 |     
176 |     // Build triangle mesh data structure
177 |     TriMesh trimesh(surf_x, surf_tri);
178 | 
179 | 
180 |     // Make the level set
181 | 	
182 | 	// Determining dimensions of voxel grid.
183 | 	// Round up to ensure voxel grid completely contains bounding box.
184 | 	// Also add padding of 2 grid points around the bounding box.
185 | 	// NOTE: We add 5 here so as to add 4 grid points of padding, as well as
186 | 	// 1 grid point at the maximal boundary of the bounding box 
187 | 	// ie: (xmax-xmin)/dx + 1 grid points to cover one axis of the bounding box
188 | 	Vec3f origin=xmin-Vec3f(2*dx);
189 | 	int ni = (int)std::ceil((xmax[0]-xmin[0])/dx)+5,
190 | 		nj = (int)std::ceil((xmax[1]-xmin[1])/dx)+5,
191 | 		nk = (int)std::ceil((xmax[2]-xmin[2])/dx)+5;
192 | 	
193 |     SDF sdf(origin, dx, ni, nj, nk); // Initialize signed distance field.
194 |     std::printf("making %dx%dx%d level set\n", ni, nj, nk);
195 |     make_signed_distance(surf_tri, surf_x, sdf);
196 | 	
197 | 	
198 |     // Then the tet mesh
199 |     TetMesh mesh;
200 | 
201 |     // Read in feature file, if given
202 |     if (feature || automatic) {
203 |         
204 |         FeatureSet featureSet;
205 | 
206 |         if (feature) {
207 |             featureSet.readFromFile(featureFile);
208 |         } else { // automatic
209 |             std::printf("automatically generating features\n");
210 |             featureSet.autoDetectFeatures(trimesh, angleThreshold);
211 |             featureSet.writeToFile("auto.feat");
212 |             std::printf("automatically generated features written to "
213 |                         "auto.feat\n");
214 |         }
215 | 
216 |         clock_t time = clock();
217 | 
218 |         // Make tet mesh with features
219 |         std::printf("making tet mesh\n");
220 |         make_tet_mesh(mesh, sdf, featureSet, optimize, intermediate, unsafe);
221 |         std::printf("done tet mesh\n");
222 |         
223 |         time = clock() - time;
224 |         std::printf("mesh generation took %f seconds.\n", 
225 |                     ((float)time)/CLOCKS_PER_SEC);
226 |     } else {
227 |         clock_t time = clock();
228 | 
229 |         // Make tet mesh without features
230 |         std::printf("making tet mesh\n");
231 | 		make_tet_mesh(mesh, sdf, optimize, intermediate, unsafe);
232 | 		std::printf("done tet mesh\n");
233 |         
234 |         time = clock() - time;
235 |         std::printf("mesh generation took %f seconds.\n", 
236 |                     ((float)time)/CLOCKS_PER_SEC);
237 |     }
238 | 
239 |     // Write it out
240 |     std::printf("Writing mesh to file: %s\n", argv[3]);
241 |     bool result = mesh.writeToFile(argv[3]);
242 |     if (!result)
243 |     {
244 |         std::printf("ERROR: Failed to write mesh to file.\n");
245 |     }
246 | 
247 |     // Strip off file extension for creating other files.
248 |     std::string filenameStr(argv[3]);
249 |     if (filenameStr.find_last_of('.') != std::string::npos)
250 |     {
251 |         filenameStr = filenameStr.substr(0, filenameStr.find_last_of('.'));
252 |     }
253 | 
254 |     // Write out an "info" file for the mesh as well.
255 |     std::stringstream ss;
256 |     ss << filenameStr << ".info";
257 |     std::printf("Writing mesh info to file: %s\n", ss.str().c_str());
258 |     result = mesh.writeInfoToFile(ss.str().c_str());
259 |     if (!result)
260 |     {
261 |         std::printf("ERROR: Failed to write mesh info to file.\n");
262 |     }
263 |     
264 |     // Write out a Matlab file containing the dihedral angles of the mesh.
265 |     std::vector<float> dihedralAngles;
266 |     dihedralAngles.reserve(mesh.tSize()*6);
267 |     for (size_t tIdx = 0; tIdx < mesh.tSize(); ++tIdx)
268 |     {
269 |         Tet currTet = mesh.getTet(tIdx);
270 |         std::vector<float> currAngles;
271 |         currTet.dihedralAngles(currAngles);
272 |         for (size_t i = 0; i < currAngles.size(); ++i)
273 |         {
274 |             dihedralAngles.push_back(currAngles[i] * 180.0 / M_PI);
275 |         }
276 |     }
277 |     std::stringstream ss2;
278 |     ss2 << filenameStr << "_hist.m";
279 |     std::ofstream out(ss2.str().c_str());
280 |     if (out.good())
281 |     {   
282 |         std::printf("Writing histogram to file: %s\n", ss2.str().c_str());
283 |         out << "histValues = [ ";
284 |         for (size_t i = 0; i < dihedralAngles.size(); ++i)
285 |         {
286 |             out << dihedralAngles[i] << " ";
287 |         }
288 |         out << "];" << std::endl;
289 |     }
290 |     else
291 |     {
292 |         std::printf("Failed to write histogram file: %s\n", ss2.str().c_str());
293 |     }
294 | 
295 |     // Write out the exterior as a trimesh, if desired.
296 |     if (surface)
297 |     {
298 |         std::vector<Vec3f> surf_verts;
299 |         std::vector<Vec3i> surf_tris;
300 |         mesh.getBoundary(surf_verts, surf_tris);
301 |         std::printf("Writing surface mesh to file: %s\n", surfaceFile);
302 |         result = write_objfile(surf_verts, surf_tris, surfaceFile);
303 |         if (!result)
304 |         {
305 |             std::printf("ERROR: Failed to write surface mesh file.\n");
306 |         }
307 |     }
308 | 
309 |     return 0;
310 | }
311 | 
312 | 


--------------------------------------------------------------------------------
/src/util.h:
--------------------------------------------------------------------------------
  1 | #ifndef UTIL_H
  2 | #define UTIL_H
  3 | 
  4 | #include <algorithm>
  5 | #include <vector>
  6 | #include <climits>
  7 | #include <cmath>
  8 | #include <iostream>
  9 | 
 10 | #ifndef M_PI
 11 | const double M_PI = 3.1415926535897932384626433832795;
 12 | #endif
 13 | 
 14 | #ifdef WIN32
 15 | #undef min
 16 | #undef max
 17 | #endif
 18 | 
 19 | using std::min;
 20 | using std::max;
 21 | using std::swap;
 22 | 
 23 | template<class T>
 24 | inline T sqr(const T& x)
 25 | { return x*x; }
 26 | 
 27 | template<class T>
 28 | inline T cube(const T& x)
 29 | { return x*x*x; }
 30 | 
 31 | template<class T>
 32 | inline T min(T a1, T a2, T a3)
 33 | { return min(a1, min(a2, a3)); }
 34 | 
 35 | template<class T>
 36 | inline T min(T a1, T a2, T a3, T a4)
 37 | { return min(min(a1, a2), min(a3, a4)); }
 38 | 
 39 | template<class T>
 40 | inline T min(T a1, T a2, T a3, T a4, T a5)
 41 | { return min(min(a1, a2), min(a3, a4), a5); }
 42 | 
 43 | template<class T>
 44 | inline T min(T a1, T a2, T a3, T a4, T a5, T a6)
 45 | { return min(min(a1, a2), min(a3, a4), min(a5, a6)); }
 46 | 
 47 | template<class T>
 48 | inline T max(T a1, T a2, T a3)
 49 | { return max(a1, max(a2, a3)); }
 50 | 
 51 | template<class T>
 52 | inline T max(T a1, T a2, T a3, T a4)
 53 | { return max(max(a1, a2), max(a3, a4)); }
 54 | 
 55 | template<class T>
 56 | inline T max(T a1, T a2, T a3, T a4, T a5)
 57 | { return max(max(a1, a2), max(a3, a4),  a5); }
 58 | 
 59 | template<class T>
 60 | inline T max(T a1, T a2, T a3, T a4, T a5, T a6)
 61 | { return max(max(a1, a2), max(a3, a4),  max(a5, a6)); }
 62 | 
 63 | template<class T>
 64 | inline void minmax(T a1, T a2, T& amin, T& amax)
 65 | {
 66 |     if(a1<a2){
 67 |         amin=a1;
 68 |         amax=a2;
 69 |     }else{
 70 |         amin=a2;
 71 |         amax=a1;
 72 |     }
 73 | }
 74 | 
 75 | template<class T>
 76 | inline void minmax(T a1, T a2, T a3, T& amin, T& amax)
 77 | {
 78 |     if(a1<a2){
 79 |         if(a1<a3){
 80 |             amin=a1;
 81 |             if(a2<a3) amax=a3;
 82 |             else amax=a2;
 83 |         }else{
 84 |             amin=a3;
 85 |             if(a1<a2) amax=a2;
 86 |             else amax=a1;
 87 |         }
 88 |     }else{
 89 |         if(a2<a3){
 90 |             amin=a2;
 91 |             if(a1<a3) amax=a3;
 92 |             else amax=a1;
 93 |         }else{
 94 |             amin=a3;
 95 |             amax=a1;
 96 |         }
 97 |     }
 98 | }
 99 | 
100 | template<class T>
101 | inline void minmax(T a1, T a2, T a3, T a4, T& amin, T& amax)
102 | {
103 |     if(a1<a2){
104 |         if(a3<a4){
105 |             amin=min(a1,a3);
106 |             amax=max(a2,a4);
107 |         }else{
108 |             amin=min(a1,a4);
109 |             amax=max(a2,a3);
110 |         }
111 |     }else{
112 |         if(a3<a4){
113 |             amin=min(a2,a3);
114 |             amax=max(a1,a4);
115 |         }else{
116 |             amin=min(a2,a4);
117 |             amax=max(a1,a3);
118 |         }
119 |     }
120 | }
121 | 
122 | template<class T>
123 | inline void minmax(T a1, T a2, T a3, T a4, T a5, T& amin, T& amax)
124 | {
125 |     //@@@ the logic could be shortcircuited a lot!
126 |     amin=min(a1,a2,a3,a4,a5);
127 |     amax=max(a1,a2,a3,a4,a5);
128 | }
129 | 
130 | template<class T>
131 | inline void minmax(T a1, T a2, T a3, T a4, T a5, T a6, T& amin, T& amax)
132 | {
133 |     //@@@ the logic could be shortcircuited a lot!
134 |     amin=min(a1,a2,a3,a4,a5,a6);
135 |     amax=max(a1,a2,a3,a4,a5,a6);
136 | }
137 | 
138 | template<class T>
139 | inline void update_minmax(T a1, T& amin, T& amax)
140 | {
141 |     if(a1<amin) amin=a1;
142 |     else if(a1>amax) amax=a1;
143 | }
144 | 
145 | // swap so that a<b
146 | template<class T>
147 | inline void sort(T &a, T &b)
148 | {
149 |     if(a>b) swap(a,b);
150 | }
151 | 
152 | // swap so that a<b<c
153 | template<class T>
154 | inline void sort(T &a, T &b, T &c)
155 | {
156 |     if(a>b) swap(a,b);
157 |     if(a>c) swap(a,c);
158 |     if(b>c) swap(b,c);
159 | }
160 | 
161 | // swap so that a<b<c<d
162 | template<class T>
163 | inline void sort(T &a, T &b, T &c, T &d)
164 | {
165 |     if(a>b) swap(a,b);
166 |     if(c>d) swap(c,d);
167 |     if(a>c) swap(a,c);
168 |     if(b>d) swap(b,d);
169 |     if(b>c) swap(b,c);
170 | }
171 | 
172 | template<class T>
173 | inline T clamp(T a, T lower, T upper)
174 | {
175 |     if(a<lower) return lower;
176 |     else if(a>upper) return upper;
177 |     else return a;
178 | }
179 | 
180 | // only makes sense with T=float or double
181 | template<class T>
182 | inline T smooth_step(T r)
183 | {
184 |     if(r<0) return 0;
185 |     else if(r>1) return 1;
186 |     return r*r*r*(10+r*(-15+r*6));
187 | }
188 | 
189 | // only makes sense with T=float or double
190 | template<class T>
191 | inline T smooth_step(T r, T r_lower, T r_upper, T value_lower, T value_upper)
192 | { return value_lower + smooth_step((r-r_lower)/(r_upper-r_lower)) * (value_upper-value_lower); }
193 | 
194 | // only makes sense with T=float or double
195 | template<class T>
196 | inline T ramp(T r)
197 | { return smooth_step((r+1)/2)*2-1; }
198 | 
199 | //#ifdef WIN32
200 | #ifdef _MSVC_VER
201 | inline int lround(double x)
202 | {
203 |     if(x>0)
204 |         return (x-floor(x)<0.5) ? (int)floor(x) : (int)ceil(x);
205 |     else
206 |         return (x-floor(x)<=0.5) ? (int)floor(x) : (int)ceil(x);
207 | }
208 | 
209 | inline double remainder(double x, double y)
210 | {
211 |     return x-std::floor(x/y+0.5)*y;
212 | }
213 | #endif
214 | 
215 | inline unsigned int round_up_to_power_of_two(unsigned int n)
216 | {
217 |     int exponent=0;
218 |     --n;
219 |     while(n){
220 |         ++exponent;
221 |         n>>=1;
222 |     }
223 |     return 1<<exponent;
224 | }
225 | 
226 | inline unsigned int round_down_to_power_of_two(unsigned int n)
227 | {
228 |     int exponent=0;
229 |     while(n>1){
230 |         ++exponent;
231 |         n>>=1;
232 |     }
233 |     return 1<<exponent;
234 | }
235 | 
236 | // Transforms even the sequence 0,1,2,3,... into reasonably good random numbers 
237 | // Challenge: improve on this in speed and "randomness"!
238 | // This seems to pass several statistical tests, and is a bijective map (of 32-bit unsigned ints)
239 | inline unsigned int randhash(unsigned int seed)
240 | {
241 |     unsigned int i=(seed^0xA3C59AC3u)*2654435769u;
242 |     i^=(i>>16);
243 |     i*=2654435769u;
244 |     i^=(i>>16);
245 |     i*=2654435769u;
246 |     return i;
247 | }
248 | 
249 | // the inverse of randhash
250 | inline unsigned int unhash(unsigned int h)
251 | {
252 |     h*=340573321u;
253 |     h^=(h>>16);
254 |     h*=340573321u;
255 |     h^=(h>>16);
256 |     h*=340573321u;
257 |     h^=0xA3C59AC3u;
258 |     return h;
259 | }
260 | 
261 | // returns repeatable stateless pseudo-random number in [0,1]
262 | inline double randhashd(unsigned int seed)
263 | { return randhash(seed)/(double)UINT_MAX; }
264 | inline float randhashf(unsigned int seed)
265 | { return randhash(seed)/(float)UINT_MAX; }
266 | 
267 | // returns repeatable stateless pseudo-random number in [a,b]
268 | inline double randhashd(unsigned int seed, double a, double b)
269 | { return (b-a)*randhash(seed)/(double)UINT_MAX + a; }
270 | inline float randhashf(unsigned int seed, float a, float b)
271 | { return ( (b-a)*randhash(seed)/(float)UINT_MAX + a); }
272 | 
273 | inline int intlog2(int x)
274 | {
275 |     int exp=-1;
276 |     while(x){
277 |         x>>=1;
278 |         ++exp;
279 |     }
280 |     return exp;
281 | }
282 | 
283 | template<class T>
284 | inline void get_barycentric(T x, int& i, T& f, int i_low, int i_high)
285 | {
286 |     T s=std::floor(x);
287 |     i=(int)s;
288 |     if(i<i_low){
289 |         i=i_low;
290 |         f=0;
291 |     }else if(i>i_high-2){
292 |         i=i_high-2;
293 |         f=1;
294 |     }else
295 |         f=(T)(x-s);
296 | }
297 | 
298 | template<class S, class T>
299 | inline S lerp(const S& value0, const S& value1, T f)
300 | { return (1-f)*value0 + f*value1; }
301 | 
302 | template<class S, class T>
303 | inline S bilerp(const S& v00, const S& v10, 
304 |         const S& v01, const S& v11, 
305 |         T fx, T fy)
306 | { 
307 |     return lerp(lerp(v00, v10, fx),
308 |             lerp(v01, v11, fx), 
309 |             fy);
310 | }
311 | 
312 | template<class S, class T>
313 | inline S trilerp(const S& v000, const S& v100,
314 |         const S& v010, const S& v110,
315 |         const S& v001, const S& v101,  
316 |         const S& v011, const S& v111,
317 |         T fx, T fy, T fz) 
318 | {
319 |     return lerp(bilerp(v000, v100, v010, v110, fx, fy),
320 |             bilerp(v001, v101, v011, v111, fx, fy),
321 |             fz);
322 | }
323 | 
324 | template<class S, class T>
325 | inline S quadlerp(const S& v0000, const S& v1000,
326 |         const S& v0100, const S& v1100,
327 |         const S& v0010, const S& v1010,  
328 |         const S& v0110, const S& v1110,
329 |         const S& v0001, const S& v1001,
330 |         const S& v0101, const S& v1101,
331 |         const S& v0011, const S& v1011,  
332 |         const S& v0111, const S& v1111,
333 |         T fx, T fy, T fz, T ft) 
334 | {
335 |     return lerp(trilerp(v0000, v1000, v0100, v1100, v0010, v1010, v0110, v1110, fx, fy, fz),
336 |             trilerp(v0001, v1001, v0101, v1101, v0011, v1011, v0111, v1111, fx, fy, fz),
337 |             ft);
338 | }
339 | 
340 | // f should be between 0 and 1, with f=0.5 corresponding to balanced weighting between w0 and w2
341 | template<class T>
342 | inline void quadratic_bspline_weights(T f, T& w0, T& w1, T& w2)
343 | {
344 |     w0=T(0.5)*sqr(f-1);
345 |     w1=T(0.75)-sqr(f-T(0.5));;
346 |     w2=T(0.5)*sqr(f);
347 | }
348 | 
349 | // f should be between 0 and 1
350 | template<class T>
351 | inline void cubic_interp_weights(T f, T& wneg1, T& w0, T& w1, T& w2)
352 | {
353 |     T f2(f*f), f3(f2*f);
354 |     wneg1=-T(1./3)*f+T(1./2)*f2-T(1./6)*f3;
355 |     w0=1-f2+T(1./2)*(f3-f);
356 |     w1=f+T(1./2)*(f2-f3);
357 |     w2=T(1./6)*(f3-f);
358 | }
359 | 
360 | template<class S, class T>
361 | inline S cubic_interp(const S& value_neg1, const S& value0, const S& value1, const S& value2, T f)
362 | {
363 |     T wneg1, w0, w1, w2;
364 |     cubic_interp_weights(f, wneg1, w0, w1, w2);
365 |     return wneg1*value_neg1 + w0*value0 + w1*value1 + w2*value2;
366 | }
367 | 
368 | template<class T>
369 | void zero(std::vector<T>& v)
370 | { for(int i=(int)v.size()-1; i>=0; --i) v[i]=0; }
371 | 
372 | template<class T>
373 | T abs_max(const std::vector<T>& v)
374 | {
375 |     T m=0;
376 |     for(int i=(int)v.size()-1; i>=0; --i){
377 |         if(std::fabs(v[i])>m)
378 |             m=std::fabs(v[i]);
379 |     }
380 |     return m;
381 | }
382 | 
383 | template<class T>
384 | bool contains(const std::vector<T>& a, T e)
385 | {
386 |     for(unsigned int i=0; i<a.size(); ++i)
387 |         if(a[i]==e) return true;
388 |     return false;
389 | }
390 | 
391 | template<class T>
392 | void add_unique(std::vector<T>& a, T e)
393 | {
394 |     for(unsigned int i=0; i<a.size(); ++i)
395 |         if(a[i]==e) return;
396 |     a.push_back(e);
397 | }
398 | 
399 | template<class T>
400 | void insert(std::vector<T>& a, unsigned int index, T e)
401 | {
402 |     a.push_back(a.back());
403 |     for(unsigned int i=(unsigned int)a.size()-1; i>index; --i)
404 |         a[i]=a[i-1];
405 |     a[index]=e;
406 | }
407 | 
408 | template<class T>
409 | void erase(std::vector<T>& a, unsigned int index)
410 | {
411 |     for(unsigned int i=index; i<a.size()-1; ++i)
412 |         a[i]=a[i+1];
413 |     a.pop_back();
414 | }
415 | 
416 | template<class T>
417 | void erase_swap(std::vector<T>& a, unsigned int index)
418 | {
419 |     for(unsigned int i=index; i<a.size()-1; ++i)
420 |         swap(a[i], a[i+1]);
421 |     a.pop_back();
422 | }
423 | 
424 | template<class T>
425 | void erase_unordered(std::vector<T>& a, unsigned int index)
426 | {
427 |     a[index]=a.back();
428 |     a.pop_back();
429 | }
430 | 
431 | template<class T>
432 | void erase_unordered_swap(std::vector<T>& a, unsigned int index)
433 | {
434 |     swap(a[index], a.back());
435 |     a.pop_back();
436 | }
437 | 
438 | template<class T>
439 | void find_and_erase_unordered(std::vector<T>& a, const T& doomed_element)
440 | {
441 |     for(unsigned int i=0; i<a.size(); ++i)
442 |         if(a[i]==doomed_element){
443 |             erase_unordered(a, i);
444 |             return;
445 |         }
446 | }
447 | 
448 | template<class T>
449 | void replace_once(std::vector<T>& a, const T& old_element, const T& new_element)
450 | {
451 |     for(unsigned int i=0; i<a.size(); ++i)
452 |         if(a[i]==old_element){
453 |             a[i]=new_element;
454 |             return;
455 |         }
456 | }
457 | 
458 | template<class T>
459 | void write_matlab(std::ostream& output, const std::vector<T>& a, const char *variable_name, bool column_vector=true, int significant_digits=18)
460 | {
461 |     output<<variable_name<<"=[";
462 |     std::streamsize old_precision=output.precision();
463 |     output.precision(significant_digits);
464 |     for(unsigned int i=0; i<a.size(); ++i){
465 |         output<<a[i]<<" ";
466 |     }
467 |     output<<"]";
468 |     if(column_vector)
469 |         output<<"'";
470 |     output<<";"<<std::endl;
471 |     output.precision(old_precision);
472 | }
473 | 
474 | #endif
475 | 


--------------------------------------------------------------------------------
/src/vec.h:
--------------------------------------------------------------------------------
  1 | #ifndef VEC_H
  2 | #define VEC_H
  3 | 
  4 | #include <cassert>
  5 | #include <cmath>
  6 | #include <iostream>
  7 | #include "util.h"
  8 | 
  9 | // Defines a thin wrapper around fixed size C-style arrays, using template
 10 | // parameters, which is useful for dealing with vectors of different dimensions.
 11 | // For example, float[3] is equivalent to Vec<3,float>.
 12 | // Entries in the vector are accessed with the overloaded [] operator, so
 13 | // for example if x is a Vec<3,float>, then the middle entry is x[1].
 14 | // For convenience, there are a number of typedefs for abbreviation:
 15 | //   Vec<3,float> -> Vec3f
 16 | //   Vec<2,int>   -> Vec2i
 17 | // and so on.
 18 | // Arithmetic operators are appropriately overloaded, and functions are defined
 19 | // for additional operations (such as dot-products, norms, cross-products, etc.)
 20 | 
 21 | template<unsigned int N, class T>
 22 | struct Vec
 23 | {
 24 |     T v[N];
 25 | 
 26 |     Vec<N,T>(void)
 27 |     {}
 28 | 
 29 |     template<class S>
 30 |     explicit Vec<N,T>(S value_for_all)
 31 |     { for(unsigned int i=0; i<N; ++i) v[i]=value_for_all; }
 32 | 
 33 |     template<class S>
 34 |     explicit Vec<N,T>(const S *source)
 35 |     { for(unsigned int i=0; i<N; ++i) v[i]=(T)source[i]; }
 36 | 
 37 |     template <class S>
 38 |     explicit Vec<N,T>(const Vec<N,S>& source)
 39 |     { for(unsigned int i=0; i<N; ++i) v[i]=(T)source[i]; }
 40 | 
 41 |     template<class S>
 42 |     Vec<N,T>(S v0, S v1)
 43 |     {
 44 |         assert(N==2);
 45 |         v[0]=v0; v[1]=v1;
 46 |     }
 47 | 
 48 |     template<class S>
 49 |     Vec<N,T>(S v0, S v1, S v2)
 50 |     {
 51 |         assert(N==3);
 52 |         v[0]=v0; v[1]=v1; v[2]=v2;
 53 |     }
 54 | 
 55 |     template<class S>
 56 |     Vec<N,T>(S v0, S v1, S v2, S v3)
 57 |     {
 58 |         assert(N==4);
 59 |         v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3;
 60 |     }
 61 | 
 62 |     template<class S>
 63 |     Vec<N,T>(S v0, S v1, S v2, S v3, S v4)
 64 |     {
 65 |         assert(N==5);
 66 |         v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; v[4]=v4;
 67 |     }
 68 | 
 69 |     template<class S>
 70 |     Vec<N,T>(S v0, S v1, S v2, S v3, S v4, S v5)
 71 |     {
 72 |         assert(N==6);
 73 |         v[0]=v0; v[1]=v1; v[2]=v2; v[3]=v3; v[4]=v4; v[5]=v5;
 74 |     }
 75 | 
 76 |     T &operator[](int index)
 77 |     {
 78 |         assert(0<=index && (unsigned int)index<N);
 79 |         return v[index];
 80 |     }
 81 | 
 82 |     const T &operator[](int index) const
 83 |     {
 84 |         assert(0<=index && (unsigned int)index<N);
 85 |         return v[index];
 86 |     }
 87 | 
 88 |     bool nonzero(void) const
 89 |     {
 90 |         for(unsigned int i=0; i<N; ++i) if(v[i]) return true;
 91 |         return false;
 92 |     }
 93 | 
 94 |     template<class S>
 95 |     Vec<N,T> operator+=(const Vec<N,S> &w)
 96 |     {
 97 |         for(unsigned int i=0; i<N; ++i) v[i]+=w[i];
 98 |         return *this;
 99 |     }
100 | 
101 |     template<class S>
102 |     Vec<N,T> operator+(const Vec<N,S> &w) const
103 |     {
104 |         Vec<N,T> sum(*this);
105 |         sum+=w;
106 |         return sum;
107 |     }
108 | 
109 |     template<class S>
110 |     Vec<N,T> operator-=(const Vec<N,S> &w)
111 |     {
112 |         for(unsigned int i=0; i<N; ++i) v[i]-=w[i];
113 |         return *this;
114 |     }
115 | 
116 |     Vec<N,T> operator-(void) const // unary minus
117 |     {
118 |         Vec<N,T> negative;
119 |         for(unsigned int i=0; i<N; ++i) negative.v[i]=-v[i];
120 |         return negative;
121 |     }
122 | 
123 |     Vec<N,T> operator-(const Vec<N,T> &w) const // (binary) subtraction
124 |     {
125 |         Vec<N,T> diff(*this);
126 |         diff-=w;
127 |         return diff;
128 |     }
129 | 
130 |     template<class S>
131 |     Vec<N,T> operator*=(S a)
132 |     {
133 |         for(unsigned int i=0; i<N; ++i) v[i]*=a;
134 |         return *this;
135 |     }
136 | 
137 |     template<class S>
138 |     Vec<N,T> operator*(S a) const
139 |     {
140 |         Vec<N,T> w(*this);
141 |         w*=a;
142 |         return w;
143 |     }
144 | 
145 |     template<class S>
146 |     Vec<N,T> operator*=(const Vec<N,S> &w)
147 |     {
148 |         for(unsigned int i=0; i<N; ++i) v[i]*=w.v[i];
149 |         return *this;
150 |     }
151 | 
152 |     Vec<N,T> operator*(const Vec<N,T> &w) const
153 |     {
154 |         Vec<N,T> componentwise_product;
155 |         for(unsigned int i=0; i<N; ++i) componentwise_product[i]=v[i]*w.v[i];
156 |         return componentwise_product;
157 |     }
158 | 
159 |     template<class S>
160 |     Vec<N,T> operator/=(S a)
161 |     {
162 |         for(unsigned int i=0; i<N; ++i) v[i]/=a;
163 |         return *this;
164 |     }
165 | 
166 |     template<class S>
167 |     Vec<N,T> operator/(S a) const
168 |     {
169 |         Vec<N,T> w(*this);
170 |         w/=a;
171 |         return w;
172 |     }
173 | };
174 | 
175 | typedef Vec<2,double>         Vec2d;
176 | typedef Vec<2,float>          Vec2f;
177 | typedef Vec<2,int>            Vec2i;
178 | typedef Vec<2,unsigned int>   Vec2ui;
179 | typedef Vec<2,short>          Vec2s;
180 | typedef Vec<2,unsigned short> Vec2us;
181 | typedef Vec<2,char>           Vec2c;
182 | typedef Vec<2,unsigned char>  Vec2uc;
183 | 
184 | typedef Vec<3,double>         Vec3d;
185 | typedef Vec<3,float>          Vec3f;
186 | typedef Vec<3,int>            Vec3i;
187 | typedef Vec<3,unsigned int>   Vec3ui;
188 | typedef Vec<3,short>          Vec3s;
189 | typedef Vec<3,unsigned short> Vec3us;
190 | typedef Vec<3,char>           Vec3c;
191 | typedef Vec<3,unsigned char>  Vec3uc;
192 | 
193 | typedef Vec<4,double>         Vec4d;
194 | typedef Vec<4,float>          Vec4f;
195 | typedef Vec<4,int>            Vec4i;
196 | typedef Vec<4,unsigned int>   Vec4ui;
197 | typedef Vec<4,short>          Vec4s;
198 | typedef Vec<4,unsigned short> Vec4us;
199 | typedef Vec<4,char>           Vec4c;
200 | typedef Vec<4,unsigned char>  Vec4uc;
201 | 
202 | typedef Vec<6,double>         Vec6d;
203 | typedef Vec<6,float>          Vec6f;
204 | typedef Vec<6,unsigned int>   Vec6ui;
205 | typedef Vec<6,int>            Vec6i;
206 | typedef Vec<6,short>          Vec6s;
207 | typedef Vec<6,unsigned short> Vec6us;
208 | typedef Vec<6,char>           Vec6c;
209 | typedef Vec<6,unsigned char>  Vec6uc;
210 | 
211 | 
212 | template<unsigned int N, class T>
213 | T mag2(const Vec<N,T> &a)
214 | {
215 |     T l=sqr(a.v[0]);
216 |     for(unsigned int i=1; i<N; ++i) l+=sqr(a.v[i]);
217 |     return l;
218 | }
219 | 
220 | template<unsigned int N, class T>
221 | T mag(const Vec<N,T> &a)
222 | { return sqrt(mag2(a)); }
223 | 
224 | template<unsigned int N, class T> 
225 | inline T dist2(const Vec<N,T> &a, const Vec<N,T> &b)
226 | { 
227 |     T d=sqr(a.v[0]-b.v[0]);
228 |     for(unsigned int i=1; i<N; ++i) d+=sqr(a.v[i]-b.v[i]);
229 |     return d;
230 | }
231 | 
232 | template<unsigned int N, class T> 
233 | inline T dist(const Vec<N,T> &a, const Vec<N,T> &b)
234 | { return std::sqrt(dist2(a,b)); }
235 | 
236 | template<unsigned int N, class T> 
237 | inline void normalize(Vec<N,T> &a)
238 | { a/=mag(a); }
239 | 
240 | template<unsigned int N, class T> 
241 | inline Vec<N,T> normalized(const Vec<N,T> &a)
242 | { return a/mag(a); }
243 | 
244 | template<unsigned int N, class T> 
245 | inline T infnorm(const Vec<N,T> &a)
246 | {
247 |     T d=std::fabs(a.v[0]);
248 |     for(unsigned int i=1; i<N; ++i) d=max(std::fabs(a.v[i]),d);
249 |     return d;
250 | }
251 | 
252 | template<unsigned int N, class T>
253 | void zero(Vec<N,T> &a)
254 | { 
255 |     for(unsigned int i=0; i<N; ++i)
256 |         a.v[i] = 0;
257 | }
258 | 
259 | template<unsigned int N, class T>
260 | std::ostream &operator<<(std::ostream &out, const Vec<N,T> &v)
261 | {
262 |     out<<v.v[0];
263 |     for(unsigned int i=1; i<N; ++i)
264 |         out<<' '<<v.v[i];
265 |     return out;
266 | }
267 | 
268 | template<unsigned int N, class T>
269 | std::istream &operator>>(std::istream &in, Vec<N,T> &v)
270 | {
271 |     in>>v.v[0];
272 |     for(unsigned int i=1; i<N; ++i)
273 |         in>>v.v[i];
274 |     return in;
275 | }
276 | 
277 | template<unsigned int N, class T> 
278 | inline bool operator==(const Vec<N,T> &a, const Vec<N,T> &b)
279 | {
280 |     bool t = (a.v[0] == b.v[0]);
281 |     unsigned int i=1;
282 |     while(i<N && t) {
283 |         t = t && (a.v[i]==b.v[i]); 
284 |         ++i;
285 |     }
286 |     return t;
287 | }
288 | 
289 | template<unsigned int N, class T> 
290 | inline bool operator!=(const Vec<N,T> &a, const Vec<N,T> &b)
291 | { 
292 |     bool t = (a.v[0] != b.v[0]);
293 |     unsigned int i=1;
294 |     while(i<N && !t) {
295 |         t = t || (a.v[i]!=b.v[i]); 
296 |         ++i;
297 |     }
298 |     return t;
299 | }
300 | 
301 | // lexicographic comparison
302 | template<unsigned int N, class T>
303 | inline bool operator<(const Vec<N,T> &a, const Vec<N,T> &b)
304 | {
305 |     for(unsigned int i=0; i<N; ++i){
306 |         if(a.v[i]<b.v[i]) return true;
307 |         if(a.v[i]>b.v[i]) return false;
308 |     }
309 |     return false;
310 | }
311 | 
312 | template<unsigned int N, class S, class T>
313 | inline Vec<N,T> operator*(S a, const Vec<N,T> &v)
314 | {
315 |     Vec<N,T> w(v);
316 |     w*=a;
317 |     return w;
318 | }
319 | 
320 | template<unsigned int N, class T>
321 | inline T min(const Vec<N,T> &a)
322 | {
323 |     T m=a.v[0];
324 |     for(unsigned int i=1; i<N; ++i) if(a.v[i]<m) m=a.v[i];
325 |     return m;
326 | }
327 | 
328 | template<unsigned int N, class T>
329 | inline Vec<N,T> min_union(const Vec<N,T> &a, const Vec<N,T> &b)
330 | {
331 |     Vec<N,T> m;
332 |     for(unsigned int i=0; i<N; ++i) (a.v[i] < b.v[i]) ? m.v[i]=a.v[i] : m.v[i]=b.v[i];
333 |     return m;
334 | }
335 | 
336 | template<unsigned int N, class T>
337 | inline Vec<N,T> max_union(const Vec<N,T> &a, const Vec<N,T> &b)
338 | {
339 |     Vec<N,T> m;
340 |     for(unsigned int i=0; i<N; ++i) (a.v[i] > b.v[i]) ? m.v[i]=a.v[i] : m.v[i]=b.v[i];
341 |     return m;
342 | }
343 | 
344 | template<unsigned int N, class T>
345 | inline T max(const Vec<N,T> &a)
346 | {
347 |     T m=a.v[0];
348 |     for(unsigned int i=1; i<N; ++i) if(a.v[i]>m) m=a.v[i];
349 |     return m;
350 | }
351 | 
352 | template<unsigned int N, class T>
353 | inline T dot(const Vec<N,T> &a, const Vec<N,T> &b)
354 | {
355 |     T d=a.v[0]*b.v[0];
356 |     for(unsigned int i=1; i<N; ++i) d+=a.v[i]*b.v[i];
357 |     return d;
358 | }
359 | 
360 | template<class T> 
361 | inline Vec<2,T> rotate(const Vec<2,T>& a, float angle) 
362 | {
363 |     T c = cos(angle);
364 |     T s = sin(angle);
365 |     return Vec<2,T>(c*a[0] - s*a[1],s*a[0] + c*a[1]); // counter-clockwise
366 | }
367 | 
368 | template<class T>
369 | inline Vec<2,T> perp(const Vec<2,T> &a)
370 | { return Vec<2,T>(-a.v[1], a.v[0]); } // counter-clockwise by 90 degrees
371 | 
372 | template<class T>
373 | inline T cross(const Vec<2,T> &a, const Vec<2,T> &b)
374 | { return a.v[0]*b.v[1]-a.v[1]*b.v[0]; }
375 | 
376 | template<class T>
377 | inline Vec<3,T> cross(const Vec<3,T> &a, const Vec<3,T> &b)
378 | {
379 |     return Vec<3,T>(a.v[1]*b.v[2]-a.v[2]*b.v[1],
380 |                     a.v[2]*b.v[0]-a.v[0]*b.v[2],
381 |                     a.v[0]*b.v[1]-a.v[1]*b.v[0]);
382 | }
383 | 
384 | template<class T>
385 | inline T triple(const Vec<3,T> &a, const Vec<3,T> &b, const Vec<3,T> &c)
386 | {
387 |     return a.v[0]*(b.v[1]*c.v[2]-b.v[2]*c.v[1])
388 |           +a.v[1]*(b.v[2]*c.v[0]-b.v[0]*c.v[2])
389 |           +a.v[2]*(b.v[0]*c.v[1]-b.v[1]*c.v[0]);
390 | }
391 | 
392 | template<unsigned int N, class T>
393 | inline unsigned int hash(const Vec<N,T> &a)
394 | {
395 |     unsigned int h=a.v[0];
396 |     for(unsigned int i=1; i<N; ++i)
397 |         h=hash(h ^ a.v[i]);
398 |     return h;
399 | }
400 | 
401 | template<unsigned int N, class T>
402 | inline void assign(const Vec<N,T> &a, T &a0, T &a1)
403 | { 
404 |     assert(N==2);
405 |     a0=a.v[0]; a1=a.v[1];
406 | }
407 | 
408 | template<unsigned int N, class T>
409 | inline void assign(const Vec<N,T> &a, T &a0, T &a1, T &a2)
410 | { 
411 |     assert(N==3);
412 |     a0=a.v[0]; a1=a.v[1]; a2=a.v[2];
413 | }
414 | 
415 | template<unsigned int N, class T>
416 | inline void assign(const Vec<N,T> &a, T &a0, T &a1, T &a2, T &a3)
417 | { 
418 |     assert(N==4);
419 |     a0=a.v[0]; a1=a.v[1]; a2=a.v[2]; a3=a.v[3];
420 | }
421 | 
422 | template<unsigned int N, class T>
423 | inline void assign(const Vec<N,T> &a, T &a0, T &a1, T &a2, T &a3, T &a4, T &a5)
424 | { 
425 |     assert(N==6);
426 |     a0=a.v[0]; a1=a.v[1]; a2=a.v[2]; a3=a.v[3]; a4=a.v[4]; a5=a.v[5];
427 | }
428 | 
429 | template<unsigned int N, class T>
430 | inline Vec<N,int> round(const Vec<N,T> &a)
431 | { 
432 |     Vec<N,int> rounded;
433 |     for(unsigned int i=0; i<N; ++i)
434 |         rounded.v[i]=lround(a.v[i]);
435 |     return rounded; 
436 | }
437 | 
438 | template<unsigned int N, class T>
439 | inline Vec<N,int> floor(const Vec<N,T> &a)
440 | { 
441 |     Vec<N,int> rounded;
442 |     for(unsigned int i=0; i<N; ++i)
443 |         rounded.v[i]=(int)floor(a.v[i]);
444 |     return rounded; 
445 | }
446 | 
447 | template<unsigned int N, class T>
448 | inline Vec<N,int> ceil(const Vec<N,T> &a)
449 | { 
450 |     Vec<N,int> rounded;
451 |     for(unsigned int i=0; i<N; ++i)
452 |         rounded.v[i]=(int)ceil(a.v[i]);
453 |     return rounded; 
454 | }
455 | 
456 | template<unsigned int N, class T>
457 | inline Vec<N,T> fabs(const Vec<N,T> &a)
458 | { 
459 |     Vec<N,T> result;
460 |     for(unsigned int i=0; i<N; ++i)
461 |         result.v[i]=fabs(a.v[i]);
462 |     return result; 
463 | }
464 | 
465 | template<unsigned int N, class T>
466 | inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, Vec<N,T> &xmin, Vec<N,T> &xmax)
467 | {
468 |     for(unsigned int i=0; i<N; ++i)
469 |         minmax(x0.v[i], x1.v[i], xmin.v[i], xmax.v[i]);
470 | }
471 | 
472 | template<unsigned int N, class T>
473 | inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, const Vec<N,T> &x2, Vec<N,T> &xmin, Vec<N,T> &xmax)
474 | {
475 |     for(unsigned int i=0; i<N; ++i)
476 |         minmax(x0.v[i], x1.v[i], x2.v[i], xmin.v[i], xmax.v[i]);
477 | }
478 | 
479 | template<unsigned int N, class T>
480 | inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, const Vec<N,T> &x2, const Vec<N,T> &x3,
481 |         Vec<N,T> &xmin, Vec<N,T> &xmax)
482 | {
483 |     for(unsigned int i=0; i<N; ++i)
484 |         minmax(x0.v[i], x1.v[i], x2.v[i], x3.v[i], xmin.v[i], xmax.v[i]);
485 | }
486 | 
487 | template<unsigned int N, class T>
488 | inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, const Vec<N,T> &x2, const Vec<N,T> &x3, const Vec<N,T> &x4,
489 |         Vec<N,T> &xmin, Vec<N,T> &xmax)
490 | {
491 |     for(unsigned int i=0; i<N; ++i)
492 |         minmax(x0.v[i], x1.v[i], x2.v[i], x3.v[i], x4.v[i], xmin.v[i], xmax.v[i]);
493 | }
494 | 
495 | template<unsigned int N, class T>
496 | inline void minmax(const Vec<N,T> &x0, const Vec<N,T> &x1, const Vec<N,T> &x2, const Vec<N,T> &x3, const Vec<N,T> &x4,
497 |         const Vec<N,T> &x5, Vec<N,T> &xmin, Vec<N,T> &xmax)
498 | {
499 |     for(unsigned int i=0; i<N; ++i)
500 |         minmax(x0.v[i], x1.v[i], x2.v[i], x3.v[i], x4.v[i], x5.v[i], xmin.v[i], xmax.v[i]);
501 | }
502 | 
503 | template<unsigned int N, class T>
504 | inline void update_minmax(const Vec<N,T> &x, Vec<N,T> &xmin, Vec<N,T> &xmax)
505 | {
506 |     for(unsigned int i=0; i<N; ++i) update_minmax(x[i], xmin[i], xmax[i]);
507 | }
508 | 
509 | #endif
510 | 


--------------------------------------------------------------------------------
/meshes/joint.obj:
--------------------------------------------------------------------------------
  1 | # 221
  2 | # 446
  3 | v 0.220516 0.705673 -0.028230
  4 | v 0.220516 -0.411409 -0.028230
  5 | v 0.187719 -0.411409 -0.008132
  6 | v 0.187719 0.705673 -0.008132
  7 | v 0.152181 -0.411409 0.006588
  8 | v 0.152181 0.705673 0.006588
  9 | v 0.114777 -0.411409 0.015568
 10 | v 0.114777 0.705673 0.015568
 11 | v 0.076430 -0.411409 0.018586
 12 | v 0.076430 0.705673 0.018586
 13 | v 0.038082 -0.411409 0.015568
 14 | v 0.038082 0.705673 0.015568
 15 | v 0.000679 -0.411409 0.006588
 16 | v 0.000679 0.705673 0.006588
 17 | v -0.034859 -0.411409 -0.008132
 18 | v -0.034859 0.705673 -0.008132
 19 | v -0.067656 -0.411409 -0.028230
 20 | v -0.067656 0.705673 -0.028230
 21 | v -0.096906 -0.411409 -0.053212
 22 | v -0.096906 0.705673 -0.053212
 23 | v -0.121888 -0.411409 -0.082463
 24 | v -0.121888 0.705673 -0.082463
 25 | v -0.141987 -0.411409 -0.115260
 26 | v -0.141987 0.705673 -0.115260
 27 | v -0.156706 -0.411409 -0.150798
 28 | v -0.156706 0.705673 -0.150798
 29 | v -0.165687 -0.411409 -0.188201
 30 | v -0.165687 0.705673 -0.188201
 31 | v -0.168704 -0.411409 -0.226548
 32 | v -0.168704 0.705673 -0.226548
 33 | v -0.165687 -0.411409 -0.264896
 34 | v -0.165687 0.705673 -0.264896
 35 | v -0.156706 -0.411409 -0.302299
 36 | v -0.156706 0.705673 -0.302299
 37 | v -0.141987 -0.411409 -0.337837
 38 | v -0.141987 0.705673 -0.337837
 39 | v -0.121888 -0.411409 -0.370634
 40 | v -0.121888 0.705673 -0.370634
 41 | v -0.096906 -0.411409 -0.399884
 42 | v -0.096906 0.705673 -0.399884
 43 | v -0.067656 -0.411409 -0.424866
 44 | v -0.067656 0.705673 -0.424866
 45 | v -0.034859 -0.411409 -0.444965
 46 | v -0.034859 0.705673 -0.444965
 47 | v 0.000679 -0.411409 -0.459685
 48 | v 0.000679 0.705673 -0.459685
 49 | v 0.038082 -0.411409 -0.468665
 50 | v 0.038082 0.705673 -0.468665
 51 | v 0.076430 -0.411409 -0.471682
 52 | v 0.076430 0.705673 -0.471682
 53 | v 0.114777 -0.411409 -0.468665
 54 | v 0.114777 0.705673 -0.468665
 55 | v 0.152180 -0.411409 -0.459685
 56 | v 0.152180 0.705673 -0.459685
 57 | v 0.187718 -0.411409 -0.444965
 58 | v 0.187718 0.705673 -0.444965
 59 | v 0.220516 -0.411409 -0.424866
 60 | v 0.220516 0.705673 -0.424866
 61 | v 0.249765 -0.411409 -0.399884
 62 | v 0.249765 0.705673 -0.399884
 63 | v 0.274748 -0.411409 -0.370634
 64 | v 0.274748 0.705673 -0.370634
 65 | v 0.294846 -0.411409 -0.337837
 66 | v 0.294846 0.705673 -0.337837
 67 | v 0.309566 -0.411409 -0.302299
 68 | v 0.309566 0.705673 -0.302299
 69 | v 0.318546 -0.411409 -0.264896
 70 | v 0.318546 0.705673 -0.264896
 71 | v 0.321564 -0.411409 -0.226548
 72 | v 0.321564 0.705673 -0.226548
 73 | v 0.318546 -0.411409 -0.188201
 74 | v 0.318546 0.705673 -0.188201
 75 | v 0.309566 -0.411409 -0.150798
 76 | v 0.309566 0.705673 -0.150798
 77 | v 0.294846 -0.411409 -0.115260
 78 | v 0.294846 0.705673 -0.115260
 79 | v 0.274748 -0.411409 -0.082463
 80 | v 0.274748 0.705673 -0.082463
 81 | v 0.249766 -0.411409 -0.053213
 82 | v 0.249766 0.705673 -0.053213
 83 | v 0.184875 -0.411409 -0.560307
 84 | v 0.235750 -0.411409 -0.539233
 85 | v 0.282704 -0.411409 -0.510460
 86 | v 0.324579 -0.411409 -0.474697
 87 | v 0.360342 -0.411409 -0.432822
 88 | v 0.389115 -0.411409 -0.385869
 89 | v 0.410188 -0.411409 -0.334993
 90 | v 0.423044 -0.411409 -0.281447
 91 | v 0.427365 -0.411409 -0.226548
 92 | v 0.423044 -0.411409 -0.171650
 93 | v 0.410188 -0.411409 -0.118104
 94 | v 0.389116 -0.411409 -0.067228
 95 | v 0.360342 -0.411409 -0.020274
 96 | v 0.324579 -0.411409 0.021601
 97 | v 0.282705 -0.411409 0.057364
 98 | v 0.235751 -0.411409 0.086137
 99 | v 0.184875 -0.411409 0.107210
100 | v 0.131328 -0.411409 0.120066
101 | v 0.076430 -0.411409 0.124386
102 | v -0.410534 -0.411409 -0.226548
103 | v 0.076430 -0.411409 -0.577483
104 | v 0.131328 -0.411409 -0.573162
105 | v 0.235751 0.705673 0.086137
106 | v 0.282705 0.705673 0.057364
107 | v 0.324579 0.705673 0.021601
108 | v 0.360342 0.705673 -0.020273
109 | v 0.389116 0.705673 -0.067228
110 | v 0.410188 0.705673 -0.118104
111 | v 0.423044 0.705673 -0.171650
112 | v 0.427365 0.705673 -0.226548
113 | v 0.423044 0.705673 -0.281447
114 | v 0.410188 0.705673 -0.334993
115 | v 0.389115 0.705673 -0.385869
116 | v 0.360342 0.705673 -0.432822
117 | v 0.324579 0.705673 -0.474697
118 | v 0.282704 0.705673 -0.510460
119 | v 0.235750 0.705673 -0.539233
120 | v 0.184875 0.705673 -0.560307
121 | v 0.131328 0.705673 -0.573162
122 | v 0.076430 0.705673 -0.577483
123 | v -0.410534 0.705673 -0.226548
124 | v 0.076430 0.705673 0.124386
125 | v 0.131328 0.705673 0.120066
126 | v 0.184875 0.705673 0.107210
127 | v -0.410534 -0.411409 -0.577483
128 | v -0.167053 -0.411409 0.124386
129 | v -0.410534 -0.411409 0.124386
130 | v -0.410534 0.705673 -0.577483
131 | v -0.410534 -0.060474 0.488458
132 | v -0.167053 -0.060474 0.488458
133 | v -0.167053 0.705673 0.488458
134 | v -0.410534 0.705673 0.488458
135 | v -0.410534 0.705673 0.124386
136 | v -0.167053 0.705673 0.124386
137 | v -0.410534 -0.060474 0.124386
138 | v -0.410534 -0.411409 0.488458
139 | v -0.167053 -0.411409 0.488458
140 | v 0.076430 -0.411409 0.488458
141 | v 0.076430 -0.060474 0.488458
142 | v -0.167053 -0.060474 0.124386
143 | v 0.076430 -0.060474 0.124386
144 | v -0.410534 -0.205097 0.403330
145 | v -0.410534 -0.220735 0.407084
146 | v -0.410534 -0.236768 0.408345
147 | v -0.410534 -0.252801 0.407084
148 | v -0.410534 -0.268439 0.403330
149 | v -0.410534 -0.283298 0.397176
150 | v -0.410534 -0.297010 0.388772
151 | v -0.410534 -0.309238 0.378327
152 | v -0.410534 -0.319683 0.366099
153 | v -0.410534 -0.328086 0.352386
154 | v -0.410534 -0.334241 0.337528
155 | v -0.410534 -0.337995 0.321890
156 | v -0.410534 -0.339257 0.305858
157 | v -0.410534 -0.337995 0.289824
158 | v -0.410534 -0.334241 0.274186
159 | v -0.410534 -0.328086 0.259329
160 | v -0.410534 -0.319683 0.245616
161 | v -0.410534 -0.309238 0.233387
162 | v -0.410534 -0.297010 0.222942
163 | v -0.410534 -0.283298 0.214539
164 | v -0.410534 -0.268439 0.208384
165 | v -0.410534 -0.252801 0.204631
166 | v -0.410534 -0.236768 0.203369
167 | v -0.410534 -0.220735 0.204631
168 | v -0.410534 -0.205097 0.208384
169 | v -0.410534 -0.190239 0.214539
170 | v -0.410534 -0.176527 0.222942
171 | v -0.410534 -0.164298 0.233387
172 | v -0.410534 -0.153853 0.245616
173 | v -0.410534 -0.145450 0.259329
174 | v -0.410534 -0.139296 0.274186
175 | v -0.410534 -0.135541 0.289824
176 | v -0.410534 -0.134280 0.305858
177 | v -0.410534 -0.135541 0.321890
178 | v -0.410534 -0.139296 0.337528
179 | v -0.410534 -0.145450 0.352386
180 | v -0.410534 -0.153853 0.366099
181 | v -0.410534 -0.164298 0.378327
182 | v -0.410534 -0.176527 0.388772
183 | v -0.410534 -0.190239 0.397176
184 | v 0.076430 -0.190239 0.397176
185 | v 0.076430 -0.176527 0.388772
186 | v 0.076430 -0.164298 0.378327
187 | v 0.076430 -0.153853 0.366099
188 | v 0.076430 -0.145450 0.352386
189 | v 0.076430 -0.139296 0.337528
190 | v 0.076430 -0.135541 0.321890
191 | v 0.076430 -0.134280 0.305858
192 | v 0.076430 -0.135541 0.289824
193 | v 0.076430 -0.139296 0.274186
194 | v 0.076430 -0.145450 0.259329
195 | v 0.076430 -0.153853 0.245616
196 | v 0.076430 -0.164298 0.233387
197 | v 0.076430 -0.176527 0.222942
198 | v 0.076430 -0.190239 0.214539
199 | v 0.076430 -0.205097 0.208384
200 | v 0.076430 -0.220735 0.204631
201 | v 0.076430 -0.236768 0.203369
202 | v 0.076430 -0.252801 0.204631
203 | v 0.076430 -0.268439 0.208384
204 | v 0.076430 -0.283298 0.214539
205 | v 0.076430 -0.297010 0.222942
206 | v 0.076430 -0.309238 0.233387
207 | v 0.076430 -0.319683 0.245616
208 | v 0.076430 -0.328086 0.259329
209 | v 0.076430 -0.334241 0.274186
210 | v 0.076430 -0.337995 0.289824
211 | v 0.076430 -0.339257 0.305858
212 | v 0.076430 -0.337995 0.321890
213 | v 0.076430 -0.334241 0.337528
214 | v 0.076430 -0.328086 0.352386
215 | v 0.076430 -0.319683 0.366099
216 | v 0.076430 -0.309238 0.378327
217 | v 0.076430 -0.297010 0.388772
218 | v 0.076430 -0.283298 0.397176
219 | v 0.076430 -0.268439 0.403330
220 | v 0.076430 -0.252801 0.407084
221 | v 0.076430 -0.236768 0.408345
222 | v 0.076430 -0.220735 0.407084
223 | v 0.076430 -0.205097 0.403330
224 | f 4 1 2
225 | f 4 2 3
226 | f 6 4 3
227 | f 6 3 5
228 | f 8 6 5
229 | f 8 5 7
230 | f 10 8 7
231 | f 10 7 9
232 | f 12 10 9
233 | f 12 9 11
234 | f 14 12 11
235 | f 14 11 13
236 | f 16 14 13
237 | f 18 15 17
238 | f 20 18 17
239 | f 24 22 21
240 | f 24 21 23
241 | f 26 24 23
242 | f 26 23 25
243 | f 28 26 25
244 | f 28 25 27
245 | f 30 28 27
246 | f 30 27 29
247 | f 32 30 29
248 | f 32 29 31
249 | f 34 32 31
250 | f 34 31 33
251 | f 36 34 33
252 | f 36 33 35
253 | f 38 36 35
254 | f 38 35 37
255 | f 40 38 37
256 | f 40 37 39
257 | f 42 40 39
258 | f 42 39 41
259 | f 44 42 41
260 | f 44 41 43
261 | f 46 44 43
262 | f 46 43 45
263 | f 48 46 45
264 | f 48 45 47
265 | f 50 48 47
266 | f 50 47 49
267 | f 52 50 49
268 | f 52 49 51
269 | f 54 52 51
270 | f 54 51 53
271 | f 56 54 53
272 | f 56 53 55
273 | f 58 56 55
274 | f 58 55 57
275 | f 60 58 57
276 | f 60 57 59
277 | f 62 60 59
278 | f 62 59 61
279 | f 64 62 61
280 | f 64 61 63
281 | f 66 64 63
282 | f 66 63 65
283 | f 68 66 65
284 | f 68 65 67
285 | f 70 68 67
286 | f 70 67 69
287 | f 72 70 69
288 | f 72 69 71
289 | f 74 72 71
290 | f 78 76 75
291 | f 78 75 77
292 | f 80 78 77
293 | f 80 77 79
294 | f 1 80 79
295 | f 1 79 2
296 | f 100 29 27
297 | f 31 29 100
298 | f 100 27 25
299 | f 33 31 100
300 | f 100 25 23
301 | f 35 33 100
302 | f 81 53 102
303 | f 84 61 59
304 | f 91 71 90
305 | f 100 23 21
306 | f 37 35 100
307 | f 21 127 100
308 | f 125 39 37
309 | f 11 98 99
310 | f 98 9 7
311 | f 98 7 5
312 | f 97 3 96
313 | f 90 71 69
314 | f 88 67 65
315 | f 102 53 51
316 | f 102 51 49
317 | f 101 49 47
318 | f 121 30 32
319 | f 28 30 121
320 | f 121 32 34
321 | f 26 28 121
322 | f 121 34 36
323 | f 24 26 121
324 | f 124 96 103
325 | f 56 116 117
326 | f 121 36 38
327 | f 104 80 1
328 | f 114 60 62
329 | f 38 40 128
330 | f 20 22 121
331 | f 119 50 52
332 | f 119 52 54
333 | f 119 54 56
334 | f 112 62 64
335 | f 112 64 66
336 | f 124 1 4
337 | f 124 4 6
338 | f 123 124 6
339 | f 123 6 8
340 | f 123 8 10
341 | f 123 10 12
342 | f 123 12 14
343 | f 14 134 122
344 | f 16 18 134
345 | f 134 18 20
346 | f 89 110 109
347 | f 89 109 90
348 | f 88 111 110
349 | f 88 110 89
350 | f 87 112 111
351 | f 87 111 88
352 | f 86 113 112
353 | f 86 112 87
354 | f 85 114 113
355 | f 85 113 86
356 | f 84 114 85
357 | f 83 115 84
358 | f 82 117 116
359 | f 82 116 83
360 | f 81 117 82
361 | f 102 119 118
362 | f 102 118 81
363 | f 101 120 119
364 | f 101 119 102
365 | f 98 123 122
366 | f 97 124 123
367 | f 97 123 98
368 | f 96 124 97
369 | f 93 106 105
370 | f 93 105 94
371 | f 92 107 106
372 | f 92 106 93
373 | f 91 108 107
374 | f 91 107 92
375 | f 90 109 108
376 | f 90 108 91
377 | f 132 129 130
378 | f 132 130 131
379 | f 125 128 120
380 | f 125 120 101
381 | f 121 128 125
382 | f 121 125 100
383 | f 121 100 127
384 | f 121 127 135
385 | f 121 135 133
386 | f 129 136 137
387 | f 129 137 130
388 | f 130 137 138
389 | f 130 138 139
390 | f 122 134 140
391 | f 130 140 134
392 | f 130 134 131
393 | f 131 134 133
394 | f 131 133 132
395 | f 132 133 135
396 | f 173 129 132
397 | f 136 127 126
398 | f 136 126 137
399 | f 168 169 135
400 | f 135 169 170
401 | f 167 168 135
402 | f 135 170 171
403 | f 166 167 135
404 | f 166 135 127
405 | f 165 166 127
406 | f 164 165 127
407 | f 163 164 127
408 | f 162 163 127
409 | f 161 162 127
410 | f 160 161 127
411 | f 159 160 127
412 | f 158 159 127
413 | f 157 158 127
414 | f 135 171 172
415 | f 135 172 173
416 | f 129 173 174
417 | f 129 174 175
418 | f 129 175 176
419 | f 129 176 177
420 | f 129 177 178
421 | f 129 178 179
422 | f 129 179 180
423 | f 129 180 181
424 | f 129 181 142
425 | f 136 129 142
426 | f 136 142 143
427 | f 136 143 144
428 | f 136 144 145
429 | f 136 145 146
430 | f 136 146 147
431 | f 136 147 148
432 | f 136 148 149
433 | f 136 149 150
434 | f 136 150 151
435 | f 136 151 152
436 | f 156 157 127
437 | f 156 127 136
438 | f 155 156 136
439 | f 154 155 136
440 | f 153 154 136
441 | f 136 152 153
442 | f 137 126 99
443 | f 137 99 138
444 | f 203 204 99
445 | f 99 204 205
446 | f 202 203 99
447 | f 99 205 206
448 | f 201 202 99
449 | f 201 99 141
450 | f 200 201 141
451 | f 199 200 141
452 | f 198 199 141
453 | f 197 198 141
454 | f 196 197 141
455 | f 195 196 141
456 | f 194 195 141
457 | f 193 194 141
458 | f 192 193 141
459 | f 99 206 207
460 | f 138 99 207
461 | f 138 207 208
462 | f 138 208 209
463 | f 138 209 210
464 | f 138 210 211
465 | f 138 211 212
466 | f 138 212 213
467 | f 138 213 214
468 | f 138 214 215
469 | f 138 215 216
470 | f 138 216 217
471 | f 139 138 217
472 | f 139 217 218
473 | f 139 218 219
474 | f 139 219 220
475 | f 139 220 221
476 | f 139 221 182
477 | f 139 182 183
478 | f 139 183 184
479 | f 139 184 185
480 | f 139 185 186
481 | f 139 186 187
482 | f 191 192 141
483 | f 191 141 139
484 | f 190 191 139
485 | f 189 190 139
486 | f 188 189 139
487 | f 139 187 188
488 | f 139 141 140
489 | f 139 140 130
490 | f 185 184 179
491 | f 185 179 178
492 | f 184 183 180
493 | f 184 180 179
494 | f 183 182 181
495 | f 183 181 180
496 | f 182 221 142
497 | f 182 142 181
498 | f 221 220 143
499 | f 221 143 142
500 | f 220 219 144
501 | f 220 144 143
502 | f 219 218 145
503 | f 219 145 144
504 | f 218 217 146
505 | f 218 146 145
506 | f 217 216 147
507 | f 217 147 146
508 | f 216 215 148
509 | f 216 148 147
510 | f 215 214 149
511 | f 215 149 148
512 | f 214 213 150
513 | f 214 150 149
514 | f 213 212 151
515 | f 213 151 150
516 | f 212 211 152
517 | f 212 152 151
518 | f 211 210 153
519 | f 211 153 152
520 | f 210 209 154
521 | f 210 154 153
522 | f 209 208 155
523 | f 209 155 154
524 | f 208 207 156
525 | f 208 156 155
526 | f 207 206 157
527 | f 207 157 156
528 | f 206 205 158
529 | f 206 158 157
530 | f 205 204 159
531 | f 205 159 158
532 | f 204 203 160
533 | f 204 160 159
534 | f 203 202 161
535 | f 203 161 160
536 | f 202 201 162
537 | f 202 162 161
538 | f 201 200 163
539 | f 201 163 162
540 | f 200 199 164
541 | f 200 164 163
542 | f 199 198 165
543 | f 199 165 164
544 | f 198 197 166
545 | f 198 166 165
546 | f 197 196 167
547 | f 197 167 166
548 | f 196 195 168
549 | f 196 168 167
550 | f 195 194 169
551 | f 195 169 168
552 | f 194 193 170
553 | f 194 170 169
554 | f 193 192 171
555 | f 193 171 170
556 | f 192 191 172
557 | f 192 172 171
558 | f 191 190 173
559 | f 191 173 172
560 | f 190 189 174
561 | f 190 174 173
562 | f 189 188 175
563 | f 189 175 174
564 | f 188 187 176
565 | f 188 176 175
566 | f 187 186 177
567 | f 187 177 176
568 | f 186 185 178
569 | f 186 178 177
570 | f 140 141 122
571 | f 98 122 141
572 | f 116 56 58
573 | f 116 58 60
574 | f 114 84 115
575 | f 60 114 115
576 | f 115 83 116
577 | f 115 116 60
578 | f 118 119 56
579 | f 117 81 118
580 | f 117 118 56
581 | f 133 134 20
582 | f 128 42 44
583 | f 40 42 128
584 | f 106 76 78
585 | f 106 78 80
586 | f 104 94 105
587 | f 80 104 105
588 | f 105 106 80
589 | f 107 74 76
590 | f 66 68 111
591 | f 62 112 113
592 | f 113 114 62
593 | f 111 68 70
594 | f 70 72 110
595 | f 110 111 70
596 | f 109 110 72
597 | f 72 74 108
598 | f 107 108 74
599 | f 76 106 107
600 | f 14 16 134
601 | f 122 123 14
602 | f 103 104 1
603 | f 1 124 103
604 | f 46 48 120
605 | f 50 119 120
606 | f 48 50 120
607 | f 128 44 46
608 | f 46 120 128
609 | f 141 99 98
610 | f 126 17 15
611 | f 15 13 99
612 | f 16 13 15
613 | f 128 121 38
614 | f 111 112 66
615 | f 108 109 72
616 | f 99 126 15
617 | f 132 135 173
618 | f 95 94 104
619 | f 95 103 96
620 | f 96 2 95
621 | f 94 2 79
622 | f 2 94 95
623 | f 2 96 3
624 | f 5 97 98
625 | f 3 97 5
626 | f 79 93 94
627 | f 93 79 77
628 | f 92 77 75
629 | f 75 91 92
630 | f 89 69 67
631 | f 87 65 63
632 | f 86 63 61
633 | f 86 61 85
634 | f 83 59 57
635 | f 82 57 55
636 | f 81 55 53
637 | f 125 37 100
638 | f 11 99 13
639 | f 61 84 85
640 | f 47 125 101
641 | f 45 125 47
642 | f 43 125 45
643 | f 41 125 43
644 | f 39 125 41
645 | f 98 11 9
646 | f 67 88 89
647 | f 49 101 102
648 | f 103 95 104
649 | f 77 92 93
650 | f 73 75 76
651 | f 69 89 90
652 | f 65 87 88
653 | f 63 86 87
654 | f 59 83 84
655 | f 57 82 83
656 | f 55 81 82
657 | f 127 17 126
658 | f 18 16 15
659 | f 121 133 20
660 | f 22 20 21
661 | f 24 121 22
662 | f 17 19 20
663 | f 20 19 21
664 | f 21 19 127
665 | f 17 127 19
666 | f 91 75 73
667 | f 74 71 73
668 | f 73 71 91
669 | f 73 76 74
670 | 


--------------------------------------------------------------------------------
/src/optimize_tet_mesh.cpp:
--------------------------------------------------------------------------------
  1 | #include "optimize_tet_mesh.h"
  2 | 
  3 | #include <iostream>
  4 | 
  5 | #include <set>
  6 | #include <queue>
  7 | #include <cfloat>
  8 | 
  9 | #include "tet_quality.h"
 10 | 
 11 | 
 12 | // Return a random number in the range -D to D
 13 | float
 14 | randf(float D)
 15 | {
 16 |     return D*(2*static_cast<float>(rand())/static_cast<float>(RAND_MAX) - 1);
 17 | }
 18 | 
 19 | 
 20 | // Do local optimization of the position of the given vertex.
 21 | float
 22 | optimize_vertex(int vertex,
 23 |                 TetMesh& mesh,
 24 | 				const SDF &sdf,
 25 |                 const FeatureSet& featureSet,
 26 | 				bool isBoundary, 
 27 |                 int featureIndex)
 28 | {
 29 | 	static const int NUM_RAND_PERTURBATIONS = 16;
 30 | 	std::vector<Vec3f> testx;
 31 | 
 32 |     const float P=0.5*sdf.dx; // max perturbation in each coordinate
 33 | 
 34 |     if (featureIndex != -1) {
 35 |         // Optimize along the feature to which the vertex is constrained.
 36 |         // Generate random perturbation points along feature.
 37 |         // Do this by distributing points along the feature's tangent vector,
 38 |         // then projecting them all onto the feature.
 39 |         Feature feature;
 40 |         featureSet.getFeature(featureIndex, feature);
 41 |         Vec3f tangent = feature.getTangent(mesh.V(vertex));
 42 |         normalize(tangent);
 43 |         for (int i = 0; i < NUM_RAND_PERTURBATIONS; ++i) {
 44 |             testx.push_back(feature.projectToFeature(mesh.V(vertex) +
 45 |                                                      randf(P)*tangent));
 46 |         }
 47 |         // and include original point and extreme points along feature.
 48 |         testx.push_back(feature.projectToFeature(mesh.V(vertex)));
 49 |         testx.push_back(feature.projectToFeature(mesh.V(vertex)-P*tangent));
 50 |         testx.push_back(feature.projectToFeature(mesh.V(vertex)+P*tangent));
 51 | 
 52 |     } else if (isBoundary) {
 53 |         // Generate random perturbation points on tangent plane, in
 54 |         // a square of side length dx, then projected onto isosurface
 55 |         Vec3f normal = sdf.normal(mesh.V(vertex));
 56 |         if (mag2(normal) == 0.0)
 57 |             normal = Vec3f(0.0, 1.0, 0.0); // Default to y-axis if no normal.
 58 |         Vec3f u(1,0,0);
 59 |         if(std::fabs(normal[0])>.5)
 60 |             u = Vec3f(-normal[1], normal[0], 0.f);
 61 |         else
 62 |             u = Vec3f(0.f, -normal[2], normal[1]);
 63 |         u /= mag(u);
 64 |         Vec3f v = cross(normal, u);
 65 |         for (int i = 0; i < NUM_RAND_PERTURBATIONS; ++i) {
 66 |             Vec3f t = mesh.V(vertex) + randf(P)*u + randf(P)*v;
 67 |             testx.push_back(sdf.projectToIsosurface(t));
 68 |         }
 69 |         // also original point and projected corners of unit square
 70 |         testx.push_back(sdf.projectToIsosurface(mesh.V(vertex)));
 71 |         testx.push_back(sdf.projectToIsosurface(mesh.V(vertex)-P*u-P*v));
 72 |         testx.push_back(sdf.projectToIsosurface(mesh.V(vertex)+P*u-P*v));
 73 |         testx.push_back(sdf.projectToIsosurface(mesh.V(vertex)-P*u+P*v));
 74 |         testx.push_back(sdf.projectToIsosurface(mesh.V(vertex)+P*u+P*v));
 75 | 
 76 |     } else { // interior vertex
 77 |         // Generate random perturbation points within cube
 78 |         for (int i = 0; i < NUM_RAND_PERTURBATIONS; ++i) {
 79 |             testx.push_back(mesh.V(vertex)+Vec3f(randf(P),randf(P),randf(P)));
 80 |         }
 81 |         // and include original point and corners of cube
 82 |         testx.push_back(mesh.V(vertex));
 83 |         testx.push_back(mesh.V(vertex)+Vec3f(-P,-P,-P));
 84 |         testx.push_back(mesh.V(vertex)+Vec3f(+P,-P,-P));
 85 |         testx.push_back(mesh.V(vertex)+Vec3f(-P,+P,-P));
 86 |         testx.push_back(mesh.V(vertex)+Vec3f(+P,+P,-P));
 87 |         testx.push_back(mesh.V(vertex)+Vec3f(-P,-P,+P));
 88 |         testx.push_back(mesh.V(vertex)+Vec3f(+P,-P,+P));
 89 |         testx.push_back(mesh.V(vertex)+Vec3f(-P,+P,+P));
 90 |         testx.push_back(mesh.V(vertex)+Vec3f(+P,+P,+P));
 91 |     }
 92 | 
 93 |     // Find incident tetrahedra, and the indices that refer to the 
 94 |     // current vertex within those tetrahedra.
 95 |     std::vector<Tet> incidentTets;
 96 |     mesh.getIncidentTets(vertex, incidentTets);
 97 |     std::vector<int> incidentVertexIndex(incidentTets.size(), -1);
 98 |     for (size_t i = 0; i < incidentTets.size(); ++i) {
 99 |         for (int v = 0; v < 4; ++v) {
100 |             if (mesh.V(vertex) == incidentTets[i][v]) {
101 |                 incidentVertexIndex[i] = v;
102 |                 continue;
103 |             }
104 |         }
105 |         assert(incidentVertexIndex[i] != -1);
106 |     }
107 | 
108 | 	
109 |     // Find quality metrics for tetrahedra created from each perturbation
110 | 	// of the given vertex.
111 | 	// We're looking for the perturbation that gives the highest quality metric.
112 | 	float bestQuality = -FLT_MAX;
113 | 	int bestPerturb = -1;
114 | 
115 | 	for (size_t p = 0; p < testx.size(); ++p) {
116 | 		// Create tetrahedra to represent the local neighbourhood if 
117 | 		// the given vertex were perturbed by the current amount.
118 | 		Vec3f perturbedVert = testx[p];
119 | 		
120 | 		// Compute quality of each tetrahedron and use the worst one
121 | 		// as representative of the current perturbation.
122 | 		float perturbQuality = FLT_MAX;
123 | 		for (size_t t = 0; t < incidentTets.size(); ++t) {
124 | 
125 | 			// Perturb the current vertex in the tetrahedron.
126 |             incidentTets[t][incidentVertexIndex[t]] = perturbedVert;
127 | 			
128 | 			float tetQuality = compute_tet_quality(incidentTets[t]);
129 | 			
130 | 			// Keep the lowest-quality tet's quality measure.
131 | 			if (tetQuality < perturbQuality) {
132 | 				perturbQuality = tetQuality;
133 | 			}
134 | 		}
135 | 		
136 | 		// Check whether the current perturbation is the best so far.
137 | 		if (perturbQuality > bestQuality) {
138 | 			bestQuality = perturbQuality;
139 | 			bestPerturb = p;
140 | 		} else if (perturbQuality == bestQuality && 
141 | 					bestPerturb >= 0) {
142 | 			// To break a tie, take the smallest perturbation.
143 | 			if (dist2(mesh.V(vertex), testx[p]) < 
144 |                     dist2(mesh.V(vertex), testx[bestPerturb])) {
145 | 				bestQuality = perturbQuality;
146 | 				bestPerturb = p;
147 | 			}
148 | 		}
149 | 	}
150 | 	
151 | 	// Pick the perturbation that yields the best quality (lowest value)
152 | 	// and apply it to the vertex.
153 |     if (bestPerturb >= 0) {
154 | 	    mesh.V(vertex) = testx[bestPerturb];
155 | 	    
156 |         // Return the quality metric for the new vertex.
157 | 	    return bestQuality;
158 |     }
159 | 
160 |     // Just in case we failed to get a good perturbation,
161 |     // compute quality of incident tets.
162 |     float quality = FLT_MAX;
163 |     for (size_t t = 0; t < incidentTets.size(); ++t) {
164 |         
165 |         // Move the vertex back to its original location in the tetrahedron.
166 |         incidentTets[t][incidentVertexIndex[t]] = mesh.V(vertex);
167 |         
168 |         float tetQuality = compute_tet_quality(incidentTets[t]);
169 |         
170 |         // Keep the lowest-quality tet's quality measure.
171 |         if (tetQuality < quality) {
172 |             quality = tetQuality;
173 |         }
174 |     }
175 |     return quality;
176 | }
177 | 
178 | 
179 | float
180 | optimize_tet_mesh(TetMesh& mesh,
181 |                   const SDF& sdf,
182 |                   const std::vector<int>& boundary_verts,
183 |                   const FeatureSet& featureSet,
184 |                   const std::vector<int>& feature_endpoints,
185 |                   const std::map<int, int>& vertex_feature_map)
186 | {
187 | 	std::vector<bool> isBoundary(mesh.vSize(), false);
188 | 	std::vector<bool> isFeatureEndpoint(mesh.vSize(), false);
189 |     std::vector<int> vertexFeatures(mesh.vSize(), -1);
190 | 
191 |     for (size_t b = 0; b < boundary_verts.size(); ++b) {
192 |         assert(boundary_verts[b] < (int)isBoundary.size());
193 |         isBoundary[boundary_verts[b]] = true;
194 |     }
195 |     for (size_t f = 0; f < feature_endpoints.size(); ++f) {
196 |         assert(feature_endpoints[f] < (int)isFeatureEndpoint.size());
197 |         isFeatureEndpoint[feature_endpoints[f]] = true;
198 |     }
199 |     for (std::map<int, int>::const_iterator vfItr = vertex_feature_map.begin();
200 |          vfItr != vertex_feature_map.end(); ++vfItr) {
201 |         assert(vfItr->first < (int)vertexFeatures.size());
202 |         vertexFeatures[vfItr->first] = vfItr->second;
203 |     }
204 | 
205 |     static const int MAX_ITERATIONS = 20;
206 |     static const float MIN_IMPROVEMENT_RATIO = 1.0;
207 | 
208 | 	// The "quality" of the tetrahedra will be represented by a
209 | 	// number that we want to maximize.
210 | 	// Therefore, a higher "quality" value => better tets
211 | 	float tetQuality = -1.0;
212 | 
213 |     for (int i = 0; i < MAX_ITERATIONS; ++i) {
214 |         float currTetQuality = FLT_MAX;
215 | 
216 |         // First loop over interior vertices
217 |         for (size_t v = 0; v < mesh.vSize(); ++v) {
218 |             if (!isBoundary[v] && !isFeatureEndpoint[v]
219 |                 && vertexFeatures[v] == -1) {
220 |                 float quality = optimize_vertex(v, mesh, sdf, featureSet,
221 |                                                 false, -1);
222 |                 if (quality < currTetQuality) {
223 |                     currTetQuality = quality;
224 |                 }
225 |             }
226 |         }
227 | 
228 |         // Then loop over boundary vertices
229 |         for (size_t v = 0; v < mesh.vSize(); ++v) {
230 |             if (isBoundary[v] && !isFeatureEndpoint[v] 
231 |                 && vertexFeatures[v] == -1) {
232 |                 float quality = optimize_vertex(v, mesh, sdf, featureSet,
233 |                                                 true, -1);
234 |                 if (quality < currTetQuality) {
235 |                     currTetQuality = quality;
236 |                 }
237 |             }
238 |         }
239 | 
240 |         // Then loop over feature vertices.
241 |         for (size_t v = 0; v < mesh.vSize(); ++v) {
242 |             if (vertexFeatures[v] != -1 && !isFeatureEndpoint[v]) {
243 |                 float quality = optimize_vertex(v, mesh, sdf, featureSet,
244 |                                                 false, vertexFeatures[v]);
245 |                 if (quality < currTetQuality) {
246 |                     currTetQuality = quality;
247 |                 }
248 |             }
249 |         }
250 | 
251 |         std::cout << "." << std::flush;
252 | 
253 |         // Terminate if quality did not improve significantly.
254 |         if (currTetQuality <= tetQuality*MIN_IMPROVEMENT_RATIO) {
255 |             std::cout << std::endl;
256 |             return currTetQuality;
257 |         }
258 | 
259 |         tetQuality = currTetQuality;
260 |     }
261 |     
262 |     std::cout << std::endl;
263 |     
264 |     return tetQuality;
265 | }
266 | 
267 | 
268 | /*
269 | float
270 | optimize_tet_mesh(TetMesh& mesh, 
271 | 			      const SDF& sdf,
272 |                   const std::vector<int> &boundary_verts, 
273 |                   const std::vector<int> &feature_verts,
274 |                   const std::map<int, Vec3f> &feature_edge_verts,
275 |                   const std::map<int, int> &vertex_feature_map)
276 | {
277 | 	// Do a breadth-first search through the tet mesh, starting at the
278 | 	// feature vertices and boundary vertices
279 | 	// (these are the ones that have been perturbed out of lattice locations).
280 | 	// At each tet vertex, try a bunch of new positions and pick the one
281 | 	// that optimizes our tet quality metric for the incident tets.
282 | 	
283 | 	std::queue<int> bfsQueue;
284 | 	std::vector<bool> alreadyTraversed(mesh.v.size(), false);
285 | 	std::vector<bool> isBoundary(mesh.v.size(), false);
286 | 	std::vector<bool> isFeature(mesh.v.size(), false);
287 |     std::vector<bool> isFeatureEdge(mesh.v.size(), false);
288 | 	
289 | 	// The "quality" of the tetrahedra will be represented by some
290 | 	// number that we want to minimize.
291 | 	// Therefore, a lower "quality" value => better tets
292 | 	float maxQualityMetric = 0.0f;
293 | 
294 |     for (std::vector<int>::const_iterator fItr = feature_verts.begin();
295 |             fItr != feature_verts.end(); ++fItr) {
296 |         isFeature[*fItr] = true;
297 |     }
298 |     for (std::map<int, Vec3f>::const_iterator fItr = feature_edge_verts.begin();
299 |             fItr != feature_edge_verts.end(); ++fItr) {
300 |         isFeatureEdge[fItr->first] = true;
301 |     }
302 |     for (std::vector<int>::const_iterator bItr = boundary_verts.begin();
303 |             bItr != boundary_verts.end(); ++bItr) {
304 |         isBoundary[*bItr] = true;
305 |     }
306 | 	
307 | 	// Add feature vertices to queue, followed by boundary vertices.
308 | 	// This ensures that all boundary vertices are visited first by the BFS.
309 | 	if (!feature_verts.empty()) {
310 | 		for (std::vector<int>::const_iterator fItr = feature_verts.begin();
311 | 				fItr != feature_verts.end(); ++fItr) {
312 |             if (!alreadyTraversed[*fItr]) {
313 | 			    bfsQueue.push(*fItr);
314 | 			    alreadyTraversed[*fItr] = true;
315 |             }
316 | 		}
317 | 	} else {
318 |         // If there are no feature vertices, start from boundary vertices.
319 | 		for (std::vector<int>::const_iterator bItr = boundary_verts.begin();
320 | 				bItr != boundary_verts.end(); ++bItr) {
321 | 			if (!alreadyTraversed[*bItr]) {
322 | 				bfsQueue.push(*bItr);
323 | 				alreadyTraversed[*bItr] = true;
324 | 			}
325 | 		}
326 | 	}
327 | 	
328 | 	// Breadth-First Search loop
329 | 	while (!bfsQueue.empty()) {
330 | 		int currVertex = bfsQueue.front();
331 | 		bfsQueue.pop();
332 | 		
333 | 		std::vector<int> incidentTets;
334 | 		std::set<int> neighbours;
335 | 		
336 | 		// Find the tets that contain the current vertex,
337 | 		// and its neighbouring vertices.
338 | 		// Shouldn't need to loop over all tets to get vertex+neighbours...
339 | 		for (size_t t = 0; t < mesh.t.size(); ++t) {
340 | 			if (mesh.t[t][0] == currVertex || mesh.t[t][1] == currVertex ||
341 | 				mesh.t[t][2] == currVertex || mesh.t[t][3] == currVertex) {
342 | 				incidentTets.push_back(t);
343 | 				neighbours.insert(mesh.t[t][0]);
344 | 				neighbours.insert(mesh.t[t][1]);
345 | 				neighbours.insert(mesh.t[t][2]);
346 | 				neighbours.insert(mesh.t[t][3]);
347 | 			}
348 | 		}
349 | 		
350 | 		// Because we didn't guard against the current vertex being added
351 | 		// to the neighbours set, remove it from the set.
352 | 		neighbours.erase(currVertex);
353 | 		
354 | 		// Add neighbours to queue if they haven't been already.
355 | 		for (std::set<int>::iterator nItr = neighbours.begin();
356 | 			 nItr != neighbours.end(); ++nItr) {
357 | 			if (!alreadyTraversed[*nItr]) {
358 | 				bfsQueue.push(*nItr);
359 | 				alreadyTraversed[*nItr] = true;
360 | 			}
361 | 		}
362 | 		
363 | 		// Don't move feature vertices.
364 | 		if (isFeature[currVertex]) {
365 | 			continue;
366 | 		}
367 | 
368 |         // Retrieve feature edge, if it exists.
369 |         Vec3f edge(0.0f, 0.0f, 0.0f);
370 |         std::map<int,Vec3f>::const_iterator e = 
371 |             feature_edge_verts.find(currVertex);
372 |         if (e != feature_edge_verts.end()) {
373 |             edge = e->second;
374 |         }
375 | 
376 |         // Use vertex_feature_map to know which verts were snapped to
377 |         // which polyline features.
378 | 		
379 | 		// Do optimization of current vertex location.
380 | 		float quality = optimize_vertex(currVertex, mesh, sdf, 
381 | 										incidentTets, 
382 |                                         isBoundary[currVertex],
383 |                                         isFeatureEdge[currVertex],
384 |                                         edge);
385 | 		
386 | 		// Update global quality metric.
387 | 		if (quality > maxQualityMetric) {
388 | 			maxQualityMetric = quality;
389 | 		}
390 | 	}
391 | 	
392 | 	return maxQualityMetric;
393 | }
394 | */
395 | 
396 | 


--------------------------------------------------------------------------------
/meshes/block.feat:
--------------------------------------------------------------------------------
  1 | feat 112
  2 | # Cube
  3 | 2
  4 | 10 -10 10
  5 | -10 -10 10
  6 | 2
  7 | 10 -10 -10
  8 | 10 -10 10
  9 | 2
 10 | -10 -10 -10
 11 | 10 -10 -10
 12 | 2
 13 | -10 -10 10
 14 | -10 -10 -10
 15 | 2
 16 | -10 10 -10
 17 | -10 10 10
 18 | 2
 19 | 10 10 -10
 20 | -10 10 -10
 21 | 2
 22 | 10 10 10
 23 | 10 10 -10
 24 | 2
 25 | -10 10 10
 26 | 10 10 10
 27 | 2
 28 | 10 -10 -10
 29 | 10 10 -10
 30 | 2
 31 | 10 10 10
 32 | 10 -10 10
 33 | 2
 34 | -10 10 10
 35 | -10 -10 10
 36 | 2
 37 | -10 10 -10
 38 | -10 -10 -10
 39 | # Cylinder caps
 40 | 17
 41 | 0 7 -20
 42 | 1.36563 6.8655 -20
 43 | 2.67878 6.46716 -20
 44 | 3.88899 5.82029 -20
 45 | 4.94975 4.94975 -20
 46 | 5.82029 3.88899 -20
 47 | 6.46716 2.67879 -20
 48 | 6.8655 1.36564 -20
 49 | 7 4e-06 -20
 50 | 6.8655 -1.36563 -20
 51 | 6.46716 -2.67878 -20
 52 | 5.82029 -3.88899 -20
 53 | 4.94975 -4.94974 -20
 54 | 3.88899 -5.82028 -20
 55 | 2.67878 -6.46715 -20
 56 | 1.36563 -6.86549 -20
 57 | -2e-06 -7 -20
 58 | 17
 59 | -2e-06 -7 -20
 60 | -1.36564 -6.86549 -20
 61 | -2.67879 -6.46715 -20
 62 | -3.88899 -5.82028 -20
 63 | -4.94975 -4.94974 -20
 64 | -5.82029 -3.88898 -20
 65 | -6.46716 -2.67878 -20
 66 | -6.8655 -1.36562 -20
 67 | -7 1.1e-05 -20
 68 | -6.8655 1.36564 -20
 69 | -6.46715 2.6788 -20
 70 | -5.82028 3.889 -20
 71 | -4.94974 4.94976 -20
 72 | -3.88898 5.8203 -20
 73 | -2.67878 6.46716 -20
 74 | -1.36562 6.8655 -20
 75 | 0 7 -20
 76 | 17
 77 | -1.36568 6.86548 20
 78 | -2.67883 6.46713 20
 79 | -3.88903 5.82026 20
 80 | -4.94978 4.94972 20
 81 | -5.82031 3.88896 20
 82 | -6.46717 2.67875 20
 83 | -6.8655 1.3656 20
 84 | -7 -3.3e-05 20
 85 | -6.86549 -1.36566 20
 86 | -6.46715 -2.67881 20
 87 | -5.82028 -3.88901 20
 88 | -4.94974 -4.94976 20
 89 | -3.88898 -5.8203 20
 90 | -2.67877 -6.46716 20
 91 | -1.36562 -6.8655 20
 92 | 7e-06 -7 20
 93 | 1.36564 -6.8655 20
 94 | 17
 95 | 1.36564 -6.8655 20
 96 | 2.67879 -6.46716 20
 97 | 3.88899 -5.82029 20
 98 | 4.94974 -4.94976 20
 99 | 5.82028 -3.889 20
100 | 6.46715 -2.6788 20
101 | 6.86549 -1.36565 20
102 | 7 -2e-05 20
103 | 6.8655 1.36561 20
104 | 6.46716 2.67877 20
105 | 5.82029 3.88898 20
106 | 4.94976 4.94973 20
107 | 3.889 5.82028 20
108 | 2.6788 6.46715 20
109 | 1.36564 6.86549 20
110 | 1.1e-05 7 20
111 | -1.36568 6.86548 20
112 | # Cylinder-cube joins
113 | 44
114 | -7 0 -10
115 | -7 -2.7e-05 -10
116 | -6.93275 -0.68284 -10
117 | -6.87688 -1.25 -10
118 | -6.86549 -1.36566 -10
119 | -6.66632 -2.02223 -10
120 | -6.52139 -2.5 -10
121 | -6.46715 -2.67881 -10
122 | -6.25 -3.08507 -10
123 | -6.14371 -3.28391 -10
124 | -5.89458 -3.75 -10
125 | -5.82028 -3.88901 -10
126 | -5.38501 -4.41938 -10
127 | -5 -4.88852 -10
128 | -4.94974 -4.94976 -10
129 | -4.88852 -5 -10
130 | -3.88898 -5.8203 -10
131 | -3.75 -5.89459 -10
132 | -3.08506 -6.25 -10
133 | -2.67878 -6.46716 -10
134 | -2.5 -6.5214 -10
135 | -2.0222 -6.66633 -10
136 | -1.36563 -6.8655 -10
137 | -1.25 -6.87689 -10
138 | 5e-06 -7 -10
139 | 1.25 -6.87689 -10
140 | 1.36564 -6.8655 -10
141 | 2.5 -6.52139 -10
142 | 2.67879 -6.46716 -10
143 | 3.08506 -6.25 -10
144 | 3.88899 -5.82029 -10
145 | 4.88852 -5 -10
146 | 4.94974 -4.94975 -10
147 | 5 -4.88852 -10
148 | 5.82028 -3.889 -10
149 | 5.89458 -3.75 -10
150 | 6.25 -3.08506 -10
151 | 6.46715 -2.6788 -10
152 | 6.52139 -2.5 -10
153 | 6.8655 -1.36565 -10
154 | 6.87688 -1.25 -10
155 | 6.93275 -0.682834 -10
156 | 7 -1.7e-05 -10
157 | 7 0 -10
158 | 45
159 | 7 0 -10
160 | 6.87689 1.25 -10
161 | 6.8655 1.36562 -10
162 | 6.66633 2.02219 -10
163 | 6.52139 2.5 -10
164 | 6.46716 2.67877 -10
165 | 6.25 3.08505 -10
166 | 5.89458 3.75 -10
167 | 5.82029 3.88898 -10
168 | 5 4.88851 -10
169 | 4.94976 4.94974 -10
170 | 4.88851 5 -10
171 | 3.889 5.82028 -10
172 | 3.75 5.89458 -10
173 | 3.08505 6.25 -10
174 | 2.67879 6.46715 -10
175 | 2.5 6.52139 -10
176 | 1.36564 6.86549 -10
177 | 1.25 6.87688 -10
178 | 1e-05 7 -10
179 | 3e-06 7 -10
180 | -0.682826 6.93274 -10
181 | -1.25 6.87688 -10
182 | -1.36567 6.86549 -10
183 | -2.02224 6.66631 -10
184 | -2.5 6.52139 -10
185 | -2.67882 6.46714 -10
186 | -3.08505 6.25 -10
187 | -3.28392 6.1437 -10
188 | -3.88902 5.82026 -10
189 | -4.4194 5.38499 -10
190 | -4.88851 5 -10
191 | -4.94977 4.94972 -10
192 | -5 4.88852 -10
193 | -5.38504 4.41934 -10
194 | -5.8203 3.88896 -10
195 | -5.89458 3.75 -10
196 | -6.14374 3.28386 -10
197 | -6.25 3.08506 -10
198 | -6.46717 2.67875 -10
199 | -6.66634 2.02218 -10
200 | -6.8655 1.3656 -10
201 | -6.87689 1.25 -10
202 | -6.93275 0.682789 -10
203 | -7 0 -10
204 | 42
205 | 7 0 10
206 | 6.87688 -1.25 10
207 | 6.8655 -1.36563 10
208 | 6.66633 -2.0222 10
209 | 6.52139 -2.5 10
210 | 6.46716 -2.67878 10
211 | 5.89458 -3.75 10
212 | 5.82029 -3.88899 10
213 | 5 -4.88852 10
214 | 4.94975 -4.94975 10
215 | 4.88851 -5 10
216 | 3.88899 -5.82028 10
217 | 3.75 -5.89458 10
218 | 3.08505 -6.25 10
219 | 2.67878 -6.46715 10
220 | 2.5 -6.52139 10
221 | 1.36563 -6.86549 10
222 | 1.25 -6.87688 10
223 | -1e-06 -7 10
224 | -1.25 -6.87688 10
225 | -1.36563 -6.86549 10
226 | -2.02221 -6.66632 10
227 | -2.5 -6.52139 10
228 | -2.67879 -6.46715 10
229 | -3.08505 -6.25 10
230 | -3.75 -5.89458 10
231 | -3.88899 -5.82028 10
232 | -4.41937 -5.38502 10
233 | -4.88851 -5 10
234 | -4.94975 -4.94974 10
235 | -5 -4.88851 10
236 | -5.38502 -4.41937 10
237 | -5.82029 -3.88899 10
238 | -5.89458 -3.75 10
239 | -6.14372 -3.28389 10
240 | -6.25 -3.08505 10
241 | -6.46716 -2.67878 10
242 | -6.66633 -2.02221 10
243 | -6.8655 -1.36563 10
244 | -6.87688 -1.25 10
245 | -6.93275 -0.682814 10
246 | -7 5e-06 10
247 | 47
248 | -7 5e-06 10
249 | -6.93275 0.682818 10
250 | -6.87688 1.25 10
251 | -6.8655 1.36564 10
252 | -6.66633 2.02221 10
253 | -6.52139 2.5 10
254 | -6.46715 2.67879 10
255 | -6.25 3.08506 10
256 | -6.14372 3.28389 10
257 | -5.89458 3.75 10
258 | -5.82028 3.889 10
259 | -5.38502 4.41937 10
260 | -5 4.88852 10
261 | -4.94975 4.94975 10
262 | -4.88852 5 10
263 | -4.41937 5.38502 10
264 | -3.88899 5.82029 10
265 | -3.75 5.89458 10
266 | -3.28389 6.14372 10
267 | -3.08506 6.25 10
268 | -2.67878 6.46716 10
269 | -2.5 6.52139 10
270 | -2.02221 6.66633 10
271 | -1.36563 6.8655 10
272 | -1.25 6.87689 10
273 | -0.682814 6.93275 10
274 | -5e-06 7 10
275 | 1e-06 7 10
276 | 1.24999 6.87689 10
277 | 1.36563 6.8655 10
278 | 2.49999 6.5214 10
279 | 2.67879 6.46716 10
280 | 3.08506 6.25 10
281 | 3.28389 6.14372 10
282 | 3.74999 5.89459 10
283 | 3.88899 5.82029 10
284 | 4.88852 5 10
285 | 4.94975 4.94975 10
286 | 4.99999 4.88853 10
287 | 5.82029 3.88899 10
288 | 5.89458 3.75 10
289 | 6.24999 3.08507 10
290 | 6.46716 2.67879 10
291 | 6.52139 2.5 10
292 | 6.8655 1.36563 10
293 | 6.87688 1.25 10
294 | 7 0 10
295 | # Holes in cube
296 | 36
297 | -5.43429 -10 -2.5
298 | -5.54328 -10 -2.2961
299 | -5.86061 -10 -1.25
300 | -5.88471 -10 -1.17054
301 | -6 -10 -2e-06
302 | -6 -10 -1e-06
303 | -5.88471 -10 1.17054
304 | -5.86061 -10 1.25
305 | -5.54328 -10 2.2961
306 | -5.43429 -10 2.5
307 | -5 -10 3.31251
308 | -4.98882 -10 3.33342
309 | -4.64694 -10 3.75
310 | -4.24264 -10 4.24264
311 | -3.75 -10 4.64694
312 | -3.33342 -10 4.98882
313 | -3.31251 -10 5
314 | -2.5 -10 5.43429
315 | -2.2961 -10 5.54328
316 | -1.25 -10 5.86061
317 | -1.17054 -10 5.88471
318 | -1e-06 -10 6
319 | -0 -10 6
320 | 1.17054 -10 5.88471
321 | 1.25 -10 5.86061
322 | 2.2961 -10 5.54328
323 | 2.5 -10 5.43429
324 | 3.31251 -10 5
325 | 3.33342 -10 4.98882
326 | 3.75 -10 4.64694
327 | 4.24264 -10 4.24264
328 | 4.64694 -10 3.75
329 | 4.98882 -10 3.33342
330 | 5 -10 3.31251
331 | 5.43429 -10 2.5
332 | 5.54328 -10 2.2961
333 | 34
334 | 5.54328 -10 2.2961
335 | 5.86061 -10 1.25
336 | 5.88471 -10 1.17054
337 | 6 -10 2e-06
338 | 6 -10 -0
339 | 5.88471 -10 -1.17054
340 | 5.86061 -10 -1.25
341 | 5.54328 -10 -2.2961
342 | 5.43429 -10 -2.5
343 | 5 -10 -3.31251
344 | 4.98882 -10 -3.33342
345 | 4.64694 -10 -3.75
346 | 4.24264 -10 -4.24264
347 | 3.75 -10 -4.64694
348 | 3.33342 -10 -4.98882
349 | 3.3125 -10 -5
350 | 2.5 -10 -5.43429
351 | 2.2961 -10 -5.54328
352 | 1.25 -10 -5.86061
353 | 1.17054 -10 -5.88471
354 | 2e-06 -10 -6
355 | 1e-06 -10 -6
356 | -1.17054 -10 -5.88471
357 | -1.25 -10 -5.86061
358 | -2.2961 -10 -5.54328
359 | -2.5 -10 -5.43429
360 | -3.3125 -10 -5
361 | -3.33342 -10 -4.98882
362 | -3.75 -10 -4.64694
363 | -4.24264 -10 -4.24264
364 | -4.64694 -10 -3.75
365 | -4.98882 -10 -3.33342
366 | -5 -10 -3.31251
367 | -5.43429 -10 -2.5
368 | 36
369 | 2.49999 10 5.43429
370 | 2.2961 10 5.54328
371 | 1.25 10 5.86061
372 | 1.17054 10 5.88471
373 | 4e-06 10 6
374 | -4e-06 10 6
375 | -1.17054 10 5.88471
376 | -1.25 10 5.86061
377 | -2.29609 10 5.54328
378 | -2.5 10 5.43429
379 | -3.31251 10 5
380 | -3.33341 10 4.98882
381 | -3.75 10 4.64694
382 | -4.24263 10 4.24265
383 | -4.64694 10 3.75
384 | -4.98881 10 3.33343
385 | -5 10 3.3125
386 | -5.43429 10 2.5
387 | -5.54327 10 2.29611
388 | -5.86061 10 1.25
389 | -5.88471 10 1.17056
390 | -6 10 2e-05
391 | -6 10 -0
392 | -5.88472 10 -1.17052
393 | -5.86061 10 -1.25
394 | -5.54329 10 -2.29608
395 | -5.43429 10 -2.5
396 | -5 10 -3.31251
397 | -4.98883 10 -3.3334
398 | -4.64694 10 -3.75
399 | -4.24266 10 -4.24262
400 | -3.75 10 -4.64694
401 | -3.33345 10 -4.9888
402 | -3.3125 10 -5
403 | -2.5 10 -5.43429
404 | -2.29613 10 -5.54326
405 | 34
406 | -2.29613 10 -5.54326
407 | -1.25 10 -5.86061
408 | -1.17057 10 -5.88471
409 | 1e-06 10 -6
410 | 8e-06 10 -6
411 | 1.17055 10 -5.88471
412 | 1.25 10 -5.86061
413 | 2.29611 10 -5.54327
414 | 2.5 10 -5.43429
415 | 3.31251 10 -4.99999
416 | 3.33343 10 -4.98881
417 | 3.75 10 -4.64694
418 | 4.24265 10 -4.24263
419 | 4.64694 10 -3.74999
420 | 4.98882 10 -3.33341
421 | 5 10 -3.31251
422 | 5.43429 10 -2.49999
423 | 5.54328 10 -2.29609
424 | 5.86061 10 -1.24999
425 | 5.88471 10 -1.17053
426 | 6 10 4e-06
427 | 6 10 1.1e-05
428 | 5.88471 10 1.17055
429 | 5.86061 10 1.25
430 | 5.54327 10 2.29611
431 | 5.43429 10 2.5
432 | 5 10 3.31251
433 | 4.98881 10 3.33343
434 | 4.64694 10 3.75
435 | 4.24264 10 4.24264
436 | 3.74999 10 4.64694
437 | 3.33342 10 4.98882
438 | 3.3125 10 5
439 | 2.49999 10 5.43429
440 | 35
441 | 10 5.54326 2.29611
442 | 10 5.8606 1.25
443 | 10 5.8847 1.17056
444 | 10 5.99999 2e-05
445 | 10 5.99999 5e-06
446 | 10 5.88471 -1.17052
447 | 10 5.8606 -1.24999
448 | 10 5.54328 -2.29608
449 | 10 5.43429 -2.49999
450 | 10 5 -3.31249
451 | 10 4.98882 -3.3334
452 | 10 4.64694 -3.74999
453 | 10 4.24265 -4.24262
454 | 10 3.75 -4.64694
455 | 10 3.33344 -4.9888
456 | 10 3.3125 -4.99999
457 | 10 2.5 -5.43429
458 | 10 2.29612 -5.54326
459 | 10 1.25 -5.86061
460 | 10 1.17057 -5.88471
461 | 10 0 -6
462 | 10 -1.4e-05 -6
463 | 10 -1.17056 -5.88471
464 | 10 -1.25 -5.86061
465 | 10 -2.29611 -5.54327
466 | 10 -2.5 -5.4343
467 | 10 -3.31251 -5
468 | 10 -3.33344 -4.98881
469 | 10 -3.75 -4.64695
470 | 10 -4.24265 -4.24263
471 | 10 -4.64695 -3.75
472 | 10 -4.98883 -3.33341
473 | 10 -5 -3.31252
474 | 10 -5.4343 -2.5
475 | 10 -5.54329 -2.29609
476 | 33
477 | 10 -5.54329 -2.29609
478 | 10 -5.86061 -1.25
479 | 10 -5.88472 -1.17053
480 | 10 -6.00001 1e-06
481 | 10 -6.00001 1.1e-05
482 | 10 -5.88472 1.17055
483 | 10 -5.86062 1.25
484 | 10 -5.54328 2.29611
485 | 10 -5.4343 2.5
486 | 10 -5 3.31251
487 | 10 -4.98882 3.33343
488 | 10 -4.64695 3.75
489 | 10 -4.24264 4.24264
490 | 10 -3.75 4.64695
491 | 10 -3.33343 4.98882
492 | 10 -3.31251 5
493 | 10 -2.5 5.43429
494 | 10 -2.29611 5.54328
495 | 10 -1.25 5.86061
496 | 10 -1.17055 5.88471
497 | 10 -1.1e-05 6
498 | 10 0 6
499 | 10 1.17053 5.88471
500 | 10 1.25 5.86061
501 | 10 2.29609 5.54328
502 | 10 2.5 5.43429
503 | 10 3.3125 5
504 | 10 3.33341 4.98882
505 | 10 3.75 4.64693
506 | 10 4.24263 4.24265
507 | 10 4.64693 3.75
508 | 10 4.9888 3.33343
509 | 10 5.54326 2.29611
510 | 33
511 | -10 0 6
512 | -10 -1.17053 5.88471
513 | -10 -1.25 5.8606
514 | -10 -2.29609 5.54328
515 | -10 -2.5 5.43429
516 | -10 -3.3125 5
517 | -10 -3.33342 4.98882
518 | -10 -3.75 4.64693
519 | -10 -4.24263 4.24264
520 | -10 -4.64694 3.75
521 | -10 -4.98881 3.33342
522 | -10 -5 3.31249
523 | -10 -5.43429 2.5
524 | -10 -5.54327 2.2961
525 | -10 -5.8606 1.25
526 | -10 -5.88471 1.17054
527 | -10 -5.99999 2e-06
528 | -10 -5.99999 -3e-06
529 | -10 -5.88471 -1.17054
530 | -10 -5.8606 -1.25
531 | -10 -5.54327 -2.2961
532 | -10 -5.43428 -2.5
533 | -10 -5 -3.31249
534 | -10 -4.98881 -3.33342
535 | -10 -4.64693 -3.75
536 | -10 -4.24264 -4.24264
537 | -10 -3.75 -4.64693
538 | -10 -3.33342 -4.98882
539 | -10 -2.5 -5.43429
540 | -10 -2.2961 -5.54328
541 | -10 -1.25 -5.86061
542 | -10 -1.17054 -5.88471
543 | -10 0 -6
544 | 34
545 | -10 0 -6
546 | -10 5e-06 -6
547 | -10 1.17055 -5.88471
548 | -10 1.25 -5.86061
549 | -10 2.29611 -5.54328
550 | -10 2.5 -5.43429
551 | -10 3.31251 -5
552 | -10 3.33343 -4.98882
553 | -10 3.75 -4.64695
554 | -10 4.24265 -4.24264
555 | -10 4.64695 -3.75
556 | -10 4.98882 -3.33342
557 | -10 5 -3.31251
558 | -10 5.4343 -2.5
559 | -10 5.54328 -2.2961
560 | -10 5.86061 -1.25
561 | -10 5.88472 -1.17054
562 | -10 6.00001 -2e-06
563 | -10 6.00001 -1e-06
564 | -10 5.88472 1.17054
565 | -10 5.86062 1.25
566 | -10 5.54328 2.2961
567 | -10 4.98882 3.33342
568 | -10 4.64695 3.75
569 | -10 4.24265 4.24264
570 | -10 3.75 4.64695
571 | -10 3.33343 4.98882
572 | -10 3.31252 5
573 | -10 2.5 5.43429
574 | -10 2.29611 5.54328
575 | -10 1.25 5.86061
576 | -10 1.17055 5.88471
577 | -10 7e-06 6
578 | -10 0 6
579 | # Interior curves
580 | 29
581 | 0 0 6
582 | 0.9375 0.9375 5.90766
583 | 1.17054 1.17054 5.88471
584 | 1.875 1.875 5.67102
585 | 2.2961 2.2961 5.54328
586 | 2.8125 2.8125 5.26725
587 | 3.33342 3.33342 4.98882
588 | 3.75 3.75 4.64694
589 | 4.24264 4.24264 4.24264
590 | 4.6875 4.6875 3.70058
591 | 4.98882 4.98882 3.33342
592 | 5.54328 5.54328 2.2961
593 | 5.625 5.625 2.02671
594 | 5.88471 5.88471 1.17055
595 | 6 6 0
596 | 5.88471 5.88471 -1.17053
597 | 5.625 5.625 -2.02669
598 | 5.54328 5.54328 -2.2961
599 | 4.98882 4.98882 -3.33342
600 | 4.6875 4.6875 -3.70058
601 | 4.24264 4.24264 -4.24264
602 | 3.75 3.75 -4.64694
603 | 3.33342 3.33342 -4.98882
604 | 2.8125 2.8125 -5.26725
605 | 2.2961 2.2961 -5.54328
606 | 1.875 1.875 -5.67102
607 | 1.17054 1.17054 -5.88471
608 | 0.9375 0.9375 -5.90766
609 | 0 0 -6
610 | 29
611 | 0 0 6
612 | -0.9375 0.9375 5.90766
613 | -1.17054 1.17054 5.88471
614 | -1.875 1.875 5.67102
615 | -2.2961 2.2961 5.54328
616 | -2.8125 2.8125 5.26725
617 | -3.33342 3.33342 4.98882
618 | -3.75 3.75 4.64694
619 | -4.24264 4.24264 4.24264
620 | -4.6875 4.6875 3.70058
621 | -4.98882 4.98882 3.33342
622 | -5.54328 5.54328 2.2961
623 | -5.625 5.625 2.02671
624 | -5.88471 5.88471 1.17055
625 | -6 6 0
626 | -5.88471 5.88471 -1.17053
627 | -5.625 5.625 -2.02669
628 | -5.54328 5.54328 -2.2961
629 | -4.98882 4.98882 -3.33342
630 | -4.6875 4.6875 -3.70058
631 | -4.24264 4.24264 -4.24264
632 | -3.75 3.75 -4.64694
633 | -3.33342 3.33342 -4.98882
634 | -2.8125 2.8125 -5.26725
635 | -2.2961 2.2961 -5.54328
636 | -1.875 1.875 -5.67102
637 | -1.17054 1.17054 -5.88471
638 | -0.9375 0.9375 -5.90766
639 | 0 0 -6
640 | 29
641 | 0 0 6
642 | 0.9375 -0.9375 5.90766
643 | 1.17054 -1.17054 5.88471
644 | 1.875 -1.875 5.67102
645 | 2.2961 -2.2961 5.54328
646 | 2.8125 -2.8125 5.26725
647 | 3.33342 -3.33342 4.98882
648 | 3.75 -3.75 4.64694
649 | 4.24264 -4.24264 4.24264
650 | 4.6875 -4.6875 3.70058
651 | 4.98882 -4.98882 3.33342
652 | 5.54328 -5.54328 2.2961
653 | 5.625 -5.625 2.02671
654 | 5.88471 -5.88471 1.17055
655 | 6 -6 0
656 | 5.88471 -5.88471 -1.17053
657 | 5.625 -5.625 -2.02669
658 | 5.54328 -5.54328 -2.2961
659 | 4.98882 -4.98882 -3.33342
660 | 4.6875 -4.6875 -3.70058
661 | 4.24264 -4.24264 -4.24264
662 | 3.75 -3.75 -4.64694
663 | 3.33342 -3.33342 -4.98882
664 | 2.8125 -2.8125 -5.26725
665 | 2.2961 -2.2961 -5.54328
666 | 1.875 -1.875 -5.67102
667 | 1.17054 -1.17054 -5.88471
668 | 0.9375 -0.9375 -5.90766
669 | 0 0 -6
670 | 29
671 | 0 0 6
672 | -0.9375 -0.9375 5.90766
673 | -1.17054 -1.17054 5.88471
674 | -1.875 -1.875 5.67102
675 | -2.2961 -2.2961 5.54328
676 | -2.8125 -2.8125 5.26725
677 | -3.33342 -3.33342 4.98882
678 | -3.75 -3.75 4.64694
679 | -4.24264 -4.24264 4.24264
680 | -4.6875 -4.6875 3.70058
681 | -4.98882 -4.98882 3.33342
682 | -5.54328 -5.54328 2.2961
683 | -5.625 -5.625 2.02671
684 | -5.88471 -5.88471 1.17055
685 | -6 -6 0
686 | -5.88471 -5.88471 -1.17053
687 | -5.625 -5.625 -2.02669
688 | -5.54328 -5.54328 -2.2961
689 | -4.98882 -4.98882 -3.33342
690 | -4.6875 -4.6875 -3.70058
691 | -4.24264 -4.24264 -4.24264
692 | -3.75 -3.75 -4.64694
693 | -3.33342 -3.33342 -4.98882
694 | -2.8125 -2.8125 -5.26725
695 | -2.2961 -2.2961 -5.54328
696 | -1.875 -1.875 -5.67102
697 | -1.17054 -1.17054 -5.88471
698 | -0.9375 -0.9375 -5.90766
699 | 0 0 -6
700 | 


--------------------------------------------------------------------------------
/src/view_tet.cpp:
--------------------------------------------------------------------------------
  1 | #include <cstdio>
  2 | #include <cstring>
  3 | #include <fstream>
  4 | #include <set>
  5 | #include "gluvi.h"
  6 | #include "vec.h"
  7 | #include "feature.h"
  8 | #include "read_obj.h"
  9 | #include "tet_mesh.h"
 10 | #include "tet_quality.h"
 11 | 
 12 | std::vector<Vec3f> x;
 13 | std::vector<Vec4i> tet;
 14 | std::set<Vec3i> boundary_face_set;
 15 | 
 16 | std::vector<Vec3i> tri;
 17 | 
 18 | bool drawTriMesh;
 19 | 
 20 | bool cutX = false, cutY = false, cutZ = false;
 21 | float px, py, pz;
 22 | 
 23 | int worst_n = 0;
 24 | std::vector<float> tet_quality;
 25 | 
 26 | FeatureSet features;
 27 | 
 28 | Vec3f centroid;
 29 | 
 30 | // decides if a vertex is cut off by the cutting planes:
 31 | // x-px = 0, y-py = 0, z-py = 0
 32 | bool isCutOff(const Vec3f& v){
 33 |     bool isCut = false;
 34 |     if(cutX){
 35 | 	    if(v[0] > px) isCut = true;
 36 |     }
 37 |     if(cutY){
 38 | 	    if(v[1] > py) isCut = true;
 39 |     }
 40 |     if(cutZ){
 41 | 	    if(v[2] > pz) isCut = true;
 42 |     }
 43 |     return isCut;
 44 | }
 45 | 
 46 | // Decides if the first tet has worse quality than the second
 47 | bool isWorse(const Vec4i& tet1, const Vec4i& tet2){
 48 |     Tet t1, t2;
 49 |     t1.v[0] = x[tet1[0]];
 50 |     t1.v[1] = x[tet1[1]];
 51 |     t1.v[2] = x[tet1[2]];
 52 |     t1.v[3] = x[tet1[3]];
 53 |     t2.v[0] = x[tet2[0]];
 54 |     t2.v[1] = x[tet2[1]];
 55 |     t2.v[2] = x[tet2[2]];
 56 |     t2.v[3] = x[tet2[3]];
 57 |     return compute_tet_quality(t1) < compute_tet_quality(t2);
 58 | 
 59 | }
 60 | 
 61 | // Rearrange tets so that the worst N tets are at the front
 62 | void sortTets(){
 63 |     std::nth_element(tet.begin(), tet.begin() + worst_n -1, tet.end(), isWorse);
 64 | }
 65 | 
 66 | bool isBoundaryFace(int v1, int v2, int v3)
 67 | {
 68 |     // Try all permutations.
 69 |     Vec3i perms[] = {
 70 |         Vec3i(v1, v2, v3),
 71 |         Vec3i(v2, v3, v1),
 72 |         Vec3i(v3, v1, v2),
 73 |         Vec3i(v1, v3, v2),
 74 |         Vec3i(v2, v1, v3),
 75 |         Vec3i(v3, v2, v1)
 76 |     };
 77 | 
 78 |     for (int i = 0; i < 6; ++i)
 79 |     {
 80 |         if (boundary_face_set.find(perms[i]) != boundary_face_set.end())
 81 |         {
 82 |             return true;
 83 |         }
 84 |     }
 85 | 
 86 |     return false;
 87 | }
 88 | 
 89 | 
 90 | void display(void)
 91 | {
 92 |     glEnable(GL_LIGHTING);
 93 |     glEnable(GL_LIGHT0);
 94 |     glEnable(GL_COLOR_MATERIAL);
 95 |     glEnable(GL_DEPTH_TEST);
 96 | 
 97 |     glEnable(GL_POLYGON_OFFSET_FILL);
 98 |     glPolygonOffset(0.5, 0.5);
 99 | 
100 |     glTranslatef(-centroid[0], -centroid[1], -centroid[2]);
101 | 
102 |     // Tet Faces
103 |     if (!drawTriMesh) {
104 |         glBegin(GL_TRIANGLES);
105 |         
106 |         // Draw worst n tets
107 |         if(worst_n > 0){
108 | 	        for(int t=0; t< worst_n; ++t){
109 |                 Vec3f p=x[tet[t][0]],
110 | 	                  q=x[tet[t][1]],
111 | 	                  r=x[tet[t][2]],
112 | 	                  s=x[tet[t][3]];
113 | 	
114 | 	            // if any vertex is cut off, don't draw tet
115 | 	            if(isCutOff(p) || isCutOff(q) || isCutOff(r) || isCutOff(s))
116 | 	            	continue;
117 | 	            
118 |                 /*
119 | 	            Vec3f c=(p+q+r+s)/4;
120 | 	            p=0.8*p+0.2*c; 
121 | 	            q=0.8*q+0.2*c;
122 | 	            r=0.8*r+0.2*c;
123 | 	            s=0.8*s+0.2*c;
124 | 	            //float h=0.25*(t+0.5)/tet.size();
125 | 	            float h = 0.25*(t+0.5)/(float)tet.size();
126 | 	            if (t%4 == 0)       glColor3f(h+0.7,h,h);
127 | 	            else if (t%4 == 1)  glColor3f(h+0.2,h+0.5,h);
128 | 	            else if (t%4 == 2)  glColor3f(h,h+0.5,h+0.2);
129 | 	            else                glColor3f(h,h,h+0.7);
130 |                 */
131 |                 glColor3f(1.0, 0.2, 0.0);
132 |                 glNormal3fv(normalized(cross((q-p),(r-p))).v);
133 | 	            glVertex3fv(p.v);
134 | 	            glVertex3fv(q.v);
135 | 	            glVertex3fv(r.v);
136 |                 glNormal3fv(normalized(cross((s-p),(q-p))).v);
137 | 	            glVertex3fv(p.v);
138 | 	            glVertex3fv(s.v);
139 | 	            glVertex3fv(q.v);
140 |                 glNormal3fv(normalized(cross((r-p),(s-p))).v);
141 | 	            glVertex3fv(p.v);
142 | 	            glVertex3fv(r.v);
143 | 	            glVertex3fv(s.v);
144 |                 glNormal3fv(normalized(cross((r-q),(s-q))).v);
145 | 	            glVertex3fv(q.v);
146 | 	            glVertex3fv(r.v);
147 | 	            glVertex3fv(s.v);
148 | 	        }
149 | 	        
150 |      	} else {
151 | 	     	// Draw all tets
152 | 	        for(size_t t=0; t<tet.size(); ++t){
153 | 	            Vec3f p=x[tet[t][0]],
154 | 	                  q=x[tet[t][1]],
155 | 	                  r=x[tet[t][2]],
156 | 	                  s=x[tet[t][3]];
157 | 	
158 | 	            // if any vertex is cut off, don't draw tet
159 | 	            if(isCutOff(p) || isCutOff(q) || isCutOff(r) || isCutOff(s))
160 | 	            	continue;
161 | 	            
162 |                 /* 
163 | 	            Vec3f c=(p+q+r+s)/4;
164 | 	            p=0.8*p+0.2*c; 
165 | 	            q=0.8*q+0.2*c;
166 | 	            r=0.8*r+0.2*c;
167 | 	            s=0.8*s+0.2*c;
168 | 	            //float h=0.25*(t+0.5)/tet.size();
169 | 	            float h = 0.25*(t+0.5)/(float)tet.size();
170 |                 */
171 |                 /*
172 | 	            if (t%4 == 0)       glColor3f(h+0.7,h,h);
173 | 	            else if (t%4 == 1)  glColor3f(h+0.2,h+0.5,h);
174 | 	            else if (t%4 == 2)  glColor3f(h,h+0.5,h+0.2);
175 | 	            else                glColor3f(h,h,h+0.7);
176 |                 */
177 | 
178 |                 // Determine colors by whether or not face is on boundary.
179 |                 if (isBoundaryFace(tet[t][0], tet[t][1], tet[t][2]))
180 |                 {
181 |                     glColor3f(1.0, 1.0, 0.7);
182 |                 }
183 |                 else
184 |                 {
185 |                     glColor3f(0.7, 0.7, 1.0);
186 |                 }
187 |                 glNormal3fv(normalized(cross((q-p),(r-p))).v);
188 | 	            glVertex3fv(p.v);
189 | 	            glVertex3fv(q.v);
190 | 	            glVertex3fv(r.v);
191 |                 if (isBoundaryFace(tet[t][0], tet[t][3], tet[t][1]))
192 |                 {
193 |                     glColor3f(1.0, 1.0, 0.7);
194 |                 }
195 |                 else
196 |                 {
197 |                     glColor3f(0.7, 0.7, 1.0);
198 |                 }
199 |                 glNormal3fv(normalized(cross((s-p),(q-p))).v);
200 | 	            glVertex3fv(p.v);
201 | 	            glVertex3fv(s.v);
202 | 	            glVertex3fv(q.v);
203 |                 if (isBoundaryFace(tet[t][0], tet[t][2], tet[t][3]))
204 |                 {
205 |                     glColor3f(1.0, 1.0, 0.7);
206 |                 }
207 |                 else
208 |                 {
209 |                     glColor3f(0.7, 0.7, 1.0);
210 |                 }
211 |                 glNormal3fv(normalized(cross((r-p),(s-p))).v);
212 | 	            glVertex3fv(p.v);
213 | 	            glVertex3fv(r.v);
214 | 	            glVertex3fv(s.v);
215 |                 if (isBoundaryFace(tet[t][1], tet[t][2], tet[t][3]))
216 |                 {
217 |                     glColor3f(1.0, 1.0, 0.7);
218 |                 }
219 |                 else
220 |                 {
221 |                     glColor3f(0.7, 0.7, 1.0);
222 |                 }
223 |                 glNormal3fv(normalized(cross((r-q),(s-q))).v);
224 | 	            glVertex3fv(q.v);
225 | 	            glVertex3fv(r.v);
226 | 	            glVertex3fv(s.v);
227 | 	        }
228 |     	}
229 |         glEnd();
230 | 
231 |         // Tet Edges
232 |         glDisable(GL_LIGHTING);
233 |         glLineWidth(1.0);
234 |         //glColor3f(1.0, 1.0, 0.0);
235 |         glColor3f(0.2, 0.2, 0.2);
236 |         glBegin(GL_LINES);
237 |         for (size_t t=0; t<tet.size(); ++t) {
238 |             Vec3f p=x[tet[t][0]],
239 |                   q=x[tet[t][1]],
240 |                   r=x[tet[t][2]],
241 |                   s=x[tet[t][3]];
242 | 			
243 |             // if any vertex is cut off, don't draw tet
244 |             if(isCutOff(p) || isCutOff(q) || isCutOff(r) || isCutOff(s))
245 |             	continue;
246 |             
247 |             /*
248 |             Vec3f c=(p+q+r+s)/4;
249 |             //p=0.8*p+0.2*c; 
250 |             //q=0.8*q+0.2*c;
251 |             //r=0.8*r+0.2*c;
252 |             //s=0.8*s+0.2*c;
253 |             p=0.81*p+0.19*c;
254 |             q=0.81*q+0.19*c;
255 |             r=0.81*r+0.19*c;
256 |             s=0.81*s+0.19*c;
257 |             */
258 |             
259 |             glVertex3fv(p.v);
260 |             glVertex3fv(q.v);
261 | 
262 |             glVertex3fv(p.v);
263 |             glVertex3fv(r.v);
264 | 
265 |             glVertex3fv(p.v);
266 |             glVertex3fv(s.v);
267 | 
268 |             glVertex3fv(q.v);
269 |             glVertex3fv(r.v);
270 | 
271 |             glVertex3fv(q.v);
272 |             glVertex3fv(s.v);
273 | 
274 |             glVertex3fv(r.v);
275 |             glVertex3fv(s.v);
276 |         }
277 |         glEnd();
278 | 
279 |     } else {
280 |         // Draw triangle mesh
281 |         glColor3f(0.9, 0.9, 0.6);
282 |         glBegin(GL_TRIANGLES);
283 |         for (size_t t = 0; t < tri.size(); ++t) {
284 |             glNormal3fv(normalized(cross(x[tri[t][1]]-x[tri[t][0]],
285 |                                          x[tri[t][2]]-x[tri[t][0]])).v);
286 |             glVertex3fv(x[tri[t][0]].v);
287 |             glVertex3fv(x[tri[t][1]].v);
288 |             glVertex3fv(x[tri[t][2]].v);
289 |         }
290 |         glEnd();
291 | 
292 |         /*
293 |         // Draw triangle edges
294 |         glDisable(GL_LIGHTING);
295 |         glLineWidth(1.0);
296 |         glColor3f(0.2, 0.2, 0.2);
297 |         glBegin(GL_LINES);
298 |         for (size_t t = 0; t < tri.size(); ++t) {
299 |             glVertex3fv(x[tri[t][0]].v);
300 |             glVertex3fv(x[tri[t][1]].v);
301 |             
302 |             glVertex3fv(x[tri[t][1]].v);
303 |             glVertex3fv(x[tri[t][2]].v);
304 |             
305 |             glVertex3fv(x[tri[t][2]].v);
306 |             glVertex3fv(x[tri[t][0]].v);
307 |         }
308 |         glEnd();
309 |         */
310 |     }
311 | 
312 |     // Features
313 |     glDisable(GL_LIGHTING);
314 |     glLineWidth(5.0);
315 |     glColor3f(0.9, 0.1, 0.7);
316 |     for (size_t f = 0; f < features.numFeatures(); ++f) {
317 |         Feature feat;
318 |         features.getFeature(f, feat);
319 |         glBegin(GL_LINE_STRIP);
320 |         for (size_t v = 0; v < feat.vertices.size(); ++v) {
321 |             glVertex3fv(feat.vertices[v].v);
322 |         }
323 |         glEnd();
324 |     }
325 | 
326 |     // Feature Endpoints
327 |     glPointSize(10.0);
328 |     glColor3f(0.0, 0.0, 0.0);
329 |     for (size_t f = 0; f < features.numFeatures(); ++f) {
330 |         Feature feat;
331 |         features.getFeature(f, feat);
332 |         glBegin(GL_POINTS);
333 |         glVertex3fv(feat.getEndpoint1().v);
334 |         if (!feat.isPoint()) {
335 |             glVertex3fv(feat.getEndpoint2().v);
336 |         }
337 |         glEnd();
338 |     }
339 | }
340 | 
341 | int main(int argc, char **argv)
342 | {
343 |     bool usage = false, failure = false;
344 |     drawTriMesh = false;
345 |     bool feature = false;
346 |     char* featureFile = NULL;
347 | 
348 |     if(argc<2 || argc>7) {
349 |         usage = true;
350 |         failure = true;
351 |     }
352 | 
353 |     // Parse command line arguments
354 |     for (int arg = 2; arg < argc && !failure; ++arg)
355 |     {
356 |         if (strcmp(argv[arg], "-s") == 0) {
357 |             drawTriMesh = true;
358 | 
359 |         } else if (strcmp(argv[arg], "-f") == 0) {
360 |             if (feature) {
361 |                 std::printf("ERROR: Feature file already specified.");
362 |                 usage = true;
363 |                 failure = true;
364 |                 break;
365 |             }
366 |             ++arg;
367 |             if (arg >= argc) {
368 |                 std::printf("ERROR: No feature file provided after "
369 |                             "-f option\n");
370 |                 usage = true;
371 | 		    } else if (strcmp(argv[arg], "-p") == 0) {
372 | 			std::printf("ERROR: No feature file provided after "
373 | 	                            "-f option\n");
374 |                 usage = true;
375 |             } else {
376 |                 feature = true;
377 |                 featureFile = argv[arg];
378 |             }
379 | 
380 | 		} else if(strcmp(argv[arg], "-p") == 0) {
381 | 			++arg;
382 | 		    if (arg >= argc) {
383 |                 std::printf("ERROR: No cutting plane specified after "
384 |                             "-p option\n");
385 |                 usage = true;
386 | 
387 |             } else {
388 | 	            
389 |                 char cutPlane;
390 |                 float cutVal;
391 |                 
392 |                 if (sscanf(argv[arg], "%c%f", &cutPlane, &cutVal) == 2) {
393 | 	                
394 | 	                if(cutPlane == 'x'){
395 | 		                cutX = true;
396 | 		                px = cutVal;
397 | 	                } else if(cutPlane == 'y'){
398 | 		                cutY = true;
399 | 		                py = cutVal;
400 | 	                } else if(cutPlane == 'z'){
401 | 		                cutZ = true;
402 | 		                pz = cutVal;
403 | 	                } else{
404 | 		                std::printf("ERROR: Wrong format in specifying cutting plane\n");
405 |                 		usage = true;
406 | 	                }
407 | 	                
408 |                 } else {
409 | 	                std::printf("ERROR: Wrong format in specifying cutting plane\n");
410 |                 	usage = true;
411 | 	                
412 |                 }
413 |             }
414 |             
415 | 		} else if(strcmp(argv[arg], "-w") == 0) {
416 | 			worst_n = atoi(argv[++arg]);
417 | 			if ( worst_n == 0) {
418 | 				std::printf("ERROR: A proper integer cannot be found after the '-w' option\n");
419 |                 	usage = true;
420 | 			}
421 | 			
422 | 			
423 |         } else { // Invalid argument
424 |             usage = true;
425 |             failure = true;
426 |         }
427 |     }
428 | 
429 |     if (usage) {
430 |         std::printf("Usage: view_tet <input.tet> [-s] [-f <feature.feat>] [-p (x|y|z)<cutting-plane-value>]* [-w num]\n");
431 |     }
432 |     if (failure) {
433 |         return 1;
434 |     }
435 | 
436 |     Gluvi::init(argv[0], &argc, argv);
437 |     Gluvi::Target3D cam;
438 |     Gluvi::camera=&cam;
439 | 
440 | 
441 |     if (!drawTriMesh) {
442 |         // Read .tet file
443 |         FILE *in=std::fopen(argv[1], "r");
444 |         if (!in) {
445 |             std::printf("Error: could not read tet mesh file: %s\n", argv[1]);
446 |             return 1;
447 |         }
448 | 
449 |         if(std::fgetc(in)!='t') return 1;
450 |         if(std::fgetc(in)!='e') return 1;
451 |         if(std::fgetc(in)!='t') return 1;
452 |         if(std::fgetc(in)!=' ') return 1;
453 |         int nv=-1, nt=-1;
454 |         std::fscanf(in, "%d %d", &nv, &nt);
455 |         if(nv<=0 || nt<=0) return 2;
456 |         x.resize(nv);
457 |         tet.resize(nt);
458 |         for(int i=0; i<nv; ++i)
459 |             std::fscanf(in, "%g %g %g", &x[i][0], &x[i][1], &x[i][2]);
460 |         for(int i=0; i<nt; ++i)
461 |             std::fscanf(in, "%d %d %d %d", &tet[i][0], &tet[i][1], &tet[i][2], &tet[i][3]);
462 |         std::fclose(in);
463 | 
464 |         // Compute boundary mesh and populate boundary_face_set
465 |         TetMesh tetMesh(x, tet);
466 |         std::vector<int> boundaryVerts;
467 |         std::vector<Vec3i> boundaryTris;
468 |         tetMesh.getBoundary(boundaryVerts, boundaryTris);
469 |         for (size_t i = 0; i < boundaryTris.size(); ++i)
470 |         {
471 |             boundary_face_set.insert(boundaryTris[i]);
472 |         }
473 |         
474 | 
475 |         if (!x.size()) {
476 |             std::printf("Error reading tet mesh file %s: "
477 |                         "no vertex data found.", argv[1]);
478 |             return 1;
479 |         }
480 |         
481 |         // Reorder to have worst N tets in front
482 |         if(worst_n > 0){
483 | 	        sortTets();
484 |         }
485 |         
486 |     } else {
487 |         bool result = read_objfile(x, tri, argv[1]);
488 |         if (!result) {
489 |             std::printf("Error: could not read tri mesh file: %s\n", argv[1]);
490 |             return 1;
491 |         }
492 |         if (!x.size()) {
493 |             std::printf("Error reading tri mesh file %s: "
494 |                         "no vertex data found.", argv[1]);
495 |             return 1;
496 |         }
497 |     }
498 | 
499 |     if (feature) {
500 |         // Read feature file
501 |         features.readFromFile(featureFile);
502 |     }
503 | 
504 |     // Construct bounding box and use to find centroid.
505 |     Vec3f bboxMin = x[0], bboxMax = x[0];
506 |     for (size_t i = 1; i < x.size(); ++i) {
507 |         for (int j = 0; j < 3; ++j) {
508 |             if (x[i][j] < bboxMin[j]) bboxMin[j] = x[i][j];
509 |             if (x[i][j] > bboxMax[j]) bboxMax[j] = x[i][j];
510 |         }
511 |     }
512 |     centroid = bboxMin + (bboxMax - bboxMin)*0.5;
513 | 
514 |     glClearColor(1.0, 1.0, 1.0, 1.0);
515 | 
516 |     glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
517 |     Gluvi::userDisplayFunc=display;
518 | 
519 |     /*
520 |     for(int t=0; t<tet.size(); ++t){
521 |         Vec3f p=x[tet[t][0]];
522 |         Vec3f q=x[tet[t][1]];
523 |         Vec3f r=x[tet[t][2]];
524 |         Vec3f s=x[tet[t][3]];
525 |         std::cout<<t<<": "<<triple(q-p, r-p, s-p)<<std::endl;
526 |     }
527 |     */
528 | 
529 |     Gluvi::run();
530 |     return 0;
531 | }
532 | 
533 | 


--------------------------------------------------------------------------------
/meshes/fandisk.feat:
--------------------------------------------------------------------------------
  1 | feat 35
  2 | 53
  3 | 0.694 15.4925 -1.122
  4 | 0.7762 15.5206 -1.0836
  5 | 0.8598 15.5523 -1.0458
  6 | 0.9437 15.5872 -1.0093
  7 | 1.0269 15.625 -0.9748
  8 | 1.1088 15.666 -0.9424
  9 | 1.1908 15.7101 -0.9124
 10 | 1.2714 15.7575 -0.8848
 11 | 1.3515 15.8084 -0.8602
 12 | 1.4305 15.8625 -0.8387
 13 | 1.5083 15.9201 -0.8211
 14 | 1.5842 15.9806 -0.808
 15 | 1.6523 16.0389 -0.7974
 16 | 1.7186 16.1 -0.7869
 17 | 1.7823 16.1634 -0.7757
 18 | 1.8441 16.229 -0.7641
 19 | 1.903 16.2966 -0.7523
 20 | 1.9641 16.3686 -0.7395
 21 | 2.0246 16.4406 -0.7267
 22 | 2.0858 16.5126 -0.7139
 23 | 2.1466 16.5847 -0.7014
 24 | 2.2084 16.657 -0.6886
 25 | 2.2721 16.7274 -0.6761
 26 | 2.3377 16.7962 -0.664
 27 | 2.4052 16.8635 -0.6521
 28 | 2.4744 16.9284 -0.6406
 29 | 2.5454 16.9918 -0.6297
 30 | 2.6184 17.0533 -0.6188
 31 | 2.6923 17.1122 -0.6083
 32 | 2.7685 17.1695 -0.5983
 33 | 2.8463 17.2248 -0.5884
 34 | 2.9254 17.278 -0.5791
 35 | 3.0061 17.3289 -0.5702
 36 | 3.088 17.3779 -0.5615
 37 | 3.1709 17.4239 -0.5532
 38 | 3.2554 17.4684 -0.5455
 39 | 3.3415 17.5104 -0.5382
 40 | 3.4283 17.5501 -0.5311
 41 | 3.5163 17.5872 -0.5247
 42 | 3.6056 17.6218 -0.5183
 43 | 3.6955 17.6541 -0.5129
 44 | 3.7864 17.6842 -0.5074
 45 | 3.878 17.7114 -0.5026
 46 | 3.9705 17.7364 -0.4981
 47 | 4.0637 17.7585 -0.4943
 48 | 4.1574 17.7783 -0.4908
 49 | 4.2516 17.7956 -0.4879
 50 | 4.3466 17.81 -0.4853
 51 | 4.4417 17.8218 -0.4831
 52 | 4.5371 17.8311 -0.4815
 53 | 4.6325 17.8378 -0.4802
 54 | 4.7282 17.842 -0.4796
 55 | 4.8277 17.8436 -0.4793
 56 | 59
 57 | 4.8277 17.85 -0.0001
 58 | 4.7291 17.8484 -0.0001
 59 | 4.6309 17.8442 -0.0001
 60 | 4.5326 17.8372 -0.0001
 61 | 4.435 17.8276 -0.0001
 62 | 4.337 17.8151 -0.0001
 63 | 4.2397 17.8001 -0.0001
 64 | 4.143 17.7821 -0.0001
 65 | 4.047 17.7617 -0.0001
 66 | 3.9513 17.7383 -0.0001
 67 | 3.8562 17.7124 -0.0001
 68 | 3.7618 17.6835 -0.0001
 69 | 3.668 17.6522 -0.0001
 70 | 3.5755 17.6182 -0.0001
 71 | 3.4843 17.5818 -0.0001
 72 | 3.3937 17.5424 -0.0001
 73 | 3.3041 17.5008 -0.0001
 74 | 3.2157 17.4566 -0.0001
 75 | 3.1286 17.4099 -0.0001
 76 | 3.0432 17.3609 -0.0001
 77 | 2.9593 17.3094 -0.0001
 78 | 2.8767 17.2556 -0.0001
 79 | 2.7954 17.1992 -0.0001
 80 | 2.7164 17.1413 -0.0001
 81 | 2.6389 17.0808 -0.0001
 82 | 2.5627 17.0181 -0.0001
 83 | 2.4888 16.9537 -0.0001
 84 | 2.4164 16.8868 -0.0001
 85 | 2.346 16.8177 -0.0001
 86 | 2.2775 16.7469 -0.0001
 87 | 2.2109 16.6743 -0.0001
 88 | 2.1466 16.5997 -0.0001
 89 | 2.0858 16.528 -0.0001
 90 | 2.025 16.4566 -0.0001
 91 | 1.9641 16.3852 -0.0001
 92 | 1.903 16.3138 -0.0001
 93 | 1.8355 16.2377 -0.0001
 94 | 1.7705 16.1698 -0.0001
 95 | 1.7029 16.1045 -0.0001
 96 | 1.6331 16.0421 -0.0001
 97 | 1.5608 15.9822 -0.0001
 98 | 1.4869 15.9252 -0.0001
 99 | 1.4104 15.8708 -0.0001
100 | 1.3322 15.8196 -0.0001
101 | 1.2519 15.771 -0.0001
102 | 1.17 15.7255 -0.0001
103 | 1.0861 15.6833 -0.0001
104 | 1.0009 15.6442 -0.0001
105 | 0.9145 15.608 -0.0001
106 | 0.8275 15.5757 -0.0001
107 | 0.7385 15.5466 -0.0001
108 | 0.6482 15.5203 -0.0001
109 | 0.5573 15.4976 -0.0001
110 | 0.4661 15.4787 -0.0001
111 | 0.3736 15.463 -0.0001
112 | 0.2807 15.4505 -0.0001
113 | 0.1873 15.4419 -0.0001
114 | 0.0938 15.4368 -0.0001
115 | 0 15.4349 -0.0001
116 | 21
117 | 2.7906 15.4688 -1.1592
118 | 2.8476 15.513 -1.0935
119 | 2.9039 15.5626 -1.0346
120 | 2.9603 15.618 -0.9812
121 | 3.0163 15.6791 -0.9332
122 | 3.0704 15.7457 -0.8912
123 | 3.1219 15.8183 -0.856
124 | 3.1693 15.8964 -0.8278
125 | 3.2099 15.9806 -0.808
126 | 3.25 16.0728 -0.7917
127 | 3.29 16.1612 -0.776
128 | 3.3313 16.2489 -0.7606
129 | 3.3742 16.3363 -0.7453
130 | 3.4187 16.4227 -0.7299
131 | 3.4648 16.5081 -0.7149
132 | 3.5124 16.593 -0.6998
133 | 3.5621 16.6765 -0.6851
134 | 3.6139 16.7594 -0.6707
135 | 3.668 16.8404 -0.6563
136 | 3.724 16.9201 -0.6422
137 | 3.7823 16.9979 -0.6284
138 | 26
139 | 2.7906 15.4688 -1.1592
140 | 2.8495 15.4816 -1.0859
141 | 2.9103 15.4941 -1.0151
142 | 2.974 15.5059 -0.9466
143 | 3.04 15.5178 -0.8807
144 | 3.1085 15.529 -0.817
145 | 3.1795 15.5398 -0.7558
146 | 3.2528 15.5501 -0.6972
147 | 3.3281 15.5597 -0.6416
148 | 3.4052 15.5693 -0.5884
149 | 3.4846 15.5779 -0.5382
150 | 3.5659 15.5866 -0.4908
151 | 3.6485 15.5943 -0.4466
152 | 3.733 15.6016 -0.4053
153 | 3.8191 15.6083 -0.3669
154 | 3.9062 15.6144 -0.332
155 | 3.9948 15.6202 -0.3003
156 | 4.0845 15.625 -0.2715
157 | 4.175 15.6295 -0.2462
158 | 4.2666 15.6333 -0.2241
159 | 4.3588 15.6368 -0.2056
160 | 4.4519 15.6394 -0.1902
161 | 4.5454 15.6416 -0.178
162 | 4.6389 15.6429 -0.1697
163 | 4.7333 15.6439 -0.1646
164 | 4.8277 15.6442 -0.1627
165 | 34
166 | 2.6988 15.2002 -2.6803
167 | 2.701 15.2172 -2.5823
168 | 2.708 15.2335 -2.4844
169 | 2.7196 15.2492 -2.3867
170 | 2.7359 15.2642 -2.2894
171 | 2.7567 15.2783 -2.1931
172 | 2.782 15.2918 -2.0977
173 | 2.8117 15.3043 -2.0036
174 | 2.8463 15.3161 -1.9101
175 | 2.8847 15.3273 -1.8189
176 | 2.9276 15.3375 -1.7296
177 | 2.9747 15.3471 -1.6422
178 | 3.0256 15.3561 -1.557
179 | 3.08 15.3641 -1.4748
180 | 3.1463 15.3782 -1.3861
181 | 3.2151 15.4009 -1.3045
182 | 3.2874 15.4313 -1.2286
183 | 3.3626 15.4688 -1.1592
184 | 3.4375 15.4803 -1.0926
185 | 3.5157 15.4915 -1.0292
186 | 3.5966 15.5021 -0.97
187 | 3.6805 15.5117 -0.9143
188 | 3.7669 15.521 -0.8627
189 | 3.8556 15.5293 -0.815
190 | 3.9455 15.537 -0.7721
191 | 4.0384 15.5437 -0.7331
192 | 4.1331 15.5498 -0.6985
193 | 4.2291 15.5552 -0.6684
194 | 4.3268 15.5597 -0.6425
195 | 4.4254 15.5632 -0.6214
196 | 4.5249 15.5664 -0.6051
197 | 4.6248 15.5683 -0.5932
198 | 4.7253 15.5696 -0.5862
199 | 4.8277 15.5699 -0.5836
200 | 34
201 | 2.6988 14.8952 -2.6265
202 | 2.7013 14.9128 -2.5266
203 | 2.7084 14.9304 -2.4274
204 | 2.7205 14.9477 -2.3282
205 | 2.7372 14.9649 -2.2302
206 | 2.7586 14.9822 -2.1326
207 | 2.7849 14.9992 -2.0362
208 | 2.8156 15.0158 -1.9411
209 | 2.8511 15.0325 -1.8477
210 | 2.8911 15.0485 -1.7558
211 | 2.9353 15.0645 -1.6659
212 | 2.984 15.0799 -1.5782
213 | 3.0368 15.0949 -1.493
214 | 3.0934 15.1096 -1.4104
215 | 3.1542 15.1237 -1.3304
216 | 3.2189 15.1372 -1.2533
217 | 3.2871 15.1503 -1.1796
218 | 3.3591 15.1628 -1.1086
219 | 3.4337 15.1746 -1.0417
220 | 3.5118 15.1855 -0.9786
221 | 3.5925 15.1961 -0.9188
222 | 3.676 15.206 -0.8631
223 | 3.7628 15.2153 -0.8112
224 | 3.8517 15.2236 -0.7632
225 | 3.9427 15.2313 -0.7197
226 | 4.0361 15.2383 -0.6803
227 | 4.1309 15.2444 -0.6454
228 | 4.2276 15.2498 -0.615
229 | 4.3255 15.2543 -0.5891
230 | 4.4244 15.2582 -0.5679
231 | 4.5246 15.261 -0.5513
232 | 4.6251 15.263 -0.5394
233 | 4.7263 15.2642 -0.5324
234 | 4.8277 15.2649 -0.5298
235 | 23
236 | 4.8277 15.6442 -0.1627
237 | 4.8277 15.7441 -0.1803
238 | 4.8277 15.8439 -0.1979
239 | 4.8277 15.9438 -0.2155
240 | 4.8277 16.0437 -0.2331
241 | 4.8277 16.1436 -0.2507
242 | 4.8277 16.2434 -0.2683
243 | 4.8277 16.3433 -0.2859
244 | 4.8277 16.4432 -0.3035
245 | 4.8277 16.543 -0.3211
246 | 4.8277 16.6429 -0.3387
247 | 4.8277 16.7428 -0.3563
248 | 4.8277 16.8426 -0.3739
249 | 4.8277 16.9425 -0.3916
250 | 4.8277 17.0424 -0.4092
251 | 4.8277 17.1423 -0.4268
252 | 4.8277 17.2421 -0.4444
253 | 4.8277 17.342 -0.462
254 | 4.8277 17.4419 -0.4796
255 | 4.8277 17.5417 -0.4975
256 | 4.8277 17.6416 -0.5151
257 | 4.8277 17.7424 -0.4972
258 | 4.8277 17.8436 -0.4793
259 | 43
260 | 2.4276 13.3984 -0.0001
261 | 2.4276 13.2822 -0.0001
262 | 2.4276 13.166 -0.0001
263 | 2.4276 13.0498 -0.0001
264 | 2.4081 12.9525 -0.0001
265 | 2.3534 12.8718 -0.0001
266 | 2.2727 12.8187 -0.0001
267 | 2.1776 12.7998 -0.0001
268 | 2.0778 12.7998 -0.0001
269 | 1.9779 12.7998 -0.0001
270 | 1.878 12.7998 -0.0001
271 | 1.7781 12.7998 -0.0001
272 | 1.6783 12.7998 -0.0001
273 | 1.5784 12.7998 -0.0001
274 | 1.4817 12.8193 -0.0001
275 | 1.4014 12.8734 -0.0001
276 | 1.3473 12.9544 -0.0001
277 | 1.3284 13.0498 -0.0001
278 | 1.3284 13.1558 -0.0001
279 | 1.3284 13.2614 -0.0001
280 | 1.3284 13.3673 -0.0001
281 | 1.3284 13.4733 -0.0001
282 | 1.3284 13.5789 -0.0001
283 | 1.3284 13.6849 -0.0001
284 | 1.3236 13.7822 -0.0001
285 | 1.3092 13.8792 -0.0001
286 | 1.2855 13.9742 -0.0001
287 | 1.2522 14.0671 -0.0001
288 | 1.2103 14.1557 -0.0001
289 | 1.16 14.2399 -0.0001
290 | 1.1015 14.319 -0.0001
291 | 1.0358 14.3917 -0.0001
292 | 0.9632 14.4576 -0.0001
293 | 0.8841 14.5162 -0.0001
294 | 0.8002 14.5664 -0.0001
295 | 0.7113 14.6087 -0.0001
296 | 0.6188 14.6416 -0.0001
297 | 0.5234 14.6657 -0.0001
298 | 0.4264 14.6801 -0.0001
299 | 0.3284 14.6849 -0.0001
300 | 0.2189 14.6849 -0.0001
301 | 0.1095 14.6849 -0.0001
302 | 0 14.6849 -0.0001
303 | 28
304 | 0 15.4349 -0.0001
305 | 0 15.4345 -0.0987
306 | 0 15.4336 -0.1969
307 | 0 15.432 -0.2955
308 | 0 15.4297 -0.3938
309 | 0 15.4269 -0.4924
310 | 0 15.4237 -0.5907
311 | 0 15.4195 -0.6892
312 | 0 15.4147 -0.7875
313 | 0 15.4096 -0.8858
314 | 0 15.4035 -0.9841
315 | 0 15.3968 -1.0823
316 | 0 15.3897 -1.1806
317 | 0 15.3817 -1.2789
318 | 0 15.3734 -1.3768
319 | 0 15.3641 -1.4748
320 | 0 15.3542 -1.5759
321 | 0 15.3436 -1.6767
322 | 0 15.3321 -1.7776
323 | 0 15.3203 -1.8781
324 | 0 15.3075 -1.9786
325 | 0 15.294 -2.0791
326 | 0 15.2802 -2.1796
327 | 0 15.2655 -2.2801
328 | 0 15.2502 -2.3803
329 | 0 15.2342 -2.4805
330 | 0 15.2175 -2.5804
331 | 0 15.2002 -2.6803
332 | 8
333 | 0 14.6849 -0.0001
334 | 0 14.7921 -0.0001
335 | 0 14.899 -0.0001
336 | 0 15.0062 -0.0001
337 | 0 15.1135 -0.0001
338 | 0 15.2204 -0.0001
339 | 0 15.3276 -0.0001
340 | 0 15.4349 -0.0001
341 | 44
342 | 4.8277 13.6119 -0.0001
343 | 4.8277 13.7105 -0.0001
344 | 4.8277 13.8091 -0.0001
345 | 4.8277 13.9073 -0.0001
346 | 4.8277 14.0059 -0.0001
347 | 4.8277 14.1045 -0.0001
348 | 4.8277 14.2031 -0.0001
349 | 4.8277 14.3017 -0.0001
350 | 4.8277 14.4003 -0.0001
351 | 4.8277 14.4989 -0.0001
352 | 4.8277 14.5975 -0.0001
353 | 4.8277 14.6961 -0.0001
354 | 4.8277 14.7947 -0.0001
355 | 4.8277 14.8929 -0.0001
356 | 4.8277 14.9915 -0.0001
357 | 4.8277 15.0901 -0.0001
358 | 4.8277 15.1887 -0.0001
359 | 4.8277 15.2873 -0.0001
360 | 4.8277 15.3859 -0.0001
361 | 4.8277 15.4845 -0.0001
362 | 4.8277 15.5831 -0.0001
363 | 4.8277 15.6817 -0.0001
364 | 4.8277 15.7802 -0.0001
365 | 4.8277 15.8785 -0.0001
366 | 4.8277 15.9771 -0.0001
367 | 4.8277 16.0757 -0.0001
368 | 4.8277 16.1743 -0.0001
369 | 4.8277 16.2729 -0.0001
370 | 4.8277 16.3715 -0.0001
371 | 4.8277 16.4701 -0.0001
372 | 4.8277 16.5686 -0.0001
373 | 4.8277 16.6672 -0.0001
374 | 4.8277 16.7658 -0.0001
375 | 4.8277 16.8641 -0.0001
376 | 4.8277 16.9627 -0.0001
377 | 4.8277 17.0613 -0.0001
378 | 4.8277 17.1599 -0.0001
379 | 4.8277 17.2585 -0.0001
380 | 4.8277 17.357 -0.0001
381 | 4.8277 17.4556 -0.0001
382 | 4.8277 17.5542 -0.0001
383 | 4.8277 17.6528 -0.0001
384 | 4.8277 17.7511 -0.0001
385 | 4.8277 17.85 -0.0001
386 | 34
387 | 3.1863 14.8952 -2.6265
388 | 3.1882 14.9086 -2.5503
389 | 3.1936 14.9221 -2.4738
390 | 3.2029 14.9355 -2.3973
391 | 3.2157 14.9489 -2.3214
392 | 3.2324 14.9621 -2.2462
393 | 3.2525 14.9752 -2.1719
394 | 3.2762 14.988 -2.0986
395 | 3.3037 15.0008 -2.0263
396 | 3.3345 15.0133 -1.9556
397 | 3.3684 15.0254 -1.8864
398 | 3.4058 15.0376 -1.8189
399 | 3.4465 15.0491 -1.7529
400 | 3.4904 15.0603 -1.6892
401 | 3.5371 15.0712 -1.6278
402 | 3.5867 15.0818 -1.5682
403 | 3.6395 15.0917 -1.5113
404 | 3.6946 15.1013 -1.4568
405 | 3.7525 15.1106 -1.405
406 | 3.8127 15.1189 -1.356
407 | 3.8751 15.1272 -1.3099
408 | 3.9401 15.1349 -1.2667
409 | 4.0067 15.142 -1.2267
410 | 4.0752 15.1484 -1.1899
411 | 4.1456 15.1544 -1.1563
412 | 4.2173 15.1596 -1.1259
413 | 4.2906 15.1644 -1.099
414 | 4.3652 15.1685 -1.0756
415 | 4.4407 15.1721 -1.0558
416 | 4.5169 15.1749 -1.0391
417 | 4.5941 15.1772 -1.0266
418 | 4.6715 15.1788 -1.0173
419 | 4.7496 15.1797 -1.0119
420 | 4.8277 15.1801 -1.01
421 | 5
422 | 4.8277 15.5699 -0.5836
423 | 4.8277 15.5885 -0.4786
424 | 4.8277 15.6071 -0.3733
425 | 4.8277 15.6256 -0.268
426 | 4.8277 15.6442 -0.1627
427 | 6
428 | 4.8277 17.85 -0.0001
429 | 4.8277 17.8497 -0.0961
430 | 4.8277 17.8487 -0.1918
431 | 4.8277 17.8474 -0.2878
432 | 4.8277 17.8458 -0.3835
433 | 4.8277 17.8436 -0.4793
434 | 28
435 | 0 14.4618 -2.5503
436 | 0 14.4781 -2.4568
437 | 0 14.4934 -2.363
438 | 0 14.5085 -2.2696
439 | 0 14.5229 -2.1758
440 | 0 14.5367 -2.0817
441 | 0 14.5498 -1.9879
442 | 0 14.5623 -1.8938
443 | 0 14.5741 -1.7997
444 | 0 14.5856 -1.7052
445 | 0 14.5962 -1.6108
446 | 0 14.6064 -1.5164
447 | 0 14.6157 -1.4219
448 | 0 14.6247 -1.3272
449 | 0 14.633 -1.2328
450 | 0 14.6407 -1.138
451 | 0 14.6477 -1.0433
452 | 0 14.6541 -0.9485
453 | 0 14.6599 -0.8538
454 | 0 14.6653 -0.759
455 | 0 14.6698 -0.6643
456 | 0 14.674 -0.5692
457 | 0 14.6772 -0.4745
458 | 0 14.6801 -0.3794
459 | 0 14.682 -0.2846
460 | 0 14.6836 -0.1899
461 | 0 14.6845 -0.0948
462 | 0 14.6849 -0.0001
463 | 4
464 | 4.8277 15.2649 -0.5298
465 | 4.8277 15.3667 -0.5478
466 | 4.8277 15.4681 -0.5657
467 | 4.8277 15.5699 -0.5836
468 | 29
469 | 0 15.2002 -2.6803
470 | 0.0963 15.2002 -2.6803
471 | 0.1927 15.2002 -2.6803
472 | 0.289 15.2002 -2.6803
473 | 0.3854 15.2002 -2.6803
474 | 0.4817 15.2002 -2.6803
475 | 0.5781 15.2002 -2.6803
476 | 0.6744 15.2002 -2.6803
477 | 0.7708 15.2002 -2.6803
478 | 0.8675 15.2002 -2.6803
479 | 0.9638 15.2002 -2.6803
480 | 1.0602 15.2002 -2.6803
481 | 1.1565 15.2002 -2.6803
482 | 1.2529 15.2002 -2.6803
483 | 1.3492 15.2002 -2.6803
484 | 1.4456 15.2002 -2.6803
485 | 1.5419 15.2002 -2.6803
486 | 1.6386 15.2002 -2.6803
487 | 1.7349 15.2002 -2.6803
488 | 1.8313 15.2002 -2.6803
489 | 1.9276 15.2002 -2.6803
490 | 2.024 15.2002 -2.6803
491 | 2.1203 15.2002 -2.6803
492 | 2.2167 15.2002 -2.6803
493 | 2.313 15.2002 -2.6803
494 | 2.4097 15.2002 -2.6803
495 | 2.5061 15.2002 -2.6803
496 | 2.6024 15.2002 -2.6803
497 | 2.6988 15.2002 -2.6803
498 | 4
499 | 2.6988 15.2002 -2.6803
500 | 2.6988 15.0984 -2.6623
501 | 2.6988 14.997 -2.6444
502 | 2.6988 14.8952 -2.6265
503 | 6
504 | 4.8277 15.1801 -1.01
505 | 4.8277 15.197 -0.914
506 | 4.8277 15.214 -0.8179
507 | 4.8277 15.231 -0.7219
508 | 4.8277 15.2479 -0.6259
509 | 4.8277 15.2649 -0.5298
510 | 25
511 | 4.8277 13.6119 -0.0001
512 | 4.7272 13.6116 -0.0001
513 | 4.627 13.6103 -0.0001
514 | 4.5265 13.6084 -0.0001
515 | 4.426 13.6058 -0.0001
516 | 4.3255 13.6026 -0.0001
517 | 4.225 13.5984 -0.0001
518 | 4.1248 13.5936 -0.0001
519 | 4.0243 13.5879 -0.0001
520 | 3.9238 13.5818 -0.0001
521 | 3.8236 13.5748 -0.0001
522 | 3.7234 13.5671 -0.0001
523 | 3.6229 13.5584 -0.0001
524 | 3.523 13.5492 -0.0001
525 | 3.4228 13.5392 -0.0001
526 | 3.3226 13.5283 -0.0001
527 | 3.2228 13.5168 -0.0001
528 | 3.1229 13.5047 -0.0001
529 | 3.0233 13.4915 -0.0001
530 | 2.9238 13.4781 -0.0001
531 | 2.8242 13.4637 -0.0001
532 | 2.725 13.4483 -0.0001
533 | 2.6258 13.4326 -0.0001
534 | 2.5265 13.416 -0.0001
535 | 2.4276 13.3984 -0.0001
536 | 6
537 | 3.1863 14.8952 -2.6265
538 | 3.0886 14.8952 -2.6265
539 | 2.9913 14.8952 -2.6265
540 | 2.8937 14.8952 -2.6265
541 | 2.7964 14.8952 -2.6265
542 | 2.6988 14.8952 -2.6265
543 | 24
544 | 2.4276 13.1951 -2.3269
545 | 2.4276 13.2134 -2.2206
546 | 2.4276 13.2297 -2.1207
547 | 2.4276 13.2454 -2.0205
548 | 2.4276 13.2601 -1.92
549 | 2.4276 13.2745 -1.8198
550 | 2.4276 13.288 -1.719
551 | 2.4276 13.3004 -1.6185
552 | 2.4276 13.3123 -1.5177
553 | 2.4276 13.3235 -1.4172
554 | 2.4276 13.3337 -1.316
555 | 2.4276 13.3433 -1.2152
556 | 2.4276 13.3523 -1.114
557 | 2.4276 13.3603 -1.0132
558 | 2.4276 13.3677 -0.912
559 | 2.4276 13.3741 -0.8109
560 | 2.4276 13.3798 -0.7097
561 | 2.4276 13.3846 -0.6086
562 | 2.4276 13.3888 -0.5071
563 | 2.4276 13.3923 -0.4056
564 | 2.4276 13.3952 -0.3045
565 | 2.4276 13.3971 -0.203
566 | 2.4276 13.3981 -0.1015
567 | 2.4276 13.3984 -0.0001
568 | 9
569 | 3.1863 14.0828 -2.4834
570 | 3.1863 14.1842 -2.5013
571 | 3.1863 14.2857 -2.5192
572 | 3.1863 14.3872 -2.5372
573 | 3.1863 14.489 -2.5551
574 | 3.1863 14.5904 -2.573
575 | 3.1863 14.6919 -2.5906
576 | 3.1863 14.7937 -2.6086
577 | 3.1863 14.8952 -2.6265
578 | 9
579 | 4.8277 14.3676 -0.8669
580 | 4.8277 14.4691 -0.8848
581 | 4.8277 14.5706 -0.9024
582 | 4.8277 14.6724 -0.9204
583 | 4.8277 14.7739 -0.9383
584 | 4.8277 14.8753 -0.9562
585 | 4.8277 14.9768 -0.9741
586 | 4.8277 15.0786 -0.9921
587 | 4.8277 15.1801 -1.01
588 | 35
589 | 3.1863 14.0828 -2.4834
590 | 3.1879 14.0956 -2.4098
591 | 3.193 14.1087 -2.3355
592 | 3.202 14.1218 -2.2613
593 | 3.2141 14.1346 -2.1876
594 | 3.2295 14.1477 -2.1143
595 | 3.2487 14.1605 -2.0417
596 | 3.2711 14.173 -1.9703
597 | 3.2967 14.1855 -1.9002
598 | 3.3258 14.1977 -1.8314
599 | 3.3578 14.2095 -1.7635
600 | 3.3934 14.221 -1.6972
601 | 3.4318 14.2326 -1.6329
602 | 3.4731 14.2434 -1.5705
603 | 3.5173 14.2543 -1.5097
604 | 3.5646 14.2646 -1.4511
605 | 3.6142 14.2745 -1.3947
606 | 3.6667 14.2841 -1.3406
607 | 3.7215 14.2931 -1.2891
608 | 3.7788 14.3017 -1.2398
609 | 3.8383 14.31 -1.1934
610 | 3.8998 14.3177 -1.1499
611 | 3.9631 14.3251 -1.1092
612 | 4.0288 14.3315 -1.0711
613 | 4.0957 14.3379 -1.0362
614 | 4.1645 14.3433 -1.0045
615 | 4.2346 14.3484 -0.9761
616 | 4.306 14.3529 -0.9504
617 | 4.3783 14.3568 -0.9284
618 | 4.4516 14.36 -0.9098
619 | 4.5259 14.3628 -0.8944
620 | 4.6008 14.3651 -0.8823
621 | 4.6763 14.3664 -0.8736
622 | 4.7519 14.3673 -0.8685
623 | 4.8277 14.3676 -0.8669
624 | 6
625 | 4.8277 14.3676 -0.8669
626 | 4.8277 14.3843 -0.7715
627 | 4.8277 14.4013 -0.6764
628 | 4.8277 14.4179 -0.5811
629 | 4.8277 14.4349 -0.486
630 | 4.8277 14.4515 -0.3906
631 | 6
632 | 2.7026 14.0828 -2.4834
633 | 2.7996 14.0828 -2.4834
634 | 2.8963 14.0828 -2.4834
635 | 2.9929 14.0828 -2.4834
636 | 3.0896 14.0828 -2.4834
637 | 3.1863 14.0828 -2.4834
638 | 35
639 | 2.7026 14.0828 -2.4834
640 | 2.7052 14.0997 -2.3867
641 | 2.7119 14.1167 -2.2904
642 | 2.7231 14.1337 -2.1944
643 | 2.7388 14.1503 -2.0986
644 | 2.7592 14.1669 -2.0042
645 | 2.7839 14.1836 -1.9107
646 | 2.813 14.1999 -1.8182
647 | 2.8463 14.2159 -1.7273
648 | 2.8838 14.2316 -1.638
649 | 2.9254 14.247 -1.5506
650 | 2.9712 14.262 -1.4648
651 | 3.0211 14.2767 -1.3816
652 | 3.0745 14.2911 -1.3006
653 | 3.1319 14.3049 -1.2222
654 | 3.193 14.3183 -1.1464
655 | 3.2573 14.3312 -1.0734
656 | 3.3252 14.3436 -1.0036
657 | 3.3963 14.3552 -0.9367
658 | 3.4702 14.3664 -0.8733
659 | 3.547 14.3769 -0.8134
660 | 3.6267 14.3872 -0.7568
661 | 3.709 14.3965 -0.704
662 | 3.7938 14.4051 -0.655
663 | 3.8806 14.4131 -0.6099
664 | 3.9695 14.4201 -0.5689
665 | 4.0601 14.4265 -0.5321
666 | 4.1523 14.4323 -0.4991
667 | 4.2461 14.4374 -0.4706
668 | 4.3412 14.4416 -0.4463
669 | 4.4372 14.4454 -0.4261
670 | 4.5342 14.448 -0.4108
671 | 4.6315 14.4499 -0.3996
672 | 4.7295 14.4512 -0.3928
673 | 4.8277 14.4515 -0.3906
674 | 10
675 | 4.8277 13.6097 -0.2421
676 | 4.8277 13.7031 -0.2587
677 | 4.8277 13.7966 -0.275
678 | 4.8277 13.8904 -0.2917
679 | 4.8277 13.9838 -0.308
680 | 4.8277 14.0773 -0.3247
681 | 4.8277 14.1708 -0.341
682 | 4.8277 14.2646 -0.3576
683 | 4.8277 14.358 -0.3743
684 | 4.8277 14.4515 -0.3906
685 | 35
686 | 4.8277 13.6097 -0.2421
687 | 4.7304 13.6093 -0.2443
688 | 4.6325 13.6081 -0.251
689 | 4.5352 13.6061 -0.2622
690 | 4.4382 13.6032 -0.2776
691 | 4.3421 13.5997 -0.2974
692 | 4.2471 13.5956 -0.3218
693 | 4.1533 13.5904 -0.3503
694 | 4.0605 13.5847 -0.3832
695 | 3.9699 13.5783 -0.4204
696 | 3.8809 13.5709 -0.4613
697 | 3.7941 13.5629 -0.5065
698 | 3.7096 13.5546 -0.5554
699 | 3.6274 13.545 -0.6083
700 | 3.5477 13.5351 -0.6646
701 | 3.4705 13.5245 -0.7245
702 | 3.3966 13.5133 -0.7882
703 | 3.3255 13.5018 -0.8547
704 | 3.2576 13.4893 -0.9245
705 | 3.1933 13.4765 -0.9975
706 | 3.1322 13.463 -1.0734
707 | 3.0749 13.4493 -1.1518
708 | 3.0214 13.4349 -1.2328
709 | 2.9715 13.4202 -1.316
710 | 2.9257 13.4051 -1.4018
711 | 2.8841 13.3897 -1.4892
712 | 2.8463 13.3741 -1.5785
713 | 2.813 13.3581 -1.6697
714 | 2.7839 13.3417 -1.7622
715 | 2.7592 13.3251 -1.8557
716 | 2.7391 13.3084 -1.9504
717 | 2.7231 13.2918 -2.0458
718 | 2.7119 13.2748 -2.1418
719 | 2.7052 13.2575 -2.2382
720 | 2.7026 13.2406 -2.3349
721 | 43
722 | 0 14.4618 -2.5503
723 | 0.1095 14.4618 -2.5503
724 | 0.2189 14.4618 -2.5503
725 | 0.3284 14.4618 -2.5503
726 | 0.4289 14.4566 -2.5493
727 | 0.5256 14.4422 -2.5468
728 | 0.6207 14.4189 -2.5426
729 | 0.7129 14.3859 -2.5369
730 | 0.8015 14.3446 -2.5295
731 | 0.8854 14.295 -2.5208
732 | 0.9638 14.2374 -2.5106
733 | 1.0365 14.1724 -2.4991
734 | 1.1018 14.101 -2.4866
735 | 1.1604 14.0235 -2.4728
736 | 1.2106 13.9406 -2.4584
737 | 1.2526 13.8532 -2.4427
738 | 1.2852 13.7623 -2.4267
739 | 1.3092 13.6689 -2.4104
740 | 1.3236 13.5735 -2.3935
741 | 1.3284 13.4768 -2.3765
742 | 1.3284 13.3728 -2.3582
743 | 1.3284 13.2684 -2.3397
744 | 1.3284 13.1644 -2.3214
745 | 1.3284 13.06 -2.3029
746 | 1.3284 12.9557 -2.2846
747 | 1.3284 12.8517 -2.2664
748 | 1.3473 12.7572 -2.2497
749 | 1.4017 12.6772 -2.2356
750 | 1.4827 12.6241 -2.226
751 | 1.5784 12.6055 -2.2228
752 | 1.6783 12.6055 -2.2228
753 | 1.7781 12.6055 -2.2228
754 | 1.878 12.6055 -2.2228
755 | 1.9779 12.6055 -2.2228
756 | 2.0778 12.6055 -2.2228
757 | 2.1776 12.6055 -2.2228
758 | 2.2737 12.6241 -2.226
759 | 2.3547 12.6775 -2.2356
760 | 2.4087 12.7575 -2.2497
761 | 2.4276 12.8517 -2.2664
762 | 2.4276 12.9659 -2.2865
763 | 2.4276 13.0805 -2.3067
764 | 2.4276 13.1951 -2.3269
765 | 10
766 | 2.7026 13.2406 -2.3349
767 | 2.7026 13.334 -2.3515
768 | 2.7026 13.4278 -2.3678
769 | 2.7026 13.5213 -2.3845
770 | 2.7026 13.6148 -2.4008
771 | 2.7026 13.7086 -2.4175
772 | 2.7026 13.802 -2.4338
773 | 2.7026 13.8955 -2.4504
774 | 2.7026 13.989 -2.4667
775 | 2.7026 14.0828 -2.4834
776 | 8
777 | 0 14.4618 -2.5503
778 | 0 14.5674 -2.5689
779 | 0 14.6727 -2.5874
780 | 0 14.7783 -2.606
781 | 0 14.884 -2.6246
782 | 0 14.9893 -2.6431
783 | 0 15.0949 -2.6617
784 | 0 15.2002 -2.6803
785 | 3
786 | 4.8277 13.6097 -0.2421
787 | 4.8277 13.6113 -0.1211
788 | 4.8277 13.6119 -0.0001
789 | 4
790 | 2.4276 13.1951 -2.3269
791 | 2.5192 13.2108 -2.3298
792 | 2.611 13.2262 -2.3323
793 | 2.7026 13.2406 -2.3349
794 | 


--------------------------------------------------------------------------------