1 // This file is part of libigl, a simple c++ geometry processing library. 2 // 3 // Copyright (C) 2017 Sebastian Koch <s.koch@tu-berlin.de> and Daniele Panozzo <daniele.panozzo@gmail.com> 4 // 5 // This Source Code Form is subject to the terms of the Mozilla Public License 6 // v. 2.0. If a copy of the MPL was not distributed with this file, You can 7 // obtain one at http://mozilla.org/MPL/2.0/. 8 const char *__doc_igl_active_set = R"igl_Qu8mg5v7(// Known Bugs: rows of [Aeq;Aieq] **must** be linearly independent. Should be 9 // using QR decomposition otherwise: 10 // http://www.okstate.edu/sas/v8/sashtml/ormp/chap5/sect32.htm 11 // 12 // ACTIVE_SET Minimize quadratic energy 13 // 14 // 0.5*Z'*A*Z + Z'*B + C with constraints 15 // 16 // that Z(known) = Y, optionally also subject to the constraints Aeq*Z = Beq, 17 // and further optionally subject to the linear inequality constraints that 18 // Aieq*Z <= Bieq and constant inequality constraints lx <= x <= ux 19 // 20 // Inputs: 21 // A n by n matrix of quadratic coefficients 22 // B n by 1 column of linear coefficients 23 // known list of indices to known rows in Z 24 // Y list of fixed values corresponding to known rows in Z 25 // Aeq meq by n list of linear equality constraint coefficients 26 // Beq meq by 1 list of linear equality constraint constant values 27 // Aieq mieq by n list of linear inequality constraint coefficients 28 // Bieq mieq by 1 list of linear inequality constraint constant values 29 // lx n by 1 list of lower bounds [] implies -Inf 30 // ux n by 1 list of upper bounds [] implies Inf 31 // params struct of additional parameters (see below) 32 // Z if not empty, is taken to be an n by 1 list of initial guess values 33 // (see output) 34 // Outputs: 35 // Z n by 1 list of solution values 36 // Returns true on success, false on error 37 // 38 // Benchmark: For a harmonic solve on a mesh with 325K facets, matlab 2.2 39 // secs, igl/min_quad_with_fixed.h 7.1 secs 40 //)igl_Qu8mg5v7"; 41 const char *__doc_igl_adjacency_list = R"igl_Qu8mg5v7(// Constructs the graph adjacency list of a given mesh (V,F) 42 // Templates: 43 // T should be a eigen sparse matrix primitive type like int or double 44 // Inputs: 45 // F #F by dim list of mesh faces (must be triangles) 46 // sorted flag that indicates if the list should be sorted counter-clockwise 47 // Outputs: 48 // A vector<vector<T> > containing at row i the adjacent vertices of vertex i 49 // 50 // Example: 51 // // Mesh in (V,F) 52 // vector<vector<double> > A; 53 // adjacency_list(F,A); 54 // 55 // See also: edges, cotmatrix, diag)igl_Qu8mg5v7"; 56 const char *__doc_igl_arap_precomputation = R"igl_Qu8mg5v7(// Compute necessary information to start using an ARAP deformation 57 // 58 // Inputs: 59 // V #V by dim list of mesh positions 60 // F #F by simplex-size list of triangle|tet indices into V 61 // dim dimension being used at solve time. For deformation usually dim = 62 // V.cols(), for surface parameterization V.cols() = 3 and dim = 2 63 // b #b list of "boundary" fixed vertex indices into V 64 // Outputs: 65 // data struct containing necessary precomputation)igl_Qu8mg5v7"; 66 const char *__doc_igl_arap_solve = R"igl_Qu8mg5v7(// Inputs: 67 // bc #b by dim list of boundary conditions 68 // data struct containing necessary precomputation and parameters 69 // U #V by dim initial guess)igl_Qu8mg5v7"; 70 const char *__doc_igl_avg_edge_length = R"igl_Qu8mg5v7(// Compute the average edge length for the given triangle mesh 71 // Templates: 72 // DerivedV derived from vertex positions matrix type: i.e. MatrixXd 73 // DerivedF derived from face indices matrix type: i.e. MatrixXi 74 // DerivedL derived from edge lengths matrix type: i.e. MatrixXd 75 // Inputs: 76 // V eigen matrix #V by 3 77 // F #F by simplex-size list of mesh faces (must be simplex) 78 // Outputs: 79 // l average edge length 80 // 81 // See also: adjacency_matrix)igl_Qu8mg5v7"; 82 const char *__doc_igl_barycenter = R"igl_Qu8mg5v7(// Computes the barycenter of every simplex 83 // 84 // Inputs: 85 // V #V x dim matrix of vertex coordinates 86 // F #F x simplex_size matrix of indices of simplex corners into V 87 // Output: 88 // BC #F x dim matrix of 3d vertices 89 //)igl_Qu8mg5v7"; 90 const char *__doc_igl_barycentric_coordinates = R"igl_Qu8mg5v7(// Compute barycentric coordinates in a tet 91 // 92 // Inputs: 93 // P #P by 3 Query points in 3d 94 // A #P by 3 Tet corners in 3d 95 // B #P by 3 Tet corners in 3d 96 // C #P by 3 Tet corners in 3d 97 // D #P by 3 Tet corners in 3d 98 // Outputs: 99 // L #P by 4 list of barycentric coordinates 100 // )igl_Qu8mg5v7"; 101 const char *__doc_igl_barycentric_to_global = R"igl_Qu8mg5v7(// Converts barycentric coordinates in the embree form to 3D coordinates 102 // Embree stores barycentric coordinates as triples: fid, bc1, bc2 103 // fid is the id of a face, bc1 is the displacement of the point wrt the 104 // first vertex v0 and the edge v1-v0. Similarly, bc2 is the displacement 105 // wrt v2-v0. 106 // 107 // Input: 108 // V: #Vx3 Vertices of the mesh 109 // F: #Fxe Faces of the mesh 110 // bc: #Xx3 Barycentric coordinates, one row per point 111 // 112 // Output: 113 // #X: #Xx3 3D coordinates of all points in bc)igl_Qu8mg5v7"; 114 115 const char *__doc_igl_bbw = R"igl_Qu8mg5v7(// Compute Bounded Biharmonic Weights on a given domain (V,Ele) with a given 116 // set of boundary conditions 117 // 118 // Templates 119 // DerivedV derived type of eigen matrix for V (e.g. MatrixXd) 120 // DerivedF derived type of eigen matrix for F (e.g. MatrixXi) 121 // Derivedb derived type of eigen matrix for b (e.g. VectorXi) 122 // Derivedbc derived type of eigen matrix for bc (e.g. MatrixXd) 123 // DerivedW derived type of eigen matrix for W (e.g. MatrixXd) 124 // Inputs: 125 // V #V by dim vertex positions 126 // Ele #Elements by simplex-size list of element indices 127 // b #b boundary indices into V 128 // bc #b by #W list of boundary values 129 // data object containing options, initial guess --> solution and results 130 // Outputs: 131 // W #V by #W list of *unnormalized* weights to normalize use 132 // igl::normalize_row_sums(W,W); 133 // Returns true on success, false on failure)igl_Qu8mg5v7"; 134 const char *__doc_igl_boundary_conditions = R"igl_Qu8mg5v7(// Compute boundary conditions for automatic weights computation. This 135 // function expects that the given mesh (V,Ele) has sufficient samples 136 // (vertices) exactly at point handle locations and exactly along bone and 137 // cage edges. 138 // 139 // Inputs: 140 // V #V by dim list of domain vertices 141 // Ele #Ele by simplex-size list of simplex indices 142 // C #C by dim list of handle positions 143 // P #P by 1 list of point handle indices into C 144 // BE #BE by 2 list of bone edge indices into C 145 // CE #CE by 2 list of cage edge indices into *P* 146 // Outputs: 147 // b #b list of boundary indices (indices into V of vertices which have 148 // known, fixed values) 149 // bc #b by #weights list of known/fixed values for boundary vertices 150 // (notice the #b != #weights in general because #b will include all the 151 // intermediary samples along each bone, etc.. The ordering of the 152 // weights corresponds to [P;BE] 153 // Returns false if boundary conditions are suspicious: 154 // P and BE are empty 155 // bc is empty 156 // some column of bc doesn't have a 0 (assuming bc has >1 columns) 157 // some column of bc doesn't have a 1 (assuming bc has >1 columns))igl_Qu8mg5v7"; 158 const char *__doc_igl_boundary_facets = R"igl_Qu8mg5v7(// BOUNDARY_FACETS Determine boundary faces (edges) of tetrahedra (triangles) 159 // stored in T (analogous to qptoolbox's `outline` and `boundary_faces`). 160 // 161 // Templates: 162 // IntegerT integer-value: e.g. int 163 // IntegerF integer-value: e.g. int 164 // Input: 165 // T tetrahedron (triangle) index list, m by 4 (3), where m is the number of tetrahedra 166 // Output: 167 // F list of boundary faces, n by 3 (2), where n is the number of boundary faces 168 // 169 //)igl_Qu8mg5v7"; 170 const char *__doc_igl_boundary_loop = R"igl_Qu8mg5v7(// Compute list of ordered boundary loops for a manifold mesh. 171 // 172 // Templates: 173 // Index index type 174 // Inputs: 175 // F #V by dim list of mesh faces 176 // Outputs: 177 // L list of loops where L[i] = ordered list of boundary vertices in loop i 178 //)igl_Qu8mg5v7"; 179 const char *__doc_igl_cat = R"igl_Qu8mg5v7(// Perform concatenation of a two matrices along a single dimension 180 // If dim == 1, then C = [A;B]. If dim == 2 then C = [A B] 181 // 182 // Template: 183 // Scalar scalar data type for sparse matrices like double or int 184 // Mat matrix type for all matrices (e.g. MatrixXd, SparseMatrix) 185 // MatC matrix type for output matrix (e.g. MatrixXd) needs to support 186 // resize 187 // Inputs: 188 // A first input matrix 189 // B second input matrix 190 // dim dimension along which to concatenate, 1 or 2 191 // Outputs: 192 // C output matrix 193 // )igl_Qu8mg5v7"; 194 const char *__doc_igl_collapse_edge = R"igl_Qu8mg5v7(See collapse_edge for the documentation.)igl_Qu8mg5v7"; 195 const char *__doc_igl_colon = R"igl_Qu8mg5v7(// Colon operator like matlab's colon operator. Enumerats values between low 196 // and hi with step step. 197 // Templates: 198 // L should be a eigen matrix primitive type like int or double 199 // S should be a eigen matrix primitive type like int or double 200 // H should be a eigen matrix primitive type like int or double 201 // T should be a eigen matrix primitive type like int or double 202 // Inputs: 203 // low starting value if step is valid then this is *always* the first 204 // element of I 205 // step step difference between sequential elements returned in I, 206 // remember this will be cast to template T at compile time. If low<hi 207 // then step must be positive. If low>hi then step must be negative. 208 // Otherwise I will be set to empty. 209 // hi ending value, if (hi-low)%step is zero then this will be the last 210 // element in I. If step is positive there will be no elements greater 211 // than hi, vice versa if hi<low 212 // Output: 213 // I list of values from low to hi with step size step)igl_Qu8mg5v7"; 214 const char *__doc_igl_column_to_quats = R"igl_Qu8mg5v7(// "Columnize" a list of quaternions (q1x,q1y,q1z,q1w,q2x,q2y,q2z,q2w,...) 215 // 216 // Inputs: 217 // Q n*4-long list of coefficients 218 // Outputs: 219 // vQ n-long list of quaternions 220 // Returns false if n%4!=0)igl_Qu8mg5v7"; 221 const char *__doc_igl_comb_cross_field = R"igl_Qu8mg5v7(// Inputs: 222 // V #V by 3 eigen Matrix of mesh vertex 3D positions 223 // F #F by 4 eigen Matrix of face (quad) indices 224 // PD1in #F by 3 eigen Matrix of the first per face cross field vector 225 // PD2in #F by 3 eigen Matrix of the second per face cross field vector 226 // Output: 227 // PD1out #F by 3 eigen Matrix of the first combed cross field vector 228 // PD2out #F by 3 eigen Matrix of the second combed cross field vector 229 //)igl_Qu8mg5v7"; 230 const char *__doc_igl_comb_frame_field = R"igl_Qu8mg5v7(// Inputs: 231 // V #V by 3 eigen Matrix of mesh vertex 3D positions 232 // F #F by 4 eigen Matrix of face (quad) indices 233 // PD1 #F by 3 eigen Matrix of the first per face cross field vector 234 // PD2 #F by 3 eigen Matrix of the second per face cross field vector 235 // BIS1_combed #F by 3 eigen Matrix of the first combed bisector field vector 236 // BIS2_combed #F by 3 eigen Matrix of the second combed bisector field vector 237 // Output: 238 // PD1_combed #F by 3 eigen Matrix of the first combed cross field vector 239 // PD2_combed #F by 3 eigen Matrix of the second combed cross field vector 240 //)igl_Qu8mg5v7"; 241 const char *__doc_igl_compute_frame_field_bisectors = R"igl_Qu8mg5v7(// Compute bisectors of a frame field defined on mesh faces 242 // Inputs: 243 // V #V by 3 eigen Matrix of mesh vertex 3D positions 244 // F #F by 3 eigen Matrix of face (triangle) indices 245 // B1 #F by 3 eigen Matrix of face (triangle) base vector 1 246 // B2 #F by 3 eigen Matrix of face (triangle) base vector 2 247 // PD1 #F by 3 eigen Matrix of the first per face frame field vector 248 // PD2 #F by 3 eigen Matrix of the second per face frame field vector 249 // Output: 250 // BIS1 #F by 3 eigen Matrix of the first per face frame field bisector 251 // BIS2 #F by 3 eigen Matrix of the second per face frame field bisector 252 //)igl_Qu8mg5v7"; 253 const char *__doc_igl_copyleft_cgal_mesh_boolean = R"igl_Qu8mg5v7(// MESH_BOOLEAN Compute boolean csg operations on "solid", consistently 254 // oriented meshes. 255 // 256 // Inputs: 257 // VA #VA by 3 list of vertex positions of first mesh 258 // FA #FA by 3 list of triangle indices into VA 259 // VB #VB by 3 list of vertex positions of second mesh 260 // FB #FB by 3 list of triangle indices into VB 261 // type type of boolean operation 262 // Outputs: 263 // VC #VC by 3 list of vertex positions of boolean result mesh 264 // FC #FC by 3 list of triangle indices into VC 265 // J #FC list of indices into [FA;FA.rows()+FB] revealing "birth" facet 266 // Returns true if inputs induce a piecewise constant winding number 267 // field and type is valid 268 // 269 // See also: mesh_boolean_cork, intersect_other, 270 // remesh_self_intersections)igl_Qu8mg5v7"; 271 const char *__doc_igl_copyleft_cgal_remesh_self_intersections = R"igl_Qu8mg5v7(// Given a triangle mesh (V,F) compute a new mesh (VV,FF) which is the same 272 // as (V,F) except that any self-intersecting triangles in (V,F) have been 273 // subdivided (new vertices and face created) so that the self-intersection 274 // contour lies exactly on edges in (VV,FF). New vertices will appear in 275 // original faces or on original edges. New vertices on edges are "merged" 276 // only across original faces sharing that edge. This means that if the input 277 // triangle mesh is a closed manifold the output will be too. 278 // 279 // Inputs: 280 // V #V by 3 list of vertex positions 281 // F #F by 3 list of triangle indices into V 282 // params struct of optional parameters 283 // Outputs: 284 // VV #VV by 3 list of vertex positions 285 // FF #FF by 3 list of triangle indices into VV 286 // IF #intersecting face pairs by 2 list of intersecting face pairs, 287 // indexing F 288 // J #FF list of indices into F denoting birth triangle 289 // IM #VV list of indices into VV of unique vertices. 290 // 291 // Known bugs: If an existing edge in (V,F) lies exactly on another face then 292 // any resulting additional vertices along that edge may not get properly 293 // connected so that the output mesh has the same global topology. This is 294 // because 295 // 296 // Example: 297 // // resolve intersections 298 // igl::copyleft::cgal::remesh_self_intersections(V,F,params,VV,FF,IF,J,IM); 299 // // _apply_ duplicate vertex mapping IM to FF 300 // for_each(FF.data(),FF.data()+FF.size(),[&IM](int & a){a=IM(a);}); 301 // // remove any vertices now unreferenced after duplicate mapping. 302 // igl::remove_unreferenced(VV,FF,SV,SF,UIM); 303 // // Now (SV,SF) is ready to extract outer hull 304 // igl::copyleft::cgal::outer_hull(SV,SF,G,J,flip); 305 //)igl_Qu8mg5v7"; 306 const char *__doc_igl_copyleft_comiso_miq = R"igl_Qu8mg5v7(// Inputs: 307 // V #V by 3 list of mesh vertex 3D positions 308 // F #F by 3 list of faces indices in V 309 // PD1 #V by 3 first line of the Jacobian per triangle 310 // PD2 #V by 3 second line of the Jacobian per triangle 311 // (optional, if empty it will be a vector in the tangent plane orthogonal to PD1) 312 // scale global scaling for the gradient (controls the quads resolution) 313 // stiffness weight for the stiffness iterations 314 // direct_round greedily round all integer variables at once (greatly improves optimization speed but lowers quality) 315 // iter stiffness iterations (0 = no stiffness) 316 // local_iter number of local iterations for the integer rounding 317 // do_round enables the integer rounding (disabling it could be useful for debugging) 318 // round_vertices id of additional vertices that should be snapped to integer coordinates 319 // hard_features #H by 2 list of pairs of vertices that belongs to edges that should be snapped to integer coordinates 320 // 321 // Output: 322 // UV #UV by 2 list of vertices in 2D 323 // FUV #FUV by 3 list of face indices in UV 324 // 325 // TODO: rename the parameters name in the cpp consistently 326 // improve the handling of hard_features, right now it might fail in difficult cases)igl_Qu8mg5v7"; 327 const char *__doc_igl_copyleft_comiso_nrosy = R"igl_Qu8mg5v7(// Generate a N-RoSy field from a sparse set of constraints 328 // 329 // Inputs: 330 // V #V by 3 list of mesh vertex coordinates 331 // F #F by 3 list of mesh faces (must be triangles) 332 // b #B by 1 list of constrained face indices 333 // bc #B by 3 list of representative vectors for the constrained 334 // faces 335 // b_soft #S by 1 b for soft constraints 336 // w_soft #S by 1 weight for the soft constraints (0-1) 337 // bc_soft #S by 3 bc for soft constraints 338 // N the degree of the N-RoSy vector field 339 // soft the strength of the soft constraints w.r.t. smoothness 340 // (0 -> smoothness only, 1->constraints only) 341 // Outputs: 342 // R #F by 3 the representative vectors of the interpolated field 343 // S #V by 1 the singularity index for each vertex (0 = regular))igl_Qu8mg5v7"; 344 const char *__doc_igl_copyleft_marching_cubes = R"igl_Qu8mg5v7(// marching_cubes( values, points, x_res, y_res, z_res, vertices, faces ) 345 // 346 // performs marching cubes reconstruction on the grid defined by values, and 347 // points, and generates vertices and faces 348 // 349 // Input: 350 // values #number_of_grid_points x 1 array -- the scalar values of an 351 // implicit function defined on the grid points (<0 in the inside of the 352 // surface, 0 on the border, >0 outside) 353 // points #number_of_grid_points x 3 array -- 3-D positions of the grid 354 // points, ordered in x,y,z order: 355 // points[index] = the point at (x,y,z) where : 356 // x = (index % (xres -1), 357 // y = (index / (xres-1)) %(yres-1), 358 // z = index / (xres -1) / (yres -1) ). 359 // where x,y,z index x, y, z dimensions 360 // i.e. index = x + y*xres + z*xres*yres 361 // xres resolutions of the grid in x dimension 362 // yres resolutions of the grid in y dimension 363 // zres resolutions of the grid in z dimension 364 // Output: 365 // vertices #V by 3 list of mesh vertex positions 366 // faces #F by 3 list of mesh triangle indices 367 //)igl_Qu8mg5v7"; 368 const char *__doc_igl_copyleft_swept_volume = R"igl_Qu8mg5v7(// Compute the surface of the swept volume of a solid object with surface 369 // (V,F) mesh under going rigid motion. 370 // 371 // Inputs: 372 // V #V by 3 list of mesh positions in reference pose 373 // F #F by 3 list of mesh indices into V 374 // transform function handle so that transform(t) returns the rigid 375 // transformation at time t∈[0,1] 376 // steps number of time steps: steps=3 --> t∈{0,0.5,1} 377 // grid_res number of grid cells on the longest side containing the 378 // motion (isolevel+1 cells will also be added on each side as padding) 379 // isolevel distance level to be contoured as swept volume 380 // Outputs: 381 // SV #SV by 3 list of mesh positions of the swept surface 382 // SF #SF by 3 list of mesh faces into SV)igl_Qu8mg5v7"; 383 const char *__doc_igl_copyleft_tetgen_tetrahedralize = R"igl_Qu8mg5v7(// Mesh the interior of a surface mesh (V,F) using tetgen 384 // 385 // Inputs: 386 // V #V by 3 vertex position list 387 // F #F list of polygon face indices into V (0-indexed) 388 // switches string of tetgen options (See tetgen documentation) e.g. 389 // "pq1.414a0.01" tries to mesh the interior of a given surface with 390 // quality and area constraints 391 // "" will mesh the convex hull constrained to pass through V (ignores F) 392 // Outputs: 393 // TV #V by 3 vertex position list 394 // TT #T by 4 list of tet face indices 395 // TF #F by 3 list of triangle face indices 396 // Returns status: 397 // 0 success 398 // 1 tetgen threw exception 399 // 2 tetgen did not crash but could not create any tets (probably there are 400 // holes, duplicate faces etc.) 401 // -1 other error)igl_Qu8mg5v7"; 402 const char *__doc_igl_cotmatrix = R"igl_Qu8mg5v7(// Constructs the cotangent stiffness matrix (discrete laplacian) for a given 403 // mesh (V,F). 404 // 405 // Templates: 406 // DerivedV derived type of eigen matrix for V (e.g. derived from 407 // MatrixXd) 408 // DerivedF derived type of eigen matrix for F (e.g. derived from 409 // MatrixXi) 410 // Scalar scalar type for eigen sparse matrix (e.g. double) 411 // Inputs: 412 // V #V by dim list of mesh vertex positions 413 // F #F by simplex_size list of mesh faces (must be triangles) 414 // Outputs: 415 // L #V by #V cotangent matrix, each row i corresponding to V(i,:) 416 // 417 // See also: adjacency_matrix 418 // 419 // Note: This Laplacian uses the convention that diagonal entries are 420 // **minus** the sum of off-diagonal entries. The diagonal entries are 421 // therefore in general negative and the matrix is **negative** semi-definite 422 // (immediately, -L is **positive** semi-definite) 423 //)igl_Qu8mg5v7"; 424 const char *__doc_igl_covariance_scatter_matrix = R"igl_Qu8mg5v7(// Construct the covariance scatter matrix for a given arap energy 425 // Inputs: 426 // V #V by Vdim list of initial domain positions 427 // F #F by 3 list of triangle indices into V 428 // energy ARAPEnergyType enum value defining which energy is being used. 429 // See ARAPEnergyType.h for valid options and explanations. 430 // Outputs: 431 // CSM dim*#V/#F by dim*#V sparse matrix containing special laplacians along 432 // the diagonal so that when multiplied by V gives covariance matrix 433 // elements, can be used to speed up covariance matrix computation)igl_Qu8mg5v7"; 434 const char *__doc_igl_cross_field_mismatch = R"igl_Qu8mg5v7(// Inputs: 435 // V #V by 3 eigen Matrix of mesh vertex 3D positions 436 // F #F by 3 eigen Matrix of face (quad) indices 437 // PD1 #F by 3 eigen Matrix of the first per face cross field vector 438 // PD2 #F by 3 eigen Matrix of the second per face cross field vector 439 // isCombed boolean, specifying whether the field is combed (i.e. matching has been precomputed. 440 // If not, the field is combed first. 441 // Output: 442 // Handle_MMatch #F by 3 eigen Matrix containing the integer mismatch of the cross field 443 // across all face edges 444 //)igl_Qu8mg5v7"; 445 const char *__doc_igl_cut_mesh_from_singularities = R"igl_Qu8mg5v7(// Given a mesh (V,F) and the integer mismatch of a cross field per edge 446 // (mismatch), finds the cut_graph connecting the singularities (seams) and the 447 // degree of the singularities singularity_index 448 // 449 // Input: 450 // V #V by 3 list of mesh vertex positions 451 // F #F by 3 list of faces 452 // mismatch #F by 3 list of per corner integer mismatch 453 // Outputs: 454 // seams #F by 3 list of per corner booleans that denotes if an edge is a 455 // seam or not 456 //)igl_Qu8mg5v7"; 457 const char *__doc_igl_deform_skeleton = R"igl_Qu8mg5v7(// Deform a skeleton. 458 // 459 // Inputs: 460 // C #C by 3 list of joint positions 461 // BE #BE by 2 list of bone edge indices 462 // vA #BE list of bone transformations 463 // Outputs 464 // CT #BE*2 by 3 list of deformed joint positions 465 // BET #BE by 2 list of bone edge indices (maintains order) 466 //)igl_Qu8mg5v7"; 467 const char *__doc_igl_directed_edge_orientations = R"igl_Qu8mg5v7(// Determine rotations that take each edge from the x-axis to its given rest 468 // orientation. 469 // 470 // Inputs: 471 // C #C by 3 list of edge vertex positions 472 // E #E by 2 list of directed edges 473 // Outputs: 474 // Q #E list of quaternions 475 //)igl_Qu8mg5v7"; 476 const char *__doc_igl_directed_edge_parents = R"igl_Qu8mg5v7(// Recover "parents" (preceding edges) in a tree given just directed edges. 477 // 478 // Inputs: 479 // E #E by 2 list of directed edges 480 // Outputs: 481 // P #E list of parent indices into E (-1) means root 482 //)igl_Qu8mg5v7"; 483 const char *__doc_igl_doublearea = R"igl_Qu8mg5v7(// DOUBLEAREA computes twice the area for each input triangle[quad] 484 // 485 // Templates: 486 // DerivedV derived type of eigen matrix for V (e.g. derived from 487 // MatrixXd) 488 // DerivedF derived type of eigen matrix for F (e.g. derived from 489 // MatrixXi) 490 // DeriveddblA derived type of eigen matrix for dblA (e.g. derived from 491 // MatrixXd) 492 // Inputs: 493 // V #V by dim list of mesh vertex positions 494 // F #F by simplex_size list of mesh faces (must be triangles or quads) 495 // Outputs: 496 // dblA #F list of triangle[quad] double areas (SIGNED only for 2D input) 497 // 498 // Known bug: For dim==3 complexity is O(#V + #F)!! Not just O(#F). This is a big deal 499 // if you have 1million unreferenced vertices and 1 face)igl_Qu8mg5v7"; 500 const char *__doc_igl_doublearea_single = R"igl_Qu8mg5v7(// Single triangle in 2D! 501 // 502 // This should handle streams of corners not just single corners)igl_Qu8mg5v7"; 503 const char *__doc_igl_doublearea_quad = R"igl_Qu8mg5v7(// DOUBLEAREA_QUAD computes twice the area for each input quadrilateral 504 // 505 // Inputs: 506 // V #V by dim list of mesh vertex positions 507 // F #F by simplex_size list of mesh faces (must be quadrilaterals) 508 // Outputs: 509 // dblA #F list of quadrilateral double areas 510 //)igl_Qu8mg5v7"; 511 const char *__doc_igl_dqs = R"igl_Qu8mg5v7(// Dual quaternion skinning 512 // 513 // Inputs: 514 // V #V by 3 list of rest positions 515 // W #W by #C list of weights 516 // vQ #C list of rotation quaternions 517 // vT #C list of translation vectors 518 // Outputs: 519 // U #V by 3 list of new positions)igl_Qu8mg5v7"; 520 const char *__doc_igl_edge_lengths = R"igl_Qu8mg5v7(// Constructs a list of lengths of edges opposite each index in a face 521 // (triangle/tet) list 522 // 523 // Templates: 524 // DerivedV derived from vertex positions matrix type: i.e. MatrixXd 525 // DerivedF derived from face indices matrix type: i.e. MatrixXi 526 // DerivedL derived from edge lengths matrix type: i.e. MatrixXd 527 // Inputs: 528 // V eigen matrix #V by 3 529 // F #F by 2 list of mesh edges 530 // or 531 // F #F by 3 list of mesh faces (must be triangles) 532 // or 533 // T #T by 4 list of mesh elements (must be tets) 534 // Outputs: 535 // L #F by {1|3|6} list of edge lengths 536 // for edges, column of lengths 537 // for triangles, columns correspond to edges [1,2],[2,0],[0,1] 538 // for tets, columns correspond to edges 539 // [3 0],[3 1],[3 2],[1 2],[2 0],[0 1] 540 //)igl_Qu8mg5v7"; 541 const char *__doc_igl_edge_topology = R"igl_Qu8mg5v7(// Initialize Edges and their topological relations (assumes an edge-manifold 542 // mesh) 543 // 544 // Output: 545 // EV : #Ex2, Stores the edge description as pair of indices to vertices 546 // FE : #Fx3, Stores the Triangle-Edge relation 547 // EF : #Ex2: Stores the Edge-Triangle relation 548 // 549 // TODO: This seems to be a inferior duplicate of edge_flaps.h: 550 // - unused input parameter V 551 // - roughly 2x slower than edge_flaps 552 // - outputs less information: edge_flaps reveals corner opposite edge 553 // - FE uses non-standard and ambiguous order: FE(f,c) is merely an edge 554 // incident on corner c of face f. In contrast, edge_flaps's EMAP(f,c) reveals 555 // the edge _opposite_ corner c of face f)igl_Qu8mg5v7"; 556 const char *__doc_igl_eigs = R"igl_Qu8mg5v7(See eigs for the documentation.)igl_Qu8mg5v7"; 557 const char *__doc_igl_embree_ambient_occlusion = R"igl_Qu8mg5v7(// Compute ambient occlusion per given point 558 // 559 // Inputs: 560 // ei EmbreeIntersector containing (V,F) 561 // P #P by 3 list of origin points 562 // N #P by 3 list of origin normals 563 // Outputs: 564 // S #P list of ambient occlusion values between 1 (fully occluded) and 565 // 0 (not occluded) 566 //)igl_Qu8mg5v7"; 567 const char *__doc_igl_embree_line_mesh_intersection = R"igl_Qu8mg5v7(// Project the point cloud V_source onto the triangle mesh 568 // V_target,F_target. 569 // A ray is casted for every vertex in the direction specified by 570 // N_source and its opposite. 571 // 572 // Input: 573 // V_source: #Vx3 Vertices of the source mesh 574 // N_source: #Vx3 Normals of the point cloud 575 // V_target: #V2x3 Vertices of the target mesh 576 // F_target: #F2x3 Faces of the target mesh 577 // 578 // Output: 579 // #Vx3 matrix of baricentric coordinate. Each row corresponds to 580 // a vertex of the projected mesh and it has the following format: 581 // id b1 b2. id is the id of a face of the source mesh. b1 and b2 are 582 // the barycentric coordinates wrt the first two edges of the triangle 583 // To convert to standard global coordinates, see barycentric_to_global.h)igl_Qu8mg5v7"; 584 const char *__doc_igl_embree_reorient_facets_raycast = R"igl_Qu8mg5v7(// Orient each component (identified by C) of a mesh (V,F) using ambient 585 // occlusion such that the front side is less occluded than back side, as 586 // described in "A Simple Method for Correcting Facet Orientations in 587 // Polygon Meshes Based on Ray Casting" [Takayama et al. 2014]. 588 // 589 // Inputs: 590 // V #V by 3 list of vertex positions 591 // F #F by 3 list of triangle indices 592 // rays_total Total number of rays that will be shot 593 // rays_minimum Minimum number of rays that each patch should receive 594 // facet_wise Decision made for each face independently, no use of patches 595 // (i.e., each face is treated as a patch) 596 // use_parity Use parity mode 597 // is_verbose Verbose output to cout 598 // Outputs: 599 // I #F list of whether face has been flipped 600 // C #F list of patch ID (output of bfs_orient > manifold patches))igl_Qu8mg5v7"; 601 const char *__doc_igl_exact_geodesic = R"igl_Qu8mg5v7( 602 // Exact geodesic algorithm for triangular mesh with the implementation from https://code.google.com/archive/p/geodesic/, 603 // and the algorithm first described by Mitchell, Mount and Papadimitriou in 1987 604 // 605 // Inputs: 606 // V #V by 3 list of 3D vertex positions 607 // F #F by 3 list of mesh faces 608 // VS #VS by 1 vector specifying indices of source vertices 609 // FS #FS by 1 vector specifying indices of source faces 610 // VT #VT by 1 vector specifying indices of target vertices 611 // FT #FT by 1 vector specifying indices of target faces 612 // Output: 613 // D #VT+#FT by 1 vector of geodesic distances of each target w.r.t. the nearest one in the source set 614 // 615 // Note: 616 // Specifying a face as target/source means its center. 617 //)igl_Qu8mg5v7"; 618 const char *__doc_igl_heat_geodesics_precompute = R"igl_Qu8mg5v7( 619 // Precompute factorized solvers for computing a fast approximation of 620 // geodesic distances on a mesh (V,F). [Crane et al. 2013] 621 // 622 // Inputs: 623 // V #V by dim list of mesh vertex positions 624 // F #F by 3 list of mesh face indices into V 625 // Outputs: 626 // data precomputation data (see heat_geodesics_solve) 627 //)igl_Qu8mg5v7"; 628 const char *__doc_igl_heat_geodesics_solve = R"igl_Qu8mg5v7( 629 // Compute fast approximate geodesic distances using precomputed data from a 630 // set of selected source vertices (gamma) 631 // 632 // Inputs: 633 // data precomputation data (see heat_geodesics_precompute) 634 // gamma #gamma list of indices into V of source vertices 635 // Outputs: 636 // D #V list of distances to gamma 637 //)igl_Qu8mg5v7"; 638 const char *__doc_igl_find_cross_field_singularities = R"igl_Qu8mg5v7(// Inputs: 639 // V #V by 3 eigen Matrix of mesh vertex 3D positions 640 // F #F by 3 eigen Matrix of face (quad) indices 641 // Handle_MMatch #F by 3 eigen Matrix containing the integer mismatch of the cross field 642 // across all face edges 643 // Output: 644 // isSingularity #V by 1 boolean eigen Vector indicating the presence of a singularity on a vertex 645 // singularityIndex #V by 1 integer eigen Vector containing the singularity indices 646 //)igl_Qu8mg5v7"; 647 const char *__doc_igl_fit_rotations = R"igl_Qu8mg5v7(// Known issues: This seems to be implemented in Eigen/Geometry: 648 // Eigen::umeyama 649 // 650 // FIT_ROTATIONS Given an input mesh and new positions find rotations for 651 // every covariance matrix in a stack of covariance matrices 652 // 653 // Inputs: 654 // S nr*dim by dim stack of covariance matrices 655 // single_precision whether to use single precision (faster) 656 // Outputs: 657 // R dim by dim * nr list of rotations 658 //)igl_Qu8mg5v7"; 659 const char *__doc_igl_fit_rotations_planar = R"igl_Qu8mg5v7(// FIT_ROTATIONS Given an input mesh and new positions find 2D rotations for 660 // every vertex that best maps its one ring to the new one ring 661 // 662 // Inputs: 663 // S nr*dim by dim stack of covariance matrices, third column and every 664 // third row will be ignored 665 // Outputs: 666 // R dim by dim * nr list of rotations, third row and third column of each 667 // rotation will just be identity 668 //)igl_Qu8mg5v7"; 669 const char *__doc_igl_fit_rotations_SSE = R"igl_Qu8mg5v7(See fit_rotations_SSE for the documentation.)igl_Qu8mg5v7"; 670 const char *__doc_igl_floor = R"igl_Qu8mg5v7(// Floor a given matrix to nearest integers 671 // 672 // Inputs: 673 // X m by n matrix of scalars 674 // Outputs: 675 // Y m by n matrix of floored integers)igl_Qu8mg5v7"; 676 const char *__doc_igl_forward_kinematics = R"igl_Qu8mg5v7(// Given a skeleton and a set of relative bone rotations compute absolute 677 // rigid transformations for each bone. 678 // 679 // Inputs: 680 // C #C by dim list of joint positions 681 // BE #BE by 2 list of bone edge indices 682 // P #BE list of parent indices into BE 683 // dQ #BE list of relative rotations 684 // dT #BE list of relative translations 685 // Outputs: 686 // vQ #BE list of absolute rotations 687 // vT #BE list of absolute translations)igl_Qu8mg5v7"; 688 const char *__doc_igl_gaussian_curvature = R"igl_Qu8mg5v7(// Compute discrete local integral gaussian curvature (angle deficit, without 689 // averaging by local area). 690 // 691 // Inputs: 692 // V #V by 3 eigen Matrix of mesh vertex 3D positions 693 // F #F by 3 eigen Matrix of face (triangle) indices 694 // Output: 695 // K #V by 1 eigen Matrix of discrete gaussian curvature values 696 //)igl_Qu8mg5v7"; 697 const char *__doc_igl_get_seconds = R"igl_Qu8mg5v7(// Return the current time in seconds since program start 698 // 699 // Example: 700 // const auto & tictoc = []() 701 // { 702 // static double t_start = igl::get_seconds(); 703 // double diff = igl::get_seconds()-t_start; 704 // t_start += diff; 705 // return diff; 706 // }; 707 // tictoc(); 708 // ... // part 1 709 // cout<<"part 1: "<<tictoc()<<endl; 710 // ... // part 2 711 // cout<<"part 2: "<<tictoc()<<endl; 712 // ... // etc)igl_Qu8mg5v7"; 713 const char *__doc_igl_grad = R"igl_Qu8mg5v7(// Gradient of a scalar function defined on piecewise linear elements (mesh) 714 // is constant on each triangle [tetrahedron] i,j,k: 715 // grad(Xijk) = (Xj-Xi) * (Vi - Vk)^R90 / 2A + (Xk-Xi) * (Vj - Vi)^R90 / 2A 716 // where Xi is the scalar value at vertex i, Vi is the 3D position of vertex 717 // i, and A is the area of triangle (i,j,k). ^R90 represent a rotation of 718 // 90 degrees 719 //)igl_Qu8mg5v7"; 720 const char *__doc_igl_harmonic = R"igl_Qu8mg5v7(// Compute k-harmonic weight functions "coordinates". 721 // 722 // 723 // Inputs: 724 // V #V by dim vertex positions 725 // F #F by simplex-size list of element indices 726 // b #b boundary indices into V 727 // bc #b by #W list of boundary values 728 // k power of harmonic operation (1: harmonic, 2: biharmonic, etc) 729 // Outputs: 730 // W #V by #W list of weights 731 //)igl_Qu8mg5v7"; 732 const char *__doc_igl_hsv_to_rgb = R"igl_Qu8mg5v7(// Convert RGB to HSV 733 // 734 // Inputs: 735 // h hue value (degrees: [0,360]) 736 // s saturation value ([0,1]) 737 // v value value ([0,1]) 738 // Outputs: 739 // r red value ([0,1]) 740 // g green value ([0,1]) 741 // b blue value ([0,1]))igl_Qu8mg5v7"; 742 const char *__doc_igl_internal_angles = R"igl_Qu8mg5v7(// Compute internal angles for a triangle mesh 743 // 744 // Inputs: 745 // V #V by dim eigen Matrix of mesh vertex nD positions 746 // F #F by poly-size eigen Matrix of face (triangle) indices 747 // Output: 748 // K #F by poly-size eigen Matrix of internal angles 749 // for triangles, columns correspond to edges [1,2],[2,0],[0,1] 750 // 751 // Known Issues: 752 // if poly-size ≠ 3 then dim must equal 3.)igl_Qu8mg5v7"; 753 const char *__doc_igl_internal_angles_using_squared_edge_lengths = R"igl_Qu8mg5v7(// Inputs: 754 // L_sq #F by 3 list of squared edge lengths 755 // Output: 756 // K #F by poly-size eigen Matrix of internal angles 757 // for triangles, columns correspond to edges [1,2],[2,0],[0,1] 758 // 759 // Note: 760 // Usage of internal_angles_using_squared_edge_lengths is preferred to internal_angles_using_squared_edge_lengths)igl_Qu8mg5v7"; 761 const char *__doc_igl_internal_angles_using_edge_lengths = R"igl_Qu8mg5v7(// Inputs: 762 // L #F by 3 list of edge lengths 763 // Output: 764 // K #F by poly-size eigen Matrix of internal angles 765 // for triangles, columns correspond to edges [1,2],[2,0],[0,1] 766 // 767 // Note: 768 // Usage of internal_angles_using_squared_edge_lengths is preferred to internal_angles_using_squared_edge_lengths 769 // This function is deprecated and probably will be removed in future versions)igl_Qu8mg5v7"; 770 const char *__doc_igl_invert_diag = R"igl_Qu8mg5v7(// Templates: 771 // T should be a eigen sparse matrix primitive type like int or double 772 // Inputs: 773 // X an m by n sparse matrix 774 // Outputs: 775 // Y an m by n sparse matrix)igl_Qu8mg5v7"; 776 const char *__doc_igl_is_irregular_vertex = R"igl_Qu8mg5v7(// Determine if a vertex is irregular, i.e. it has more than 6 (triangles) 777 // or 4 (quads) incident edges. Vertices on the boundary are ignored. 778 // 779 // Inputs: 780 // V #V by dim list of vertex positions 781 // F #F by 3[4] list of triangle[quads] indices 782 // Returns #V vector of bools revealing whether vertices are singular 783 //)igl_Qu8mg5v7"; 784 const char *__doc_igl_jet = R"igl_Qu8mg5v7(// JET like MATLAB's jet 785 // 786 // Inputs: 787 // m number of colors 788 // Outputs: 789 // J m by list of RGB colors between 0 and 1 790 // 791 //#ifndef IGL_NO_EIGEN 792 // void jet(const int m, Eigen::MatrixXd & J); 793 //#endif 794 // Wrapper for directly computing [r,g,b] values for a given factor f between 795 // 0 and 1 796 // 797 // Inputs: 798 // f factor determining color value as if 0 was min and 1 was max 799 // Outputs: 800 // r red value 801 // g green value 802 // b blue value)igl_Qu8mg5v7"; 803 const char *__doc_igl_lbs_matrix = R"igl_Qu8mg5v7(// LBS_MATRIX Linear blend skinning can be expressed by V' = M * T where V' is 804 // a #V by dim matrix of deformed vertex positions (one vertex per row), M is a 805 // #V by (dim+1)*#T (composed of weights and rest positions) and T is a 806 // #T*(dim+1) by dim matrix of #T stacked transposed transformation matrices. 807 // See equations (1) and (2) in "Fast Automatic Skinning Transformations" 808 // [Jacobson et al 2012] 809 // 810 // Inputs: 811 // V #V by dim list of rest positions 812 // W #V+ by #T list of weights 813 // Outputs: 814 // M #V by #T*(dim+1) 815 // 816 // In MATLAB: 817 // kron(ones(1,size(W,2)),[V ones(size(V,1),1)]).*kron(W,ones(1,size(V,2)+1)))igl_Qu8mg5v7"; 818 const char *__doc_igl_lbs_matrix_column = R"igl_Qu8mg5v7(// LBS_MATRIX construct a matrix that when multiplied against a column of 819 // affine transformation entries computes new coordinates of the vertices 820 // 821 // I'm not sure it makes since that the result is stored as a sparse matrix. 822 // The number of non-zeros per row *is* dependent on the number of mesh 823 // vertices and handles. 824 // 825 // Inputs: 826 // V #V by dim list of vertex rest positions 827 // W #V by #handles list of correspondence weights 828 // Output: 829 // M #V * dim by #handles * dim * (dim+1) matrix such that 830 // new_V(:) = LBS(V,W,A) = reshape(M * A,size(V)), where A is a column 831 // vectors formed by the entries in each handle's dim by dim+1 832 // transformation matrix. Specifcally, A = 833 // reshape(permute(Astack,[3 1 2]),n*dim*(dim+1),1) 834 // or A = [Lxx;Lyx;Lxy;Lyy;tx;ty], and likewise for other dim 835 // if Astack(:,:,i) is the dim by (dim+1) transformation at handle i)igl_Qu8mg5v7"; 836 const char *__doc_igl_local_basis = R"igl_Qu8mg5v7(// Compute a local orthogonal reference system for each triangle in the given mesh 837 // Templates: 838 // DerivedV derived from vertex positions matrix type: i.e. MatrixXd 839 // DerivedF derived from face indices matrix type: i.e. MatrixXi 840 // Inputs: 841 // V eigen matrix #V by 3 842 // F #F by 3 list of mesh faces (must be triangles) 843 // Outputs: 844 // B1 eigen matrix #F by 3, each vector is tangent to the triangle 845 // B2 eigen matrix #F by 3, each vector is tangent to the triangle and perpendicular to B1 846 // B3 eigen matrix #F by 3, normal of the triangle 847 // 848 // See also: adjacency_matrix)igl_Qu8mg5v7"; 849 const char *__doc_igl_lscm = R"igl_Qu8mg5v7(// Compute a Least-squares conformal map parametrization (equivalently 850 // derived in "Intrinsic Parameterizations of Surface Meshes" [Desbrun et al. 851 // 2002] and "Least Squares Conformal Maps for Automatic Texture Atlas 852 // Generation" [Lévy et al. 2002]), though this implementation follows the 853 // derivation in: "Spectral Conformal Parameterization" [Mullen et al. 2008] 854 // (note, this does **not** implement the Eigen-decomposition based method in 855 // [Mullen et al. 2008], which is not equivalent). Input should be a manifold 856 // mesh (also no unreferenced vertices) and "boundary" (fixed vertices) `b` 857 // should contain at least two vertices per connected component. 858 // 859 // Inputs: 860 // V #V by 3 list of mesh vertex positions 861 // F #F by 3 list of mesh faces (must be triangles) 862 // b #b boundary indices into V 863 // bc #b by 3 list of boundary values 864 // Outputs: 865 // UV #V by 2 list of 2D mesh vertex positions in UV space 866 // Returns true only on solver success. 867 //)igl_Qu8mg5v7"; 868 const char *__doc_igl_map_vertices_to_circle = R"igl_Qu8mg5v7(// Map the vertices whose indices are in a given boundary loop (bnd) on the 869 // unit circle with spacing proportional to the original boundary edge 870 // lengths. 871 // 872 // Inputs: 873 // V #V by dim list of mesh vertex positions 874 // b #W list of vertex ids 875 // Outputs: 876 // UV #W by 2 list of 2D position on the unit circle for the vertices in b)igl_Qu8mg5v7"; 877 const char *__doc_igl_massmatrix = R"igl_Qu8mg5v7(// Constructs the mass (area) matrix for a given mesh (V,F). 878 // 879 // Templates: 880 // DerivedV derived type of eigen matrix for V (e.g. derived from 881 // MatrixXd) 882 // DerivedF derived type of eigen matrix for F (e.g. derived from 883 // MatrixXi) 884 // Scalar scalar type for eigen sparse matrix (e.g. double) 885 // Inputs: 886 // V #V by dim list of mesh vertex positions 887 // F #F by simplex_size list of mesh faces (must be triangles) 888 // type one of the following ints: 889 // MASSMATRIX_TYPE_BARYCENTRIC barycentric 890 // MASSMATRIX_TYPE_VORONOI voronoi-hybrid {default} 891 // MASSMATRIX_TYPE_FULL full {not implemented} 892 // Outputs: 893 // M #V by #V mass matrix 894 // 895 // See also: adjacency_matrix 896 //)igl_Qu8mg5v7"; 897 const char *__doc_igl_min_quad_with_fixed_precompute = R"igl_Qu8mg5v7(// Known Bugs: rows of Aeq **should probably** be linearly independent. 898 // During precomputation, the rows of a Aeq are checked via QR. But in case 899 // they're not then resulting probably will no longer be sparse: it will be 900 // slow. 901 // 902 // MIN_QUAD_WITH_FIXED Minimize a quadratic energy of the form 903 // 904 // trace( 0.5*Z'*A*Z + Z'*B + constant ) 905 // 906 // subject to 907 // 908 // Z(known,:) = Y, and 909 // Aeq*Z = Beq 910 // 911 // Templates: 912 // T should be a eigen matrix primitive type like int or double 913 // Inputs: 914 // A n by n matrix of quadratic coefficients 915 // known list of indices to known rows in Z 916 // Y list of fixed values corresponding to known rows in Z 917 // Aeq m by n list of linear equality constraint coefficients 918 // pd flag specifying whether A(unknown,unknown) is positive definite 919 // Outputs: 920 // data factorization struct with all necessary information to solve 921 // using min_quad_with_fixed_solve 922 // Returns true on success, false on error 923 // 924 // Benchmark: For a harmonic solve on a mesh with 325K facets, matlab 2.2 925 // secs, igl/min_quad_with_fixed.h 7.1 secs 926 //)igl_Qu8mg5v7"; 927 const char *__doc_igl_min_quad_with_fixed_solve = R"igl_Qu8mg5v7(// Solves a system previously factored using min_quad_with_fixed_precompute 928 // 929 // Template: 930 // T type of sparse matrix (e.g. double) 931 // DerivedY type of Y (e.g. derived from VectorXd or MatrixXd) 932 // DerivedZ type of Z (e.g. derived from VectorXd or MatrixXd) 933 // Inputs: 934 // data factorization struct with all necessary precomputation to solve 935 // B n by k column of linear coefficients 936 // Y b by k list of constant fixed values 937 // Beq m by k list of linear equality constraint constant values 938 // Outputs: 939 // Z n by k solution 940 // sol #unknowns+#lagrange by k solution to linear system 941 // Returns true on success, false on error)igl_Qu8mg5v7"; 942 const char *__doc_igl_min_quad_with_fixed = R"igl_Qu8mg5v7(See min_quad_with_fixed for the documentation.)igl_Qu8mg5v7"; 943 const char *__doc_igl_normalize_row_lengths = R"igl_Qu8mg5v7(// Obsolete: just use A.rowwise().normalize() or B=A.rowwise().normalized(); 944 // 945 // Normalize the rows in A so that their lengths are each 1 and place the new 946 // entries in B 947 // Inputs: 948 // A #rows by k input matrix 949 // Outputs: 950 // B #rows by k input matrix, can be the same as A)igl_Qu8mg5v7"; 951 const char *__doc_igl_normalize_row_sums = R"igl_Qu8mg5v7(// Normalize the rows in A so that their sums are each 1 and place the new 952 // entries in B 953 // Inputs: 954 // A #rows by k input matrix 955 // Outputs: 956 // B #rows by k input matrix, can be the same as A 957 // 958 // Note: This is just calling an Eigen one-liner.)igl_Qu8mg5v7"; 959 const char *__doc_igl_parula = R"igl_Qu8mg5v7(// PARULA like MATLAB's parula 960 // 961 // Inputs: 962 // m number of colors 963 // Outputs: 964 // J m by list of RGB colors between 0 and 1 965 // 966 // Wrapper for directly computing [r,g,b] values for a given factor f between 967 // 0 and 1 968 // 969 // Inputs: 970 // f factor determining color value as if 0 was min and 1 was max 971 // Outputs: 972 // r red value 973 // g green value 974 // b blue value)igl_Qu8mg5v7"; 975 const char *__doc_igl_per_corner_normals = R"igl_Qu8mg5v7(// Compute vertex normals via vertex position list, face list 976 // Inputs: 977 // V #V by 3 eigen Matrix of mesh vertex 3D positions 978 // F #F by 3 eigne Matrix of face (triangle) indices 979 // corner_threshold threshold in degrees on sharp angles 980 // Output: 981 // CN #F*3 by 3 eigen Matrix of mesh vertex 3D normals, where the normal 982 // for corner F(i,j) is at CN(i*3+j,:) )igl_Qu8mg5v7"; 983 const char *__doc_igl_per_edge_normals = R"igl_Qu8mg5v7(// Compute face normals via vertex position list, face list 984 // Inputs: 985 // V #V by 3 eigen Matrix of mesh vertex 3D positions 986 // F #F by 3 eigen Matrix of face (triangle) indices 987 // weight weighting type 988 // FN #F by 3 matrix of 3D face normals per face 989 // Output: 990 // N #2 by 3 matrix of mesh edge 3D normals per row 991 // E #E by 2 matrix of edge indices per row 992 // EMAP #E by 1 matrix of indices from all edges to E 993 //)igl_Qu8mg5v7"; 994 const char *__doc_igl_per_face_normals = R"igl_Qu8mg5v7(// Compute face normals via vertex position list, face list 995 // Inputs: 996 // V #V by 3 eigen Matrix of mesh vertex 3D positions 997 // F #F by 3 eigen Matrix of face (triangle) indices 998 // Z 3 vector normal given to faces with degenerate normal. 999 // Output: 1000 // N #F by 3 eigen Matrix of mesh face (triangle) 3D normals 1001 // 1002 // Example: 1003 // // Give degenerate faces (1/3,1/3,1/3)^0.5 1004 // per_face_normals(V,F,Vector3d(1,1,1).normalized(),N);)igl_Qu8mg5v7"; 1005 const char *__doc_igl_per_face_normals_stable = R"igl_Qu8mg5v7(// Special version where order of face indices is guaranteed not to effect 1006 // output.)igl_Qu8mg5v7"; 1007 const char *__doc_igl_per_vertex_normals = R"igl_Qu8mg5v7(// Compute vertex normals via vertex position list, face list 1008 // Inputs: 1009 // V #V by 3 eigen Matrix of mesh vertex 3D positions 1010 // F #F by 3 eigne Matrix of face (triangle) indices 1011 // weighting Weighting type 1012 // Output: 1013 // N #V by 3 eigen Matrix of mesh vertex 3D normals)igl_Qu8mg5v7"; 1014 const char *__doc_igl_planarize_quad_mesh = R"igl_Qu8mg5v7(// Inputs: 1015 // Vin #V by 3 eigen Matrix of mesh vertex 3D positions 1016 // F #F by 4 eigen Matrix of face (quad) indices 1017 // maxIter maximum numbers of iterations 1018 // threshold minimum allowed threshold for non-planarity 1019 // Output: 1020 // Vout #V by 3 eigen Matrix of planar mesh vertex 3D positions 1021 //)igl_Qu8mg5v7"; 1022 const char *__doc_igl_png_readPNG = R"igl_Qu8mg5v7(// Read an image from a .png file into 4 memory buffers 1023 // 1024 // Input: 1025 // png_file path to .png file 1026 // Output: 1027 // R,G,B,A texture channels 1028 // Returns true on success, false on failure 1029 //)igl_Qu8mg5v7"; 1030 const char *__doc_igl_png_writePNG = R"igl_Qu8mg5v7(// Writes an image to a png file 1031 // 1032 // Input: 1033 // R,G,B,A texture channels 1034 // Output: 1035 // png_file path to .png file 1036 // Returns true on success, false on failure 1037 //)igl_Qu8mg5v7"; 1038 const char *__doc_igl_point_mesh_squared_distance = R"igl_Qu8mg5v7(// Compute distances from a set of points P to a triangle mesh (V,F) 1039 // 1040 // Inputs: 1041 // P #P by 3 list of query point positions 1042 // V #V by 3 list of vertex positions 1043 // Ele #Ele by (3|2|1) list of (triangle|edge|point) indices 1044 // Outputs: 1045 // sqrD #P list of smallest squared distances 1046 // I #P list of primitive indices corresponding to smallest distances 1047 // C #P by 3 list of closest points 1048 // 1049 // Known bugs: This only computes distances to given primitivess. So 1050 // unreferenced vertices are ignored. However, degenerate primitives are 1051 // handled correctly: triangle [1 2 2] is treated as a segment [1 2], and 1052 // triangle [1 1 1] is treated as a point. So one _could_ add extra 1053 // combinatorially degenerate rows to Ele for all unreferenced vertices to 1054 // also get distances to points.)igl_Qu8mg5v7"; 1055 const char *__doc_igl_polar_svd = R"igl_Qu8mg5v7(// Computes the polar decomposition (R,T) of a matrix A using SVD singular 1056 // value decomposition 1057 // 1058 // Inputs: 1059 // A 3 by 3 matrix to be decomposed 1060 // Outputs: 1061 // R 3 by 3 rotation matrix part of decomposition (**always rotataion**) 1062 // T 3 by 3 stretch matrix part of decomposition 1063 // U 3 by 3 left-singular vectors 1064 // S 3 by 1 singular values 1065 // V 3 by 3 right-singular vectors 1066 // 1067 //)igl_Qu8mg5v7"; 1068 const char *__doc_igl_principal_curvature = R"igl_Qu8mg5v7(// Compute the principal curvature directions and magnitude of the given triangle mesh 1069 // DerivedV derived from vertex positions matrix type: i.e. MatrixXd 1070 // DerivedF derived from face indices matrix type: i.e. MatrixXi 1071 // Inputs: 1072 // V eigen matrix #V by 3 1073 // F #F by 3 list of mesh faces (must be triangles) 1074 // radius controls the size of the neighbourhood used, 1 = average edge length 1075 // 1076 // Outputs: 1077 // PD1 #V by 3 maximal curvature direction for each vertex. 1078 // PD2 #V by 3 minimal curvature direction for each vertex. 1079 // PV1 #V by 1 maximal curvature value for each vertex. 1080 // PV2 #V by 1 minimal curvature value for each vertex. 1081 // 1082 // See also: average_onto_faces, average_onto_vertices 1083 // 1084 // This function has been developed by: Nikolas De Giorgis, Luigi Rocca and Enrico Puppo. 1085 // The algorithm is based on: 1086 // Efficient Multi-scale Curvature and Crease Estimation 1087 // Daniele Panozzo, Enrico Puppo, Luigi Rocca 1088 // GraVisMa, 2010)igl_Qu8mg5v7"; 1089 const char *__doc_igl_quad_planarity = R"igl_Qu8mg5v7(// Compute planarity of the faces of a quad mesh 1090 // Inputs: 1091 // V #V by 3 eigen Matrix of mesh vertex 3D positions 1092 // F #F by 4 eigen Matrix of face (quad) indices 1093 // Output: 1094 // P #F by 1 eigen Matrix of mesh face (quad) planarities 1095 //)igl_Qu8mg5v7"; 1096 const char *__doc_igl_randperm = R"igl_Qu8mg5v7(// Like matlab's randperm(n) but minus 1 1097 // 1098 // Inputs: 1099 // n number of elements 1100 // Outputs: 1101 // I n list of rand permutation of 0:n-1)igl_Qu8mg5v7"; 1102 const char *__doc_igl_readDMAT = R"igl_Qu8mg5v7(See readDMAT for the documentation.)igl_Qu8mg5v7"; 1103 const char *__doc_igl_readMESH = R"igl_Qu8mg5v7(// load a tetrahedral volume mesh from a .mesh file 1104 // 1105 // Templates: 1106 // Scalar type for positions and vectors (will be read as double and cast 1107 // to Scalar) 1108 // Index type for indices (will be read as int and cast to Index) 1109 // Input: 1110 // mesh_file_name path of .mesh file 1111 // Outputs: 1112 // V double matrix of vertex positions #V by 3 1113 // T #T list of tet indices into vertex positions 1114 // F #F list of face indices into vertex positions 1115 // 1116 // Known bugs: Holes and regions are not supported)igl_Qu8mg5v7"; 1117 const char *__doc_igl_readOBJ = R"igl_Qu8mg5v7(// Read a mesh from an ascii obj file, filling in vertex positions, normals 1118 // and texture coordinates. Mesh may have faces of any number of degree 1119 // 1120 // Templates: 1121 // Scalar type for positions and vectors (will be read as double and cast 1122 // to Scalar) 1123 // Index type for indices (will be read as int and cast to Index) 1124 // Inputs: 1125 // str path to .obj file 1126 // Outputs: 1127 // V double matrix of vertex positions #V by 3 1128 // TC double matrix of texture coordinats #TC by 2 1129 // N double matrix of corner normals #N by 3 1130 // F #F list of face indices into vertex positions 1131 // FTC #F list of face indices into vertex texture coordinates 1132 // FN #F list of face indices into vertex normals 1133 // Returns true on success, false on errors)igl_Qu8mg5v7"; 1134 const char *__doc_igl_readOFF = R"igl_Qu8mg5v7(// Read a mesh from an ascii OFF file, filling in vertex positions, normals 1135 // and texture coordinates. Mesh may have faces of any number of degree 1136 // 1137 // Templates: 1138 // Scalar type for positions and vectors (will be read as double and cast 1139 // to Scalar) 1140 // Index type for indices (will be read as int and cast to Index) 1141 // Inputs: 1142 // str path to .obj file 1143 // Outputs: 1144 // V double matrix of vertex positions #V by 3 1145 // F #F list of face indices into vertex positions 1146 // N list of vertex normals #V by 3 1147 // C list of rgb color values per vertex #V by 3 1148 // Returns true on success, false on errors)igl_Qu8mg5v7"; 1149 const char *__doc_igl_readTGF = R"igl_Qu8mg5v7(// READTGF 1150 // 1151 // [V,E,P,BE,CE,PE] = readTGF(filename) 1152 // 1153 // Read a graph from a .tgf file 1154 // 1155 // Input: 1156 // filename .tgf file name 1157 // Output: 1158 // V # vertices by 3 list of vertex positions 1159 // E # edges by 2 list of edge indices 1160 // P # point-handles list of point handle indices 1161 // BE # bone-edges by 2 list of bone-edge indices 1162 // CE # cage-edges by 2 list of cage-edge indices 1163 // PE # pseudo-edges by 2 list of pseudo-edge indices 1164 // 1165 // Assumes that graph vertices are 3 dimensional)igl_Qu8mg5v7"; 1166 const char *__doc_igl_read_triangle_mesh = R"igl_Qu8mg5v7(// read mesh from an ascii file with automatic detection of file format. 1167 // supported: obj, off, stl, wrl, ply, mesh) 1168 // 1169 // Templates: 1170 // Scalar type for positions and vectors (will be read as double and cast 1171 // to Scalar) 1172 // Index type for indices (will be read as int and cast to Index) 1173 // Inputs: 1174 // str path to file 1175 // Outputs: 1176 // V eigen double matrix #V by 3 1177 // F eigen int matrix #F by 3 1178 // Returns true iff success)igl_Qu8mg5v7"; 1179 const char *__doc_igl_remove_duplicate_vertices = R"igl_Qu8mg5v7(// REMOVE_DUPLICATE_VERTICES Remove duplicate vertices upto a uniqueness 1180 // tolerance (epsilon) 1181 // 1182 // Inputs: 1183 // V #V by dim list of vertex positions 1184 // epsilon uniqueness tolerance (significant digit), can probably think of 1185 // this as a tolerance on L1 distance 1186 // Outputs: 1187 // SV #SV by dim new list of vertex positions 1188 // SVI #V by 1 list of indices so SV = V(SVI,:) 1189 // SVJ #SV by 1 list of indices so V = SV(SVJ,:) 1190 // 1191 // Example: 1192 // % Mesh in (V,F) 1193 // [SV,SVI,SVJ] = remove_duplicate_vertices(V,1e-7); 1194 // % remap faces 1195 // SF = SVJ(F); 1196 //)igl_Qu8mg5v7"; 1197 const char *__doc_igl_rotate_vectors = R"igl_Qu8mg5v7(// Rotate the vectors V by A radiants on the tangent plane spanned by B1 and 1198 // B2 1199 // 1200 // Inputs: 1201 // V #V by 3 eigen Matrix of vectors 1202 // A #V eigen vector of rotation angles or a single angle to be applied 1203 // to all vectors 1204 // B1 #V by 3 eigen Matrix of base vector 1 1205 // B2 #V by 3 eigen Matrix of base vector 2 1206 // 1207 // Output: 1208 // Returns the rotated vectors 1209 //)igl_Qu8mg5v7"; 1210 const char *__doc_igl_setdiff = R"igl_Qu8mg5v7(// Set difference of elements of matrices 1211 // 1212 // Inputs: 1213 // A m-long vector of indices 1214 // B n-long vector of indices 1215 // Outputs: 1216 // C (k<=m)-long vector of unique elements appearing in A but not in B 1217 // IA (k<=m)-long list of indices into A so that C = A(IA) 1218 //)igl_Qu8mg5v7"; 1219 const char *__doc_igl_shape_diameter_function = R"igl_Qu8mg5v7(// Compute shape diamater function per given point. In the parlence of the 1220 // paper "Consistent Mesh Partitioning and Skeletonisation using the Shape 1221 // Diameter Function" [Shapiro et al. 2008], this implementation uses a 180° 1222 // cone and a _uniform_ average (_not_ a average weighted by inverse angles). 1223 // 1224 // Inputs: 1225 // shoot_ray function handle that outputs hits of a given ray against a 1226 // mesh (embedded in function handles as captured variable/data) 1227 // P #P by 3 list of origin points 1228 // N #P by 3 list of origin normals 1229 // Outputs: 1230 // S #P list of shape diamater function values between bounding box 1231 // diagonal (perfect sphere) and 0 (perfect needle hook) 1232 //)igl_Qu8mg5v7"; 1233 const char *__doc_igl_signed_distance = R"igl_Qu8mg5v7(// Computes signed distance to a mesh 1234 // 1235 // Inputs: 1236 // P #P by 3 list of query point positions 1237 // V #V by 3 list of vertex positions 1238 // F #F by ss list of triangle indices, ss should be 3 unless sign_type == 1239 // SIGNED_DISTANCE_TYPE_UNSIGNED 1240 // sign_type method for computing distance _sign_ S 1241 // Outputs: 1242 // S #P list of smallest signed distances 1243 // I #P list of facet indices corresponding to smallest distances 1244 // C #P by 3 list of closest points 1245 // N #P by 3 list of closest normals (only set if 1246 // sign_type=SIGNED_DISTANCE_TYPE_PSEUDONORMAL) 1247 // 1248 // Known bugs: This only computes distances to triangles. So unreferenced 1249 // vertices and degenerate triangles are ignored.)igl_Qu8mg5v7"; 1250 const char *__doc_igl_signed_distance_pseudonormal = R"igl_Qu8mg5v7(// Computes signed distance to mesh 1251 // 1252 // Inputs: 1253 // tree AABB acceleration tree (see AABB.h) 1254 // F #F by 3 list of triangle indices 1255 // FN #F by 3 list of triangle normals 1256 // VN #V by 3 list of vertex normals (ANGLE WEIGHTING) 1257 // EN #E by 3 list of edge normals (UNIFORM WEIGHTING) 1258 // EMAP #F*3 mapping edges in F to E 1259 // q Query point 1260 // Returns signed distance to mesh 1261 //)igl_Qu8mg5v7"; 1262 const char *__doc_igl_signed_distance_winding_number = R"igl_Qu8mg5v7(// Inputs: 1263 // tree AABB acceleration tree (see cgal/point_mesh_squared_distance.h) 1264 // hier Winding number evaluation hierarchy 1265 // q Query point 1266 // Returns signed distance to mesh)igl_Qu8mg5v7"; 1267 const char *__doc_igl_slice = R"igl_Qu8mg5v7(// Act like the matlab X(row_indices,col_indices) operator, where 1268 // row_indices, col_indices are non-negative integer indices. 1269 // 1270 // Inputs: 1271 // X m by n matrix 1272 // R list of row indices 1273 // C list of column indices 1274 // Output: 1275 // Y #R by #C matrix 1276 // 1277 // See also: slice_mask)igl_Qu8mg5v7"; 1278 const char *__doc_igl_slice_into = R"igl_Qu8mg5v7(// Act like the matlab Y(row_indices,col_indices) = X 1279 // 1280 // Inputs: 1281 // X xm by xn rhs matrix 1282 // R list of row indices 1283 // C list of column indices 1284 // Y ym by yn lhs matrix 1285 // Output: 1286 // Y ym by yn lhs matrix, same as input but Y(R,C) = X)igl_Qu8mg5v7"; 1287 const char *__doc_igl_slice_mask = R"igl_Qu8mg5v7(// Act like the matlab X(row_mask,col_mask) operator, where 1288 // row_mask, col_mask are non-negative integer indices. 1289 // 1290 // Inputs: 1291 // X m by n matrix 1292 // R m list of row bools 1293 // C n list of column bools 1294 // Output: 1295 // Y #trues-in-R by #trues-in-C matrix 1296 // 1297 // See also: slice_mask)igl_Qu8mg5v7"; 1298 const char *__doc_igl_marching_tets = R"igl_Qu8mg5v7(// SLICE_TETS Slice through a tet mesh (V,T) along a given plane (via its 1299 // implicit equation). 1300 // 1301 // Inputs: 1302 // V #V by 3 list of tet mesh vertices 1303 // T #T by 4 list of tet indices into V 1304 // plane list of 4 coefficients in the plane equation: [x y z 1]'*plane = 0 1305 // Optional: 1306 // 'Manifold' followed by whether to stitch together triangles into a 1307 // manifold mesh {true}: results in more compact U but slightly slower. 1308 // Outputs: 1309 // U #U by 3 list of triangle mesh vertices along slice 1310 // G #G by 3 list of triangles indices into U 1311 // J #G list of indices into T revealing from which tet each faces comes 1312 // BC #U by #V list of barycentric coordinates (or more generally: linear 1313 // interpolation coordinates) so that U = BC*V 1314 // )igl_Qu8mg5v7"; 1315 const char *__doc_igl_sortrows = R"igl_Qu8mg5v7(// Act like matlab's [Y,I] = sortrows(X) 1316 // 1317 // Templates: 1318 // DerivedX derived scalar type, e.g. MatrixXi or MatrixXd 1319 // DerivedI derived integer type, e.g. MatrixXi 1320 // Inputs: 1321 // X m by n matrix whose entries are to be sorted 1322 // ascending sort ascending (true, matlab default) or descending (false) 1323 // Outputs: 1324 // Y m by n matrix whose entries are sorted (**should not** be same 1325 // reference as X) 1326 // I m list of indices so that 1327 // Y = X(I,:);)igl_Qu8mg5v7"; 1328 const char *__doc_igl_streamlines_init = R"igl_Qu8mg5v7(// Given a mesh and a field the function computes the /data/ necessary for tracing the field' 1329 // streamlines, and creates the initial /state/ for the tracing. 1330 // Inputs: 1331 // V #V by 3 list of mesh vertex coordinates 1332 // F #F by 3 list of mesh faces 1333 // temp_field #F by 3n list of the 3D coordinates of the per-face vectors 1334 // (n-degrees stacked horizontally for each triangle) 1335 // treat_as_symmetric 1336 // if true, adds n symmetry directions to the field (N = 2n). Else N = n 1337 // percentage [0-1] percentage of faces sampled 1338 // Outputs: 1339 // data struct containing topology information of the mesh and field 1340 // state struct containing the state of the tracing)igl_Qu8mg5v7"; 1341 const char *__doc_igl_streamlines_next = R"igl_Qu8mg5v7(// The function computes the next state for each point in the sample 1342 // V #V by 3 list of mesh vertex coordinates 1343 // F #F by 3 list of mesh faces 1344 // data struct containing topology information 1345 // state struct containing the state of the tracing)igl_Qu8mg5v7"; 1346 const char *__doc_igl_triangle_triangle_adjacency = R"igl_Qu8mg5v7(// Constructs the triangle-triangle adjacency matrix for a given 1347 // mesh (V,F). 1348 // 1349 // Templates: 1350 // Scalar derived type of eigen matrix for V (e.g. derived from 1351 // MatrixXd) 1352 // Index derived type of eigen matrix for F (e.g. derived from 1353 // MatrixXi) 1354 // Inputs: 1355 // F #F by simplex_size list of mesh faces (must be triangles) 1356 // Outputs: 1357 // TT #F by #3 adjacent matrix, the element i,j is the id of the triangle adjacent to the j edge of triangle i 1358 // TTi #F by #3 adjacent matrix, the element i,j is the id of edge of the triangle TT(i,j) that is adjacent with triangle i 1359 // NOTE: the first edge of a triangle is [0,1] the second [1,2] and the third [2,3]. 1360 // this convention is DIFFERENT from cotmatrix_entries.h 1361 // Known bug: this should not need to take V as input.)igl_Qu8mg5v7"; 1362 const char *__doc_igl_triangle_triangle_adjacency_preprocess = R"igl_Qu8mg5v7(// Preprocessing)igl_Qu8mg5v7"; 1363 const char *__doc_igl_triangle_triangle_adjacency_extractTT = R"igl_Qu8mg5v7(// Extract the face adjacencies)igl_Qu8mg5v7"; 1364 const char *__doc_igl_triangle_triangle_adjacency_extractTTi = R"igl_Qu8mg5v7(// Extract the face adjacencies indices (needed for fast traversal))igl_Qu8mg5v7"; 1365 const char *__doc_igl_triangle_triangulate = R"igl_Qu8mg5v7(// Triangulate the interior of a polygon using the triangle library. 1366 // 1367 // Inputs: 1368 // V #V by 2 list of 2D vertex positions 1369 // E #E by 2 list of vertex ids forming unoriented edges of the boundary of the polygon 1370 // H #H by 2 coordinates of points contained inside holes of the polygon 1371 // flags string of options pass to triangle (see triangle documentation) 1372 // Outputs: 1373 // V2 #V2 by 2 coordinates of the vertives of the generated triangulation 1374 // F2 #F2 by 3 list of indices forming the faces of the generated triangulation 1375 //)igl_Qu8mg5v7"; 1376 const char *__doc_igl_unique = R"igl_Qu8mg5v7(// Act like matlab's [C,IA,IC] = unique(X) 1377 // 1378 // Templates: 1379 // T comparable type T 1380 // Inputs: 1381 // A #A vector of type T 1382 // Outputs: 1383 // C #C vector of unique entries in A 1384 // IA #C index vector so that C = A(IA); 1385 // IC #A index vector so that A = C(IC);)igl_Qu8mg5v7"; 1386 const char *__doc_igl_unique_rows = R"igl_Qu8mg5v7(// Act like matlab's [C,IA,IC] = unique(X,'rows') 1387 // 1388 // Templates: 1389 // DerivedA derived scalar type, e.g. MatrixXi or MatrixXd 1390 // DerivedIA derived integer type, e.g. MatrixXi 1391 // DerivedIC derived integer type, e.g. MatrixXi 1392 // Inputs: 1393 // A m by n matrix whose entries are to unique'd according to rows 1394 // Outputs: 1395 // C #C vector of unique rows in A 1396 // IA #C index vector so that C = A(IA,:); 1397 // IC #A index vector so that A = C(IC,:);)igl_Qu8mg5v7"; 1398 const char *__doc_igl_unproject_onto_mesh = R"igl_Qu8mg5v7(// Unproject a screen location (using current opengl viewport, projection, and 1399 // model view) to a 3D position _onto_ a given mesh, if the ray through the 1400 // given screen location (x,y) _hits_ the mesh. 1401 // 1402 // Inputs: 1403 // pos screen space coordinates 1404 // model model matrix 1405 // proj projection matrix 1406 // viewport vieweport vector 1407 // V #V by 3 list of mesh vertex positions 1408 // F #F by 3 list of mesh triangle indices into V 1409 // Outputs: 1410 // fid id of the first face hit 1411 // bc barycentric coordinates of hit 1412 // Returns true if there's a hit)igl_Qu8mg5v7"; 1413 const char *__doc_igl_upsample = R"igl_Qu8mg5v7(// Subdivide without moving vertices: Given the triangle mesh [V, F], 1414 // where n_verts = V.rows(), computes newV and a sparse matrix S s.t. 1415 // [newV, newF] is the subdivided mesh where newV = S*V. 1416 // 1417 // Inputs: 1418 // n_verts an integer (number of mesh vertices) 1419 // F an m by 3 matrix of integers of triangle faces 1420 // Outputs: 1421 // S a sparse matrix (will become the subdivision matrix) 1422 // newF a matrix containing the new faces)igl_Qu8mg5v7"; 1423 const char *__doc_igl_winding_number = R"igl_Qu8mg5v7(// WINDING_NUMBER Compute the sum of solid angles of a triangle/tetrahedron 1424 // described by points (vectors) V 1425 // 1426 // Templates: 1427 // dim dimension of input 1428 // Inputs: 1429 // V n by 3 list of vertex positions 1430 // F #F by 3 list of triangle indices, minimum index is 0 1431 // O no by 3 list of origin positions 1432 // Outputs: 1433 // S no by 1 list of winding numbers 1434 // 1435 // 3d)igl_Qu8mg5v7"; 1436 const char *__doc_igl_winding_number_3 = R"igl_Qu8mg5v7(// Inputs: 1437 // V pointer to array containing #V by 3 vertex positions along rows, 1438 // given in column major order 1439 // n number of mesh vertices 1440 // F pointer to array containing #F by 3 face indices along rows, 1441 // given in column major order 1442 // m number of faces 1443 // O pointer to array containing #O by 3 query positions along rows, 1444 // given in column major order 1445 // no number of origins 1446 // Outputs: 1447 // S no by 1 list of winding numbers)igl_Qu8mg5v7"; 1448 const char *__doc_igl_winding_number_2 = R"igl_Qu8mg5v7(//// Only one evaluation origin 1449 //template <typename DerivedF> 1450 //IGL_INLINE void winding_number_3( 1451 // const double * V, 1452 // const int n, 1453 // const DerivedF * F, 1454 // const int m, 1455 // const double * O, 1456 // double * S); 1457 // 2d)igl_Qu8mg5v7"; 1458 const char *__doc_igl_writeMESH = R"igl_Qu8mg5v7(// save a tetrahedral volume mesh to a .mesh file 1459 // 1460 // Templates: 1461 // Scalar type for positions and vectors (will be cast as double) 1462 // Index type for indices (will be cast to int) 1463 // Input: 1464 // mesh_file_name path of .mesh file 1465 // V double matrix of vertex positions #V by 3 1466 // T #T list of tet indices into vertex positions 1467 // F #F list of face indices into vertex positions 1468 // 1469 // Known bugs: Holes and regions are not supported)igl_Qu8mg5v7"; 1470 const char *__doc_igl_writeOBJ = R"igl_Qu8mg5v7(// Write a mesh in an ascii obj file 1471 // Inputs: 1472 // str path to outputfile 1473 // V #V by 3 mesh vertex positions 1474 // F #F by 3|4 mesh indices into V 1475 // CN #CN by 3 normal vectors 1476 // FN #F by 3|4 corner normal indices into CN 1477 // TC #TC by 2|3 texture coordinates 1478 // FTC #F by 3|4 corner texture coord indices into TC 1479 // Returns true on success, false on error 1480 // 1481 // Known issues: Horrifyingly, this does not have the same order of 1482 // parameters as readOBJ.)igl_Qu8mg5v7"; 1483 const char *__doc_igl_writePLY = R"igl_Qu8mg5v7(// Write a mesh in an ascii ply file 1484 // Inputs: 1485 // str path to outputfile 1486 // V #V by 3 mesh vertex positions 1487 // F #F by 3 mesh indices into V 1488 // N #V by 3 normal vectors 1489 // UV #V by 2 texture coordinates 1490 // Returns true on success, false on error)igl_Qu8mg5v7"; 1491 const char *__doc_igl_readPLY= R"igl_Qu8mg5v7(// Read a mesh from an ascii ply file, filling in vertex positions, 1492 // mesh indices, normals and texture coordinates 1493 // Inputs: 1494 // str path to .obj file 1495 // Outputs: 1496 // V double matrix of vertex positions #V by 3 1497 // F #F list of face indices into vertex positions 1498 // N double matrix of corner normals #N by 3 1499 // UV #V by 2 texture coordinates 1500 // Returns true on success, false on errors)igl_Qu8mg5v7"; 1501 const char *__doc_igl_seam_edges=R"igl_Qu8mg5v7(// Finds all UV-space boundaries of a mesh. 1502 // 1503 // Inputs: 1504 // V #V by dim list of positions of the input mesh. 1505 // TC #TC by 2 list of 2D texture coordinates of the input mesh 1506 // F #F by 3 list of triange indices into V representing a 1507 // manifold-with-boundary triangle mesh 1508 // FTC #F by 3 list of indices into TC for each corner 1509 // Outputs: 1510 // seams Edges where the forwards and backwards directions have different 1511 // texture coordinates, as a #seams-by-4 matrix of indices. Each row is 1512 // organized as [ forward_face_index, forward_face_vertex_index, 1513 // backwards_face_index, backwards_face_vertex_index ] such that one side 1514 // of the seam is the edge: 1515 // F[ seams( i, 0 ), seams( i, 1 ) ], F[ seams( i, 0 ), (seams( i, 1 ) + 1) % 3 ] 1516 // and the other side is the edge: 1517 // F[ seams( i, 2 ), seams( i, 3 ) ], F[ seams( i, 2 ), (seams( i, 3 ) + 1) % 3 ] 1518 // boundaries Edges with only one incident triangle, as a #boundaries-by-2 1519 // matrix of indices. Each row is organized as 1520 // [ face_index, face_vertex_index ] 1521 // such that the edge is: 1522 // F[ boundaries( i, 0 ), boundaries( i, 1 ) ], F[ boundaries( i, 0 ), (boundaries( i, 1 ) + 1) % 3 ] 1523 // foldovers Edges where the two incident triangles fold over each other 1524 // in UV-space, as a #foldovers-by-4 matrix of indices. 1525 // Each row is organized as [ forward_face_index, forward_face_vertex_index, 1526 // backwards_face_index, backwards_face_vertex_index ] 1527 // such that one side of the foldover is the edge: 1528 // F[ foldovers( i, 0 ), foldovers( i, 1 ) ], F[ foldovers( i, 0 ), (foldovers( i, 1 ) + 1) % 3 ] 1529 // and the other side is the edge: 1530 // F[ foldovers( i, 2 ), foldovers( i, 3 ) ], F[ foldovers( i, 2 ), (foldovers( i, 3 ) + 1) % 3 ])igl_Qu8mg5v7"; 1531