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

Merge branch 'python_bindings' of https://github.com/s-koch/libigl

Browse Source
This commit is contained in:
Daniele Panozzo
2016-10-19 09:19:17 -04:00
parent adb01e11ac f8ac33ec81
commit 1dc17bb6c8
29 changed files with 1002 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
python/py_doc.cpp
+159
View File
@@ -76,6 +76,45 @@ const char *__doc_igl_barycentric_coordinates = R"igl_Qu8mg5v7(// Compute baryce
// Outputs:
// L #P by 4 list of barycentric coordinates
// )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`).
//
@@ -132,6 +171,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
@@ -370,6 +416,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:
@@ -398,6 +470,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
//
@@ -493,6 +574,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).
//
@@ -591,6 +684,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
@@ -702,6 +828,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:
@@ -894,6 +1036,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)
//