Merge branch 'master' of github.com:libigl/libigl into alecjacobson

Former-commit-id: 0c826a14d05f3707974581e280f6f0035cdf192f

.gitignore

@@ -100,3 +100,4 @@ python/buildstatic
 tutorial/cmake-build-debug
 .vscode/
 .idea/
+site/

CONTRIBUTING.md

@@ -1,17 +0,0 @@
-Before opening an issue on creating a pull request, please check the following:
-
-## Compilation Issues
-
-- If you are on Windows, did you select the **x64** version of the Visual Studio compiler?
-
-- If you have a **CMake issue**, make sure you follow the same approach as the  [libigl-example-project](https://github.com/libigl/libigl-example-project) to build libigl with your project, and make sure that you can compile the example project.
-
-- If you have an issue with a **submodule**, check if your submodules are up to date. If you have a doubt about a submodule, delete its folder and run `git submodule update --init --recursive` in the libigl directory.
-
-- If you have an issue with a missing **template issue**, check if your code compile with the *header-only* option of libigl activated. Turn **`OFF`** the CMake option `LIBIGL_USE_STATIC_LIBRARY`: either modify your `CMakeCache.txt` via CMake GUI or ccmake, or delete your `CMakeCache.txt` and re-run `cmake -DLIBIGL_USE_STATIC_LIBRARY=OFF ..` in your build folder.
-
-- Make sure your read the [**FAQ**](https://github.com/libigl/libigl/wiki/FAQ) before asking a new question, and search [**existing issues**](https://github.com/libigl/libigl/issues?q=is%3Aissue+is%3Aclosed) for a problem similar to yours.
-
-- Make sure you read the informations contained in the libigl [homepage](https://github.com/libigl/libigl) as well as the [tutorials](http://libigl.github.io/libigl/tutorial/tutorial.html).
-
-- If none of these solve your problem, then please report your issue in the bug tracker!

LICENSE.md

@@ -1,40 +0,0 @@
-Libigl is primarily licensed under MPL2
-  - http://www.mozilla.org/MPL/2.0/
-  - http://www.mozilla.org/MPL/2.0/FAQ.html
-
-All `.h` and `.cpp` _files_ directly in `include/igl` (but not necessarily in
-sub-directories) are subject only to the terms of the MPL2; they should not
-include any code that is covered by other/less-permissive licenses.
-
-The `.h` and `.cpp` _files_ in sub-directories of `include/igl` allow libigl to
-integrate with external third-party libraries (e.g., those in `external/`) and
-are subject to the MPL2, _**and**_ also the terms of licenses of the
-corresponding external library.  The licenses used by these libraries fall under
-three categories:
-
-- common "free, non-copyleft licenses" (such as zlib, BSD, MIT, and public
-  domain)
-  - `include/igl/anttweakbar`
-  - `include/igl/embree`
-  - `include/igl/opengl`
-  - `include/igl/opengl/glfw`
-  - `include/igl/opengl2`
-  - `include/igl/png`
-  - `include/igl/viewer`
-  - `include/igl/xml`
-- common "copyleft" licences (such as GPL, LGPL, and AGPL)
-  - `include/igl/copyleft`
-  - `include/igl/copyleft/cgal`
-  - `include/igl/copyleft/comiso`
-  - `include/igl/copyleft/cork`
-  - `include/igl/copyleft/tetgen`
-- other "uncommon" licenses or commercial software
-  - `include/igl/lim`
-  - `include/igl/matlab`
-  - `include/igl/mosek`
-  - `include/igl/triangle`
-
-The Libigl code that interfaces with "copyleft" libraries is in
-`include/igl/copyleft`.  Only include these headers if you are accept the
-licensing terms of the corresponding external library.  For example, using
-`include/igl/copyleft/tetgen` requires that you accept the terms of the AGPLv3.

README.md

@@ -26,7 +26,7 @@ header file contains a single function (e.g. `igl/cotmatrix.h` contains
 stored in an n-by-3 matrix of vertex positions `V` and an m-by-3 matrix of
 triangle indices `F`.
 
-_Optionally_ the library may also be [pre-compiled](optional/) into a statically
+_Optionally_ the library may also be [pre-compiled](http://libigl.github.io/libigl/static-library/) into a statically
 linked library, for faster compile times with your projects. This only effects
 compile time (run-time performance and behavior is identical). If in doubt, use
 the header-only default mode: (i.e. just include the headers you want to use).
@@ -41,7 +41,7 @@ and Windows with Visual Studio 2015 Community Edition.
 ## Tutorial
 
 As of version 1.0, libigl includes an introductory
-[tutorial](http://libigl.github.io/libigl/tutorial/tutorial.html) that covers many functionalities.
+[tutorial](http://libigl.github.io/libigl/tutorial) that covers many functionalities.
 
 ## libigl Example Project
 
@@ -49,7 +49,7 @@ We provide a [blank project example](https://github.com/libigl/libigl-example-pr
 
 ## Coding Guidelines and Tips
 
-libigl follows strict coding guidelines, please take a look [here](http://libigl.github.io/libigl/style-guidelines.html) before submitting your pull requests. We also have a set of [general coding tips](http://libigl.github.io/libigl/coding-guidelines.html) on how to code a geometry processing research project.
+libigl follows strict coding guidelines, please take a look [here](http://libigl.github.io/libigl/style-guidelines) before submitting your pull requests. We also have a set of [general coding tips](http://libigl.github.io/libigl/coding-guidelines) on how to code a geometry processing research project.
 
 ## Installation
 
@@ -100,7 +100,7 @@ Hello, mesh:
 Dependencies are on a per-include basis and the majority of the functions in
 libigl depends only on the [Eigen](http://eigen.tuxfamily.org) library.
 
-For more information see our [tutorial](tutorial/tutorial.html).
+For more information see our [tutorial](http://libigl.github.io/libigl/tutorial).
 
 ### Optional Dependencies
 
@@ -150,7 +150,7 @@ a major _todo_ for our development.
 ## Git Submodules
 Libigl uses git submodules for its _optional_ dependencies,
 in particular, those needed by the OpenGL viewer to run the examples in the
-[tutorial](tutorial/tutorial.html). Git submodules allow use to treat clones of
+[tutorial](http://libigl.github.io/libigl/tutorial). Git submodules allow use to treat clones of
 other libraries as sub-directories within ours while separating our commits.
 Read the [documentation](http://git-scm.com/docs/git-submodule) for a detailed
 explanation, but essentially our libigl repo stores a hash for each of its
@@ -175,7 +175,7 @@ repository](https://github.com/libigl/libigl-unit-tests) for unit testing.
 
 If you are interested in joining development, please fork the repository and
 submit a [pull request](https://help.github.com/articles/using-pull-requests/)
-with your changes. libigl follows strict coding guidelines, please take a look at our  [style guidelines](style-guidelines.html) before submitting your pull requests.
+with your changes. libigl follows strict coding guidelines, please take a look at our  [style guidelines](http://libigl.github.io/libigl/style-guidelines) before submitting your pull requests.
 
 ## License
 libigl is primarily [MPL2](http://www.mozilla.org/MPL/2.0/) licensed

RELEASE_HISTORY.md

@@ -1,151 +0,0 @@
-title: libigl Tutorial
-author: Alec Jacobson
-date: 17 June 2015
-css: tutorial/style.css
-html header:   <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
-<link rel="stylesheet" href="http://yandex.st/highlightjs/7.3/styles/default.min.css">
-<script src="http://yandex.st/highlightjs/7.3/highlight.min.js"></script>
-<script>hljs.initHighlightingOnLoad();</script>
-
-# Libigl version tracking
-
-Version | Short description
---------|----------------------------------------------------------------------
-1.2.1   | Reorganization opengl-dependent functions: opengl and opengl2 extras
-1.2.0   | Reorganization of "extras", rm deprecated funcs, absorb boost & svd3x3
-1.1.7   | Switch build for static library to cmake.
-1.1.6   | Major boolean robustness fix, drop CGAL dependency for AABB/distances
-1.1.5   | Bug fix in booleans
-1.1.4   | Edge collapsing and linear program solving
-1.1.3   | Bug fixes in active set and boundary_conditions
-1.1.1   | PLY file format support
-1.1.0   | Mesh boolean operations using CGAL and cork, implementing [Attene 14]
-1.0.3   | Bone heat method
-1.0.2   | Bug fix in winding number code
-1.0.1   | Bug fixes and more CGAL support
-1.0.0   | Major beta release: many renames, tutorial, triangle, org. build
-0.4.6   | Generalized Winding Numbers
-0.4.5   | CGAL extra: mesh selfintersection
-0.4.4   | STL file format support
-0.4.3   | ARAP implementation
-0.4.1   | Migrated much of the FAST code including extra for Sifakis' 3x3 svd
-0.4.0   | Release under MPL2 license
-0.3.7   | Embree2.0 support
-0.3.6   | boost extra, patches, mosek 7 support, libiglbbw (mosek optional)
-0.3.5   | More examples, naive primitive sorting
-0.3.3   | Many more examples, ambient occlusion with Embree.
-0.3.1   | Linearly dependent constraints in min_quad_with_fixed, SparseQR buggy
-0.3.0   | Better active set method support
-0.2.3   | More explicits, active set method, opengl/anttweakbar guards
-0.2.2   | More explicit instantiations, faster sorts and uniques
-0.2.1   | Bug fixes in barycenter and doublearea found by Martin Bisson
-0.2.0   | XML serializer more stable and fixed bug in remove_duplicate_vertices
-0.1.8   | Embree and xml (windows only) extras
-0.1.5   | Compilation on windows, bug fix for compilation with cygwin
-0.1.1   | Alpha release with core functions, extras, examples
-
-## Version 1.2 Changes ##
-This change introduces better organization of dependencies and removes some
-deprecated/repeated functions. The 3x3 svd code and dependent functions
-(including ARAP) were absorbed into the main library. Similarly, the boost
-dependency extra was absorbed.
-
-
-### External libraries as git subrepos ###
-The core functionality of libigl (still) just depends on stl, c++11 and Eigen.
-There are additional _optional_ dependencies (e.g. CGAL, embree, glfw, tetgen,
-triangle). Libigl functions using these are located (still) in sub-folders of
-the include directory (e.g.  `include/igl/cgal/`, `include/igl/embree/`). Prior
-to version 1.2 we included copies of the code for some of these dependencies in the
-`external/` directory. As of
-version 1.2, these have been replaced with git sub-repos. If you have cloned
-libigl _before version 1.2_ then you should issue 
-
-    git submodule update --init --recursive
-
-### Deprecated/repeated functions ###
-
-Old                                     | New
---------------------------------------- | -----------------------------------
-`igl::angles`                           | `igl::internal_angles`
-`igl::get_modifiers`                    | [deleted]
-`igl::nchoosek(offset,K,N,std::vector)` | `igl::nchoosek(Eigen,K,Eigen)`
-`#include <igl/boost/components.h>`     | `#include <igl/components.h>`
-`#include <igl/boost/bfs_orient.h>`     | `#include <igl/bfs_orient.h>`
-`#include <igl/boost/orientable_patches.h>` | `#include <igl/orientable_patches.h>`
-`#include <igl/svd3x3/arap.h>`          | `#include <igl/arap.h>`
-`#include <igl/svd3x3/arap_dof.h>`      | `#include <igl/arap_dof.h>`
-`#include <igl/svd3x3/fit_rotations.h>` | `#include <igl/fit_rotations.h>`
-`#include <igl/svd3x3/polar_svd3x3.h>`  | `#include <igl/polar_svd3x3.h>`
-`#include <igl/svd3x3/svd3x3.h>`        | `#include <igl/svd3x3.h>`
-`#include <igl/svd3x3/svd3x3_avx.h>`    | `#include <igl/svd3x3_avx.h>`
-`#include <igl/svd3x3/svd3x3_sse.h>`    | `#include <igl/svd3x3_sse.h>`
-
-
-## Version 1.0 Changes ##
-Our beta release marks our confidence that this library can be used outside of
-casual experimenting. To maintain order, we have made a few changes which
-current users should read and adapt their code accordingly.
-
-### Renamed functions ###
-The following table lists functions which have changed name as of version
-1.0.0:
-
-Old                              | New
--------------------------------- | -------------------------------------
-`igl::add_barycenter`            | `igl::false_barycentric_subdivision`
-`igl::areamatrix`                | `igl::vector_area_matrix`
-`igl::barycentric2global`        | `igl::barycentric_to_global`
-`igl::boundary_faces`            | `igl::boundary_facets`
-`igl::boundary_vertices_sorted`  | `igl::boundary_loop`
-`igl::cotangent`                 | `igl::cotmatrix_entries`
-`igl::edgetopology`              | `igl::edge_topology`
-`igl::gradMat`                   | `igl::grad`
-`igl::is_manifold`               | `igl::is_edge_manifold`
-`igl::mexStream`                 | `igl::MexStream`
-`igl::moveFV`                    | `igl::average_onto_vertices`
-`igl::moveVF`                    | `igl::average_onto_faces`
-`igl::plot_vector`               | `igl::print_vector`
-`igl::pos`                       | `igl::HalfEdgeIterator`
-`igl::plane_project`             | `igl::project_isometrically_to_plane`
-`igl::project_points_mesh`       | `igl::line_mesh_intersection`
-`igl::read`                      | `igl::read_triangle_mesh`
-`igl::removeDuplicates.cpp`      | `igl::remove_duplicates`
-`igl::removeUnreferenced`        | `igl::remove_unreferenced`
-`igl::tt`                        | `igl::triangle_triangle_adjacency`
-`igl::vf`                        | `igl::vertex_triangle_adjacency`
-`igl::write`                     | `igl::write_triangle_mesh`
-`igl::manifold_patches`          | `igl::orientable_patches`
-`igl::selfintersect`             | `igl::remesh_self_intersections`
-`igl::project_mesh`              | `igl::line_mesh_intersection`
-`igl::triangulate`               | `igl::polygon_mesh_to_triangle_mesh`
-`igl::is_manifold`               | `igl::is_edge_manifold`
-`igl::triangle_wrapper`          | `igl::triangulate`
-
-### Miscellaneous ###
- - To match interfaces provided by (all) other quadratic optimization
-   libraries, `igl::min_quad_with_fixed` and `igl::active_set` now expect as
-   input twice the quadratic coefficients matrix, i.e. the Hessian. For
-   example, `igl::min_quad_with_fixed(H,B,...)` minimizes $\frac{1}{2}x^T H
-   x+x^T B$.
- - We have inverted the `IGL_HEADER_ONLY` macro to `IGL_STATIC_LIBRARY`. To
-   compile using libigl as a header-only library, simply include headers and
-   libigl in the header search path. To link to libigl, you must define the
-   `IGL_STATIC_LIBRARY` macro at compile time and link to the `libigl*.a`
-   libraries.
- - Building libigl as a static library is now more organized. There is a
-   `build/` directory with Makefiles for the main library (`Makefile`) and each
-   dependency (e.g. `Makefile_mosek` for `libiglmosek.a`)
- - `igl::polar_svd` now always returns a rotation in `R`, never a reflection.
-   This mirrors the behavior of `igl::polar_svd3x3`.  Consequently the `T`
-   part may have negative skews.
- - We have organized the static library build
- - The previous `igl::grad` function, which computed the per-triangle gradient
-   of a per-vertex scalar function has been replaced. Now `igl::grad` computes
-   the linear operator (previous computed using `igl::gradMat`). The gradient
-   values can still be recovered by multiplying the operator against the scalar
-   field as a vector and reshaping to have gradients per row.
- - `MASSMATRIX_*` has become `MASSMATRIX_TYPE_*`
- - The function `igl::project_normals`, which cast a line for each vertex of
-   mesh _A_ in the normal direction and found the closest intersection along
-   these lines with mesh _B_, has been removed.

before-submitting-pull-request.md

@@ -1,62 +0,0 @@
-# Before submitting a pull request
-
-There are a variety of things you can do before submitting a pull request that
-will reduce the effort on the libigl team to merge your code and increase the
-likelihood that the merge ever happens.
-
-  1. Test your code and submit a unit test as part of the pull request
-  2. Verify that your code matches the [libigl style
-  guidelines](style-guidelines.md)
-  3. Run the [exhaustive build test](#exhaustivebuildtest) below
-
-## Exhaustive build test
-
-This script will `git clone` libigl to a temporary directory and build 
-
-  1. the static libigl library, 
-  2. the tutorial using the default header only libigl, and 
-  3. the tutorial using the static library libigl.
-  
-Eventually this script should also run the unit tests.
-
-```bash
-# In scripts/clone_and_build.sh add your email address to the line:
-# `recipients="alecjacobson@gmail.com,youremail@domain.com"`
-# In your email client (e.g. gmail) create a filter to prevent emails 
-# from your local machine from going to spam
-scripts/clone_and_build.sh
-```
-
-### Direct test of tutorial using static library
-
-This part of the `clone_and_build.sh` script catches 99% of the compilation
-issues that _don't_ show up when testing:
-
-```bash
-cd tutorial/
-mkdir build-use-static
-cd build-use-static
-cmake -DCMAKE_BUILD_TYPE=Release -DLIBIGL_USE_STATIC_LIBRARY=ON ..
-make
-```
-
-A typical issue is a missing template instantiation (symbol not found):
-
-    "void igl::cgal::points_inside_component<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&)", referenced from:
-        void igl::cgal::outer_hull<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<long, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<long, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&) in libiglboolean.a(mesh_boolean.cpp.o)
-        void igl::cgal::outer_hull<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<long, -1, 1, 0, -1, 1>, Eigen::Matrix<bool, -1, 1, 0, -1, 1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&, Eigen::PlainObjectBase<Eigen::Matrix<long, -1, 1, 0, -1, 1> >&, Eigen::PlainObjectBase<Eigen::Matrix<bool, -1, 1, 0, -1, 1> >&) in libiglboolean.a(mesh_boolean.cpp.o)
-
-This looks like a mess, but the solution is very simple. Copy the chunk inside of the quotes, in this case:
-
-    "void igl::cgal::points_inside_component<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&)"
-
-and paste it at the bottom of the relevant .cpp file with the word template in front of it and a semicolon at then. In this case, in include/igl/cgal/points_inside_component.cpp:
-
-```cpp
-#ifdef IGL_STATIC_LIBRARY
-// Explicit template instantiation
-template void igl::cgal::points_inside_component<Eigen::Matrix<CGAL::Lazy_exact_nt<CGAL::Gmpq>, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<CGAL::Lazy_exact_nt<CGAL::Gmpq>, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 1, 0, -1, 1> >(Eigen::PlainObjectBase<Eigen::Matrix<CGAL::Lazy_exact_nt<CGAL::Gmpq>, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<CGAL::Lazy_exact_nt<CGAL::Gmpq>, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 1, 0, -1, 1> >&);
-#endif
-```
-
-Then "rinse and repeat".

coding-guidelines.html

@@ -1,60 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
-<head>
-	<meta charset="utf-8"/>
-	<title>libigl</title>
-	<meta name="author" content="Alec Jacobson and Daniele Panozzo and others"/>
-	<link type="text/css" rel="stylesheet" href="../tutorial/style.css"/>
-<script type='text/javascript' src='http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'></script> <link rel='stylesheet' href='http://yandex.st/highlightjs/7.3/styles/default.min.css'> <script src='http://yandex.st/highlightjs/7.3/highlight.min.js'></script> <script>hljs.initHighlightingOnLoad();</script>
-</head>
-<body>
-
-<h1 id="libiglcodingtipsakahowtocodeasiggraphproject">Libigl Coding Tips (aka &#8220;How to code a SIGGRAPH project&#8221;)</h1>
-
-<p>This is a short list of coding tips that will greatly reduce your pain and suffering before (and after) the SIGGRAPH deadline.</p>
-
-<h3 id="1.serializeitall">1. Serialize it all</h3>
-
-<p>The entire state of your application should be serializable, i.e. It should be possible to save it into a binary file and reload it at any point. This drastically simplifies debugging, since you can serialize just before a crash happens and debug from that point without running your complete algorithm again. Serializing all results shown in the paper&#8217;s figures enables quicker editing iterations before (and after) the deadline. It also allows you to share your results with others that wish to compare with your method. An additional tip is to serialize the state of the application on the window close event and automatically reload it when you launch it again.</p>
-
-<h3 id="2.alwaysassert">2. Always assert</h3>
-
-<p>Even if you know what you are doing, always assert, you will be surprised. Assertion is a powerful but underused feature available in all programming languages. It is essential for writing research code since often you will have to implement algorithms that turns out to not be doing what you expect: in these cases it is important to know if the algorithm is flawed or if there is a bug in your implementation. Discarding a good idea because of a coding bug is frustrating and unfortunately common. Assertion is an ideal way to reduce the chances of introducing bugs in your code and, differently from unit testing, requires a very minor programming effort. You should use them extensively.</p>
-
-<h3 id="3.ploteverything">3. Plot everything</h3>
-
-<p>If you can visually plot the results or some intermediate steps of your algorithm, do it, even if you think your implementation is correct! It is a lot easier to find bugs or to get an intuition on an algorithm by looking at a plot than by looking at the code.</p>
-
-<h3 id="4.ifthecompilationtimeafteracodechangeismorethanfivesecondsyouaredoingitwrong">4. If the compilation time after a code change is more than five seconds, you are doing it wrong</h3>
-
-<p>You will change your code hundreds of times every day for months. Let&#8217;s say that you will change it a hundred times a day (which is a very conservative estimate): if the compilation takes one minute, you will waste almost two hours every day, just waiting! What is even worse, is that since it is only 1&#8211;2 minutes at a time, it will not even be sufficient to prepare a coffee. Spend the hour or two that is needed to get your code to compile in a few seconds, you will benefit from it in the same day already, and the time saved over an entire project will be gigantic.</p>
-
-<h3 id="5.commitoftenandwithameaningfuldescription">5. Commit often (and with a meaningful description)</h3>
-
-<p>Use a distributed version control system (git,hg), and keep the repository on a remote host. Commit often and put meaningful comments. This will serve you as an emergency backup and it will always allow you to have a running version of your code whenever your advisor is passing by and asking to see some results. She will be impressed and you will not have to quickly fix your build with your boss breathing down your neck.</p>
-
-<h3 id="6.dependenciesareevilavoidthem">6. Dependencies are evil, avoid them</h3>
-
-<p>Keep your code simple and with minimal external dependencies. Spending a day or two to code something from scratch while avoiding to use third party code is usually an investment that pays off. The more code you have in your algorithm that is not written by you, the harder debugging becomes. In particular, refrain from building your entire project on code that you do not understand to avoid bad surprises just before the deadline. If you must use code written by others, spend the time that is needed to fully understand what it does, and link it statically so that it will be easy to place breakpoints inside it.</p>
-
-<h3 id="7.globalvariablesarenotevilusethem">7. Global variables are not evil, use them</h3>
-
-<p>Global variables are often extremely useful &#8212; if you think you need one, use it. They are indeed dangerous for large projects, but you are not coding one of those, you are coding a prototype to test a research idea. I suggest to keep one single copy of your entire application state in a global variable (or a singleton class) that can be serialized (see tip 1). This variable should include everything rendered on screen and all the temporary data produced by your algorithm. This will allow you to easily access all the data in your project for plotting or debugging purposes.</p>
-
-<h3 id="8.prototypefirst">8. Prototype first</h3>
-
-<p>Don’t preemptively optimize and try to quickly write code that is clean and correct. It is common to try multiple different approaches to solve a new problem before finding the right one. This means that the majority of the code that you will write will not be used at the end of the project. While you should still write high-quality and bug-free code to make sure that your results is correct, you definitely do not want to spend time optimizing it before you are sure that is the right approach. In particular, it is helpful to learn a good prototyping language (Python, matlab) and use it for the early stages of the project and switch to (or mix it with) c++ only after finding a promising direction.</p>
-
-<h3 id="9.avoidexplicitpointers">9. Avoid explicit pointers</h3>
-
-<p>Do yourself a favor, do not use explicit pointers. If you use a language that supports explicit pointers, use them only if you really have to. And even in that case, keep them isolated in a single file and be very careful with them. Writing data inside another variable by accident might not trigger a crash, and simply produce strange artifacts that might convince you that a promising research direction does not work, while the problem lies in a nasty bug in your code. There is no reason to take that risk during prototyping, just avoid them and leave them for the end of the project in case they become necessary to optimize your code.</p>
-
-<h3 id="10.ifyourprogramcrashesfixitnow">10. If your program crashes, fix it now!</h3>
-
-<p>If your program crashes, don&#8217;t close your eyes and move on. Try to make it happen again, debug it and fix it immediately. These bugs are a nightmare to find, and the more code you add on top of a bug will just make it harder to find. If you don&#8217;t fix it, due to Murphy&#8217;s law, it will start to be problematic only a few days before the deadline and you will have no time to fix it at that point.</p>
-
-<p><em>Daniele Panozzo</em></p>
-
-</body>
-</html>
-

coding-guidelines.md

@@ -1,42 +0,0 @@
-# Libigl Coding Tips (aka "How to code a SIGGRAPH project")
-
-This is a short list of coding tips that will greatly reduce your pain and suffering before (and after) the SIGGRAPH deadline.
-
-
-### 1. Serialize it all
-The entire state of your application should be serializable, i.e. It should be possible to save it into a binary file and reload it at any point. This drastically simplifies debugging, since you can serialize just before a crash happens and debug from that point without running your complete algorithm again. Serializing all results shown in the paper's figures enables quicker editing iterations before (and after) the deadline. It also allows you to share your results with others that wish to compare with your method. An additional tip is to serialize the state of the application on the window close event and automatically reload it when you launch it again.
-
-### 2. Always assert
-Even if you know what you are doing, always assert, you will be surprised. Assertion is a powerful but underused feature available in all programming languages. It is essential for writing research code since often you will have to implement algorithms that turns out to not be doing what you expect: in these cases it is important to know if the algorithm is flawed or if there is a bug in your implementation. Discarding a good idea  because of a coding bug is frustrating and unfortunately common. Assertion is an ideal way to reduce the chances of introducing bugs in your code and, differently from unit testing, requires a very minor programming effort. You should use them extensively.
-
-### 3. Plot everything
-
-If you can visually plot the results or some intermediate steps of your algorithm, do it, even if you think your implementation is correct! It is a lot easier to find bugs or to get an intuition on an algorithm by looking at a plot than by looking at the code.
-
-### 4. If the compilation time after a code change is more than five seconds, you are doing it wrong
-
-You will change your code hundreds of times every day for months. Let's say that you will change it a hundred times a day (which is a  very conservative estimate): if the compilation takes one minute, you will waste almost two hours every day, just waiting! What is even worse, is that since it is only 1-2 minutes at a time, it will not even be sufficient to prepare a coffee. Spend the hour or two that is needed to get your code to compile in a few seconds, you will benefit from it in the same day already, and the time saved over an entire project will be gigantic.
-
-### 5. Commit often (and with a meaningful description)
-
-Use a distributed version control system (git,hg), and keep the repository on a remote host. Commit often and put meaningful comments. This will serve you as an emergency backup and it will always allow you to have a running version of your code whenever your advisor is passing by and asking to see some results. She will be impressed and you will not have to quickly fix your build with your boss breathing down your neck.
-
-### 6. Dependencies are evil, avoid them
-
-Keep your code simple and with minimal external dependencies. Spending a day or two to code something from scratch while avoiding to use third party code is usually an investment that pays off. The more code you have in your algorithm that is not written by you, the harder debugging becomes. In particular, refrain from building your entire project on code that you do not understand to avoid bad surprises just before the deadline. If you must use code written by others, spend the time that is needed to fully understand what it does, and link it statically so that it will be easy to place breakpoints inside it.
-
-### 7. Global variables are not evil, use them
-
-Global variables are often extremely useful --- if you think you need one, use it. They are indeed dangerous for large projects, but you are not coding one of those, you are coding a prototype to test a research idea. I suggest to keep one single copy of your entire application state in a global variable (or a singleton class) that can be serialized (see tip 1). This variable should include everything rendered on screen and all the temporary data produced by your algorithm. This will allow you to easily access all the data in your project for plotting or debugging purposes.
-
-### 8. Prototype first
-Don’t preemptively optimize and try to quickly write code that is clean and correct. It is common to try multiple different approaches to solve a new problem before finding the right one. This means that the majority of the code that you will write will not be used at the end of the project. While you should still write high-quality and bug-free code to make sure that your results is correct, you definitely do not want to spend time optimizing it before you are sure that is the right approach. In particular, it is helpful to learn a good prototyping language (Python, matlab) and use it for the early stages of the project and switch to (or mix it with) c++ only after finding a promising direction.
-
-### 9. Avoid explicit pointers
-Do yourself a favor, do not use explicit pointers. If you use a language that supports explicit pointers, use them only if you really have to. And even in that case, keep them isolated in a single file and be very careful with them. Writing data inside another variable by accident might not trigger a crash, and simply produce strange artifacts that might convince you that a promising research direction does not work, while the problem lies in a nasty bug in your code. There is no reason to take that risk during prototyping, just avoid them and leave them for the end of the project in case they become necessary to optimize your code.
-
-### 10. If your program crashes, fix it now!
-
-If your program crashes, don't close your eyes and move on. Try to make it happen again, debug it and fix it immediately. These bugs are a nightmare to find, and the more code you add on top of a bug will just make it harder to find. If you don't fix it, due to Murphy's law, it will start to be problematic only a few days before the deadline and you will have no time to fix it at that point.
-
-_Daniele Panozzo_

file-formats/bf.html

@@ -1,30 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-  <head>
-    <link rel='stylesheet' type='text/css' href='../style.css' >
-    <title>libigl file formats | .bf</title>
-  </head>
-  <body class=article_outer>
-  <div class=article_inner>
-    <a href=..><img src=../libigl-logo.jpg alt="igl logo" class=center></a>
-    <h1>.bf - bone forests</h1>
-    <hr>
-    <p>
-A .bf file contains a "bone forest". Normally a skeleton for linear blend
-skinning is a "bone tree" with a single root. But this format may store
-multiple trees, hence a forest.
-    <p>
-Each line contains data about a vertex (joint) of the bone forest:
-    </p>
-    <pre><code>[weight index] [parent index] [x] [y] [z] [undocument optional data]</code></pre>
-    <p>
-Indices begin with 0.  The weight index is -1 if the bone does not have an
-associated weight. The parent index is -1 for root nodes. The x,y,z coordinates
-are offset vectors from this joint's parent's location (for roots, an offset
-from the origin).
-    </p>
-    <p>See also: <a href=.>file formats</a></p>
-  </div>
-  </body>
-</html>
-

file-formats/dmat.html

@@ -1,44 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-  <head>
-    <link rel='stylesheet' type='text/css' href='../style.css' >
-    <title>libigl file formats | .dmat</title>
-  </head>
-  <body class=article_outer>
-  <div class=article_inner>
-    <a href=..><img src=../libigl-logo.jpg alt="igl logo" class=center></a>
-    <h1>.dmat - dense matrices</h1>
-    <hr>
-    <p>
-A .dmat file contains a dense matrix in column major order. It can contain
-ASCII or binary data. Note that it is uncompressed so binary only reduces the
-file size by 50%. But writing and reading binary is usually faster. In MATLAB,
-binary is almost 100x faster.
-    </p>
-    <h2>ASCII</h2>
-    <p>
-The first line is a header containing:
-    </p>
-    <pre><code>[#cols] [#rows]</code></pre>
-    <p>
-Then the coefficients are printed in column-major order separated by spaces. 
-    </p>
-    <h2>Binary</h2>
-    <p>
-Binary files will also contain the ascii header, but it should read:
-    </p>
-    <pre><code>0 0</code></pre>
-    <p>
-Then there should be another header containing the size of the binary part:
-    </p>
-    <pre><code>[#cols] [#rows]</code></pre>
-    <p>
-Then coefficients are written in column-major order in Little-endian 8-byte
-double precision IEEE floating point format.
-    </p>
-    <p><strong>Note:</strong> Line endings must be <code>'\n'</code> aka char(10) aka line feeds.</p>
-    <p>See also: <a href=.>file formats</a></p>
-  </div>
-  </body>
-</html>
-

file-formats/index.html

@@ -1,97 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-  <head>
-    <link rel='stylesheet' type='text/css' href='../style.css' >
-    <title>libigl file formats</title>
-  </head>
-  <body class=article_outer>
-  <div  class=article_inner>
-    <a href=..><img src=../libigl-logo.jpg alt="igl logo" class=center></a>
-  <h1>libigl file formats</h1>
-  <ul>
-    <li><a href="./bf.html">.bf</a> ASCII files for representing skeletal bone "forests"</li>
-    <li><a href="./dmat.html">.dmat</a> uncompressed ASCII/binary files for dense matrices</li>
-    <li><i>.ele</i> Element (triangle or tet) list. This format comes in similar flavors: <a
-    href=http://tetgen.berlios.de/fformats.ele.html>tetgen's</a>, <a
-    href=http://www.cs.berkeley.edu/~jrs/stellar/#fileformats>stellar's</a>,
-    and <a href=https://www.cs.cmu.edu/~quake/triangle.ele.html>triangle's</a>.
-    The formats of TetGen and stellar are identical upto conventions on index
-    ordering and number of allowed attributes (unverified).</li>
-    <li><a href=http://tetgen.berlios.de/fformats.face.html
-    class=missing>.face</a> TetGen's file format for simplicial facets.</li>
-    <li><a href="http://www.ann.jussieu.fr/frey/publications/RT-0253.pdf#page=33">.mesh</a> Medit's triangle surface mesh + tetrahedral volume mesh file format, see page 33, section 7.2.1</li>
-    <li><i>.node</i> List of points (vertices). Described identically (upto
-        accepted dimensions, use of attributes and boundary markers) by <a
-    href="https://www.cs.cmu.edu/~quake/triangle.node.html">Triangle</a>, <a
-    href=http://tetgen.berlios.de/fformats.node.html>TetGen</a>, and <a
-    href=http://www.cs.berkeley.edu/~jrs/stellar/#fileformats>Stellar</a>.
-    </li>
-    <li><a href="http://wias-berlin.de/software/tetgen/fformats.off.html">.off</a> Geomview's polyhedral file format</li>
-    <li><a
-    href="http://en.wikipedia.org/wiki/Wavefront_.obj_file#File_format">.obj</a>
-    Wavefront object file format. Usually unsafe to assume anything more than
-    vertex positions and triangle indices are supported</li>
-    <li><a href=http://en.wikipedia.org/wiki/PLY_%28file_format%29>.ply</a>
-    Polygon File Format, supporting ASCII and binary encoding</li>
-    <li><a
-    href=https://en.wikipedia.org/wiki/Portable_Network_Graphics>.png</a>
-    Portable Network Graphics image file. IGLLIB (in the libiglpng extra)
-  supports png image files via the <a href=https://github.com/yig/yimg>yimg</a>
-  library. Alpha channels and compression are supported.</li>
-    <li><i>.poly</i> Piecewise-linear complex. This format comes in many similar but importantly different flavors: 
-      <a href="https://www.cs.cmu.edu/~quake/triangle.poly.html">triangle's</a>, <a href="http://tetgen.berlios.de/fformats.poly.html">tetgen's</a>, <a href="http://sparse-meshing.com/svr/0.2.1/format-poly.html">pyramid/SVR's</a></li>
-    <li><a href=./rbr.html>.rbr</a> ASCII files for saving state of ReAntTweakBar</li>
-    <li><a href=http://en.wikipedia.org/wiki/STL_(file_format)>.stl</a> 3D Systems' CAD and 3D printing mesh file format. ASCII and binary versions.</li>
-    <li><a href=http://en.wikipedia.org/wiki/Truevision_TGA>.tga</a> Truevision TGA or TARGA image file format. IGLLIB supports only very basic reading and writing RGB/RGBA files without colormaps and (unverified) run-length compression.</li>
-    <li><a href="./tgf.html">.tgf</a> ASCII files for representing control handle graphs</li>
-    <li><a href="http://en.wikipedia.org/wiki/VRML#WRL_File_Format">.wrl</a>
-    VRML (Virtual Reality Modeling Language) file format for 3D scenes.</li>
-    <li><a href="./xml.html">.xml</a> XMLSerializer's file format containing the serialization of object data structures.</li>
-  </ul>
-  <h3>Triangle mesh file format performance</h3>
-  <p>
-  <a
-  href="http://en.wikipedia.org/wiki/Wavefront_.obj_file#File_format">.obj</a>
-  and <a href="http://tetgen.berlios.de/fformats.off.html">.off</a> file
-  formats support meshes with arbitrary polygon degrees. However, often we are
-  only working with triangle meshes. Further, .obj files do not have useful
-  headers revealing the number of elements. For triangle meshes, .off and .obj
-  are inferior file formats to the <a
-  href="http://www.ann.jussieu.fr/frey/publications/RT-0253.pdf#page=33">.mesh</a>
-  file format. The current (version 0.1.6) IO functions for these file formats perform as follows for reading and writing a 300,000 triangle mesh:
-  </p>
-  <pre><code>
-writeOBJ:  1.33742 secs
-writeOFF:  0.510111 secs
-writeMESH: 0.218139 secs
-
-readOBJ:   1.3782 secs
-readOFF:   0.691496 secs
-readMESH:  0.242315 secs
-  </code></pre>
-  <p>
-  This reveals that .mesh is 6.5x faster than .obj and about 2.5x faster than .off.
-  </p>
-  <p>
-  While .obj files support normals, it is typically much faster to (re)compute
-  normals from the geometry using <code>per_face_normals</code>,
-  <code>per_vertex_normals</code>, <code>per_corner_normals</code> than to read
-  and write them to files.</p>
-  <p>It gets even better if you're willing to use a nonstandard format. If your
-  triangle mesh is in (<code>V</code>,<code>F</code>) then you can read and
-  write those variables as dense matrices of doubles to 
-  <a href="./dmat.html">.dmat</a> uncompressed <strong>binary</strong> files.
-  This not only ensures perfect precision but also big speed ups. On that same
-  300,000 triangle mesh, .dmat achieves:</p>
-  <pre><code>
-writeDMAT: 0.0384338 secs
-
-readDMAT:  0.0117921 secs
-  </code></pre>
-  <p>This reveals that binary .dmat files are 34x/116x faster at writing and
-  reading than .obj and a hefty 5x/20x over .mesh. In this case it may pay to
-  compute normals once into <code>N</code> and also read and write it to a
-  .dmat file.</p>
-  </div>
-  </body>
-</html>

file-formats/rbr.html

@@ -1,34 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-  <head>
-    <link rel='stylesheet' type='text/css' href='../style.css' >
-    <title>libigl file formats | .rbr</title>
-  </head>
-  <body class=article_outer>
-  <div  class=article_inner>
-    <a href=..><img src=../libigl-logo.jpg alt="igl logo" class=center></a>
-    <h1>.rbr - ReAntTweakbar state file</h1>
-    <hr>
-    <p>
-An .rbr file contains the saved values of the ReAntTweakBar class. It is used
-to load and save variables (and states specified via callbacks) stored in an
-AntTweakBar GUI.
-    </p>
-    <p>
-Each line contains the name of the AntTweakBar item, the type of item and the
-value as a string:
-    </p>
-    <pre><code>[name]: [type] [value]</code></pre>
-    <p>
-As per AntTweakBar's own advice, names should not contain spaces. Names should
-also not contain colons (':'). An example of a line looks like:
-    </p>
-    <pre><code>my_rotation: TW_TYPE_QUAT4 0.0111272 -0.00101157 0.00648534 -0.999917</code></pre>
-    <p>Not all AntTweakBar types are currently supported. See
-    <code>igl/ReAntTweakbar.h</code> for an up-to-date list of supported
-    types.</p>
-    <p>See also: <a href=.>file formats</a></p>
-  </div>
-  </body>
-</html>
-

file-formats/tgf.html

@@ -1,36 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-  <head>
-    <link rel='stylesheet' type='text/css' href='../style.css' >
-    <title>libigl file formats | .tgf</title>
-  </head>
-  <body class=article_outer>
-  <div class=article_inner>
-    <a href=..><img src=../libigl-logo.jpg alt="igl logo" class=center></a>
-    <h1>.tgf - control handle graphs</h1>
-    <hr>
-    <p>
-A .tgf file contains a graph of describing a set of control handles/structures:
-point controls, bones of a skeleton and cages made of "cage edges".
-    </p>
-    <p>
-The first part of the file consists of lines regarding each vertex of the graph. Each line reads:
-    </p>
-    <pre><code>[index] [x] [y] [z] [undocument optional data]</code></pre>
-    <p>
-Indices begin with 1 and should proceed in order.
-Then there should be a line with a sole:
-    </p>
-    <pre><code>#</code></pre>
-    <p>
-The next section concerns the edges of the graph. Each line corresponds to an edge:
-    </p>
-    <pre><code>[source index] [dest index] [is bone] [is pseudo-edge] [is cage edge] [undocument other data]</code></pre>
-    <p>
-Bone edges trump pseudo and cage edges. 
-    </p>
-    <p>See also: <a href=.>file formats</a></p>
-  </div>
-  </body>
-</html>
-

file-formats/xml.html

@@ -1,86 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-  <head>
-    <link rel='stylesheet' type='text/css' href='../style.css' >
-    <title>libigl file formats | .xml</title>
-  </head>
-  <body class=article_outer>
-  <div class=article_inner>
-    <a href=..><img src=../libigl-logo.jpg alt="igl logo" class=center></a>
-    <h1>.xml - serialization format</h1>
-    <hr>
-    <p>
-A .xml file contains the serialization of an object data structure generated with the XMLSerializer:
-    </p>
-    <p>
-The top level elements represent the groups in which the object are organised. The object names are unique within these groups.
-    </p>
-    <pre><code>&lt;group1&gt;
-  &lt;object1 val="value of object 1"/&gt;
-  &lt;object2 val="value of object 2"/&gt;
-&lt;/group1&gt;
-
-&lt;group2&gt;
-  &lt;object1 val="value of object 1"/&gt;
-&lt;/group2&gt;</code></pre>
-    <p>
-An object can be of following type:<br/>
-<br/>
-Basic types: <b>char, char*, std::string, bool, usigned int, int, float, double</b><br/>
-STL containers: <b>std::array, std::vector, std::pair</b><br/>
-Eigen types: <b>Eigen::Matrix, Eigen::SparseMatrix</b><br/>
-User defined types: <b>XMLSerializable*.</b><br/>
-<br/>
-There can also be a hierarchical structure like vector&lt;int&gt;, this will result in the following serialization:
-    </p>
-    <pre><code>&lt;group&gt;
-  &lt;vector size="3"&gt;
-    &lt;value0 val="1"/&gt;
-    &lt;value1 val="2"/&gt;
-    &lt;value2 val="3"/&gt;
-  &lt;/vector&gt;
-&lt;/group&gt;</code></pre>
-
-    <p>An example of a serialization of an instance of the class Test</p>
-    
-	<pre><code>class Test{
-  int var1;
-  vector&ltfloat&gt; vec1;  
-};</code></pre>
-
-<p> is shown here:</p>
-
-<pre><code>&lt;group&gt;
-  &lt;Test&gt;
-    &lt;var1 val="0"&gt;
-    &lt;vec1 size="2"&gt;
-      &lt;value0 val="1"/&gt;
-      &lt;value1 val="2"/&gt;
-    &lt;/vector&gt;
-  &lt;/Test&gt;
-&lt;/group&gt;</code></pre>
-
-<p>In the following we show the serialization of Eigen matrices.</p>
-
-<p>Eigen::Matrix&lt;int,4,3&gt;:</p>
-<pre><code>&lt;group&gt;
-  &lt;matrix row="4" col="3" matrix="
-1,2,3,
-4,5,6,
-7,8,9,
-10,11,12/&gt;
-&lt;/group&gt;</code></pre>
-
-<p>Eigen::SparseMatrix&lt;int&gt; (3x3 identity saved as triplets of the non-zero entries):</p>
-<pre><code>&lt;group&gt;
-  &lt;matrix row="3" col="3" matrix="
-0,0,1,
-1,1,1,
-2,2,1/&gt;
-&lt;/group&gt;</code></pre>
-
-    <p>See also: <a href=.>file formats</a></p>
-  </div>
-  </body>
-</html>
-

include/igl/guess_extension.cpp

@@ -1,4 +1,7 @@
 #include "guess_extension.h"
+
+#include <string.h>
+
 #include "is_stl.h"
 #include "ply.h"
 
@@ -21,7 +24,7 @@ IGL_INLINE void igl::guess_extension(FILE * fp, std::string & guess)
   {
     int nelems;
     char ** elem_names;
-    PlyFile * in_ply = ply_read(ply_file,&nelems,&elem_names);
+    igl::ply::PlyFile * in_ply = igl::ply::ply_read(ply_file,&nelems,&elem_names);
     if(in_ply==NULL)
     {
       return false;

include/igl/ply.h.REMOVED.git-id

@@ -1 +1 @@
-71f4860db5bab6831ffc0ceb38c42c4973c0fc1a
+60f2b29de2e29d034e068eb5ae4bf9747a63232e

include/igl/readPLY.cpp

@@ -58,7 +58,7 @@ IGL_INLINE bool igl::readPLY(
      void *other_props;       /* other properties */
    } Face;
 
-  PlyProperty vert_props[] = { /* list of property information for a vertex */
+  igl::ply::PlyProperty vert_props[] = { /* list of property information for a vertex */
     {"x", PLY_DOUBLE, PLY_DOUBLE, offsetof(Vertex,x), 0, 0, 0, 0},
     {"y", PLY_DOUBLE, PLY_DOUBLE, offsetof(Vertex,y), 0, 0, 0, 0},
     {"z", PLY_DOUBLE, PLY_DOUBLE, offsetof(Vertex,z), 0, 0, 0, 0},
@@ -69,14 +69,14 @@ IGL_INLINE bool igl::readPLY(
     {"t", PLY_DOUBLE, PLY_DOUBLE, offsetof(Vertex,t), 0, 0, 0, 0},
   };
 
-  PlyProperty face_props[] = { /* list of property information for a face */
+  igl::ply::PlyProperty face_props[] = { /* list of property information for a face */
     {"vertex_indices", PLY_INT, PLY_INT, offsetof(Face,verts),
       1, PLY_UCHAR, PLY_UCHAR, offsetof(Face,nverts)},
   };
 
   int nelems;
   char ** elem_names;
-  PlyFile * in_ply = ply_read(ply_file,&nelems,&elem_names);
+  igl::ply::PlyFile * in_ply = igl::ply::ply_read(ply_file,&nelems,&elem_names);
   if(in_ply==NULL)
   {
     return false;
@@ -84,11 +84,11 @@ IGL_INLINE bool igl::readPLY(
 
   bool has_normals = false;
   bool has_texture_coords = false;
-  PlyProperty **plist;
+  igl::ply::PlyProperty **plist;
   int nprops;
   int elem_count;
   plist = ply_get_element_description (in_ply,"vertex", &elem_count, &nprops);
-  int native_binary_type = get_native_binary_type2();
+  int native_binary_type = igl::ply::get_native_binary_type2();
   if (plist != NULL)
   {
     /* set up for getting vertex elements */
@@ -97,18 +97,18 @@ IGL_INLINE bool igl::readPLY(
     ply_get_property (in_ply,"vertex",&vert_props[2]);
     for (int j = 0; j < nprops; j++)
     {
-      PlyProperty * prop = plist[j];
-      if (equal_strings ("nx", prop->name) 
-        || equal_strings ("ny", prop->name)
-        || equal_strings ("nz", prop->name))
+      igl::ply::PlyProperty * prop = plist[j];
+      if (igl::ply::equal_strings ("nx", prop->name) 
+        || igl::ply::equal_strings ("ny", prop->name)
+        || igl::ply::equal_strings ("nz", prop->name))
       {
         ply_get_property (in_ply,"vertex",&vert_props[3]);
         ply_get_property (in_ply,"vertex",&vert_props[4]);
         ply_get_property (in_ply,"vertex",&vert_props[5]);
         has_normals = true;
       }
-      if (equal_strings ("s", prop->name) ||
-        equal_strings ("t", prop->name))
+      if (igl::ply::equal_strings ("s", prop->name) ||
+        igl::ply::equal_strings ("t", prop->name))
       {
         ply_get_property(in_ply,"vertex",&vert_props[6]);
         ply_get_property(in_ply,"vertex",&vert_props[7]);

include/igl/writePLY.cpp

@@ -56,7 +56,7 @@ IGL_INLINE bool igl::writePLY(
     FScalar *verts;              /* vertex index list */
   } Face;
 
-  PlyProperty vert_props[] =
+  igl::ply::PlyProperty vert_props[] =
   { /* list of property information for a vertex */
     {"x", ply_type<VScalar>(), ply_type<VScalar>(),offsetof(Vertex,x),0,0,0,0},
     {"y", ply_type<VScalar>(), ply_type<VScalar>(),offsetof(Vertex,y),0,0,0,0},
@@ -68,7 +68,7 @@ IGL_INLINE bool igl::writePLY(
     {"t", ply_type<UVScalar>(),ply_type<UVScalar>(),offsetof(Vertex,t),0,0,0,0},
   };
 
-  PlyProperty face_props[] =
+  igl::ply::PlyProperty face_props[] =
   { /* list of property information for a face */
     {"vertex_indices", ply_type<FScalar>(), ply_type<FScalar>(), 
       offsetof(Face,verts), 1, PLY_UCHAR, PLY_UCHAR, offsetof(Face,nverts)},
@@ -110,14 +110,14 @@ IGL_INLINE bool igl::writePLY(
   {
     return false;
   }
-  PlyFile * ply = ply_write(fp, 2,elem_names,
+  igl::ply::PlyFile * ply = igl::ply::ply_write(fp, 2,elem_names,
       (ascii ? PLY_ASCII : PLY_BINARY_LE));
   if(ply==NULL)
   {
     return false;
   }
 
-  std::vector<PlyProperty> plist;
+  std::vector<igl::ply::PlyProperty> plist;
   plist.push_back(vert_props[0]);
   plist.push_back(vert_props[1]);
   plist.push_back(vert_props[2]);
@@ -137,7 +137,7 @@ IGL_INLINE bool igl::writePLY(
 
   ply_describe_element(ply, "face", F.rows(),1,&face_props[0]);
   ply_header_complete(ply);
-  int native_binary_type = get_native_binary_type2();
+  int native_binary_type = igl::ply::get_native_binary_type2();
   ply_put_element_setup(ply, "vertex");
   for(const auto v : vlist)
   {

index.html

@@ -1,288 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
-<head>
-	<meta charset="utf-8"/>
-	<title>libigl</title>
-	<meta name="author" content="Alec Jacobson and Daniele Panozzo and others"/>
-	<link type="text/css" rel="stylesheet" href="tutorial/style.css"/>
-<script type='text/javascript' src='http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'></script> <link rel='stylesheet' href='http://yandex.st/highlightjs/7.3/styles/default.min.css'> <script src='http://yandex.st/highlightjs/7.3/highlight.min.js'></script> <script>hljs.initHighlightingOnLoad();</script>
-</head>
-<body>
-
-<h1 id="libigl-asimplecgeometryprocessinglibrary">libigl - A simple C++ geometry processing library</h1>
-
-<p><a href="https://travis-ci.org/libigl/libigl"><img src="https://travis-ci.org/libigl/libigl.svg?branch=master" alt="Build Status" /></a>
-<a href="https://ci.appveyor.com/project/danielepanozzo/libigl-6hjk1/branch/master"><img src="https://ci.appveyor.com/api/projects/status/mf3t9rnhco0vhly8/branch/master?svg=true" alt="Build status" /></a>
-<img src="libigl-teaser.png" alt="" /></p>
-
-<p><a href="https://github.com/libigl/libigl/">https://github.com/libigl/libigl/</a></p>
-
-<blockquote>
-<p>Get started with:</p>
-</blockquote>
-
-<pre><code class="bash">git clone --recursive https://github.com/libigl/libigl.git
-</code></pre>
-
-<p>libigl is a simple C++ geometry processing library. We have a wide
-functionality including construction of sparse discrete differential geometry
-operators and finite-elements matrices such as the cotangent Laplacian and
-diagonalized mass matrix, simple facet and edge-based topology data structures,
-mesh-viewing utilities for OpenGL and GLSL, and many core functions for matrix
-manipulation which make <a href="http://eigen.tuxfamily.org">Eigen</a> feel a lot more
-like MATLAB.</p>
-
-<p>It is <strong>a header-only library</strong>. You do not need to compile anything to use,
-just include igl headers (e.g. <code>#include &lt;igl/cotmatrix.h&gt;</code>) and run. Each
-header file contains a single function (e.g. <code>igl/cotmatrix.h</code> contains
-<code>igl::cotmatrix()</code>). Most are tailored to operate on a generic triangle mesh
-stored in an n-by-3 matrix of vertex positions <code>V</code> and an m-by-3 matrix of
-triangle indices <code>F</code>.</p>
-
-<p><em>Optionally</em> the library may also be <a href="optional/">pre-compiled</a> into a statically
-linked library, for faster compile times with your projects. This only effects
-compile time (run-time performance and behavior is identical). If in doubt, use
-the header-only default mode: (i.e. just include the headers you want to use).</p>
-
-<p>We use the <a href="http://eigen.tuxfamily.org">Eigen</a> library heavily in our code. Our
-group prototypes a lot in MATLAB, and we have a useful <a href="matlab-to-eigen.html">MATLAB to libigl+Eigen
-conversion table</a>.</p>
-
-<p>We regularly test compiling our library on Mac OS X with clang, Linux with gcc
-and Windows with Visual Studio 2015 Community Edition.</p>
-
-<h2 id="tutorial">Tutorial</h2>
-
-<p>As of version 1.0, libigl includes an introductory
-<a href="http://libigl.github.io/libigl/tutorial/tutorial.html">tutorial</a> that covers many functionalities.</p>
-
-<h2 id="libiglexampleproject">libigl Example Project</h2>
-
-<p>We provide a <a href="https://github.com/libigl/libigl-example-project">blank project example</a> showing how to use libigl and cmake. Feel free and encouraged to copy or fork this project as a way of starting a new personal project using libigl.</p>
-
-<h2 id="codingguidelinesandtips">Coding Guidelines and Tips</h2>
-
-<p>libigl follows strict coding guidelines, please take a look <a href="http://libigl.github.io/libigl/style-guidelines.html">here</a> before submitting your pull requests. We also have a set of <a href="http://libigl.github.io/libigl/coding-guidelines.html">general coding tips</a> on how to code a geometry processing research project.</p>
-
-<h2 id="installation">Installation</h2>
-
-<p>Libigl is a <strong>header-only</strong> library. You do <strong>not</strong> need to build anything to
-install. Simply add <code>libigl/include</code> to your include path and include relevant
-headers. Here is a small &#8220;Hello, World&#8221; program:</p>
-
-<pre><code class="cpp">#include &lt;igl/cotmatrix.h&gt;
-#include &lt;Eigen/Dense&gt;
-#include &lt;Eigen/Sparse&gt;
-#include &lt;iostream&gt;
-int main()
-{
-  Eigen::MatrixXd V(4,2);
-  V&lt;&lt;0,0,
-     1,0,
-     1,1,
-     0,1;
-  Eigen::MatrixXi F(2,3);
-  F&lt;&lt;0,1,2,
-     0,2,3;
-  Eigen::SparseMatrix&lt;double&gt; L;
-  igl::cotmatrix(V,F,L);
-  std::cout&lt;&lt;&quot;Hello, mesh: &quot;&lt;&lt;std::endl&lt;&lt;L*V&lt;&lt;std::endl;
-  return 0;
-}
-</code></pre>
-
-<p>If you save this in <code>hello.cpp</code>, then you could compile this with (assuming
-Eigen is installed in <code>/usr/local/include/eigen3</code>):</p>
-
-<pre><code class="bash">g++ -std=c++11 -I/usr/local/include/eigen3 -I./libigl/include/ hello.cpp -o hello
-</code></pre>
-
-<p>Running <code>./hello</code> would then produce</p>
-
-<pre><code>Hello, mesh:
- 0.5  0.5
--0.5  0.5
--0.5 -0.5
- 0.5 -0.5
-</code></pre>
-
-<h2 id="dependencies">Dependencies</h2>
-
-<p>Dependencies are on a per-include basis and the majority of the functions in
-libigl depends only on the <a href="http://eigen.tuxfamily.org">Eigen</a> library.</p>
-
-<p>For more information see our <a href="tutorial/tutorial.html">tutorial</a>.</p>
-
-<h3 id="optionaldependencies">Optional Dependencies</h3>
-
-<p>Libigl compartmentalizes its <strong>optional</strong> dependences via its directory
-organization in the <code>include/</code> folder. All header files located <em>directly</em> in
-the <code>include/igl/</code> folder have only stl and Eigen as dependencies. For example,
-all of the headers that depend on CGAL are located in <code>include/igl/copyleft/cgal</code>.
-For a full list of <em>optional</em> dependencies check <code>optional/CMakeLists.txt</code>.</p>
-
-<h3 id="gccandtheoptionalcgaldependency">GCC and the Optional CGAL Dependency</h3>
-
-<p>The <code>include/igl/copyleft/cgal/*.h</code> headers depend on CGAL. It has come to
-our attention that CGAL does not work properly with GCC 4.8. To the best of
-our knowledge, GCC 4.7 and clang will work correctly.</p>
-
-<h3 id="openmpandwindows">OpenMP and Windows</h3>
-
-<p>Some of our functions will take advantage of OpenMP if available. However, it
-has come to our attention that Visual Studio + Eigen + OpenMP does not work
-properly. Since we use OpenMP only to improve performance, we recommend
-avoiding OpenMP on Windows or proceeding with caution.</p>
-
-<h2 id="download">Download</h2>
-
-<p>You can keep up to date by cloning a read-only copy of our GitHub
-<a href="https://github.com/libigl">repository</a>.</p>
-
-<h2 id="knownissues">Known Issues</h2>
-
-<p>We rely heavily on Eigen. Nearly all inputs and outputs are Eigen matrices of
-some kind. However, we currently <em>only</em> officially support Eigen&#8217;s default
-column-major ordering. That means, we <strong>do not</strong> expect our code to work for
-matrices using the <code>Eigen::RowMajor</code> flag. If you can, change definitions like:</p>
-
-<pre><code class="cpp">Eigen::Matrix&lt;double, Eigen::Dynamic, 3, Eigen::RowMajor&gt; A;
-</code></pre>
-
-<p>to</p>
-
-<pre><code class="cpp">Eigen::Matrix&lt;double, Eigen::Dynamic, 3, Eigen::ColMajor&gt; A;
-// or simply
-Eigen::Matrix&lt;double, Eigen::Dynamic, 3&gt; A;
-</code></pre>
-
-<p>We hope to fix this, or at least identify which functions are safe (many of
-them probably work just fine). This requires setting up unit testing, which is
-a major <em>todo</em> for our development.</p>
-
-<h2 id="gitsubmodules">Git Submodules</h2>
-
-<p>Libigl uses git submodules for its <em>optional</em> dependencies,
-in particular, those needed by the OpenGL viewer to run the examples in the
-<a href="tutorial/tutorial.html">tutorial</a>. Git submodules allow use to treat clones of
-other libraries as sub-directories within ours while separating our commits.
-Read the <a href="http://git-scm.com/docs/git-submodule">documentation</a> for a detailed
-explanation, but essentially our libigl repo stores a hash for each of its
-subrepos containing which version to update to. When a change is introduced in
-a dependencies repo we can incorporate that change by pulling in our sub-repo
-and updating (i.e. committing) that change to the hash.</p>
-
-<p>When pulling new changes to libigl it&#8217;s also a good idea to update changes to
-subrepos:</p>
-
-<pre><code class="bash">git pull
-git submodule update --recursive
-</code></pre>
-
-<h2 id="unittesting">Unit Testing</h2>
-
-<p>Libigl maintains <a href="https://github.com/libigl/libigl-unit-tests">separate
-repository</a> for unit testing.</p>
-
-<h2 id="howtocontribute">How to Contribute</h2>
-
-<p>If you are interested in joining development, please fork the repository and
-submit a <a href="https://help.github.com/articles/using-pull-requests/">pull request</a>
-with your changes. libigl follows strict coding guidelines, please take a look at our <a href="style-guidelines.html">style guidelines</a> before submitting your pull requests.</p>
-
-<h2 id="license">License</h2>
-
-<p>libigl is primarily <a href="http://www.mozilla.org/MPL/2.0/">MPL2</a> licensed
-(<a href="http://www.mozilla.org/MPL/2.0/FAQ.html">FAQ</a>). Some files contain
-third-party code under other licenses. We&#8217;re currently in the processes of
-identifying these and marking appropriately.</p>
-
-<h2 id="attribution">Attribution</h2>
-
-<p>If you use libigl in your academic projects, please cite the papers we
-implement as appropriate. To cite the library in general, you could use this
-BibTeX entry:</p>
-
-<pre><code class="bibtex">@misc{libigl,
-  title = {{libigl}: A simple {C++} geometry processing library},
-  author = {Alec Jacobson and Daniele Panozzo and others},
-  note = {http://libigl.github.io/libigl/},
-  year = {2017},
-}
-</code></pre>
-
-<h2 id="projectsuniversitiesusinglibigl">Projects/Universities using libigl</h2>
-
-<p>Libigl is used by many research groups around the world. In 2015, it won the
-Eurographics/ACM Symposium on Geometry Processing software award. Here are a
-few labs/companies/institutions using libigl:</p>
-
-<ul>
-<li> <a href="http://www.activision.com">Activision</a></li>
-<li> <a href="http://www.adobe.com/technology/">Adobe Research</a></li>
-<li> <a href="http://www.ea.com">Electronic Arts, Inc</a></li>
-<li> <a href="https://epicgames.com">Epic Games</a></li>
-<li> <a href="https://research.google.com">Google Research</a></li>
-<li> <a href="http://ilm.com">Industrial Light and Magic</a></li>
-<li> <a href="http://meshconsultants.ca/">Mesh consultants</a>, Canada</li>
-<li> <a href="https://www.microsoft.com/en-us/research/">Microsoft Research</a></li>
-<li> <a href="http://graphics.pixar.com/research/">Pixar</a></li>
-<li> <a href="http://esotericsoftware.com/">Spine by Esoteric Software</a> is an animation tool dedicated to 2D characters.</li>
-<li> <a href="http://vvvv.org">vvvv toolkit</a> a multipurpose tookit</li>
-<li> Columbia University, <a href="http://www.cs.columbia.edu/cg/">Columbia Computer Graphics Group</a>, USA</li>
-<li> <a href="http://www.graphics.cornell.edu/">Cornell University</a>, USA</li>
-<li> <a href="http://dcgi.felk.cvut.cz/">Czech Technical University in Prague</a>, Czech</li>
-<li> EPF Lausanne, <a href="http://lgg.epfl.ch/people.php">Computer Graphics and Geometry Laboratory</a>, Switzerland</li>
-<li> ETH Zurich, <a href="http://igl.ethz.ch/">Interactive Geometry Lab</a> and <a href="http://ait.inf.ethz.ch/">Advanced Technologies Lab</a>, Swizterland</li>
-<li> George Mason University, <a href="http://cs.gmu.edu/~ygingold/">CraGL</a>, USA</li>
-<li> <a href="http://www.ust.hk/">Hong Kong University of Science and Technology</a>, Hong Kong</li>
-<li> <a href="https://www.inria.fr/centre/grenoble/">Inria, Université Grenoble Alpes</a>, France</li>
-<li> <a href="http://english.jiangnan.edu.cn">Jiangnan university</a>, China</li>
-<li> <a href="http://www.nii.ac.jp/en/">National Institute of Informatics</a>, Japan</li>
-<li> New York University, <a href="http://mrl.nyu.edu/">Media Research Lab</a>, USA</li>
-<li> NYUPoly, <a href="http://game.engineering.nyu.edu/">Game Innovation Lab</a>, USA</li>
-<li> <a href="https://www.cg.tu-berlin.de">TU Berlin</a>, Germany</li>
-<li> <a href="http://www.tudelft.nl/en/">TU Delft</a>, Netherlands</li>
-<li> <a href="https://www.tuwien.ac.at/en/tuwien_home/">TU Wien</a>, Austria</li>
-<li> <a href="http://www.telecom-paristech.fr/en/formation-et-innovation-dans-le-numerique.html">Telecom ParisTech</a>, Paris, France</li>
-<li> <a href="http://www.staff.science.uu.nl/~vaxma001/">Utrecht University</a>, The Netherlands</li>
-<li> <a href="http://mtm.ufsc.br/~leo/">Universidade Federal de Santa Catarina</a>, Brazil</li>
-<li> <a href="http://vecg.cs.ucl.ac.uk/">University College London</a>, England</li>
-<li> <a href="http://vis.berkeley.edu/">University of California Berkeley</a>, USA</li>
-<li> <a href="http://www.cam.ac.uk/">University of Cambridge</a>, England</li>
-<li> <a href="http://cg.cis.upenn.edu/">University of Pennsylvania</a>, USA</li>
-<li> <a href="http://www.cs.utexas.edu/users/evouga/">University of Texas at Austin</a>, USA</li>
-<li> <a href="http://dgp.toronto.edu">University of Toronto</a>, Canada</li>
-<li> <a href="https://www.csc.uvic.ca/Research/graphics/">University of Victoria</a>, Canada</li>
-<li> <a href="http://www.uwec.edu/computer-science/">University of Wisconsin-Eau Claire</a>, USA</li>
-<li> <a href="http://www.usi.ch/en">Università della Svizzera Italiana</a>, Switzerland</li>
-<li> <a href="http://www.univ-tlse3.fr/">Université Toulouse III Paul Sabatier</a>, France</li>
-<li> <a href="http://www.math.zju.edu.cn/cagd/">Zhejiang University</a>, China</li>
-</ul>
-
-<h2 id="contact">Contact</h2>
-
-<p>Libigl is a group endeavor led by <a href="http://www.cs.toronto.edu/~jacobson/">Alec
-Jacobson</a> and <a href="http://cs.nyu.edu/~panozzo/">Daniele
-Panozzo</a>. Please <a href="mailto:alecjacobson@gmail.com,daniele.panozzo@gmail.com">contact
-us</a> if you have
-questions or comments. For troubleshooting, please post an
-<a href="https://github.com/libigl/libigl/issues">issue</a> on github.</p>
-
-<p>If you&#8217;re using libigl in your projects, quickly <a href="mailto:alecjacobson@gmail.com,daniele.panozzo@gmail.com">drop us a
-note</a>. Tell us who you
-are and what you&#8217;re using it for. This helps us apply for funding and justify
-spending time maintaining this.</p>
-
-<p>If you find bugs or have problems please use our <a href="https://github.com/libigl/libigl/issues">github issue tracking
-page</a>.</p>
-
-<h2 id="copyright">Copyright</h2>
-
-<p>2017 Alec Jacobson, Daniele Panozzo, Christian Schüller, Olga Diamanti, Qingnan Zhou, Sebastian Koch, Jeremie Dumas, Amir Vaxman, Nico Pietroni, Stefan Brugger, Kenshi Takayama, Wenzel Jakob, Nikolas De Giorgis, Luigi Rocca, Leonardo Sacht, Kevin Walliman, Olga Sorkine-Hornung, and others.</p>
-
-<p>Please see individual files for appropriate copyright notices.</p>
-
-</body>
-</html>
-

libigl-teaser.png.REMOVED.git-id

@@ -1 +0,0 @@
-9bcc46445af9bf39049eca841aa080838c2ee837

matlab-to-eigen.html

@@ -1,317 +0,0 @@
-<html> <head>
-    <title>MATLAB to Eigen</title>
-    <link href="./style.css" rel="stylesheet" type="text/css">
-  </head>
-  <body>
-    <table>
-      <tr class="header">
-        <th>MATLAB</th>
-        <th>Eigen with libigl</th>
-        <th>Notes</th>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>[Y,IX] = sort(X,dim,mode)</code></pre></td>
-        <td><pre><code>igl::sort(X,dim,mode,Y,IX)</code></pre></td>
-        <td>MATLAB version allows Y to be a multidimensional matrix, but the
-        Eigen version is only for 1D or 2D matrices.</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>B(i:(i+w),j:(j+h)) = A(x:(x+w),y:(y+h))</code></pre></td>
-        <td><pre><code>B.block(i,j,w,h) = A.block(i,j,w,h)</code></pre></td>
-        <td>MATLAB version would allow w and h to be non-positive since the
-        colon operator evaluates to a list of indices, but the Eigen version
-        needs non-negative width and height values.</td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>max(A(:))</code></pre></td>
-        <td><pre><code>A.maxCoeff()</code></pre></td>
-        <td>Find the maximum coefficient over all entries of the matrix.</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>min(A(:))</code></pre></td>
-        <td><pre><code>A.minCoeff()</code></pre></td>
-        <td>Find the minimum coefficient over all entries of the matrix.</td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>eye(w,h)</code></pre></td>
-        <td><pre><code>MatrixXd::Identity(w,h), MatrixXf::Identity(w,h), etc.</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>A(i:(i+w),j:(j+h)) = eye(w,h)</code></pre></td>
-        <td><pre><code>A.block(i,j,w,h).setIdentity()</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>[I,J,V] = find(X)</code></pre></td>
-        <td><pre><code>igl::find(X,I,J,V)</code></pre></td>
-        <td>Matlab supports finding subscripts (I and J) as well as indices
-        (just I), but so far igl::find only supports subscripts. Also,
-        igl::find requires X to be sparse.</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>X(:,j) = X(:,j) + x</code></pre></td>
-        <td><pre><code>X.col(j).array() += x</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>Acol_sum = sum(A,1)<br>Arow_sum = sum(A,2)<br>Adim_sum = sum(Asparse,dim)</code></pre></td>
-        <td><pre><code>Acol_sum = A.colwise().sum()<br>Arow_sum = A.rowwise().sum()<br>igl::sum(Asparse,dim,Adim_sum)</code></pre></td>
-        <td>Currently the igl version only supports sparse matrix input (and
-            dim must be 1 or 2).<br>
-            For sparse matrices, one could use
-            <code>A*Matrix&lt;Atype,Dynamic,1&gt;::Ones(A.cols(),1);</code> but this
-            will <b>not</b> work as expected for
-            <code>SparseMatrix&lt;bool&gt;</code>.
-        </td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>D = diag(M)</code></pre></td>
-        <td><pre><code>igl::diag(M,D)</code></pre></td>
-        <td>Extract the main diagonal of a matrix. Currently igl version
-        supports sparse only.</td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>M = diag(D)</code></pre></td>
-        <td><pre><code>igl::diag(D,M)</code></pre></td>
-        <td>Construct new square matrix M with entries of vector D along the
-        diagonal. Currently igl version supports sparse only. Might also
-        consider simply: <code>M = D.asDiagonal();</code></td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>[Y,I] = max(X,[],dim)</code></pre></td>
-        <td id=mat_max><pre><code>igl::mat_max(X,dim,Y,I)</code></pre></td>
-        <td>Matlab has a bizarre convention of passing [] as the second
-          argument to mean take the max/min along dimension dim.</td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>Y = max(X,[],1)<br>Y = max(X,[],2)<br>Y = min(X,[],1)<br>Y = min(X,[],2)</code></pre></td>
-        <td><pre><code>Y = X.colwise().maxCoeff()<br>Y = X.rowwise().maxCoeff()<br>Y = X.colwise().minCoeff()<br>Y = X.rowwise().minCoeff()</code></pre></td>
-        <td>Matlab allows you to obtain the indices of extrema see <a href=#mat_max>mat_max</a></td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>C = A.*B</code></pre></td>
-        <td><pre><code>C = (A.array() * B.array()).matrix()</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>C = A.^b</code></pre></td>
-        <td><pre><code>C = A.array().pow(b).matrix()</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>A(B == 0) = C(B==0)</code></pre></td>
-        <td><pre><code>A = (B.array() == 0).select(C,A)</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=gotcha1>
-        <td><pre><code>C = A + B'</code></pre></td>
-        <td><pre><code>SparseMatrixType BT = B.transpose()<br>SparseMatrixType C = A+BT;</code></pre></td>
-        <td>Do <b>not</b> attempt to combine .transpose() in expression like
-        this: <pre><code>C = A + B.transpose()</code></pre></td>
-      </tr>
-
-      <tr class=gotcha2>
-        <td><pre><code>[L,p] = chol(A)</code></pre></td>
-        <td><pre><code>SparseLLT&lt;SparseMatrixType&gt; A_LLT(A.template triangularView&lt;Lower&gt;())<br>SparseMatrixType L = A_LLT.matrixL();bool p = (L*0).eval().nonZeros()==0;</code></pre></td>
-        <td>Do <b>not</b> attempt to use A in constructor of A_LLT like
-        this: <pre><code>SparseLLT&lt;SparseMatrixType&gt; A_LLT(A)</code></pre><br>
-        Do <b>not</b> attempt to use A_LLT.succeeded() to determine if Cholesky
-        factorization succeeded, like this:
-        <pre><code>bool p = A_LLT.succeeded()</code></pre>
-        </td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>X = U\(L\b)</code></pre></td>
-        <td><pre><code>X = b;<br>L.template triangularView&lt;Lower&gt;().solveInPlace(X);<br>U.template triangularView&lt;Upper&gt;().solveInPlace(X);</code></pre></td>
-        <td>Expects that L and U are lower and upper triangular matrices
-        respectively</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>B = repmat(A,i,j)</code></pre></td>
-        <td><pre><code>igl::repmat(A,i,j,B);
-B = A.replicate(i,j);</code></pre></td>
-        <td>igl::repmat is also implemented for Sparse Matrices.
-        </td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>I = low:step:hi</code></pre></td>
-        <td><pre><code>igl::colon(low,step,hi,I);
-// or
-const int size = ((hi-low)/step)+1;
-I = VectorXi::LinSpaced(size,low,low+step*(size-1));</code></pre></td>
-        <td>IGL version should be templated enough to handle same situations as
-        matlab's colon. The matlab keyword <b>end</b> does not correspond in
-        the C++ version. You'll have to use M.size(),M.rows() or whatever.
-        </td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>O = ones(m,n)</code></pre></td>
-        <td><pre><code>Matrix* O = Matrix*::Ones(m,n)</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>O = zeros(m,n)</code></pre></td>
-        <td><pre><code>Matrix* O = Matrix*::Zero(m,n)</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>B = A(I,J)<br>B = A(I,:)</code></pre></td>
-        <td><pre><code>igl::slice(A,I,J,B)<br>igl::slice(A,I,1,B)</code></pre></td>
-        <td>This is only for the case when I and J are lists of indices and
-        not vectors of logicals.</td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>B(I,J) = A<br>B(I,:) = A</code></pre></td>
-        <td><pre><code>igl::slice_into(A,I,J,B)<br>igl::slice_into(A,I,1,B)</code></pre></td>
-        <td>This is only for the case when I and J are lists of indices and
-        not vectors of logicals.</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>M = mode(X,dim)</code></pre></td>
-        <td><pre><code>igl::mode(X,dim,M)</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>B = arrayfun(FUN, A)</code></pre></td>
-        <td><pre><code>B = A.unaryExpr(ptr_fun(FUN))</code></pre></td>
-        <td>If FUN is templated, the templates must be fully resolved.</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>B = fliplr(A)<br>B = flipud(A)</code></pre></td>
-        <td><pre><code>B = A.rowwise().reverse().eval()<br>B =
-	A.colwise().reverse().eval()</code></pre></td>
-        <td>The <code>.eval()</code> is not necessary if A != B</td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>B = IM(A)
-
-A = IM(A);
-  </code></pre></td>
-        <td><pre><code>B = A.unaryExpr(bind1st(mem_fun( 
-  static_cast&lt;VectorXi::Scalar&amp;(VectorXi::*)(VectorXi::Index)&gt;
-  (&amp;VectorXi::operator())), &amp;IM)).eval();
-// or
-for_each(A.data(),A.data()+A.size(),[&amp;IM](int &amp; a){a=IM(a);});
-  </code></pre></td>
-        <td>Where IM is an "index map" column vector and A is an arbitrary
-        matrix. The <code>.eval()</code> is not necessary if A != B, but then
-        the second option should be used.</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>A = sparse(I,J,V)</code></pre></td>
-        <td><pre><code>// build std::vector&ltEigen::Triplet&gt; IJV
-A.setFromTriplets(IJV);
-        </code></pre></td>
-        <td>IJV and A should not be empty! (this might be fixed)</td>
-      </tr>
-
-
-      <tr class=d0>
-        <td><pre><code>A = min(A,c);</code></pre></td>
-        <td><pre><code>C.array() = A.array().min(c);
-        </code></pre></td>
-        <td>Coefficient-wise minimum of matrix and scalar (or matching size matrix)</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>I=1:10;
-...
-IP = I(P==0);</code></pre></td>
-        <td><pre><code>I = VectorXi::LinSpaced(10,0,9);
-...
-VectorXi IP = I;
-IP.conservativeResize(stable_partition(
-  IP.data(), 
-  IP.data()+IP.size(), 
-  [&amp;P](int i){return P(i)==0;})-IP.data());
-        </code></pre></td>
-        <td>Where I is a vector of increasing indices from 0 to n, and P is a vector. <i>Requires C++11 and <code>#include &lt;algorithm&gt;</code></i></td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>B = A(R&lt;2,C&gt;1);</code></pre>
-        <td><pre><code>B = igl::slice_mask(A,R.array()&lt;2,C.array()&gt;1);</code></pre>
-        <td></td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>a = any(A(:))</code></pre></td>
-        <td><pre><code><del>bool a = any_of(A.data(),A.data()+A.size(),[](bool a){ return a;});</del>
-bool a = A.array().any();
-        </code></pre></td>
-        <td>Casts <code>Matrix::Scalar<code> to <code>bool</code>.</td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>B = mod(A,2)</code></pre></td>
-        <td><pre><code>igl::mod(A,2,B)</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>[IA,LOCB] = ismember(A,B)</code></pre></td>
-        <td><pre><code>igl::ismember(A,B,IA,LOCB)</code></pre></td>
-        <td></td>
-      </tr>
-
-      <tr class=d0>
-        <td><pre><code>A = A - diag(diag(A));</code></pre></td>
-        <td><pre><code>A.prune([](const int r, const int c, const Scalar)-&gt;bool{return r!=c;});</code></pre></td>
-        <td>Remove the diagonal from a sparse matrix.</td>
-      </tr>
-
-      <tr class=d1>
-        <td><pre><code>A = A - diag(diag(A));</code></pre></td>
-        <td><pre><code>A.prune([](const int r, const int c, const Scalar)-&gt;bool{return r!=c;});</code></pre></td>
-        <td>Remove the diagonal from a sparse matrix.</td>
-      </tr>
-
-      <!-- Insert rows for each command pair -->
-
-      <!-- Leave this here for copy and pasting
-
-      <tr class=d0>
-        <td><pre><code>Matlab code</code></pre></td>
-        <td><pre><code>Eigen code</code></pre></td>
-        <td>Notes</td>
-      </tr>
-
-      -->
-
-    </table>
-    <a href="http://eigen.tuxfamily.org/dox/AsciiQuickReference.txt">Eigen's
-    "ASCII Quick Reference" with MATLAB translations</a>
-    <br>
-    <a href="./tutorial.html">IGL Lib Tutorial</a>
-  </body>
-</html>

mkdocs.yml

@@ -0,0 +1,85 @@
+site_name: libigl
+site_url: 'http://libigl.github.io/libigl/'
+repo_name: 'libigl/libigl'
+repo_url: 'https://github.com/libigl/libigl'
+site_description: "Simple C++ geometry processing library"
+strict: true
+theme:
+  name: material
+  favicon: 'favicon.ico'
+  logo:
+    icon: ' '
+  palette:
+    primary: 'light blue'
+    accent: 'blue'
+extra:
+  social:
+    - type: 'github'
+      link: 'https://github.com/libigl'
+markdown_extensions:
+  - codehilite
+  - footnotes
+  - admonition
+  - toc:
+      permalink: true
+  - scripts.figureAltCaption
+  - markdown.extensions.smarty
+  - markdown.extensions.toc:
+      permalink: true
+  - pymdownx.arithmatex
+  - pymdownx.betterem:
+      smart_enable: all
+  - pymdownx.caret
+  - pymdownx.critic
+  - pymdownx.details
+  - pymdownx.inlinehilite
+  - pymdownx.magiclink
+  - pymdownx.mark
+  - pymdownx.smartsymbols
+  - pymdownx.superfences
+  - pymdownx.tasklist:
+      custom_checkbox: true
+  - pymdownx.tilde
+  - scripts.fixPaths:
+      variables:
+        repo_url: 'https://github.com/libigl/libigl/tree/master'
+extra_javascript:
+  - 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-MML-AM_CHTML'
+extra_css:
+  - 'css/style.css'
+pages:
+  - Home: index.md
+  - Tutorial: tutorial.md
+    # - "Chapter 1: Introduction to libigl": tutorial/chapter-1.md
+    # - "Chapter 2: Discrete Geometric Quantities and Operators": tutorial/chapter-2.md
+    # - "Chapter 3: Matrices and Linear Algebra": tutorial/chapter-3.md
+    # - "Chapter 4: Shape Deformation": tutorial/chapter-4.md
+    # - "Chapter 5: Parametrization": tutorial/chapter-5.md
+    # - "Chapter 6: External libraries": tutorial/chapter-6.md
+    # - "Chapter 7: Miscellaneous": tutorial/chapter-7.md
+    # - "Chapter 8: Outlook for continuing development": tutorial/chapter-8.md
+  - Compilation:
+    - Example Project: example-project.md
+    - Static Library: static-library.md
+    - External Dependencies: third-party.md
+    - Python Bindings: python-bindings.md
+  - Contributing:
+    - Style Guidelines: style-guidelines.md
+    - Bug Report: CONTRIBUTING.md
+    - Creating a Pull Request: before-submitting-pull-request.md
+    - Unit Tests: unit-tests.md
+  - Misc:
+    - Matlab-libigl Cheatsheet: matlab-to-eigen.md
+    - Coding Tips: coding-guidelines.md
+    - File Formats:
+      - Index: file-formats/index.md
+      - bf: file-formats/bf.md
+      - dmat: file-formats/dmat.md
+      - rbr: file-formats/rbr.md
+      - tgf: file-formats/tgf.md
+      - xml: file-formats/xml.md
+    - Building the Website: readme.md
+  - FAQ: faq.md
+  - About:
+    - Release History: RELEASE_HISTORY.md
+    - License: LICENSE.md

optional/README.md

@@ -1,306 +0,0 @@
-# Compiling libigl as a static library
-
-> Warning: compiling libigl as a static library is considerably more difficult
-> than using it as a header-only library (see [../README.md](../) instead). Do
-> it only if you are experienced with C++, cmake and make, and you want to
-> improve your compilation times.
-
-Libigl is developed most often on Mac OS X, though has current users in Linux
-and Windows.
-
-### Linux/Mac OS X/Cygwin ###
-
-Libigl may also be compiled to a static library. This is advantageous when
-building a project with libigl, since when used as an header-only library can
-slow down compile times.
-
-To build the entire libigl library producing at least `libigl/lib/libigl.a` and
-possible other (automatically detected) extras, e.g. `libigl/lib/libiglcgal.a`
-from _this current directory_: issue:
-
-    mkdir -p ../lib
-    cd ../lib
-    cmake -DCMAKE_BUILD_TYPE=Release ../optional
-    make
-
-#### Warnings ####
-
-You should expect to see a few linker warnings of the form:
-
-    /opt/local/bin/ranlib: file: libigl.a(*.cpp.o) has no symbols
-
-These are (admittedly unpopular) functions that have never been used by us
-statically so we haven't explicit instantiations (yet).
-
-#### External ####
-
-Finally there are a number of external libraries that we include in
-`./external/` because they are either difficult to obtain or they have been
-patched for easier use with libigl. Please see the respective readmes in those
-directories or build the tutorial using cmake, which will recursively build all
-dependencies.
-
-##### Installing Embree 2.0 #####
-To build the embree library and executables on Mac OS X issue:
-
-    cd external/embree
-    mkdir build
-    cd build
-    cmake ..
-    # Or using a different compiler
-    #cmake .. -DCMAKE_C_COMPILER=/opt/local/bin/gcc -DCMAKE_CXX_COMPILER=/opt/local/bin/g++
-    make
-    # Could also install embree to your root, but libigl examples don't expect
-    # this
-    #sudo make install
-
-## Extras ##
-
-### bbw ###
-This library extra contains functions for computing Bounded Biharmonic Weights, can
-be used with and without the [mosek](#mosek) extra via the `IGL_NO_MOSEK`
-macro.
-
-### boolean ##
-This library extra contains functions for computing mesh-mesh booleans,
-depending on CGAL and optionally Cork.
-
-### cgal ###
-This library extra utilizes CGAL's efficient and exact intersection and
-proximity queries.
-
-### embree ###
-This library extra utilizes embree's efficient ray tracing queries.
-
-### matlab ###
-This library extra provides support for reading and writing `.mat` workspace
-files, interfacing with Matlab at run time and compiling mex functions.
-
-### mosek ###
-This library extra utilizes mosek's efficient interior-point solver for
-quadratic programs.
-
-### png ###
-This library extra uses `libpng` and `YImage` to read and write `.png` files.
-
-### tetgen ###
-This library extra provides a simplified wrapper to the tetgen 3d tetrahedral
-meshing library.
-
-### Triangle ###
-This library extra provides a simplified wrapper to the triangle 2d triangle
-meshing library.
-
-### viewer ###
-This library extra utilizes glfw and glew to open an opengl context and launch
-a simple mesh viewer.
-
-### xml ###
-This library extra utilizes tinyxml2 to read and write serialized classes
-containing Eigen matrices and other standard simple data-structures.
-
-## Development ##
-Further documentation for developers is listed in 
-[style_guidelines.html](../style_guidelines.html).
-
-## License ##
-See `LICENSE.txt`
-
-## Zipping ##
-Zip this directory without .git litter and binaries using:
-
-    git archive -prefix=libigl/ -o libigl.zip master
-
-## Explicit instantiations of templated functions
-
-Special care must be taken by the developers of each function and
-class in the libigl library that uses C++ templates. If this function
-is intended to be compiled into the statically linked libigl library
-then function is only compiled for each <i>explicitly</i> instantiated 
-declaration. These should be added at the bottom of the corresponding
-.cpp file surrounded by a
-
-    #ifdef IGL_STATIC_LIBRARY
-
-Of course, a developer may not know ahead of time which
-instantiations should be explicitly included in the igl static lib.
-One way to find out is to add one explicit instantiation for each
-call in one's own project. This only ever needs to be done once for
-each template.
-
-The process is somewhat mechanical using a linker with reasonable error
-output.
-
-Supposed for example we have compiled the igl static lib, including the
-cat.h and cat.cpp functions, without any explicit instantiation. Say
-using the makefile in the `libigl` directory:
-
-    cd $LIBIGL
-    make
-
-Now if we try to compile a project and link against it we may get
-an error like:
-
-
-    Undefined symbols for architecture x86_64:
-    "Eigen::Matrix<int, -1, -1, 0, -1, -1> igl::cat<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(int, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&)", referenced from:
-    uniform_sample(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&, int, double, Eigen::Matrix<double, -1, -1, 0, -1, -1>&)in Skinning.o
-    "Eigen::SparseMatrix<double, 0, int> igl::cat<Eigen::SparseMatrix<double, 0, int> >(int, Eigen::SparseMatrix<double, 0, int> const&, Eigen::SparseMatrix<double, 0, int> const&)", referenced from:
-    covariance_scatter_matrix(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&, ArapEnergy, Eigen::SparseMatrix<double, 0, int>&)in arap_dof.o
-    arap_rhs(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&, ArapEnergy, Eigen::SparseMatrix<double, 0, int>&)in arap_dof.o
-
-This looks like a mess, but luckily we don't really need to read it
-all. Just copy the first part in quotes
-
-    Eigen::Matrix<int, -1, -1, 0, -1, -1> igl::cat<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(int, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&)
-
-, then append it
-to the list of explicit template instantiations at the end of
-`cat.cpp` after the word
-**template** and followed by a semi-colon.
-Like this:
-
-    #ifdef IGL_STATIC_LIBRARY
-    // Explicit template instantiation
-    template Eigen::Matrix<int, -1, -1, 0, -1, -1> igl::cat<Eigen::Matrix<int, -1, -1, 0, -1, -1> >(int, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&, Eigen::Matrix<int, -1, -1, 0, -1, -1> const&);
-    #endif
-
-Then you must recompile the IGL static library.
-
-    cd $LIBIGL
-    make
-
-And try to compile your project again, potentially repeating this
-process until no more symbols are undefined.
-
-`It may be useful to check that you code compiles with
-no errors first using the headers-only version to be sure that all errors are from missing template
-instantiations.`
-
-If you're using make then the following command will
-reveal each missing symbol on its own line:
-
-    make 2>&1 | grep "referenced from" | sed -e "s/, referenced from.*//"
-
-Alternatively you can use the `autoexplicit.sh` function
-which (for well organized .h/.cpp pairs in libigl) automatically
-create explicit instantiations from your compiler's error messages.
-Repeat this process until convergence:
-
-    cd /to/your/project
-    make 2>$LIBIGL/make.err
-    cd $LIBIGL
-    cat make.err | ./autoexplicit.sh
-    make clean
-    make
-
-
-### Benefits of static library
-
-* **Faster compile time**: Because the libigl library
-    is already compiled, only the new code in ones project must be
-    compiled and then linked to IGL. This means compile times are
-    generally faster.
-* **Debug or optimized**: The IGL static
-    library may be compiled in debug mode or optimized release mode
-    regardless of whether one's project is being optimized or
-    debugged.
-
-### Drawbacks of static library
-
-*  **Hard to use templates**: Special
-    care</a> (by the developers of the library) needs to be taken when
-    exposing templated functions.
-
-# Compressed .h/.cpp pair
-Calling the script:
-
-    scripts/compress.sh igl.h igl.cpp
-
-will create a single header `igl.h` and a single cpp file `igl.cpp`.
-
-Alternatively, you can also compress everything into a single header file:
-
-    scripts/compress.sh igl.h
-
-### Benefits of compressed .h/.cpp pair
-
-* **Easy incorporation**: This can be easily incorporated
-  into external projects.
-
-### Drawbacks of compressed .h/.cpp pair
-
-* **Hard to debug/edit**: The compressed files are
-  automatically generated. They're huge and should not be edited. Thus
-  debugging and editing are near impossible.
-
-* **Compounded dependencies**:
-  An immediate disadvantage of this
-  seems to be that even to use a single function (e.g.
-  `cotmatrix`), compiling and linking against
-  `igl.cpp` will require linking to all of `libigl`'s
-  dependencies (`OpenGL`, `GLUT`,
-  `AntTweakBar`, `BLAS`). However, because all
-  dependencies other than Eigen should be encapsulated between
-  `#ifndef` guards (e.g. `#ifndef IGL_NO_OPENGL`, it
-  is possible to ignore certain functions that have such dependencies.
-
-* **Long compile**: 
-  Compiling `igl.cpp` takes a long time and isn't easily parallelized (no `make
-  -j12` equivalent).
-
-Here's a tiny test example using `igl.h` and `igl.cpp`. Save the following in `test.cpp`:
-
-    #include <igl.h>
-    #include <Eigen/Core>
-
-    int main(int argc, char * argv[])
-    {
-    Eigen::MatrixXd V;
-    Eigen::MatrixXi F;
-    return (argc>=2 && igl::read_triangle_mesh(argv[1],V,F)?0:1);
-    }
-
-Then compile `igl.cpp` with:
-
-    g++ -o igl.o -c igl.cpp -I/opt/local/include/eigen3 -DIGL_NO_OPENGL -DIGL_NO_ANTTWEAKBAR
-
-Notice that we're using `-DIGL_NO_OPENGL -DIGL_NO_ANTTWEAKBAR` to disable any libigl dependencies on OpenGL and AntTweakBar.
-
-Now compile `test.cpp` with:
-
-    g++ -g -I/opt/local/include/eigen3/ -I/usr/local/igl/libigl/ -L/usr/local/igl/libigl/ -ligl -DIGL_NO_OPENGL -DIGL_NO_ANTTWEAKBAR -o test
-
-Try running it with:
-
-    ./test path/to/mesh.obj
-
-
-The following bash one-liner will find all source files that contain the string `OpenGL` but don't contain and `IGL_NO_OPENGL` guard:
-
-    grep OpenGL `grep -L IGL_NO_OPENGL include/igl/*`
-
-### Optional ###
-- OpenGL (disable with `IGL_NO_OPENGL`)
-    * OpenGL >= 4 (enable with `IGL_OPENGL_4`)
-- AntTweakBar  (disable with `IGL_NO_ANTTWEAKBAR`) Last tested 1.16 (see
-  `libigl/external/AntTweakBar`)
-- GLEW  Windows and Linux
-- OpenMP
-- libpng  libiglpng extra only
-- Mosek  libiglmosek extra only
-- Matlab  libiglmatlab extra only
-- boost  libiglboost, libiglcgal extra only
-- SSE/AVX  libiglsvd3x3 extra only
-- CGAL  libiglcgal extra only
-    * boost
-    * gmp
-    * mpfr
-- CoMiSo libcomiso extra only
-
-### Optional (included in external/) ###
-- TetGen  libigltetgen extra only
-- Embree  libiglembree extra only
-- tinyxml2  libiglxml extra only
-- glfw libviewer extra only
-- LIM  liblim extra only

python/README.md

@@ -1,169 +0,0 @@
-# Python wrappers for libigl
-
-
-## Work in progress
-<span style="color:#F62217">
-Everything in this folder is currently being developed and it is likely to be
-changed radically in the next couple of months, breaking compatibility between
-different version. We plan to stabilize the python API by the end of 2016.
-</span>
-
-## Introduction
-
-libigl functions can be called natively from python by compiling the wrappers
-in this folder. The wrappers supports both python 2.7 and python 3.5 and are
-generated using [pybind11](https://github.com/wjakob/pybind11).
-
-The generated library will statically link against all dependencies producing a single,
-self-contained binary.
-
-## Installation
-
-The python bindings can be compiled with the following instructions, assuming
-that your terminal is pointing to the root of libigl:
-
-```bash
-cd python
-mkdir build
-cd build; cmake ..; make; cd ..
-```
-
-The cmake script will complain if it is not able to find python. In that case
-you can specify the location of the interpreter by specifying the following
-cmake variables.
-
-
-MacOSX:
-
-```cmake
-SET(PYTHON_LIBRARIES "/usr/local/Cellar/python3/3.5.0/Frameworks/Python.framework/Versions/3.5/lib/libpython3.5m.dylib")
-SET(PYTHON_INCLUDE_DIR "/usr/local/Cellar/python3/3.5.0/Frameworks/Python.framework/Versions/3.5/include/python3.5m")
-```
-
-Windows:
-
-```cmake
-SET(PYTHON_LIBRARIES "C:/Python35/libs/python35.lib")
-SET(PYTHON_INCLUDE_DIR "C:/Python35/include")
-```
-
-On Linux you may need to install the development version of python:
-
-```bash
-sudo apt-get install python-dev
-```
-
-
-## Tutorial
-
-All libigl tutorials will be ported to python and will use the same naming
-scheme. You can find the tutorials in the folder python/tutorials and you can
-launch them with the following commands:
-
-```bash
-cd python
-python 102_DrawMesh.py
-```
-
-## Matrix Representation
-
-TODO: describe in detail the wrapped eigen classes and how to convert them to
-numpy.
-
-## Viewer and callbacks
-
-The igl viewer provides a convenient and efficient way of visualizing 3D
-surfaces in python. It behaves in the same way as the C++ viewer and supports
-native python functions as callbacks. This is a simple example that loads
-two meshes and switches between the two when a key is pressed:
-
-```python
-import pyigl as igl
-
-V1 = igl.eigen.MatrixXd()
-F1 = igl.eigen.MatrixXi()
-
-V2 = igl.eigen.MatrixXd()
-F2 = igl.eigen.MatrixXi()
-
-def key_pressed(viewer, key, modifier):
-    print("Key: ", chr(key))
-
-    if key == ord('1'):
-        # # Clear should be called before drawing the mesh
-        viewer.data().clear();
-        # # Draw_mesh creates or updates the vertices and faces of the displayed mesh.
-        # # If a mesh is already displayed, draw_mesh returns an error if the given V and
-        # # F have size different than the current ones
-        viewer.data().set_mesh(V1, F1);
-        viewer.core.align_camera_center(V1,F1);
-    elif key == ord('2'):
-        viewer.data().clear();
-        viewer.data().set_mesh(V2, F2);
-        viewer.core.align_camera_center(V2,F2);
-    return False
-
-
-#  Load two meshes
-igl.readOFF("../tutorial/shared/bumpy.off", V1, F1);
-igl.readOFF("../tutorial/shared/fertility.off", V2, F2);
-
-print("1 Switch to bump mesh")
-print("2 Switch to fertility mesh")
-
-viewer = igl.glfw.Viewer()
-
-# Register a keyboard callback that allows to switch between
-# the two loaded meshes
-viewer.callback_key_pressed = key_pressed
-viewer.data().set_mesh(V1, F1)
-viewer.launch()
-```
-
-### Remote viewer
-
-When using the viewer from an interactive python shell (iPython), it is
-inconvenient to let the viewer take control of the main thread for rendering
-purposes. We provide a simple wrapper for the viewer that allows to launch
-a remote process and send meshes to it via a TCP/IP socket. For more
-information on how to use it see the documentation in [tcpviewer.py](tcpviewer.py)
-
-## Matlab
-
-The python wrappers can be natively being used from MATLAB.
-We provide a few examples in the folder python/matlab.
-
-## Documentation
-
-The python functions have exactly the same prototypes as their C++ counterpart.
-Docstrings for all available python functions are extracted from the C++ header files and compiled into the python module. To get help for a certain function, you can run `help(pyigl.<function_name>)` in the python console.
-
-In the scripts folder there is the script `generate_docstrings.py` that automatically generates python docstrings for a new function. You can run it with `generate_docstrings.py <path_to_cpp_header_files> <path_to_python_files>`. 
-The script depends on additional libraries (joblib, mako, clang), make sure to install them (e.g. through pip. python-clang is included in external/pybind11/tools/clang).
-
-
-## Known Issues
-
-## Contact
-
-Libigl is a group endeavor led by [Alec
-Jacobson](http://www.cs.columbia.edu/~jacobson/) and [Daniele
-Panozzo](http://cs.nyu.edu/~panozzo/). Please [contact
-us](mailto:alecjacobson@gmail.com,daniele.panozzo@gmail.com) if you have
-questions or comments. For troubleshooting, please post an
-[issue](https://github.com/libigl/libigl/issues) on github.
-
-If you're using libigl in your projects, quickly [drop us a
-note](mailto:alecjacobson@gmail.com,daniele.panozzo@gmail.com). Tell us who you
-are and what you're using it for. This helps us apply for funding and justify
-spending time maintaining this.
-
-If you find bugs or have problems please use our [github issue tracking
-page](https://github.com/libigl/libigl/issues).
-
-## Copyright
-2015 Alec Jacobson, Daniele Panozzo, Christian Schüller, Olga Diamanti, Qingnan
-Zhou, Sebastian Koch, Nico Pietroni, Stefan Brugger, Kenshi Takayama, Wenzel Jakob, Nikolas De
-Giorgis, Luigi Rocca, Leonardo Sacht, Olga Sorkine-Hornung, and others.
-
-Please see individual files for appropriate copyright notices.

scripts/figureAltCaption/LICENSE.md

@@ -0,0 +1,339 @@
+GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    Extension for markdown to parse images with captions inside a figure element.
+    Copyright (C) 2013  Helder Correia
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  {signature of Ty Coon}, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

scripts/figureAltCaption/README.md

@@ -0,0 +1,31 @@
+Generates a figurecaption each Image which stands alone in a paragraph,
+similar to [pandoc’s handling of images/figures](http://pandoc.org/README.html#extension-implicit_figures)
+
+--------------------------------------------
+
+Licensed under the GPL 2 (see LICENSE.md)
+
+Copyright 2015 - Jan Dittrich by
+building upon the [markdown-figures](https://github.com/helderco/markdown-figures) Plugin by
+Copyright 2013 - [Helder Correia](http://heldercorreia.com) (GPL2)
+
+--------------------------------------------
+
+Example – this source:
+
+    Bla bla bla
+
+    ![this is the caption](http://lorempixel.com/400/200/)
+
+    Next paragraph starts here
+
+would generate this:
+
+    <p> Bla bla bla</p>
+    
+    <figure>
+        <img src="http://lorempixel.com/400/200/">
+        <figcaption>this is the caption</figcaption>
+    </figure>
+   
+    <p>Next paragraph starts here</p>

scripts/figureAltCaption/__init__.py

@@ -0,0 +1 @@
+from .figureAltCaption import *

scripts/figureAltCaption/figureAltCaption.py

@@ -0,0 +1,80 @@
+"""
+Generates a Caption for Figures for each Image which stands alone in a paragraph,
+similar to pandoc#s handling of images/figures
+
+--------------------------------------------
+
+Licensed under the GPL 2 (see LICENSE.md)
+
+Copyright 2015 - Jan Dittrich by
+building upon the markdown-figures Plugin by
+Copyright 2013 - [Helder Correia](http://heldercorreia.com) (GPL2)
+
+--------------------------------------------
+
+Examples:
+    Bla bla bla
+
+    ![this is the caption](http://lorempixel.com/400/200/)
+
+    Next paragraph starts here
+
+would generate a figure like this:
+
+    <figure>
+        <img src="http://lorempixel.com/400/200/">
+        <figcaption>this is the caption</figcaption>
+    </figure>
+"""
+
+
+from __future__ import unicode_literals
+from markdown import Extension
+from markdown.inlinepatterns import IMAGE_LINK_RE, IMAGE_REFERENCE_RE, NOBRACKET, BRK
+from markdown.blockprocessors import BlockProcessor
+from markdown.util import etree
+import re #regex
+
+import logging
+logger = logging.getLogger('MARKDOWN')
+
+FIGURES = [u'^\s*'+IMAGE_LINK_RE+u'\s*$', u'^\s*'+IMAGE_REFERENCE_RE+u'\s*$'] #is: linestart, any whitespace (even none), image, any whitespace (even none), line ends.
+
+# This is the core part of the extension
+class FigureCaptionProcessor(BlockProcessor):
+    FIGURES_RE = re.compile('|'.join(f for f in FIGURES))
+    def test(self, parent, block): # is the block relevant
+        # Wenn es ein Bild gibt und das Bild alleine im paragraph ist, und das Bild nicht schon einen figure parent hat, returne True
+        isImage = bool(self.FIGURES_RE.search(block))
+        isOnlyOneLine = (len(block.splitlines())== 1)
+        isInFigure = (parent.tag == 'figure')
+
+        # print(block, isImage, isOnlyOneLine, isInFigure, "T,T,F")
+        if (isImage and isOnlyOneLine and not isInFigure):
+            return True
+        else:
+            return False
+
+    def run(self, parent, blocks): # how to process the block?
+        raw_block = blocks.pop(0)
+        captionText = self.FIGURES_RE.search(raw_block).group(1)
+
+        # create figure
+        figure = etree.SubElement(parent, 'figure')
+
+        # render image in figure
+        figure.text = raw_block
+
+        # create caption
+        figcaptionElem = etree.SubElement(figure,'figcaption')
+        figcaptionElem.text = captionText #no clue why the text itself turns out as html again and not raw. Anyhow, it suits me, the blockparsers annoyingly wrapped everything into <p>.
+
+class FigureCaptionExtension(Extension):
+    def extendMarkdown(self, md, md_globals):
+        """ Add an instance of FigcaptionProcessor to BlockParser. """
+        md.parser.blockprocessors.add('figureAltcaption',
+                                      FigureCaptionProcessor(md.parser),
+                                      '<ulist')
+
+def makeExtension(configs={}):
+    return FigureCaptionExtension(configs=configs)

scripts/figureAltCaption/setup.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+
+from setuptools import setup
+
+setup(
+    name='figureAltCaption',
+    description='Extension for Python-Markdown to parse images with captions.',
+    url='https://github.com/jdittrich/figureAltCaption',
+    py_modules=['figureAltCaption'],
+    install_requires=['Markdown>=2.0',],
+)

scripts/fixPaths/__init__.py

@@ -0,0 +1 @@
+from .pathconverter import *

scripts/fixPaths/pathconverter.py

@@ -0,0 +1,146 @@
+"""
+Path Converter.
+
+pymdownx.pathconverter
+An extension for Python Markdown.
+
+An extension to covert tag paths to relative or absolute:
+
+Given an absolute base and a target relative path, this extension searches for file
+references that are relative and converts them to a path relative
+to the base path.
+
+-or-
+
+Given an absolute base path, this extension searches for file
+references that are relative and converts them to absolute paths.
+
+MIT license.
+
+Copyright (c) 2014 - 2017 Isaac Muse <isaacmuse@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+"""
+from __future__ import unicode_literals
+import os
+import re
+import sys
+import logging
+from markdown import Extension
+from markdown.postprocessors import Postprocessor
+from . import util
+
+RE_TAG_HTML = r'''(?xus)
+    (?:
+        (?P<comments>(\r?\n?\s*)<!--[\s\S]*?-->(\s*)(?=\r?\n)|<!--[\s\S]*?-->)|
+        (?P<open><(?P<tag>(?:%s)))
+        (?P<attr>(?:\s+[\w\-:]+(?:\s*=\s*(?:"[^"]*"|'[^']*'))?)*)
+        (?P<close>\s*(?:\/?)>)
+    )
+    '''
+
+RE_TAG_LINK_ATTR = re.compile(
+    r'''(?xus)
+    (?P<attr>
+        (?:
+            (?P<name>\s+(?:href|src)\s*=\s*)
+            (?P<path>"[^"]*"|'[^']*')
+        )
+    )
+    '''
+)
+
+log = logging.getLogger(__name__)
+
+
+def pprint(*args):
+    print(*args)
+    sys.stdout.flush()
+
+
+def repl_absolute(m, key, val):
+    """Replace path with absolute path."""
+
+    link = m.group(0)
+    try:
+        scheme, netloc, path, params, query, fragment, is_url, is_absolute = util.parse_url(m.group('path')[1:-1])
+        new_path = m.group('path')[1:-1].replace('../{{ %s }}' % key, val)
+
+        if (not is_absolute and not is_url):
+            link = '%s"%s"' % (m.group('name'), new_path)
+
+    except Exception:  # pragma: no cover
+        # Parsing crashed and burned; no need to continue.
+        pass
+
+    return link
+
+
+def repl(m, key, val):
+    """Replace."""
+
+    if m.group('comments'):
+        tag = m.group('comments')
+    else:
+        tag = m.group('open')
+        tag += RE_TAG_LINK_ATTR.sub(lambda m2: repl_absolute(m2, key, val), m.group('attr'))
+        tag += m.group('close')
+    return tag
+
+
+class PathConverterPostprocessor(Postprocessor):
+    """Post process to find tag links to convert."""
+
+    def run(self, text):
+        """Find and convert paths."""
+
+        variables = self.config['variables']
+        # relativepath = self.config['relative_path']
+        # absolute = bool(self.config['absolute'])
+        tags = re.compile(RE_TAG_HTML % '|'.join(self.config['tags'].split()))
+        # pprint(absolute, basepath, relativepath)
+        # if not absolute and basepath and relativepath:
+        #     text = tags.sub(lambda m: repl(m, basepath, relativepath), text)
+        for key, val in variables.items():
+            text = tags.sub(lambda m, k=key, v=val: repl(m, k, v), text)
+        return text
+
+
+class PathConverterExtension(Extension):
+    """PathConverter extension."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize."""
+
+        self.config = {
+            'variables': [{}, "Dict of variables to replace"],
+            'tags': ["a link", "tags to convert src and/or href in - Default: 'img scripts a link'"]
+        }
+
+        super(PathConverterExtension, self).__init__(*args, **kwargs)
+
+    def extendMarkdown(self, md, md_globals):
+        """Add post processor to Markdown instance."""
+
+        rel_path = PathConverterPostprocessor(md)
+        rel_path.config = self.getConfigs()
+        md.postprocessors.add("path-converter", rel_path, "_end")
+        md.registerExtension(self)
+
+
+def makeExtension(*args, **kwargs):
+    """Return extension."""
+
+    return PathConverterExtension(*args, **kwargs)

scripts/fixPaths/util.py

@@ -0,0 +1,180 @@
+"""
+General utilities.
+
+MIT license.
+
+Copyright (c) 2017 Isaac Muse <isaacmuse@gmail.com>
+"""
+from __future__ import unicode_literals
+import sys
+import copy
+import re
+
+PY3 = sys.version_info >= (3, 0)
+PY34 = sys.version_info >= (3, 4)
+
+if PY3:
+    uchr = chr  # noqa
+    from urllib.request import pathname2url, url2pathname  # noqa
+    from urllib.parse import urlparse, urlunparse, quote  # noqa
+    from html.parser import HTMLParser  # noqa
+    if PY34:
+        import html  # noqa
+        html_unescape = html.unescape  # noqa
+    else:  # pragma: no cover
+        html_unescape = HTMLParser().unescape  # noqa
+else:
+    uchr = unichr  # noqa
+    from urllib import pathname2url, url2pathname, quote  # noqa
+    from urlparse import urlparse, urlunparse  # noqa
+    from HTMLParser import HTMLParser  # noqa
+    html_unescape = HTMLParser().unescape  # noqa
+
+RE_WIN_DRIVE_LETTER = re.compile(r"^[A-Za-z]$")
+RE_WIN_DRIVE_PATH = re.compile(r"^[A-Za-z]:(?:\\.*)?$")
+RE_URL = re.compile('(http|ftp)s?|data|mailto|tel|news')
+IS_NARROW = sys.maxunicode == 0xFFFF
+
+if IS_NARROW:
+    def get_code_points(s):
+        """Get the Unicode code points."""
+
+        pt = []
+
+        def is_full_point(p, point):
+            """
+            Check if we have a full code point.
+
+            Surrogates are stored in point.
+            """
+            v = ord(p)
+            if 0xD800 <= v <= 0xDBFF:
+                del point[:]
+                point.append(p)
+                return False
+            if point and 0xDC00 <= v <= 0xDFFF:
+                point.append(p)
+                return True
+            del point[:]
+            return True
+
+        return [(''.join(pt) if pt else c) for c in s if is_full_point(c, pt)]
+
+    def get_ord(c):
+        """Get Unicode ord."""
+
+        if len(c) == 2:
+            high, low = [ord(p) for p in c]
+            ordinal = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000
+        else:
+            ordinal = ord(c)
+
+        return ordinal
+
+    def get_char(value):
+        """Get the Unicode char."""
+        if value > 0xFFFF:
+            c = ''.join(
+                [
+                    uchr(int((value - 0x10000) / (0x400)) + 0xD800),
+                    uchr((value - 0x10000) % 0x400 + 0xDC00)
+                ]
+            )
+        else:
+            c = uchr(value)
+        return c
+
+else:
+    def get_code_points(s):
+        """Get the Unicode code points."""
+
+        return [c for c in s]
+
+    def get_ord(c):
+        """Get Unicode ord."""
+
+        return ord(c)
+
+    def get_char(value):
+        """Get the Unicode char."""
+
+        return uchr(value)
+
+
+def escape_chars(md, echrs):
+    """
+    Add chars to the escape list.
+
+    Don't just append as it modifies the global list permanently.
+    Make a copy and extend **that** copy so that only this Markdown
+    instance gets modified.
+    """
+
+    escaped = copy.copy(md.ESCAPED_CHARS)
+    for ec in echrs:
+        if ec not in escaped:
+            escaped.append(ec)
+    md.ESCAPED_CHARS = escaped
+
+
+def parse_url(url):
+    """
+    Parse the URL.
+
+    Try to determine if the following is a file path or
+    (as we will call anything else) a URL.
+
+    We return it slightly modified and combine the path parts.
+
+    We also assume if we see something like c:/ it is a Windows path.
+    We don't bother checking if this **is** a Windows system, but
+    'nix users really shouldn't be creating weird names like c: for their folder.
+    """
+
+    is_url = False
+    is_absolute = False
+    scheme, netloc, path, params, query, fragment = urlparse(html_unescape(url))
+
+    if RE_URL.match(scheme):
+        # Clearly a url
+        is_url = True
+    elif scheme == '' and netloc == '' and path == '':
+        # Maybe just a url fragment
+        is_url = True
+    elif scheme == 'file' and (RE_WIN_DRIVE_PATH.match(netloc)):
+        # file://c:/path or file://c:\path
+        path = '/' + (netloc + path).replace('\\', '/')
+        netloc = ''
+        is_absolute = True
+    elif scheme == 'file' and netloc.startswith('\\'):
+        # file://\c:\path or file://\\path
+        path = (netloc + path).replace('\\', '/')
+        netloc = ''
+        is_absolute = True
+    elif scheme == 'file':
+        # file:///path
+        is_absolute = True
+    elif RE_WIN_DRIVE_LETTER.match(scheme):
+        # c:/path
+        path = '/%s:%s' % (scheme, path.replace('\\', '/'))
+        scheme = 'file'
+        netloc = ''
+        is_absolute = True
+    elif scheme == '' and netloc != '' and url.startswith('//'):
+        # //file/path
+        path = '//' + netloc + path
+        scheme = 'file'
+        netloc = ''
+        is_absolute = True
+    elif scheme != '' and netloc != '':
+        # A non-filepath or strange url
+        is_url = True
+    elif path.startswith(('/', '\\')):
+        # /root path
+        is_absolute = True
+
+    return (scheme, netloc, path, params, query, fragment, is_url, is_absolute)
+
+
+class PymdownxDeprecationWarning(UserWarning):  # pragma: no cover
+    """Deprecation warning for Pymdownx that is not hidden."""

style-guidelines.html

@@ -1,392 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
-<head>
-	<meta charset="utf-8"/>
-	<title>libigl</title>
-	<meta name="author" content="Alec Jacobson and Daniele Panozzo and others"/>
-	<link type="text/css" rel="stylesheet" href="tutorial/style.css"/>
-<script type='text/javascript' src='http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'></script> <link rel='stylesheet' href='http://yandex.st/highlightjs/7.3/styles/default.min.css'> <script src='http://yandex.st/highlightjs/7.3/highlight.min.js'></script> <script>hljs.initHighlightingOnLoad();</script>
-</head>
-<body>
-
-<h1 id="libiglstyleguidelines">Libigl Style Guidelines</h1>
-
-<p>Libigl is used and developed by many people. This document highlights some
-style guidelines for <em>developers</em> of the library, but also acts as
-best-practices for users.</p>
-
-<h2 id="filefunction">One function, one .h/.cpp pair </h2>
-
-<p>The structure of libigl is very flat and function-based. For every
-function/sub-routine, create a single .h and .cpp file. For example, if you have
-a function that determines connected components from a face list <code>F</code> you would
-create the header <code>connected_components.h</code> and <code>connected_components.cpp</code> and the only
-function defined should be <code>void connected_components(const ... F, ... C)</code>. If the
-implementation of <code>connected_components</code> requires a subroutine to compute an
-adjacency matrix then <em>create another pair</em> <code>adjacency_matrix.h</code> and
-<code>adjacency_matrix.cpp</code> with a single function <code>void adjacency_matrix(const ... F, ... A)</code>.</p>
-
-<h3 id="example">Example</h3>
-
-<p>Here is an example function that would be defined in
-<code>include/igl/example_fun.h</code> and implemented in <code>include/igl/example_fun.cpp</code>.</p>
-
-<h4 id="example_fun.h"><code>example_fun.h</code></h4>
-
-<pre><code class="cpp">// This file is part of libigl, a simple c++ geometry processing library.
-// 
-// Copyright (C) 2015 [Your Name] [your email address]
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public License 
-// v. 2.0. If a copy of the MPL was not distributed with this file, You can 
-// obtain one at http://mozilla.org/MPL/2.0/
-#ifndef IGL_EXAMPLE_FUN_H
-#define IGL_EXAMPLE_FUN_H
-
-#include &quot;igl_inline.h&quot;
-
-namespace igl
-{
-  // This is an example of a function, it takes a templated parameter and
-  // shovels it into cout
-  //
-  // Input:
-  //   input  some input of a Printable type
-  // Returns true for the sake of returning something
-  template &lt;typename Printable&gt;
-  IGL_INLINE bool example_fun(const Printable &amp; input);
-}
-
-#ifndef IGL_STATIC_LIBRARY
-#include &quot;example_fun.cpp&quot;
-#endif
-
-#endif
-</code></pre>
-
-<h4 id="example_fun.cpp"><code>example_fun.cpp</code></h4>
-
-<pre><code>// This file is part of libigl, a simple c++ geometry processing library.
-// 
-// Copyright (C) 2015 [Your Name] [your email address]
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public License 
-// v. 2.0. If a copy of the MPL was not distributed with this file, You can 
-// obtain one at http://mozilla.org/MPL/2.0/
-#include &quot;igl/example_fun.h&quot;
-#include &lt;iostream&gt;
-
-template &lt;typename Printable&gt;
-IGL_INLINE bool igl::example_fun(const Printable &amp; input)
-{
-  using namespace std;
-  cout&lt;&lt;&quot;example_fun: &quot;&lt;&lt;input&lt;&lt;endl;
-  return true;
-}
-
-#ifdef IGL_STATIC_LIBRARY
-template bool igl::example_fun&lt;double&gt;(const double&amp; input);
-template bool igl::example_fun&lt;int&gt;(const int&amp; input);
-#endif
-</code></pre>
-
-<h3 id="avoidstatichelperfunctions">Avoid static &#8220;helper&#8221; functions</h3>
-
-<p>Strive to encapsulate sub-functions that could possibly be useful outside of
-the implementation of your current function. This might mean abstracting the
-interface a bit. If it doesn&#8217;t dramatically effect performance then create a
-new pair of .h/.cpp files with this sub-function.</p>
-
-<h4 id="lambdafunctions">Lambda functions</h4>
-
-<p>If encapsulation in a separate file is not possible or does not make sense,
-then avoid crowding the namespace by creating lambda functions within the
-function implementation.</p>
-
-<p>These lambda functions must still be documented with clear <a href="#headerdocumentation">input and output
-arguments</a>. Avoid using full capturing of all automatic
-variables: do not use <code>[&amp;]</code> or <code>[=]</code>. Rather specify each captured variable
-individually.</p>
-
-<h3 id="avoidhelperclasses">Avoid &#8220;helper&#8221; classes</h3>
-
-<p>Libigl is built around the high-performance paradigm of &#8220;struct of arrays&#8221;
-rather than &#8220;array of structs&#8221;. The way we achieve this is to avoid classes and
-pass &#8220;basic types&#8221; directly. The price we pay is long function interfaces, but
-this increases code reuse dramatically. A &#8220;basic type&#8221; in our context is a
-Eigen type, stl type, or basic C type.</p>
-
-<h2 id="headerdocumentation">Header Documentation</h2>
-
-<p>Each function prototype should be well documented in its corresponding .h
-header file. A typical documentation consists of four parts:</p>
-
-<pre><code class="cpp">// [A human readable description of what the function does.]
-//
-// Inputs:
-//   [variable name of first (const) input]   [dimensions and description of
-//     this input variable]
-//   [variable name of second (const) input]   [dimensions and description of
-//     this input variable]
-//   ...
-// Outputs:
-//   [variable name of first output ]   [dimensions and description of this
-//     output variable]
-//   [variable name of second output ]   [dimensions and description of this
-//     output variable]
-//   ...
-// Returns [description of return value]
-</code></pre>
-
-<h3 id="example">Example</h3>
-
-<p>For example the header <code>barycenter.h</code></p>
-
-<pre><code>// Computes the barycenter of every simplex
-//
-// Inputs:
-//   V  #V by dim matrix of vertex coordinates
-//   F  #F by simplex_size  matrix of indices of simplex corners into V
-// Output:
-//   BC  #F by dim matrix of 3d vertices
-//
-</code></pre>
-
-<h2 id="constinputs">Const inputs</h2>
-
-<p>All input parameters should be demarcated <code>const</code>. If an input is also an
-output than consider exposing two parameters (one <code>const</code>) or be sure to list
-the variable under both <code>// Inputs:</code> and <code>// Outputs:</code> in the header comments.</p>
-
-<h2 id="referenceparameters">Reference parameters</h2>
-
-<p>All but simple types should be passed by reference (e.g. <code>Matrix &amp; mat</code>) rather
-than pointers (e.g. <code>Matrix * mat</code>) or value (e.g. <code>Matrix mat</code>).</p>
-
-<h2 id="returnsvsoutputparameters">Returns vs output parameters</h2>
-
-<p>All functions should be implemented with at least one overload that has a
-<code>void</code> or simple return type (e.g. <code>bool</code> on success/failure). With this
-implementation its then possible to write an overload that returns a single
-output. Please see <a href="#templatingwitheigen">Templating with Eigen</a>.</p>
-
-<p>For example:</p>
-
-<pre><code class="cpp">template &lt;typename Atype&gt;
-void adjacency_matrix(const ... &amp; F, Eigen::SparseMatrix&lt;AType&gt; &amp; A);
-
-template &lt;typename Atype&gt;
-Eigen::SparseMatrix&lt;Atype&gt; adjacency_matrix(const ... &amp; F);
-</code></pre>
-
-<h2 id="templatingwitheigen">Templating with Eigen</h2>
-
-<p>Functions taking Eigen dense matrices/arrays as inputs and outputs (but <strong>not</strong>
-return arguments), should template on top of <code>Eigen::MatrixBase</code>. <strong>Each
-parameter</strong> should be derived using its own template.</p>
-
-<p>For example,</p>
-
-<pre><code class="cpp">template &lt;typename DerivedV, typename DerivedF, typename DerivedBC&gt;
-void barycenter(
-  const Eigen::MatrixBase&lt;DerivedV&gt; &amp; V,
-  const Eigen::MatrixBase&lt;DerivedF&gt; &amp; F,
-  const Eigen::MatrixBase&lt;DerivedBC&gt; &amp; BC);
-</code></pre>
-
-<p>The <code>Derived*</code> template encodes the scalar type (e.g. <code>double</code>, <code>int</code>), the
-number of rows and cols at compile time, and the data storage (Row-major vs.
-column-major).</p>
-
-<p>Returning Eigen types is discouraged. In cases where the size and scalar type
-are a fixed <strong>and matching</strong> function of an input <code>Derived*</code> template, then
-return that <code>Derived*</code> type. <strong>Do not</strong> return
-<code>Eigen::PlainObjectBase&lt;...&gt;</code> types. For example, this function scales fits a
-given set of points to the unit cube. The return is a new set of vertex
-positions so its type should <em>match</em> that of the input points:</p>
-
-<pre><code class="cpp">template &lt;typename DerivedV&gt;
-void DerivedV fit_to_unit_cube(const Eigen::PlainObjectBase&lt;DerivedV&gt; &amp; V);
-</code></pre>
-
-<p>To implement this function, it is <strong>required</strong> to implement a more generic
-output-argument version and call that. So a full implementation looks like:</p>
-
-<p>In <code>igl/fit_in_unit_cube.h</code>:</p>
-
-<pre><code class="cpp">template &lt;typename DerivedV, typename DerivedW&gt;
-void fit_to_unit_cube(
-  const Eigen::MatrixBase&lt;DerivedV&gt; &amp; V,
-  Eigen::PlainObjectBase&lt;DerivedW&gt; &amp; W);
-template &lt;typename DerivedV&gt;
-void DerivedV fit_to_unit_cube(const Eigen::PlainObjectBase&lt;DerivedV&gt; &amp; V);
-</code></pre>
-
-<p>In <code>igl/fit_in_unit_cube.cpp</code>:</p>
-
-<pre><code>template &lt;typename DerivedV, typename DerivedW&gt;
-void fit_to_unit_cube(
-  const Eigen::MatrixBase&lt;DerivedV&gt; &amp; V,
-  Eigen::PlainObjectBase&lt;DerivedW&gt; &amp; W)
-{
-  W = (V.rowwise()-V.colwise().minCoeff()).array() /
-    (V.maxCoeff()-V.minCoeff());
-}
-
-template &lt;typename DerivedV&gt;
-void DerivedV fit_to_unit_cube(const Eigen::MatrixBase&lt;DerivedV&gt; &amp; V)
-{
-  DerivedV W;
-  fit_to_unit_cube(V,W);
-  return W;
-}
-</code></pre>
-
-<p>Notice that <code>W</code> is declared as a <code>DerivedV</code> type and <strong>not</strong>
-<code>Eigen::PlainObjectBase&lt;DerivedV&gt;</code> type.</p>
-
-<p><strong>Note:</strong> Not all functions are suitable for returning Eigen types. For example
-<code>igl::barycenter</code> above outputs a #F by dim list of barycenters. Returning a
-<code>DerivedV</code> type would be inappropriate since the number of rows in <code>DerivedV</code>
-will be #V and may not match the number of rows in <code>DerivedF</code> (#F).</p>
-
-<h2 id="functionnamingconventions">Function naming conventions</h2>
-
-<p>Functions (and <a href="#filefunction">thus also files</a>) should have simple,
-descriptive names using lowercase letters and underscores between words. Avoid
-unnecessary prefaces. For example, instead of <code>compute_adjacency_matrix</code>,
-<code>construct_adjacency_matrix</code>, <code>extract_adjacency_matrix</code>,
-<code>get_adjacency_matrix</code>, or <code>set_adjacency_matrix</code> just call the function
-<code>adjacency_matrix</code>.</p>
-
-<h2 id="variablenamingconventions">Variable naming conventions</h2>
-
-<p>Libigl prefers short (even single character) variable names <em>with heavy
-documentation</em> in the comments in the header file or above the declaration of
-the function. When possible use <code>V</code> to mean a list of vertex positions and <code>F</code>
-to mean a list of faces/triangles.</p>
-
-<h2 id="classnamingconventions">Class naming conventions</h2>
-
-<p>Classes should be avoided. When naming a class use CamelCase (e.g.
-SortableRow.h).</p>
-
-<h2 id="enumnamingconversion">Enum naming conversion</h2>
-
-<p>Enums types should be placed in the appropriate <code>igl::</code> namespace and should be
-named in CamelCase (e.g. <code>igl::SolverStatus</code>) and instances should be named in
-ALL_CAPS with underscores between words and prefaced with the name of the enum.
-For example:</p>
-
-<pre><code class="cpp">namespace igl
-{
-  enum SolverStatus
-  {
-    // Good
-    SOLVER_STATUS_CONVERGED = 0,
-    // OK
-    SOLVER_STATUS_MAX_ITER = 1,
-    // Bad
-    SOLVER_STATUS_ERROR = 2,
-    NUM_SOLVER_STATUSES = 3,
-  };
-};
-</code></pre>
-
-<h3 id="exceptionforfileio">Exception for file IO</h3>
-
-<p>For legacy reasons, file reading and writing functions use a different naming
-convention. A functions reading a <code>.xyz</code> file should be named <code>readXYZ</code> and a
-function writing <code>.xyz</code> files should be names <code>writeXYZ</code>.</p>
-
-<h2 id="usingnamespace...inglobalscope"><code>using namespace ...</code> in global scope</h2>
-
-<p>Writing <code>using namespace std;</code>, <code>using namespace Eigen;</code> etc. outside of a
-global scope is strictly forbidden. Place these lines at the top of each
-function instead.</p>
-
-<h2 id="namespacesandexternaldependencies">Namespaces and external dependencies</h2>
-
-<p>Functions in the main library (directly in <code>include/igl</code>) should only depend on
-Eigen and stl. These functions should have the <code>igl::</code> namespace.</p>
-
-<p>Functions with other dependencies should be placed into
-appropriate sub-directories (e.g. if <code>myfunction</code> depends on tetgen then create
-<code>igl/copyleft/tetgen/myfunction.h</code> and <code>igl/copyleft/tetgen/myfunction.cpp</code> and give the function
-the namespace <code>igl::copyleft::tetgen::myfunction</code>.</p>
-
-<h3 id="copyleftsubdirectorynamespace">copyleft subdirectory/namespace</h3>
-
-<p>Dependencies that require users of libigl to release their projects open source
-(e.g. GPL) are considered aggressively &#8220;copyleft&#8221; and should be placed in the
-<code>include/igl/copyleft/</code> sub-directory and <code>igl::copyleft::</code> namespace.</p>
-
-<h2 id="assertions">Assertions</h2>
-
-<p>Be generous with assertions and always identify the assertion with strings:</p>
-
-<pre><code class="cpp">assert(m &lt; n &amp;&amp; &quot;m must be less than n&quot;);
-</code></pre>
-
-<h2 id="ifndefincludeguard">ifndef include guard</h2>
-
-<p>Every header file should be wrapped in an <code>#ifndef</code> compiler directive. The
-name of the guard should be in direct correspondence with the path of the .h
-file. For example, <code>include/igl/copyleft/tetgen/tetrahedralize.h</code> should be</p>
-
-<pre><code class="cpp">#ifndef IGL_COPYLEFT_TETGEN_TETRAHEDRALIZE_H
-#define IGL_COPYLEFT_TETGEN_TETRAHEDRALIZE_H
-...
-#endif
-</code></pre>
-
-<h2 id="spacesvs.tabsindentation">Spaces vs. tabs indentation</h2>
-
-<p>Do not use tabs. Use 2 spaces for each indentation level.</p>
-
-<h2 id="maxlinelength">Max line length</h2>
-
-<p>Limit lines to 80 characters. Break up long lines into many operations (this
-also helps performance).</p>
-
-<h2 id="includeorder">Include order</h2>
-
-<p><code>#include</code> directives at the top of a .h or .cpp file should be sorted
-according to a simple principle: place headers of files most likely to be
-edited by you first. This means for
-<code>include/igl/copyleft/tetgen/tetrahedralize.cpp</code> you might see</p>
-
-<pre><code class="cpp">// [Includes of headers in this directory]
-#include &quot;tetrahedralize.h&quot;
-#include &quot;mesh_to_tetgenio.h&quot;
-#include &quot;tetgenio_to_tetmesh.h&quot;
-// [Includes of headers in this project]
-#include &quot;../../matrix_to_list.h&quot;
-#include &quot;../../list_to_matrix.h&quot;
-#include &quot;../../boundary_facets.h&quot;
-// [Includes of headers of related projects]
-#include &lt;Eigen/Core&gt;
-// [Includes of headers of standard libraries]
-#include &lt;cassert&gt;
-#include &lt;iostream&gt;
-</code></pre>
-
-<h2 id="placementofincludes">Placement of includes</h2>
-
-<p>Whenever possible <code>#include</code> directives should be placed in the <code>.cpp</code>
-implementation file rather than the <code>.h</code> header file.</p>
-
-<h2 id="warnings">Warnings</h2>
-
-<p>Code should compile without firing any warnings.</p>
-
-<h3 id="anexception">An Exception</h3>
-
-<p>The only exception is for the use of the deprecated
-<code>Eigen::DynamicSparseMatrix</code> in core sub-routines (e.g. <code>igl::cat</code>). This class
-is still supported and faster than the standard, non-deprecated Eigen
-implementation so we&#8217;re keeping it as long as possible and profitable.</p>
-
-</body>
-</html>
-

style-guidelines.md

@@ -1,392 +0,0 @@
-# Libigl Style Guidelines
-
-Libigl is used and developed by many people. This document highlights some
-style guidelines for _developers_ of the library, but also acts as
-best-practices for users.
-
-## One function, one .h/.cpp pair [filefunction]
-
-The structure of libigl is very flat and function-based. For every
-function/sub-routine, create a single .h and .cpp file. For example, if you have
-a function that determines connected components from a face list `F` you would
-create the header `connected_components.h` and `connected_components.cpp` and the only
-function defined should be `void connected_components(const ... F, ... C)`. If the
-implementation of `connected_components` requires a subroutine to compute an
-adjacency matrix then _create another pair_ `adjacency_matrix.h` and
-`adjacency_matrix.cpp` with a single function `void adjacency_matrix(const ... F, ... A)`.
-
-### Example
-Here is an example function that would be defined in
-`include/igl/example_fun.h` and implemented in `include/igl/example_fun.cpp`.
-
-#### `example_fun.h`
-
-```cpp
-// This file is part of libigl, a simple c++ geometry processing library.
-// 
-// Copyright (C) 2015 [Your Name] [your email address]
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public License 
-// v. 2.0. If a copy of the MPL was not distributed with this file, You can 
-// obtain one at http://mozilla.org/MPL/2.0/
-#ifndef IGL_EXAMPLE_FUN_H
-#define IGL_EXAMPLE_FUN_H
-
-#include "igl_inline.h"
-
-namespace igl
-{
-  // This is an example of a function, it takes a templated parameter and
-  // shovels it into cout
-  //
-  // Input:
-  //   input  some input of a Printable type
-  // Returns true for the sake of returning something
-  template <typename Printable>
-  IGL_INLINE bool example_fun(const Printable & input);
-}
-
-#ifndef IGL_STATIC_LIBRARY
-#  include "example_fun.cpp"
-#endif
-
-#endif
-```
-
-#### `example_fun.cpp`
-
-```
-// This file is part of libigl, a simple c++ geometry processing library.
-// 
-// Copyright (C) 2015 [Your Name] [your email address]
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public License 
-// v. 2.0. If a copy of the MPL was not distributed with this file, You can 
-// obtain one at http://mozilla.org/MPL/2.0/
-#include "igl/example_fun.h"
-#include <iostream>
-
-template <typename Printable>
-IGL_INLINE bool igl::example_fun(const Printable & input)
-{
-  using namespace std;
-  cout<<"example_fun: "<<input<<endl;
-  return true;
-}
-
-#ifdef IGL_STATIC_LIBRARY
-template bool igl::example_fun<double>(const double& input);
-template bool igl::example_fun<int>(const int& input);
-#endif
-```
-
-
-### Avoid static "helper" functions
-
-Strive to encapsulate sub-functions that could possibly be useful outside of
-the implementation of your current function. This might mean abstracting the
-interface a bit. If it doesn't dramatically effect performance then create a
-new pair of .h/.cpp files with this sub-function.
-
-#### Lambda functions
-
-If encapsulation in a separate file is not possible or does not make sense,
-then avoid crowding the namespace by creating lambda functions within the
-function implementation.
-
-These lambda functions must still be documented with clear [input and output
-arguments](#headerdocumentation). Avoid using full capturing of all automatic
-variables: do not use `[&]` or `[=]`. Rather specify each captured variable
-individually.
-
-### Avoid "helper" classes
-
-Libigl is built around the high-performance paradigm of "struct of arrays"
-rather than "array of structs". The way we achieve this is to avoid classes and
-pass "basic types" directly. The price we pay is long function interfaces, but
-this increases code reuse dramatically. A "basic type" in our context is a
-Eigen type, stl type, or basic C type.
-
-## Header Documentation
-
-Each function prototype should be well documented in its corresponding .h
-header file. A typical documentation consists of four parts:
-
-```cpp
-// [A human readable description of what the function does.]
-//
-// Inputs:
-//   [variable name of first (const) input]   [dimensions and description of
-//     this input variable]
-//   [variable name of second (const) input]   [dimensions and description of
-//     this input variable]
-//   ...
-// Outputs:
-//   [variable name of first output ]   [dimensions and description of this
-//     output variable]
-//   [variable name of second output ]   [dimensions and description of this
-//     output variable]
-//   ...
-// Returns [description of return value]
-```
-
-### Example
-
-For example the header `barycenter.h`
-
-```
-// Computes the barycenter of every simplex
-//
-// Inputs:
-//   V  #V by dim matrix of vertex coordinates
-//   F  #F by simplex_size  matrix of indices of simplex corners into V
-// Output:
-//   BC  #F by dim matrix of 3d vertices
-//
-```
-
-## Const inputs
-
-All input parameters should be demarcated `const`. If an input is also an
-output than consider exposing two parameters (one `const`) or be sure to list
-the variable under both `// Inputs:` and `// Outputs:` in the header comments.
-
-## Reference parameters
-
-All but simple types should be passed by reference (e.g. `Matrix & mat`) rather
-than pointers (e.g. `Matrix * mat`) or value (e.g. `Matrix mat`).
-
-
-## Returns vs output parameters
-
-All functions should be implemented with at least one overload that has a
-`void` or simple return type (e.g. `bool` on success/failure). With this
-implementation its then possible to write an overload that returns a single
-output. Please see [Templating with Eigen](#templatingwitheigen).
-
-For example:
-
-```cpp
-template <typename Atype>
-void adjacency_matrix(const ... & F, Eigen::SparseMatrix<AType> & A);
-
-template <typename Atype>
-Eigen::SparseMatrix<Atype> adjacency_matrix(const ... & F);
-```
-
-## Templating with Eigen
-
-Functions taking Eigen dense matrices/arrays as inputs and outputs (but **not**
-return arguments), should template on top of `Eigen::MatrixBase`. **Each
-parameter** should be derived using its own template.
-
-For example,
-
-```cpp
-template <typename DerivedV, typename DerivedF, typename DerivedBC>
-void barycenter(
-  const Eigen::MatrixBase<DerivedV> & V,
-  const Eigen::MatrixBase<DerivedF> & F,
-  const Eigen::MatrixBase<DerivedBC> & BC);
-```
-
-The `Derived*` template encodes the scalar type (e.g. `double`, `int`), the
-number of rows and cols at compile time, and the data storage (Row-major vs.
-column-major). 
-
-Returning Eigen types is discouraged. In cases where the size and scalar type
-are a fixed **and matching** function of an input `Derived*` template, then
-return that `Derived*` type. **Do not** return
-`Eigen::PlainObjectBase<...>` types. For example, this function scales fits a
-given set of points to the unit cube. The return is a new set of vertex
-positions so its type should _match_ that of the input points:
-
-```cpp
-template <typename DerivedV>
-void DerivedV fit_to_unit_cube(const Eigen::PlainObjectBase<DerivedV> & V);
-```
-
-To implement this function, it is **required** to implement a more generic
-output-argument version and call that. So a full implementation looks like:
-
-In `igl/fit_in_unit_cube.h`:
-
-```cpp
-template <typename DerivedV, typename DerivedW>
-void fit_to_unit_cube(
-  const Eigen::MatrixBase<DerivedV> & V,
-  Eigen::PlainObjectBase<DerivedW> & W);
-template <typename DerivedV>
-void DerivedV fit_to_unit_cube(const Eigen::PlainObjectBase<DerivedV> & V);
-```
-
-In `igl/fit_in_unit_cube.cpp`:
-
-```
-template <typename DerivedV, typename DerivedW>
-void fit_to_unit_cube(
-  const Eigen::MatrixBase<DerivedV> & V,
-  Eigen::PlainObjectBase<DerivedW> & W)
-{
-  W = (V.rowwise()-V.colwise().minCoeff()).array() /
-    (V.maxCoeff()-V.minCoeff());
-}
-
-template <typename DerivedV>
-void DerivedV fit_to_unit_cube(const Eigen::MatrixBase<DerivedV> & V)
-{
-  DerivedV W;
-  fit_to_unit_cube(V,W);
-  return W;
-}
-```
-
-Notice that `W` is declared as a `DerivedV` type and **not**
-`Eigen::PlainObjectBase<DerivedV>` type.
-
-**Note:** Not all functions are suitable for returning Eigen types. For example
-`igl::barycenter` above outputs a #F by dim list of barycenters. Returning a
-`DerivedV` type would be inappropriate since the number of rows in `DerivedV`
-will be #V and may not match the number of rows in `DerivedF` (#F).
-
-## Function naming conventions 
-
-Functions (and [thus also files](#filefunction)) should have simple,
-descriptive names using lowercase letters and underscores between words. Avoid
-unnecessary prefaces. For example, instead of `compute_adjacency_matrix`,
-`construct_adjacency_matrix`, `extract_adjacency_matrix`,
-`get_adjacency_matrix`, or `set_adjacency_matrix` just call the function
-`adjacency_matrix`.
-
-## Variable naming conventions
-
-Libigl prefers short (even single character) variable names _with heavy
-documentation_ in the comments in the header file or above the declaration of
-the function. When possible use `V` to mean a list of vertex positions and `F`
-to mean a list of faces/triangles.
-
-## Class naming conventions 
-
-Classes should be avoided. When naming a class use CamelCase (e.g.
-SortableRow.h).
-
-## Enum naming conversion
-
-Enums types should be placed in the appropriate `igl::` namespace and should be
-named in CamelCase (e.g. `igl::SolverStatus`) and instances should be named in
-ALL_CAPS with underscores between words and prefaced with the name of the enum.
-For example:
-
-```cpp
-namespace igl
-{
-  enum SolverStatus
-  {
-    // Good
-    SOLVER_STATUS_CONVERGED = 0,
-    // OK
-    SOLVER_STATUS_MAX_ITER = 1,
-    // Bad
-    SOLVER_STATUS_ERROR = 2,
-    NUM_SOLVER_STATUSES = 3,
-  };
-};
-```
-
-### Exception for file IO
-
-For legacy reasons, file reading and writing functions use a different naming
-convention. A functions reading a `.xyz` file should be named `readXYZ` and a
-function writing `.xyz` files should be names `writeXYZ`.
-
-## `using namespace ...` in global scope
-
-Writing `using namespace std;`, `using namespace Eigen;` etc. outside of a
-global scope is strictly forbidden. Place these lines at the top of each
-function instead.
-
-
-## Namespaces and external dependencies
-
-Functions in the main library (directly in `include/igl`) should only depend on
-Eigen and stl. These functions should have the `igl::` namespace.
-
-Functions with other dependencies should be placed into
-appropriate sub-directories (e.g. if `myfunction` depends on tetgen then create
-`igl/copyleft/tetgen/myfunction.h` and `igl/copyleft/tetgen/myfunction.cpp` and give the function
-the namespace `igl::copyleft::tetgen::myfunction`.
-
-### copyleft subdirectory/namespace 
-
-Dependencies that require users of libigl to release their projects open source
-(e.g. GPL) are considered aggressively "copyleft" and should be placed in the
-`include/igl/copyleft/` sub-directory and `igl::copyleft::` namespace.
-
-## Assertions
-
-Be generous with assertions and always identify the assertion with strings:
-
-```cpp
-assert(m < n && "m must be less than n");
-```
-
-## ifndef include guard
-
-Every header file should be wrapped in an `#ifndef` compiler directive. The
-name of the guard should be in direct correspondence with the path of the .h
-file. For example, `include/igl/copyleft/tetgen/tetrahedralize.h` should be
-
-```cpp
-#ifndef IGL_COPYLEFT_TETGEN_TETRAHEDRALIZE_H
-#define IGL_COPYLEFT_TETGEN_TETRAHEDRALIZE_H
-...
-#endif
-```
-
-## Spaces vs. tabs indentation
-
-Do not use tabs. Use 2 spaces for each indentation level.
-
-## Max line length
-
-Limit lines to 80 characters. Break up long lines into many operations (this
-also helps performance).
-
-## Include order
-
-`#include` directives at the top of a .h or .cpp file should be sorted
-according to a simple principle: place headers of files most likely to be
-edited by you first. This means for
-`include/igl/copyleft/tetgen/tetrahedralize.cpp` you might see
-
-```cpp
-// [Includes of headers in this directory]
-#include "tetrahedralize.h"
-#include "mesh_to_tetgenio.h"
-#include "tetgenio_to_tetmesh.h"
-// [Includes of headers in this project]
-#include "../../matrix_to_list.h"
-#include "../../list_to_matrix.h"
-#include "../../boundary_facets.h"
-// [Includes of headers of related projects]
-#include <Eigen/Core>
-// [Includes of headers of standard libraries]
-#include <cassert>
-#include <iostream>
-```
-
-## Placement of includes
-
-Whenever possible `#include` directives should be placed in the `.cpp`
-implementation file rather than the `.h` header file.
-
-## Warnings
-
-Code should compile without firing any warnings.
-
-### An Exception
-
-The only exception is for the use of the deprecated
-`Eigen::DynamicSparseMatrix` in core sub-routines (e.g. `igl::cat`). This class
-is still supported and faster than the standard, non-deprecated Eigen
-implementation so we're keeping it as long as possible and profitable.

style.css

@@ -1,198 +0,0 @@
-table
-{
-  border-spacing: 0px;
-}
-
-table.full
-{
-  width: 100%;
-  table-layout: fixed;
-}
-
-tr.header th
-{
-  border-bottom: 1px solid; 
-  background-color: #ffb;
-  padding-left: 10px;
-  padding-right: 20px;
-  text-align: left;
-}
-tr.d0 td 
-{
-  background-color: #EEE; 
-  color: black;
-  padding-left: 10px;
-  padding-right: 20px;
-  min-width: 200px;
-}
-tr.d1 td
-{
-  background-color: #bcf; 
-  color: black;
-  padding-left: 10px;
-  padding-right: 20px;
-  min-width: 200px;
-}
-
-tr.gotcha1 td
-{
-  background-color: #fcb;
-  color: black;
-  padding-left: 10px;
-  padding-right: 20px;
-  min-width: 200px;
-}
-
-tr.gotcha2 td
-{
-  background-color: #fed;
-  color: black;
-  padding-left: 10px;
-  padding-right: 20px;
-  min-width: 200px;
-}
-/* Don't color pre tag like a box when it shows up in table */
-tr pre
-{
-  background-color: inherit;
-  border: 1px dashed #888;
-  overflow: auto;
-  padding: none;
-}
-
-.note:before
-{
-  font-style: normal;
-  content: "Note: ";
-}
-.note
-{
-  background-color: #ddd;
-  border: 1px solid #bbb;
-  margin-top: 2px;
-  margin-bottom: 2px;
-  font-style: italic;
-  padding-left: 4px;
-  padding-right: 4px;
-  padding-top: 2px;
-  padding-bottom: 2px;
-}
-span.highlight
-{
-  background-color: #4F5;
-}
-a 
-{
-  text-decoration:none;
-  border:none;
-  outline:none;
-  color:#0645AD;
-}
-a:hover 
-{
-  color:#0645AD;
-  text-decoration: underline;
-}
-a.missing
-{
-  color:#F32;
-}
-a:visited
-{
-  color:#0b0080;
-}
-span.todo:before
-{
-  font-style: normal;
-  content: "TODO: ";
-}
-span.todo
-{
-  color: #F54;
-  font-style: italic;
-}
-pre
-{
-  background-color: #c3e0f0;
-  overflow: auto;
-  padding-left: 8px;
-  padding-right: 8px;
-  padding-top: 4px;
-  padding-bottom: 4px;
-  border: 1px solid #999;
-}
-img.center
-{
-  display: block;
-  margin-left: auto;
-  margin-right: auto;
-}
-
-body, html
-{
-  margin: 0px;
-  padding: 0px;
-  background-color: #bbb;
-  font-family: "HelveticaNeueLight", "HelveticaNeue-Light", "Helvetica Neue Light", "HelveticaNeue", "Helvetica Neue", 'TeXGyreHerosRegular', "Helvetica", "Tahoma", "Geneva", "Arial", sans-serif; font-weight:300; font-stretch:normal;
-  height: 100%;
-}
-
-.article_outer
-{
-  padding: 0px;
-  margin:0px auto;
-  /* 600px = 2*300px wider that article_inner*/
-  width: 1415px;
-}
-
-.article_inner
-{
-  padding: 20px;
-  position:relative;
-  font-size: 14pt;
-  background-color: #fff;
-  margin:0px auto;
-  border-left: 1px solid #888;
-  border-right: 1px solid #888;
-  width: 815px;
-  text-align: left;
-}
-
-#container
-{
-  position:absolute;
-  top:0px;
-  bottom: -0px;
-  left:0px;
-  right:0px;
-  overflow:auto;
-}
-
-#fixed_sidebar
-{
-  margin: 0px;
-  position:absolute;
-  padding: 5px 10px;
-  top:10px;
-  left:0px;
-  right:0px;
-  background-color: #fff;
-  overflow:hidden;
-  width: 250px;
-  z-index:100;
-  border-right: 1px solid #888;
-  border-top: 1px solid #888;
-  border-bottom: 1px solid #888;
-}
-ul
-{
-  margin:0px;
-  padding: 0px 20px;
-  /*list-style-type:none;*/
-}
-li { font-size: 100% }
-li li { font-size: 90% }
-li li li { font-size: 80% }
-li li li li { font-size: 70% }
-li li li li li { font-size: 60%}
-

tutorial/images/102_DrawMesh.png.REMOVED.git-id

@@ -1 +0,0 @@
-c936e7988b44f8047af4c77805f037b742793abe

tutorial/images/104_Colors.png.REMOVED.git-id

@@ -1 +0,0 @@
-f3849d85e8946a298f288132cd3b3a3eee9ff228

tutorial/images/105_Overlays.png.REMOVED.git-id

@@ -1 +0,0 @@
-c81c264b82b4fd4cded7da143be3ae9cad47c634

tutorial/images/106_ViewerMenu.png.REMOVED.git-id

@@ -1 +0,0 @@
-af40ffb84d7d8aaa7b021b8c676d5458918fef7e

tutorial/images/501_HarmonicParam.png.REMOVED.git-id

@@ -1 +0,0 @@
-c83e722e160a101036a28bff54be0367c6db3f3c

tutorial/images/502_LSCMParam.png.REMOVED.git-id

@@ -1 +0,0 @@
-81f6613358be22cf2fbcd93954303b8508b9c8fc

tutorial/images/503_ARAPParam.png.REMOVED.git-id

@@ -1 +0,0 @@
-c853fa15b768b5dcf88bea69aa24715ab18e1f98

tutorial/images/504_nrosy_field.png.REMOVED.git-id

@@ -1 +0,0 @@
-1686bacfbb5df106f28812c957d09305bec2ba92

tutorial/images/504_vector_field.png.REMOVED.git-id

@@ -1 +0,0 @@
-f50949f140bda0226adfecbc622a03987faac74e

tutorial/images/505_MIQ_1.png.REMOVED.git-id

@@ -1 +0,0 @@
-433c482262ee9d30f58bd3400eb95790cfcd9f0a

tutorial/images/505_MIQ_2.png.REMOVED.git-id

@@ -1 +0,0 @@
-2a722b5a91fbe49d34f0bba1476beefc11daaf78

tutorial/images/505_MIQ_3.png.REMOVED.git-id

@@ -1 +0,0 @@
-78bb8ce227dbfce1dc4ad037db4994b7bb0fda22

tutorial/images/505_MIQ_4.png.REMOVED.git-id

@@ -1 +0,0 @@
-0d63d20eab443d6ded5487915ba532b0d5e5b202

tutorial/images/505_MIQ_5.png.REMOVED.git-id

@@ -1 +0,0 @@
-3a80d5a52fc68e4206c5854008869216bf9d2977

tutorial/images/505_MIQ_6.png.REMOVED.git-id

@@ -1 +0,0 @@
-e63976e71eeee28470da60b732a24654e1ce7b84

tutorial/images/505_MIQ_7.png.REMOVED.git-id

@@ -1 +0,0 @@
-124ada800a90dba1fc780c33a12a0c84a50777af

tutorial/images/505_MIQ_8.png.REMOVED.git-id

@@ -1 +0,0 @@
-e0a6eb0701d8155e3af93ece4d86ce7d8c3a737d

tutorial/images/506_FrameField_1.png.REMOVED.git-id

@@ -1 +0,0 @@
-33e082f2adb373fe71cec2d76ff66da33f102e12

tutorial/images/506_FrameField_2.png.REMOVED.git-id

@@ -1 +0,0 @@
-b75e297a5acf0abbbb81a86e5df8f3ebfe65803f

tutorial/images/506_FrameField_3.png.REMOVED.git-id

@@ -1 +0,0 @@
-a8c51e8c1520154d85d6344be61a449d5af9ac80

tutorial/images/506_FrameField_4.png.REMOVED.git-id

@@ -1 +0,0 @@
-43ee5e148a9e99d3c68a62005144d5cfcab9766b

tutorial/images/507_PolyVectorField.png.REMOVED.git-id

@@ -1 +0,0 @@
-7938096b6ac2de948e718d7991ef8f337bc4f5b4

tutorial/images/508_ConjugateField.png.REMOVED.git-id

@@ -1 +0,0 @@
-251c8335a4f4aad1420dbd3743503dfe71ff4ed9

tutorial/images/509_Planarization.png.REMOVED.git-id

@@ -1 +0,0 @@
-10b1d8bda9486dcbbbf6d8e04aa00edfa25de838

tutorial/images/510_Integrable.png.REMOVED.git-id

@@ -1 +0,0 @@
-3a795cc747818088e17608f2efb62bc8e3a482cf

tutorial/images/511_PolyVectorFieldGeneral.png.REMOVED.git-id

@@ -1 +0,0 @@
-9a6cb4e375e2b9a94155e147f94dfe3684c23265

tutorial/images/602_Matlab_2.png.REMOVED.git-id

@@ -1 +0,0 @@
-2beb0ca7990862a5838a719ad3c13680f169ede3

tutorial/images/604_Triangle.png.REMOVED.git-id

@@ -1 +0,0 @@
-36007271400d1da84375594fce31ffa8a994beef

tutorial/images/605_Tetgen.png.REMOVED.git-id

@@ -1 +0,0 @@
-9573b35d541d6f4fafd0f686be21f59162f54c1d

tutorial/images/606_AmbientOcclusion.png.REMOVED.git-id

@@ -1 +0,0 @@
-24cf1f058d4c5a8b0a085f2189189b2f790734f8

tutorial/images/607_Picking.png.REMOVED.git-id

@@ -1 +0,0 @@
-82a2caf85135d994691b249beef229bc7a192ea1

tutorial/images/608_LIM.png.REMOVED.git-id

@@ -1 +0,0 @@
-8e3efaad08e135f073207ab69f7929ca258f21b6

tutorial/images/712_beetles.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-5513240871aa3e7a212ac8c2ae8cb466ffac3793

tutorial/images/713_ShapeUp.png.REMOVED.git-id

@@ -1 +0,0 @@
-7d8e22cf732b9663645b9cd17e86d342959cf4be

tutorial/images/VF.pdf.REMOVED.git-id

@@ -1 +0,0 @@
-e37343c2bb0fffbe8572d6c0ecd62713430b76d3

tutorial/images/VF.png.REMOVED.git-id

@@ -1 +0,0 @@
-8df9bef00048d9fd942f74ee127b14ab2d86984d

tutorial/images/arm-dqs.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-7f3e75bd08422e9d73cc3d6864862cc9c7f7328f

tutorial/images/armadillo-fast.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-15c64de24bc8c6f038afc3975355364907f1a8b6

tutorial/images/armadillo-marching-cubes.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-69b7f8aa6e34f6d5f47f14d39c398f1e97b903b5

tutorial/images/beetle-eigen-decomposition.gif.REMOVED.git-id

@@ -1 +0,0 @@
-31e086f020145bd94727cab9f02fbee4b1c3e35b

tutorial/images/big-sigcat-winding-number.gif.REMOVED.git-id

@@ -1 +0,0 @@
-848269f54baa921cd2b5799d8cc77e3024bae9d5

tutorial/images/bump-k-harmonic.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-e2b983b8b9ee35f70aad5ae130419ae78d52d813

tutorial/images/bumpy-gaussian-curvature.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-bd2c02b7b891c2fae7344caad4108f45e0511ad2

tutorial/images/bunny-signed-distance.gif.REMOVED.git-id

@@ -1 +0,0 @@
-28f9e039292c070f3b8f51dfe2f33e42aeb4ffb4

tutorial/images/bunny-swept-volume.gif.REMOVED.git-id

@@ -1 +0,0 @@
-9e6709cd47b785c86caa8b2ed044d820acb1f596

tutorial/images/camelhead-laplace-equation.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-39ddde658cbb1e577caeb58083724a81f796956e

tutorial/images/cheburashka-biharmonic-leq.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-3254fdfb5863a1fe149c14f0630a90c0b942d842

tutorial/images/cheburashka-gradient.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-f423446740ec2dd88082ee2a47d836d378e07495

tutorial/images/cheburashka-knight-boolean.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-687b6cd2769b89898267be8a92eb47e1fe599c02

tutorial/images/cheburashka-multiscale-biharmonic-kernels.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-e81844bdd47fc074d33e369495ea84569e66856d

tutorial/images/cow-curvature-flow.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-e95f80c272b8beed26cff70d5df644e8441150ce

tutorial/images/cube-sphere-cylinders-csg-tree.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-d612c4b22ebb2fd61e89a20d15c58b907e81adec

tutorial/images/cube-sphere-cylinders-csg.gif.REMOVED.git-id

@@ -1 +0,0 @@
-67d4e3cdf207f058f73c2f9d841c4d3bd8f88fcb

tutorial/images/decimated-knight-arap.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-6d8a702c1f31e02c9ca5f11eb4ecae77e7f010da

tutorial/images/decimated-knight-slice-color.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-480151754ff0e57c7111cc288fd6c0b6b163f404

tutorial/images/decimated-knight-sort-color.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-7172cceb268b1fb836116ae527caa912200b416c

tutorial/images/decimated-knight-subdivision.gif.REMOVED.git-id

@@ -1 +0,0 @@
-c334c086e2f3ec1de26911b03329804c4ab90ea7

tutorial/images/edge-collapse.pdf.REMOVED.git-id

@@ -1 +0,0 @@
-8bf78140fdc48fa6597d2579892b6c88bc7701e0

tutorial/images/fandisk-normals.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-f2cb86a67341a5a5f3978f2c336eed2bb29cdc83

tutorial/images/fertility-edge-collapse.gif.REMOVED.git-id

@@ -1 +0,0 @@
-9c5fd841eac14ffcb1da4d52c7f2d6075f36c9cd

tutorial/images/fertility-principal-curvature.jpg.REMOVED.git-id

@@ -1 +0,0 @@
-54d3ee53cc0b43659f330f645a76a79f3b3ab851