phynexis-deps/igl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master'

Browse Source 
Former-commit-id: 231b465472
This commit is contained in:
Guillermo Lomas Rodríguez
2016-10-20 11:40:26 +02:00
parent ea18a88d58 f049d35759
commit 86d93f31db
94 changed files with 4115 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files
python/py_doc.cpp
+182 -15
View File
@@ -90,6 +90,45 @@ const char *__doc_igl_barycentric_to_global = R"igl_Qu8mg5v7(// Converts barycen
// Output:
// #X: #Xx3 3D coordinates of all points in bc
// )igl_Qu8mg5v7";
const char *__doc_igl_bbw_bbw = R"igl_Qu8mg5v7(// Compute Bounded Biharmonic Weights on a given domain (V,Ele) with a given
// set of boundary conditions
//
// Templates
// DerivedV derived type of eigen matrix for V (e.g. MatrixXd)
// DerivedF derived type of eigen matrix for F (e.g. MatrixXi)
// Derivedb derived type of eigen matrix for b (e.g. VectorXi)
// Derivedbc derived type of eigen matrix for bc (e.g. MatrixXd)
// DerivedW derived type of eigen matrix for W (e.g. MatrixXd)
// Inputs:
// V #V by dim vertex positions
// Ele #Elements by simplex-size list of element indices
// b #b boundary indices into V
// bc #b by #W list of boundary values
// data object containing options, intial guess --> solution and results
// Outputs:
// W #V by #W list of *unnormalized* weights to normalize use
// igl::normalize_row_sums(W,W);
// Returns true on success, false on failure)igl_Qu8mg5v7";
const char *__doc_igl_boundary_conditions = R"igl_Qu8mg5v7(// Compute boundary conditions for automatic weights computation. This
// function expects that the given mesh (V,Ele) has sufficient samples
// (vertices) exactly at point handle locations and exactly along bone and
// cage edges.
//
// Inputs:
// V #V by dim list of domain vertices
// Ele #Ele by simplex-size list of simplex indices
// C #C by dim list of handle positions
// P #P by 1 list of point handle indices into C
// BE #BE by 2 list of bone edge indices into C
// CE #CE by 2 list of cage edge indices into *P*
// Outputs:
// b #b list of boundary indices (indices into V of vertices which have
// known, fixed values)
// bc #b by #weights list of known/fixed values for boundary vertices
// (notice the #b != #weights in general because #b will include all the
// intermediary samples along each bone, etc.. The ordering of the
// weights corresponds to [P;BE]
// Returns true if boundary conditions make sense)igl_Qu8mg5v7";
const char *__doc_igl_boundary_facets = R"igl_Qu8mg5v7(// BOUNDARY_FACETS Determine boundary faces (edges) of tetrahedra (triangles)
// stored in T (analogous to qptoolbox's `outline` and `boundary_faces`).
//
@@ -146,6 +185,13 @@ const char *__doc_igl_colon = R"igl_Qu8mg5v7(// Colon operator like matlab's col
// than hi, vice versa if hi<low
// Output:
// I list of values from low to hi with step size step)igl_Qu8mg5v7";
const char *__doc_igl_column_to_quats = R"igl_Qu8mg5v7(// "Columnize" a list of quaternions (q1x,q1y,q1z,q1w,q2x,q2y,q2z,q2w,...)
//
// Inputs:
// Q n*4-long list of coefficients
// Outputs:
// vQ n-long list of quaternions
// Returns false if n%4!=0)igl_Qu8mg5v7";
const char *__doc_igl_comb_cross_field = R"igl_Qu8mg5v7(// Inputs:
// V #V by 3 eigen Matrix of mesh vertex 3D positions
// F #F by 4 eigen Matrix of face (quad) indices
@@ -229,7 +275,12 @@ const char *__doc_igl_copyleft_cgal_remesh_self_intersections = R"igl_Qu8mg5v7(/
// // remove any vertices now unreferenced after duplicate mapping.
// igl::remove_unreferenced(VV,FF,SV,SF,UIM);
// // Now (SV,SF) is ready to extract outer hull
<<<<<<< HEAD
// igl::copyleft::cgal::outer_hull(SV,SF,G,J,flip);)igl_Qu8mg5v7";
=======
// igl::copyleft::cgal::outer_hull(SV,SF,G,J,flip);
//)igl_Qu8mg5v7";
>>>>>>> upstream/master
const char *__doc_igl_copyleft_comiso_miq = R"igl_Qu8mg5v7(// Inputs:
// V #V by 3 list of mesh vertex 3D positions
// F #F by 3 list of faces indices in V
@@ -383,6 +434,32 @@ const char *__doc_igl_cut_mesh_from_singularities = R"igl_Qu8mg5v7(// Given a me
// seams #F by 3 list of per corner booleans that denotes if an edge is a
// seam or not
//)igl_Qu8mg5v7";
const char *__doc_igl_deform_skeleton = R"igl_Qu8mg5v7(// Deform a skeleton.
//
// Inputs:
// C #C by 3 list of joint positions
// BE #BE by 2 list of bone edge indices
// vA #BE list of bone transformations
// Outputs
// CT #BE*2 by 3 list of deformed joint positions
// BET #BE by 2 list of bone edge indices (maintains order)
//)igl_Qu8mg5v7";
const char *__doc_igl_directed_edge_orientations = R"igl_Qu8mg5v7(// Determine rotations that take each edge from the x-axis to its given rest
// orientation.
//
// Inputs:
// C #C by 3 list of edge vertex positions
// E #E by 2 list of directed edges
// Outputs:
// Q #E list of quaternions
//)igl_Qu8mg5v7";
const char *__doc_igl_directed_edge_parents = R"igl_Qu8mg5v7(// Recover "parents" (preceeding edges) in a tree given just directed edges.
//
// Inputs:
// E #E by 2 list of directed edges
// Outputs:
// P #E list of parent indices into E (-1) means root
//)igl_Qu8mg5v7";
const char *__doc_igl_doublearea = R"igl_Qu8mg5v7(// DOUBLEAREA computes twice the area for each input triangle[quad]
//
// Templates:
@@ -411,6 +488,15 @@ const char *__doc_igl_doublearea_quad = R"igl_Qu8mg5v7(// DOUBLEAREA_QUAD comput
// Outputs:
// dblA #F list of quadrilateral double areas
//)igl_Qu8mg5v7";
const char *__doc_igl_dqs = R"igl_Qu8mg5v7(// Dual quaternion skinning
//
// Inputs:
// V #V by 3 list of rest positions
// W #W by #C list of weights
// vQ #C list of rotation quaternions
// vT #C list of translation vectors
// Outputs:
// U #V by 3 list of new positions)igl_Qu8mg5v7";
const char *__doc_igl_edge_lengths = R"igl_Qu8mg5v7(// Constructs a list of lengths of edges opposite each index in a face
// (triangle/tet) list
//
@@ -426,7 +512,7 @@ const char *__doc_igl_edge_lengths = R"igl_Qu8mg5v7(// Constructs a list of leng
// or
// T #T by 4 list of mesh elements (must be tets)
// Outputs:
// L #F by {1|3|6} list of edge lengths
// L #F by {1|3|6} list of edge lengths
// for edges, column of lengths
// for triangles, columns correspond to edges [1,2],[2,0],[0,1]
// for tets, columns correspond to edges
@@ -438,7 +524,8 @@ const char *__doc_igl_edge_topology = R"igl_Qu8mg5v7(// Initialize Edges and the
// EV : #Ex2, Stores the edge description as pair of indices to vertices
// FE : #Fx3, Stores the Triangle-Edge relation
// EF : #Ex2: Stores the Edge-Triangle relation
//)igl_Qu8mg5v7";
//
// TODO: This seems to be a duplicate of edge_flaps.h)igl_Qu8mg5v7";
const char *__doc_igl_eigs = R"igl_Qu8mg5v7(See eigs for the documentation.)igl_Qu8mg5v7";
const char *__doc_igl_embree_ambient_occlusion = R"igl_Qu8mg5v7(// Compute ambient occlusion per given point
//
@@ -522,6 +609,18 @@ const char *__doc_igl_floor = R"igl_Qu8mg5v7(// Floor a given matrix to nearest
// X m by n matrix of scalars
// Outputs:
// Y m by n matrix of floored integers)igl_Qu8mg5v7";
const char *__doc_igl_forward_kinematics = R"igl_Qu8mg5v7(// Given a skeleton and a set of relative bone rotations compute absolute
// rigid transformations for each bone.
//
// Inputs:
// C #C by dim list of joint positions
// BE #BE by 2 list of bone edge indices
// P #BE list of parent indices into BE
// dQ #BE list of relative rotations
// dT #BE list of relative translations
// Outputs:
// vQ #BE list of absolute rotations
// vT #BE list of absolute translations)igl_Qu8mg5v7";
const char *__doc_igl_gaussian_curvature = R"igl_Qu8mg5v7(// Compute discrete local integral gaussian curvature (angle deficit, without
// averaging by local area).
//
@@ -547,12 +646,12 @@ const char *__doc_igl_get_seconds = R"igl_Qu8mg5v7(// Return the current time in
// ... // part 2
// cout<<"part 2: "<<tictoc()<<endl;
// ... // etc)igl_Qu8mg5v7";
const char *__doc_igl_grad = R"igl_Qu8mg5v7(// Gradient of a scalar function defined on piecewise linear elements (mesh)
// is constant on each triangle i,j,k:
// grad(Xijk) = (Xj-Xi) * (Vi - Vk)^R90 / 2A + (Xk-Xi) * (Vj - Vi)^R90 / 2A
// where Xi is the scalar value at vertex i, Vi is the 3D position of vertex
// i, and A is the area of triangle (i,j,k). ^R90 represent a rotation of
// 90 degrees
const char *__doc_igl_grad = R"igl_Qu8mg5v7(// Gradient of a scalar function defined on piecewise linear elements (mesh)
// is constant on each triangle i,j,k:
// grad(Xijk) = (Xj-Xi) * (Vi - Vk)^R90 / 2A + (Xk-Xi) * (Vj - Vi)^R90 / 2A
// where Xi is the scalar value at vertex i, Vi is the 3D position of vertex
// i, and A is the area of triangle (i,j,k). ^R90 represent a rotation of
// 90 degrees
//)igl_Qu8mg5v7";
const char *__doc_igl_harmonic = R"igl_Qu8mg5v7(// Compute k-harmonic weight functions "coordinates".
//
@@ -620,6 +719,39 @@ const char *__doc_igl_jet = R"igl_Qu8mg5v7(// JET like MATLAB's jet
// r red value
// g green value
// b blue value)igl_Qu8mg5v7";
const char *__doc_igl_lbs_matrix = R"igl_Qu8mg5v7(// LBS_MATRIX Linear blend skinning can be expressed by V' = M * T where V' is
// a #V by dim matrix of deformed vertex positions (one vertex per row), M is a
// #V by (dim+1)*#T (composed of weights and rest positions) and T is a
// #T*(dim+1) by dim matrix of #T stacked transposed transformation matrices.
// See equations (1) and (2) in "Fast Automatic Skinning Transformations"
// [Jacobson et al 2012]
//
// Inputs:
// V #V by dim list of rest positions
// W #V+ by #T list of weights
// Outputs:
// M #V by #T*(dim+1)
//
// In MATLAB:
// kron(ones(1,size(W,2)),[V ones(size(V,1),1)]).*kron(W,ones(1,size(V,2)+1)))igl_Qu8mg5v7";
const char *__doc_igl_lbs_matrix_column = R"igl_Qu8mg5v7(// LBS_MATRIX construct a matrix that when multiplied against a column of
// affine transformation entries computes new coordinates of the vertices
//
// I'm not sure it makes since that the result is stored as a sparse matrix.
// The number of non-zeros per row *is* dependent on the number of mesh
// vertices and handles.
//
// Inputs:
// V #V by dim list of vertex rest positions
// W #V by #handles list of correspondence weights
// Output:
// M #V * dim by #handles * dim * (dim+1) matrix such that
// new_V(:) = LBS(V,W,A) = reshape(M * A,size(V)), where A is a column
// vectors formed by the entries in each handle's dim by dim+1
// transformation matrix. Specifcally, A =
// reshape(permute(Astack,[3 1 2]),n*dim*(dim+1),1)
// or A = [Lxx;Lyx;Lxy;Lyy;tx;ty], and likewise for other dim
// if Astack(:,:,i) is the dim by (dim+1) transformation at handle i)igl_Qu8mg5v7";
const char *__doc_igl_local_basis = R"igl_Qu8mg5v7(// Compute a local orthogonal reference system for each triangle in the given mesh
// Templates:
// DerivedV derived from vertex positions matrix type: i.e. MatrixXd
@@ -731,6 +863,22 @@ const char *__doc_igl_n_polyvector = R"igl_Qu8mg5v7(// Inputs:
// Output:
// 3 by 3 rotation matrix that takes v0 to v1
//)igl_Qu8mg5v7";
const char *__doc_igl_normalize_row_lengths = R"igl_Qu8mg5v7(// Obsolete: just use A.rowwise().normalize() or B=A.rowwise().normalized();
//
// Normalize the rows in A so that their lengths are each 1 and place the new
// entries in B
// Inputs:
// A #rows by k input matrix
// Outputs:
// B #rows by k input matrix, can be the same as A)igl_Qu8mg5v7";
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
// entries in B
// Inputs:
// A #rows by k input matrix
// Outputs:
// B #rows by k input matrix, can be the same as A
//
// Note: This is just calling an Eigen one-liner.)igl_Qu8mg5v7";
const char *__doc_igl_parula = R"igl_Qu8mg5v7(// PARULA like MATLAB's parula
//
// Inputs:
@@ -923,6 +1071,23 @@ const char *__doc_igl_readOFF = R"igl_Qu8mg5v7(// Read a mesh from an ascii obj
// N double matrix of corner normals #N by 3
// FN #F list of face indices into vertex normals
// Returns true on success, false on errors)igl_Qu8mg5v7";
const char *__doc_igl_readTGF = R"igl_Qu8mg5v7(// READTGF
//
// [V,E,P,BE,CE,PE] = readTGF(filename)
//
// Read a graph from a .tgf file
//
// Input:
// filename .tgf file name
// Ouput:
// V # vertices by 3 list of vertex positions
// E # edges by 2 list of edge indices
// P # point-handles list of point handle indices
// BE # bone-edges by 2 list of bone-edge indices
// CE # cage-edges by 2 list of cage-edge indices
// PE # pseudo-edges by 2 list of pseudo-edge indices
//
// Assumes that graph vertices are 3 dimensional)igl_Qu8mg5v7";
const char *__doc_igl_read_triangle_mesh = R"igl_Qu8mg5v7(// read mesh from an ascii file with automatic detection of file format.
// supported: obj, off, stl, wrl, ply, mesh)
//
@@ -936,7 +1101,7 @@ const char *__doc_igl_read_triangle_mesh = R"igl_Qu8mg5v7(// read mesh from an a
// V eigen double matrix #V by 3
// F eigen int matrix #F by 3
// Returns true iff success)igl_Qu8mg5v7";
const char *__doc_igl_remove_duplicate_vertices = R"igl_Qu8mg5v7( // REMOVE_DUPLICATE_VERTICES Remove duplicate vertices upto a uniqueness
const char *__doc_igl_remove_duplicate_vertices = R"igl_Qu8mg5v7(// REMOVE_DUPLICATE_VERTICES Remove duplicate vertices upto a uniqueness
// tolerance (epsilon)
//
// Inputs:
@@ -945,7 +1110,7 @@ const char *__doc_igl_remove_duplicate_vertices = R"igl_Qu8mg5v7( // REMOVE_DUP
// this as a tolerance on L1 distance
// Outputs:
// SV #SV by dim new list of vertex positions
// SVI #V by 1 list of indices so SV = V(SVI,:)
// SVI #V by 1 list of indices so SV = V(SVI,:)
// SVJ #SV by 1 list of indices so V = SV(SVJ,:)
//
// Example:
@@ -953,7 +1118,6 @@ const char *__doc_igl_remove_duplicate_vertices = R"igl_Qu8mg5v7( // REMOVE_DUP
// [SV,SVI,SVJ] = remove_duplicate_vertices(V,1e-7);
// % remap faces
// SF = SVJ(F);
//
//)igl_Qu8mg5v7";
const char *__doc_igl_rotate_vectors = R"igl_Qu8mg5v7(// Rotate the vectors V by A radiants on the tangent plane spanned by B1 and
// B2
@@ -1072,7 +1236,7 @@ const char *__doc_igl_sortrows = R"igl_Qu8mg5v7(// Act like matlab's [Y,I] = sor
// reference as X)
// I m list of indices so that
// Y = X(I,:);)igl_Qu8mg5v7";
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'
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'
// streamlines, and creates the initial /state/ for the tracing.
// Inputs:
// V #V by 3 list of mesh vertex coordinates
@@ -1084,12 +1248,12 @@ const char *__doc_igl_streamlines_init = R"igl_Qu8mg5v7( // Given a mesh and
// percentage [0-1] percentage of faces sampled
// Outputs:
// data struct containing topology information of the mesh and field
// state struct containing the state of the tracing )igl_Qu8mg5v7";
const char *__doc_igl_streamlines_next = R"igl_Qu8mg5v7( // The function computes the next state for each point in the sample
// state struct containing the state of the tracing)igl_Qu8mg5v7";
const char *__doc_igl_streamlines_next = R"igl_Qu8mg5v7(// The function computes the next state for each point in the sample
// V #V by 3 list of mesh vertex coordinates
// F #F by 3 list of mesh faces
// data struct containing topology information
// state struct containing the state of the tracing )igl_Qu8mg5v7";
// state struct containing the state of the tracing)igl_Qu8mg5v7";
const char *__doc_igl_triangle_triangle_adjacency = R"igl_Qu8mg5v7(// Constructs the triangle-triangle adjacency matrix for a given
// mesh (V,F).
//
@@ -1106,6 +1270,9 @@ const char *__doc_igl_triangle_triangle_adjacency = R"igl_Qu8mg5v7(// Constructs
// NOTE: the first edge of a triangle is [0,1] the second [1,2] and the third [2,3].
// this convention is DIFFERENT from cotmatrix_entries.h
// Known bug: this should not need to take V as input.)igl_Qu8mg5v7";
const char *__doc_igl_triangle_triangle_adjacency_preprocess = R"igl_Qu8mg5v7(// Preprocessing)igl_Qu8mg5v7";
const char *__doc_igl_triangle_triangle_adjacency_extractTT = R"igl_Qu8mg5v7(// Extract the face adjacencies)igl_Qu8mg5v7";
const char *__doc_igl_triangle_triangle_adjacency_extractTTi = R"igl_Qu8mg5v7(// Extract the face adjacencies indices (needed for fast traversal))igl_Qu8mg5v7";
const char *__doc_igl_triangle_triangulate = R"igl_Qu8mg5v7(// Triangulate the interior of a polygon using the triangle library.
//
// Inputs: