├── .gitignore
├── .gitmodules
├── io.cpp
├── io.h
├── reinflate.h
├── filter.h
├── cgal.cpp
├── README.md
├── energy.h
├── gradient.h
├── flow.h
├── cgal.h
├── energy.cpp
├── gradient.cpp
├── CMakeLists.txt
├── filter.cpp
├── nested_cages.cpp
├── reinflate.cpp
├── cmake
    ├── FindLAPACK.cmake
    ├── FindLIBIGL.cmake
    └── FindBLAS.cmake
├── flow.cpp
├── gargo_500.off
├── LICENSE.GPL
└── gargo_1000.off


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.DS_Store~
 2 | *.DS_Store
 3 | *.aux
 4 | *.bbl
 5 | *.blg
 6 | *.log
 7 | TeX/nested.pdf
 8 | *.gz
 9 | *.un~
10 | *.cache.mat
11 | *.cache.*.mat
12 | *.mexmaci64
13 | *.aux*.make
14 | *.fls
15 | *.dvi
16 | *.d
17 | TeX/multigrid-notes.txt
18 | TeX/nested.fdb_latexmk
19 | TeX/nested.fls
20 | *.mexa64
21 | *~
22 | build*
23 | *.swp
24 | *.swo
25 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
 1 | [submodule "collisiondetection"]
 2 | 	path = collisiondetection
 3 | 	url = https://github.com/evouga/collisiondetection.git
 4 | [submodule "eltopo"]
 5 | 	path = eltopo
 6 | 	url = https://github.com/leokollersacht/eltopo.git
 7 | [submodule "libigl"]
 8 | 	path = libigl
 9 | 	url = https://github.com/libigl/libigl
10 | [submodule "MeshFix-v2.1"]
11 | 	path = MeshFix-v2.1
12 | 	url = https://github.com/alecjacobson/MeshFix-v2.1
13 | 


--------------------------------------------------------------------------------
/io.cpp:
--------------------------------------------------------------------------------
 1 | #include "io.h"
 2 | 
 3 | #include <iostream>
 4 | #include <set>
 5 | #include <algorithm>
 6 | #include <cstdlib>
 7 | 
 8 | // Remove all characters 'c' from string 'str'.
 9 | // Also output the number of characters removed
10 | int remove_all_chars_and_count(
11 |   char* str, 
12 |   const char c) 
13 | 
14 | {
15 |   int removed = 0;
16 |   char *pr = str, *pw = str;
17 |   while (*pr) {
18 |     *pw = *pr++;
19 |     removed += (*pw == c);
20 |     pw += (*pw != c);
21 |   }
22 |   *pw = '\0';
23 |   return removed;
24 | }
25 | 
26 | // Check if a given string is a number
27 | bool legal_int(
28 |   const char *str) 
29 | 
30 | {
31 |   while (*str)
32 |     if (!isdigit(*str++))
33 |       return false;
34 |   return true;
35 | }


--------------------------------------------------------------------------------
/io.h:
--------------------------------------------------------------------------------
 1 | #ifndef IO_H
 2 | #define IO_H
 3 | 
 4 | // This file implements functions to help parse
 5 | // the command line arguments
 6 | //   - remove_all_chars_and_count
 7 | //   - legal_int
 8 | //
 9 | 
10 | // Remove all characters 'c' from string 'str'.
11 | // Also output the number of characters removed
12 | //
13 | // Inputs:
14 | //   str  input string
15 | //   c  character to remove from str
16 | // Output:
17 | //   removed  number of characters removed (number of appearences of 'c' in 'str')
18 | //   str  overwritten 'str' without 'c'  
19 | //
20 | int remove_all_chars_and_count(
21 |   char* str, 
22 |   const char c);
23 | 
24 | // Check if a given string is a number
25 | //
26 | // Inputs:
27 | //   str  input string
28 | // Output:
29 | //   bool  
30 | 
31 | bool legal_int(
32 |   const char * str); 
33 | 
34 | #endif 


--------------------------------------------------------------------------------
/reinflate.h:
--------------------------------------------------------------------------------
 1 | #ifndef REINFLATE_H
 2 | #define REINFLATE_H
 3 | 
 4 | #include <Eigen/Core>
 5 | #include <Eigen/SparseCore>
 6 | #include <stack>
 7 | 
 8 | // Given a history of fine flown meshes H, reinflates the fine
 9 | // mesh pushing the coarse mesh (C_hat,F_hat) away to new positions (C,F_hat).
10 | // 
11 | // Inputs:
12 | //   H  history of flow mesh positions
13 | //   T  connectivity of the fine meshes (same for all meshes in H)
14 | //   C_hat  #C_hat by 3 list of coarse mesh initial positions
15 | //   F_hat  #F_hat by 3 list of coarse mesh triangle indices C_hat
16 | //   EnergyInflation  either "None", or "DispInitial", or "DispStep" or
17 | //           "Volume" or "SurfARAP" or "VolARAP"
18 | //   EnergyFinal  either "None", or "DispInitial", or "DispStep" or
19 | //           "Volume" or "SurfARAP" or "VolARAP"
20 | // Output:
21 | //  C  #C by 3 list of final coarse mesh vertex positions (optimal cage)
22 | void reinflate(
23 |   std::stack<Eigen::MatrixXd> & H, 
24 |   const Eigen::MatrixXi & T, 
25 |   const Eigen::MatrixXd & C_hat, 
26 |   const Eigen::MatrixXi & F_hat, 
27 |   const char* EnergyInflation,
28 |   const char* EnergyFinal,
29 |   Eigen::MatrixXd & C);
30 | 
31 | #endif 


--------------------------------------------------------------------------------
/filter.h:
--------------------------------------------------------------------------------
 1 | #ifndef FILTER_H
 2 | #define FILTER_H
 3 | 
 4 | #include <Eigen/Core>
 5 | #include <Eigen/SparseCore>
 6 | 
 7 | // This file implements the filter subroutine of the algorithm in "Nested Cages"
 8 | // [Sacht et al. 2015]. It consists of subroutines:
 9 | //   - filter
10 | 
11 | void velocity_filter_ACM(
12 |   const Eigen::MatrixXd & V0, 
13 |   Eigen::MatrixXd & V1, 
14 |   const Eigen::MatrixXi & F0, 
15 |   double outer,
16 |   double inner,
17 |   int numinfinite);
18 | 
19 | double inflate_ACM(
20 |   Eigen::MatrixXd & V0, 
21 |   const Eigen::MatrixXi & F0, 
22 |   double eps_distance,
23 |   int numinfinite);
24 | 
25 | // Inputs:
26 | //   Vf  fine mesh positions before stepping
27 | //   T   fine mesh vertex indices into Vf 
28 | //   Uf  Desired velocities of the fine mesh
29 | //   C  coarse mesh positions before stepping
30 | //   F_hat   coarse mesh vertex indices into C 
31 | //   eps_prox   minimum separation distance
32 | //   Uc  Desired velocities of the fine mesh
33 | // Output:
34 | //  Uc  Corrected coarse mesh velocities
35 | void filter(
36 |   const Eigen::MatrixXd & Vf, 
37 |   const Eigen::MatrixXi & T, 
38 |   const Eigen::MatrixXd & Uf, 
39 |   const Eigen::MatrixXd & C, 
40 |   const Eigen::MatrixXi & F_coarse, 
41 |   double eps_prox,
42 |   Eigen::MatrixXd & Uc);
43 | 
44 | #endif 


--------------------------------------------------------------------------------
/cgal.cpp:
--------------------------------------------------------------------------------
 1 | #include "cgal.h"
 2 | 
 3 | // computes (overlapping) decimations using CGAL's routines
 4 | void decimate_CGAL(
 5 |   Surface_mesh* surface_mesh, 
 6 |   const float ratio, 
 7 |   const bool adaptive)
 8 | 
 9 | {
10 | 
11 |   int index = 0 ;
12 |   
13 |   for( Surface_mesh::Halfedge_iterator eb = (*surface_mesh).halfedges_begin()
14 |     , ee = (*surface_mesh).halfedges_end()
15 |     ; eb != ee
16 |     ; ++ eb
17 |     ) 
18 |     eb->id() = index++;
19 | 
20 |   index = 0 ;
21 |   for( Surface_mesh::Vertex_iterator vb = (*surface_mesh).vertices_begin()
22 |     , ve = (*surface_mesh).vertices_end()
23 |     ; vb != ve
24 |     ; ++ vb
25 |     )  
26 |     vb->id() = index++;
27 |     
28 |   // Decimate to output 10% resolution mesh
29 |   SMS::Count_ratio_stop_predicate<Surface_mesh> stop(ratio);
30 |  
31 |   Stats stats ;
32 |   My_visitor vis(&stats) ;
33 |     
34 |   // The index maps are not explicitelty passed as in the previous
35 |   // example because the surface mesh items have a proper id() field.
36 |   // On the other hand, we pass here explicit cost and placement
37 |   // function which differ from the default policies, ommited in
38 |   // the previous example.
39 |   if (adaptive){
40 |     int r = SMS::edge_collapse
41 |       (*surface_mesh
42 |       ,stop
43 | #if CGAL_VERSION_NR >= 1040700000
44 |       ,CGAL::parameters::visitor      (vis)
45 | #else
46 |       ,CGAL::visitor      (vis)
47 | #endif
48 |       );
49 |   } else {
50 |   int r = SMS::edge_collapse
51 |     (*surface_mesh
52 |     ,stop
53 | #if CGAL_VERSION_NR >= 1040700000
54 |     ,CGAL::parameters::get_cost     (SMS::Edge_length_cost  <Surface_mesh>())
55 | #else
56 |     ,CGAL::get_cost     (SMS::Edge_length_cost  <Surface_mesh>())
57 | #endif
58 |     .get_placement(SMS::Midpoint_placement<Surface_mesh>())
59 |     .visitor      (vis)
60 |     );
61 |    }
62 | 
63 |   
64 |   return;
65 | 
66 | }
67 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Nested Cages 
 2 | 
 3 | This C++ project implements:
 4 | 
 5 | [Nested Cages] (http://www.cs.columbia.edu/cg/nested-cages/)  
 6 | ACM Transactions on Graphics, vol. 34, no. 6 (SIGGRAPH Asia 2015).  
 7 | Leonardo Sacht, Etienne Vouga and Alec Jacobson
 8 | 
 9 | > Get started with:
10 | >
11 | ```bash
12 | git clone --recursive https://github.com/alecjacobson/nested_cages.git
13 | ```
14 | 
15 | [![Bunny teaser from "Nested Cages"](http://www.cs.columbia.edu/cg/nested-cages/bunny-shelf-teaser.jpg)](http://www.cs.columbia.edu/cg/nested-cages/)
16 | 
17 | ## Compilation
18 | 
19 | This code has been tested on Linux and Mac OS X. In theory this should also
20 | work on Windows.
21 | 
22 | To compile, 
23 | 
24 | ```bash
25 | mkdir build
26 | cd build
27 | cmake -DCMAKE_BUILD_TYPE=Release  ..
28 | make
29 | ```
30 | 
31 | This will build all remaining dependencies and the `nested_cages` executable.
32 | 
33 | ### Dependencies
34 | 
35 | The main dependencies libigl, eltopo and collisiondetection are included as  [git
36 | submodules](https://git-scm.com/docs/git-submodule). If you clone this repo
37 | using `git clone --recursive` then the dependency layout should be:
38 | 
39 |     nested_cages/
40 |       collisiondetection/
41 |       eltopo/
42 |       eigen/
43 |       libigl/
44 | 
45 | The cmake build of libigl will further download cgal and tetgen as external
46 | dependencies.
47 | 
48 | 
49 | ## Example usages
50 | 
51 | Help information
52 | 
53 |     ./nested_cages
54 | 
55 | Obtain 2 volume minimizing nested cages for `../gargo.off`: one regular with
56 | 1000 faces and the other regular with 500 faces. Output resulting cages to
57 | `../test_1.off` and `../test_2.off`
58 | 
59 |     ./nested_cages ../gargo.off 2 1000r 500r None Volume ../test
60 | 
61 | The same as above, but outputs adaptive decimations (instead of regular)
62 | 
63 |     ./nested_cages ../gargo.off 2 1000 500 None Volume ../test
64 | 
65 | Obtain 2 nested cages for `../gargo.off` that minimize surface ARAP energy,
66 | using as input decimations `../gargo_1000.off` and `gargo_500.off`
67 | 
68 |     ./nested_cages ../gargo.off 2 ../gargo_1000.off ../gargo_500.off SurfARAP None ../test
69 | 
70 | 
71 | ## Contact
72 | 
73 | If you have any comments or questions, please contact Leonardo Sacht by e-mail:
74 | leo@mtm.ufsc.br
75 | 


--------------------------------------------------------------------------------
/energy.h:
--------------------------------------------------------------------------------
 1 | #ifndef ENERGY_H
 2 | #define ENERGY_H
 3 | 
 4 | #include <Eigen/Core>
 5 | #include <Eigen/SparseCore>
 6 | #include <igl/arap.h>
 7 | 
 8 | // This file implements the energy subroutine of the algorithm in "Nested Cages"
 9 | // [Sacht et al. 2015]. It consists of subroutines:
10 | //   - energy_displacement
11 | //   - energy_surface_arap
12 | //   - energy_volumetric_arap
13 | //   - energy_volume
14 | //   - energy
15 | 
16 | // computes the squared norm of the difference between 2 meshes C and C_hat
17 | //
18 | // Inputs:
19 | //   C  #C by 3 list of vertex positions of the 1st mesh
20 | //   C_hat  #C by 3 list of vertex positions of the 2nd mesh
21 | // Output:
22 | //   energy   ((C-C_hat).rowwise().norm()).norm();
23 | double energy_displacement(
24 |   const Eigen::MatrixXi & C, 
25 |   const Eigen::MatrixXd & C_hat);
26 | 
27 | // Given rest-pose (surface) mesh (V,F) calculates the ARAP energy ('spokes-and-rims')
28 | // of a deformed mesh (U,F)
29 | //
30 | // Inputs:
31 | //   V  #V by 3 list of vertex positions of the rest pose mesh mesh
32 | //   F  #F by 3 list of vertex indices into V
33 | //   U  #V by 3 list of vertex positions of the deforming mesh
34 | // Output:
35 | //   energy   Surface ARAP energy
36 | double energy_surface_arap(
37 |   const Eigen::MatrixXd & V, 
38 |   const Eigen::MatrixXi & F,
39 |   const Eigen::MatrixXd & U);
40 | 
41 | // Given rest-pose (tetrahedral) mesh (V,F) calculates the ARAP energy ('elements')
42 | // of a deformed mesh (U,F)
43 | //
44 | // Inputs:
45 | //   V  #V by 3 list of vertex positions of the rest pose mesh mesh
46 | //   F  #F by 4 list of vertex indices into V
47 | //   U  #V by 3 list of vertex positions of the deforming mesh
48 | // Output:
49 | //   energy   Volumetric ARAP energy
50 | double energy_volumetric_arap(
51 |   const Eigen::MatrixXd & V, 
52 |   const Eigen::MatrixXi & F,
53 |   const Eigen::MatrixXd & U);
54 | 
55 | // Calculates the volume of a mesh (V,F)
56 | //
57 | // Inputs:
58 | //   V  #V by 3 list of vertex positions of the rest pose mesh mesh
59 | //   F  #F by 3 list of vertex indices into V
60 | // Output:
61 | //   energy   Volume of (V,F)
62 | double energy_volume(
63 |   const Eigen::MatrixXd & V, 
64 |   const Eigen::MatrixXi & F);
65 | 
66 | // Choose between energies above depending on char* Energy and returns 
67 | // energy value
68 | //
69 | // Inputs:
70 | //   C  #C by 3 list of vertex positions of current coarse mesh
71 | //   C_hat  #C by 3 list of vertex positions of initial coarse mesh
72 | //   C_hat  #C by 3 list of vertex positions of previous coarse mesh
73 | //   F  #F by 3 list of vertex indices into V
74 | //   Energy  char specifying the energy to be calculated
75 | // Output:
76 | //   energy value
77 | double energy(
78 |   const Eigen::MatrixXd & C, 
79 |   const Eigen::MatrixXd & C_hat, 
80 |   const Eigen::MatrixXd & C_prev, 
81 |   const Eigen::MatrixXi & F,
82 |   const char* Energy);
83 | 
84 | #endif 


--------------------------------------------------------------------------------
/gradient.h:
--------------------------------------------------------------------------------
 1 | #ifndef GRADIENT_H
 2 | #define GRADIENT_H
 3 | 
 4 | #include <Eigen/Core>
 5 | #include <Eigen/SparseCore>
 6 | #include <igl/arap.h>
 7 | 
 8 | 
 9 | // This file implements the gradient subroutine of the algorithm in "Nested Cages"
10 | // [Sacht et al. 2015]. It consists of subroutines:
11 | //   - gradient_displacement
12 | //   - gradient_surface_arap
13 | //   - gradient_volumetric_arap
14 | //   - gradient_volume
15 | //   - gradient
16 | 
17 | // computes the gradient of the squared norm of the difference between 2 meshes C and C_hat
18 | //
19 | // Inputs:
20 | //   C  #C by 3 list of vertex positions of the 1st mesh
21 | //   C_hat  #C by 3 list of vertex positions of the 2nd mesh
22 | // Output:
23 | //   grad   #C by 3 gradient of displacement energy
24 | void gradient_displacement(
25 |   const Eigen::MatrixXd & C, 
26 |   const Eigen::MatrixXd & C_hat,
27 |   Eigen::MatrixXd & grad);
28 | 
29 | // Given rest-pose (surface) mesh (V,F) calculates the gradient of 
30 | // the ARAP energy ('spokes-and-rims') of a deformed mesh (U,F)
31 | //
32 | // Inputs:
33 | //   V  #V by 3 list of vertex positions of the rest pose mesh mesh
34 | //   F  #F by 3 list of vertex indices into V
35 | //   U  #V by 3 list of vertex positions of the deforming mesh
36 | // Output:
37 | //   grad   Gradient of surface ARAP energy
38 | void gradient_surface_arap(
39 |   const Eigen::MatrixXd & V, 
40 |   const Eigen::MatrixXi & F,
41 |   const Eigen::MatrixXd & U, 
42 |   Eigen::MatrixXd & grad);
43 | 
44 | // Given rest-pose (tetrahedral) mesh (V,F) calculates the gradient of
45 | // the ARAP energy ('elements') of a deformed mesh (U,F)
46 | //
47 | // Inputs:
48 | //   V  #V by 3 list of vertex positions of the rest pose mesh mesh
49 | //   F  #F by 4 list of vertex indices into V
50 | //   U  #V by 3 list of vertex positions of the deforming mesh
51 | // Output:
52 | //   grad   Gradient of volumetric ARAP energy
53 | void gradient_volumetric_arap(
54 |   const Eigen::MatrixXd & V, 
55 |   const Eigen::MatrixXi & F,
56 |   const Eigen::MatrixXd & U,
57 |   Eigen::MatrixXd & grad);
58 | 
59 | // Calculates the gradient of the volume of a mesh (V,F)
60 | //
61 | // Inputs:
62 | //   V  #V by 3 list of vertex positions of the rest pose mesh mesh
63 | //   F  #F by 3 list of vertex indices into V
64 | // Output:
65 | //   grad   Gradient of volume at (V,F)
66 | void gradient_volume(
67 |   const Eigen::MatrixXd & V, 
68 |   const Eigen::MatrixXi & F,
69 |   Eigen::MatrixXd & grad);
70 | 
71 | // Choose between gradients above depending on char* Energy and returns 
72 | // energy value
73 | //
74 | // Inputs:
75 | //   C  #C by 3 list of vertex positions of current coarse mesh
76 | //   C_hat  #C by 3 list of vertex positions of initial coarse mesh
77 | //   C_hat  #C by 3 list of vertex positions of previous coarse mesh
78 | //   F  #F by 3 list of vertex indices into V
79 | //   Energy  char specifying the energy to be calculated
80 | // Output:
81 | //   grad   #C by 3 gradient
82 | //   bool   false if found error, true otherwise
83 | bool gradient(
84 |   const Eigen::MatrixXd & C, 
85 |   const Eigen::MatrixXd & C_hat, 
86 |   const Eigen::MatrixXd & C_prev, 
87 |   const Eigen::MatrixXi & F,
88 |   const char* Energy,
89 |   Eigen::MatrixXd & grad);
90 | 
91 | #endif 


--------------------------------------------------------------------------------
/flow.h:
--------------------------------------------------------------------------------
  1 | #ifndef FLOW_H
  2 | #define FLOW_H
  3 | 
  4 | // This file implements the flow subroutine of the algorithm in "Nested Cages"
  5 | // [Sacht et al. 2015]. It consists of subroutines:
  6 | //   - gradQ_to_gradV
  7 | //   - signed_distance_direction
  8 | //   - grad_energy
  9 | //   - flow_one_step
 10 | //   - flow_fine_inside_coarse
 11 | //
 12 | 
 13 | #include <Eigen/Core>
 14 | #include <Eigen/SparseCore>
 15 | #include <stack>
 16 | 
 17 | // compute the matrix that converts gradient at quadrature 
 18 | // points to gradient at mesh vertices 
 19 | //
 20 | // Inputs:
 21 | //   V0  #V0 by 3 list of mesh vertex positions
 22 | //   F0  #F0 by 3 list of triangle indices into V0
 23 | //   area_0  #F0 list of triangle areas (precomputed)
 24 | //   quad_order  quadrature rule order: 1, 2, or 3
 25 | // Output:
 26 | //   A   #V0 by #A matrix taking quadrature points to gradients at vertices.
 27 | //     For quad_order=1,2,3 then #A=#F,3*#F,4*#F
 28 | //
 29 | void gradQ_to_gradV(
 30 |   const Eigen::MatrixXd & V0, 
 31 |   const Eigen::MatrixXi & F0, 
 32 |   const Eigen::VectorXd & area_0, 
 33 |   const int quad_order,
 34 |   Eigen::SparseMatrix<double> & A);
 35 | 
 36 | // For a set of points P compute the direction of decrease according to the signed
 37 | // distance field of a mesh (V,F).
 38 | //
 39 | // Inputs:
 40 | //   P  #P by 3 list of points
 41 | //   V  #V by 3 list of mesh vertex positions
 42 | //   F  #F by 3 list of triangle indices into V
 43 | // Outputs:
 44 | //   D  #P by 3 list of directions
 45 | //
 46 | void signed_distance_direction(
 47 |   const Eigen::MatrixXd & P, 
 48 |   const Eigen::MatrixXd & V, 
 49 |   const Eigen::MatrixXi & F, 
 50 |   Eigen::MatrixXd & D);
 51 | 
 52 | // Inputs:
 53 | //   V  #V by 3 list of fine mesh positions
 54 | //   F  #F by 3 list of fine mesh triangle indices into V
 55 | //   V_coarse  #V_coarse by 3 list of coarse mesh positions
 56 | //   F_coarse  #F_coarse by 3 list of coarse mesh triangle indices into
 57 | //     V_coarse
 58 | //   A_qv   #V0 by #A_qv matrix taking quadrature points to gradients at vertices.
 59 | //     For quad_order=1,2,3 then #A_qv=#F,3*#F,4*#F
 60 | //   M   mass matrix of the input fine matrix
 61 | // Outputs:
 62 | //   grad  #V by 3 list of gradient coordinates
 63 | void grad_energy(
 64 |   const Eigen::MatrixXd & V, 
 65 |   const Eigen::MatrixXi & F, 
 66 |   const Eigen::MatrixXd & V_coarse, 
 67 |   const Eigen::MatrixXi & F_coarse, 
 68 |   const Eigen::SparseMatrix<double> & A_qv, 
 69 |   const Eigen::SparseMatrix<double> & M_inv, 
 70 |   Eigen::MatrixXd & grad);
 71 | 
 72 | // Calculates the diameter of the uninon of the vertex positions
 73 | // into V and V_coarse.
 74 | //
 75 | // Inputs:
 76 | //   V  #V by 3 list of fine mesh positions
 77 | //   V_coarse  #V_coarse by 3 list of coarse mesh positions
 78 | // Outputs:
 79 | //   diameter  
 80 | double diameter(
 81 |   const Eigen::MatrixXd & V, 
 82 |   const Eigen::MatrixXd & V_coarse);
 83 | 
 84 | // Move the shrinking fine mesh one step along its flow inside the coarse mesh
 85 | // using a specified quadrature order.
 86 | //
 87 | // Inputs:
 88 | //   V  #V by 3 Previous positions of fine mesh vertex positions
 89 | //   F  #F by 3 fine mesh triangle indices into V
 90 | //   V_coarse  #V_coarse by 3 list of coarse mesh positions
 91 | //   F_coarse  #F_coarse by 3 list of coarse mesh triangle indices into
 92 | //   A   #V0 by #A matrix taking quadrature points to gradients at vertices.
 93 | //     For quad_order=1,2,3 then #A=#F,3*#F,4*#F
 94 | //   M_inv inverse of the mass matrix of the fine mesh
 95 | // Output:
 96 | //  V_new  #V by 3 list of new fine mesh vertex positions
 97 | //   
 98 | void flow_one_step(
 99 |   const Eigen::MatrixXd & V, 
100 |   const Eigen::MatrixXi & F, 
101 |   const Eigen::MatrixXd & V_coarse, 
102 |   const Eigen::MatrixXi & F_coarse, 
103 |   const Eigen::SparseMatrix<double> & A_qv, 
104 |   const double delta_t, 
105 |   Eigen::MatrixXd & V_new);
106 | 
107 | // Flow the fine mesh inside the coarse mesh using a specified quadrature order
108 | // 
109 | // Inputs:
110 | //   V0  #V0 by 3 Previous positions of fine mesh vertex positions
111 | //   F0  #F0 by 3 fine mesh triangle indices into V0
112 | //   V_coarse  #V_coarse by 3 list of coarse mesh positions
113 | //   F_coarse  #F_coarse by 3 list of coarse mesh triangle indices into
114 | //   A   #V0 by #A matrix taking quadrature points to gradients at vertices.
115 | //     For quad_order=1,2,3 then #A=#F0,3*#F,4*#F0
116 | // Output:
117 | //   H  history of flow mesh positions
118 | //   a boolean, that says whether the flkow failed or succeeded
119 | //      after 1000 iterations
120 | bool flow_fine_inside_coarse(
121 |   const Eigen::MatrixXd & V0, 
122 |   const Eigen::MatrixXi & F0, 
123 |   const Eigen::MatrixXd & V_coarse, 
124 |   const Eigen::MatrixXi & F_coarse, 
125 |   const Eigen::SparseMatrix<double> & A_qv,
126 |   std::stack<Eigen::MatrixXd> & H);
127 | #endif 
128 | 


--------------------------------------------------------------------------------
/cgal.h:
--------------------------------------------------------------------------------
  1 | #ifndef CGAL_H
  2 | #define CGAL_H
  3 | 
  4 | // This file contains CGAL routines for decimating meshes,
  5 | // most of them adapted from CGAL's example
  6 | // Surface_Mesh_Simplification/edge_collapse_enriched_polyhedron.cpp
  7 | //   - decimate_CGAL
  8 | 
  9 | // *Leo*: I wasn't able to move all these headers to
 10 | // cgal.cpp, so I kept as it is.
 11 | 
 12 | // BEGIN of CGAL includes
 13 | #include <fstream>
 14 | #include <CGAL/Simple_cartesian.h>
 15 | #include <CGAL/Polyhedron_3.h>
 16 | #include <CGAL/IO/Polyhedron_iostream.h>
 17 | // Adaptor for Polyhedron_3
 18 | //#include <CGAL/Surface_mesh_simplification/HalfedgeGraph_Polyhedron_3.h>
 19 | // Simplification function
 20 | #include <CGAL/Surface_mesh_simplification/edge_collapse.h>
 21 | // Visitor base
 22 | #include <CGAL/Surface_mesh_simplification/Edge_collapse_visitor_base.h>
 23 | // Extended polyhedron items which include an id() field
 24 | #include <CGAL/Polyhedron_items_with_id_3.h>
 25 | // Stop-condition policy
 26 | #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_ratio_stop_predicate.h>
 27 | // Non-default cost and placement policies
 28 | #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_length_cost.h>
 29 | #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_length_stop_predicate.h>
 30 | #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Midpoint_placement.h>
 31 | 
 32 | typedef CGAL::Simple_cartesian<double> Kernel;
 33 | typedef Kernel::Point_3 Point_CGAL ;
 34 | typedef CGAL::Polyhedron_3<Kernel,CGAL::Polyhedron_items_with_id_3> Surface_mesh; 
 35 | typedef Surface_mesh::Halfedge_handle Halfedge_handle ;
 36 | typedef Surface_mesh::Vertex_handle   Vertex_handle ;
 37 | namespace SMS = CGAL::Surface_mesh_simplification ;
 38 | typedef SMS::Edge_profile<Surface_mesh> Profile ;   
 39 | // END of CGAL includes
 40 | 
 41 | // The following is a Visitor that keeps track of the simplification process.
 42 | // In this example the progress is printed real-time and a few statistics are
 43 | // recorded (and printed in the end).
 44 | //
 45 | struct Stats
 46 | {
 47 |   Stats() 
 48 |     : collected(0)
 49 |     , processed(0)
 50 |     , collapsed(0)
 51 |     , non_collapsable(0)
 52 |     , cost_uncomputable(0) 
 53 |     , placement_uncomputable(0) 
 54 |   {} 
 55 |   
 56 |   std::size_t collected ;
 57 |   std::size_t processed ;
 58 |   std::size_t collapsed ;
 59 |   std::size_t non_collapsable ;
 60 |   std::size_t cost_uncomputable  ;
 61 |   std::size_t placement_uncomputable ; 
 62 | } ;
 63 | 
 64 | struct My_visitor : SMS::Edge_collapse_visitor_base<Surface_mesh>
 65 | {
 66 |   My_visitor( Stats* s) : stats(s){} 
 67 | 
 68 |   // Called during the collecting phase for each edge collected.
 69 |   void OnCollected( Profile const&, boost::optional<double> const& )
 70 |   {
 71 |     ++ stats->collected ;
 72 |     // std::cerr << "\rEdges collected: " << stats->collected << std::flush ;
 73 |   }                
 74 |   
 75 |   // Called during the processing phase for each edge selected.
 76 |   // If cost is absent the edge won't be collapsed.
 77 |   void OnSelected(Profile const&          
 78 |                  ,boost::optional<double> cost
 79 |                  ,std::size_t             initial
 80 |                  ,std::size_t             current
 81 |                  )
 82 |   {
 83 |     ++ stats->processed ;
 84 |     if ( !cost )
 85 |       ++ stats->cost_uncomputable ;
 86 |   }                
 87 |   
 88 |   // Called during the processing phase for each edge being collapsed.
 89 |   // If placement is absent the edge is left uncollapsed.
 90 |   void OnCollapsing(Profile const&          
 91 |                    ,boost::optional<Point_CGAL>  placement
 92 |                    )
 93 |   {
 94 |     if ( !placement )
 95 |       ++ stats->placement_uncomputable ;
 96 |   }                
 97 |   
 98 |   // Called for each edge which failed the so called link-condition,
 99 |   // that is, which cannot be collapsed because doing so would
100 |   // turn the surface mesh into a non-manifold.
101 |   void OnNonCollapsable( Profile const& )
102 |   {
103 |     ++ stats->non_collapsable;
104 |   }                
105 |   
106 |   // Called AFTER each edge has been collapsed
107 |   void OnCollapsed( Profile const&, Vertex_handle )
108 |   {
109 |     ++ stats->collapsed;
110 |   }                
111 |   
112 |   Stats* stats ;
113 | } ;
114 | 
115 | 
116 | // computes (overlapping) decimations using CGAL's routines
117 | //
118 | // Inputs:
119 | //   surface_mesh  Pointer to the input mesh in Surface_mesh CGAL's format
120 | //   ratio  percentage of faces of the decimated mesh compared to original
121 | //   adaptive  true for adaptive decimation, false for regular
122 | // Output:
123 | //   surface_mesh   Decimated mesh (overwrites input)
124 | void decimate_CGAL(
125 |   Surface_mesh* surface_mesh, 
126 |   const float ratio, 
127 |   const bool adpative);
128 | 
129 | #endif 
130 | 


--------------------------------------------------------------------------------
/energy.cpp:
--------------------------------------------------------------------------------
  1 | #include "energy.h"
  2 | #include "gradient.h"
  3 | #include <stdio.h>
  4 | #include <igl/centroid.h>
  5 | 
  6 | double energy_displacement(
  7 |   const Eigen::MatrixXd & C, 
  8 |   const Eigen::MatrixXd & C_hat)
  9 | {
 10 |   // gradient direction is the difference between current and reference meshes
 11 | 	return ((C-C_hat).rowwise().norm()).norm();
 12 | }
 13 | 
 14 | double energy_surface_arap(
 15 |   const Eigen::MatrixXd & V, 
 16 |   const Eigen::MatrixXi & F,
 17 |   const Eigen::MatrixXd & U)
 18 | {
 19 | 
 20 | 	using namespace Eigen;
 21 |   using namespace std;
 22 |   using namespace igl;
 23 | 
 24 |   // rest-pose mesh
 25 |   MatrixXd ref_V = V;
 26 |   MatrixXi ref_F = F;
 27 | 
 28 |   // precomputation of cotangent matrix of the rest-pose
 29 |   SparseMatrix<double> data_L;
 30 |   cotmatrix(ref_V,ref_F,data_L);
 31 | 
 32 |   // precomputation of stack of covariance matrices
 33 |   // note: for SurfARAP we use 'spokes_and_rims' energy
 34 |   SparseMatrix<double> data_CSM;
 35 |   covariance_scatter_matrix(ref_V,ref_F,ARAP_ENERGY_TYPE_SPOKES_AND_RIMS,data_CSM);
 36 | 
 37 |   // precomputation of RHS for ARAP solve
 38 |   SparseMatrix<double> data_K;
 39 |   arap_rhs(ref_V,ref_F,3,ARAP_ENERGY_TYPE_SPOKES_AND_RIMS,data_K);
 40 | 
 41 |   // repeat positions and mulitply by covraiance matrices
 42 |   MatrixXd U_rep;
 43 |   repmat(U,3,1,U_rep);
 44 |   MatrixXd S = data_CSM*U_rep;
 45 | 
 46 |   // rotation matrices (side-by-side)
 47 |   MatrixXd R;
 48 |   fit_rotations(S,false,R);
 49 | 
 50 |   // columnize R
 51 |   VectorXd Rcol;
 52 |   columnize(R,R.cols()/3,2,Rcol);
 53 | 
 54 |   // multiplication of R by RHS of ARAP
 55 |   MatrixXd dV;
 56 |   dV = data_K*Rcol;
 57 |   MatrixXd dV3(U.rows(),U.cols());
 58 |   dV3.col(0) = dV.block(0,0,U.rows(),1);
 59 |   dV3.col(1) = dV.block(U.rows(),0,U.rows(),1);
 60 |   dV3.col(2) = dV.block(2*U.rows(),0,U.rows(),1);
 61 | 
 62 |   // energy
 63 |   return (-U.transpose()*(0.5*data_L)*U - U.transpose()*dV3 - V.transpose()*(0.5*data_L)*V).trace();
 64 | 
 65 | }
 66 | 
 67 | double energy_volumetric_arap(
 68 |   const Eigen::MatrixXd & V, 
 69 |   const Eigen::MatrixXi & F,
 70 |   const Eigen::MatrixXd & U)
 71 | {
 72 | 
 73 |   using namespace Eigen;
 74 |   using namespace std;
 75 |   using namespace igl;
 76 | 
 77 |   // rest-pose mesh
 78 |   MatrixXd ref_V = V;
 79 |   MatrixXi ref_F = F;
 80 | 
 81 |   // precomputation of cotangent matrix of the rest-pose
 82 |   SparseMatrix<double> data_L;
 83 |   cotmatrix(ref_V,ref_F,data_L);
 84 | 
 85 |   // precomputation of stack of covariance matrices
 86 |   // note: for SurfARAP we use 'elements' energy
 87 |   SparseMatrix<double> data_CSM;
 88 |   covariance_scatter_matrix(ref_V,ref_F,ARAP_ENERGY_TYPE_ELEMENTS,data_CSM);
 89 | 
 90 |   // precomputation of RHS for ARAP solve
 91 |   SparseMatrix<double> data_K;
 92 |   arap_rhs(ref_V,ref_F,3,ARAP_ENERGY_TYPE_ELEMENTS,data_K);
 93 | 
 94 |   // repeat positions and mulitply by covraiance matrices
 95 |   MatrixXd U_rep;
 96 |   repmat(U,3,1,U_rep);
 97 |   MatrixXd S = data_CSM*U_rep;
 98 | 
 99 |   // rotation matrices (side-by-side)
100 |   MatrixXd R;
101 |   fit_rotations(S,false,R);
102 | 
103 |   // columnize R
104 |   VectorXd Rcol;
105 |   columnize(R,R.cols()/3,2,Rcol);
106 | 
107 |   // multiplication of R by RHS of ARAP
108 |   MatrixXd dV;
109 |   dV = data_K*Rcol;
110 |   MatrixXd dV3(U.rows(),U.cols());
111 |   dV3.col(0) = dV.block(0,0,U.rows(),1);
112 |   dV3.col(1) = dV.block(U.rows(),0,U.rows(),1);
113 |   dV3.col(2) = dV.block(2*U.rows(),0,U.rows(),1);
114 | 
115 |   // energy
116 |   return (-U.transpose()*(0.5*data_L)*U - U.transpose()*dV3 - V.transpose()*(0.5*data_L)*V).trace();
117 | }
118 | 
119 | double energy_volume(
120 |   const Eigen::MatrixXd & V, 
121 |   const Eigen::MatrixXi & F)
122 | {
123 | 
124 | 	using namespace Eigen;
125 |   using namespace igl;
126 | 
127 |   VectorXd c(3,1);
128 |   double volume;
129 | 
130 |   // call IGLS's function to calculate volume
131 |   centroid(V,F,c,volume);
132 | 
133 | 	return volume;
134 | 
135 | }
136 | 
137 | double energy(
138 |   const Eigen::MatrixXd & C, 
139 |   const Eigen::MatrixXd & C_hat, 
140 |   const Eigen::MatrixXd & C_prev,
141 |   const Eigen::MatrixXi & F, 
142 |   const char* Energy)
143 | {
144 |   using namespace std;
145 |   // call gradient depending on given energy
146 | 	if (strcmp(Energy,"DispStep")==0)
147 |   {
148 | 		return energy_displacement(C,C_prev);
149 | 	}
150 | 	else if (strcmp(Energy,"DispInitial")==0)
151 | 	{
152 | 		return energy_displacement(C,C_hat);
153 | 	}
154 | 	else if (strcmp(Energy,"SurfARAP")==0)
155 | 	{
156 | 		return energy_surface_arap(C_hat,F,C);
157 | 	}
158 |   else if (strcmp(Energy,"VolARAP")==0)
159 |   {
160 |     return energy_volumetric_arap(C_hat,F,C);
161 |   }
162 | 	else if (strcmp(Energy,"Volume")==0)
163 | 	{
164 | 		return energy_volume(C,F);
165 | 	}
166 |   else {
167 |     cout << "ERROR: specify one of these energies:" << endl;
168 |     cout << "DispStep, DispInitial, Volume, SurfARAP, VolARAP or None" << endl;
169 |   }
170 | 
171 | 	return 0.0;
172 | }


--------------------------------------------------------------------------------
/gradient.cpp:
--------------------------------------------------------------------------------
  1 | #include "gradient.h"
  2 | #include <igl/cotmatrix.h>
  3 | #include <igl/covariance_scatter_matrix.h>
  4 | #include <igl/arap_rhs.h>
  5 | #include <igl/repmat.h>
  6 | #include <igl/fit_rotations.h>
  7 | #include <igl/doublearea.h>
  8 | #include <igl/per_face_normals.h>
  9 | #include <stdio.h>
 10 | 
 11 | void gradient_displacement(
 12 |   const Eigen::MatrixXd & C, 
 13 |   const Eigen::MatrixXd & C_hat,
 14 |   Eigen::MatrixXd & grad)
 15 | {
 16 | 	grad = C-C_hat;
 17 | 	return;
 18 | }
 19 | 
 20 | // add description here
 21 | void gradient_surface_arap(
 22 |   const Eigen::MatrixXd & V, 
 23 |   const Eigen::MatrixXi & F,
 24 |   const Eigen::MatrixXd & U,
 25 |   Eigen::MatrixXd & grad)
 26 | {
 27 | 
 28 | 	using namespace Eigen;
 29 |   	using namespace std;
 30 |   	using namespace igl;
 31 | 
 32 |     MatrixXd ref_V = V; 
 33 |     MatrixXi ref_F = F;
 34 | 
 35 |     SparseMatrix<double> data_L;
 36 |     cotmatrix(ref_V,ref_F,data_L);
 37 | 
 38 |     SparseMatrix<double> data_CSM;
 39 |     covariance_scatter_matrix(ref_V,ref_F,ARAP_ENERGY_TYPE_SPOKES_AND_RIMS,data_CSM);
 40 | 
 41 | 	SparseMatrix<double> data_K;
 42 |     arap_rhs(ref_V,ref_F,3,ARAP_ENERGY_TYPE_SPOKES_AND_RIMS,data_K);
 43 | 
 44 |     MatrixXd U_rep;
 45 |     repmat(U,3,1,U_rep);
 46 |     MatrixXd S = data_CSM*U_rep;
 47 | 
 48 |     MatrixXd R;
 49 |     fit_rotations(S,false,R);
 50 | 
 51 |     VectorXd Rcol;
 52 | 	columnize(R,R.cols()/3,2,Rcol);
 53 | 
 54 | 	MatrixXd dV;
 55 | 	dV = data_K*Rcol;
 56 | 	MatrixXd dV3(U.rows(),U.cols());
 57 | 	dV3.col(0) = dV.block(0,0,U.rows(),1);
 58 | 	dV3.col(1) = dV.block(U.rows(),0,U.rows(),1);
 59 | 	dV3.col(2) = dV.block(2*U.rows(),0,U.rows(),1);
 60 | 
 61 | 	grad = -(data_L*U + dV3);
 62 | 
 63 | }
 64 | 
 65 | // add description here
 66 | void gradient_volumetric_arap(
 67 |   const Eigen::MatrixXd & V, 
 68 |   const Eigen::MatrixXi & F,
 69 |   const Eigen::MatrixXd & U,
 70 |   Eigen::MatrixXd & grad)
 71 | {
 72 | 
 73 | 	int n_boundary = grad.rows();
 74 | 
 75 | 	using namespace Eigen;
 76 |   	using namespace std;
 77 |   	using namespace igl;
 78 | 
 79 |     MatrixXd ref_V = V; 
 80 |     MatrixXi ref_F = F;
 81 | 
 82 |     SparseMatrix<double> data_L;
 83 |     cotmatrix(ref_V,ref_F,data_L);
 84 | 
 85 |     SparseMatrix<double> data_CSM;
 86 |     covariance_scatter_matrix(ref_V,ref_F,ARAP_ENERGY_TYPE_ELEMENTS,data_CSM);
 87 | 
 88 | 	SparseMatrix<double> data_K;
 89 |     arap_rhs(ref_V,ref_F,3,ARAP_ENERGY_TYPE_ELEMENTS,data_K);
 90 | 
 91 |     MatrixXd U_rep;
 92 |     repmat(U,3,1,U_rep);
 93 |     MatrixXd S = data_CSM*U_rep;
 94 | 
 95 |     MatrixXd R;
 96 |     fit_rotations(S,false,R);
 97 | 
 98 |     VectorXd Rcol;
 99 | 	columnize(R,R.cols()/3,2,Rcol);
100 | 
101 | 	MatrixXd dV;
102 | 	dV = data_K*Rcol;
103 | 	MatrixXd dV3(U.rows(),U.cols());
104 | 	dV3.col(0) = dV.block(0,0,U.rows(),1);
105 | 	dV3.col(1) = dV.block(U.rows(),0,U.rows(),1);
106 | 	dV3.col(2) = dV.block(2*U.rows(),0,U.rows(),1);
107 | 
108 | 	grad = -(data_L*U + dV3);
109 | 
110 |     grad = grad.block(0,0,n_boundary,3);
111 | 
112 | }
113 | 
114 | void gradient_volume(
115 |   const Eigen::MatrixXd & V, 
116 |   const Eigen::MatrixXi & F,
117 |   Eigen::MatrixXd & grad)
118 | {
119 | 
120 | 	using namespace Eigen;
121 |   	using namespace std;
122 |   	using namespace igl;
123 | 
124 | 	MatrixXd N;
125 | 	per_face_normals(V,F,N); // unit normals
126 | 	VectorXd area;
127 | 	doublearea(V,F,area);
128 | 	// weight normals by triangle areas
129 | 	for (int k=0; k<F.rows(); k++)
130 | 	{
131 | 		N(k,0) = (area(k)/2.0)*N(k,0);
132 | 		N(k,1) = (area(k)/2.0)*N(k,1);
133 | 		N(k,2) = (area(k)/2.0)*N(k,2);
134 | 	}
135 | 
136 | 	grad.resize(V.rows(),3);
137 | 	for (int k=0; k<F.rows(); k++)
138 | 	{
139 | 		grad(F(k,0),0) = N(k,0);
140 | 		grad(F(k,0),1) = N(k,1);
141 | 		grad(F(k,0),2) = N(k,2);
142 | 
143 | 		grad(F(k,1),0) = N(k,0);
144 | 		grad(F(k,1),1) = N(k,1);
145 | 		grad(F(k,1),2) = N(k,2);
146 | 
147 | 		grad(F(k,2),0) = N(k,0);
148 | 		grad(F(k,2),1) = N(k,1);
149 | 		grad(F(k,2),2) = N(k,2);
150 | 	}
151 | 
152 | 	return;
153 | }
154 | 
155 | bool gradient(
156 |   const Eigen::MatrixXd & C, 
157 |   const Eigen::MatrixXd & C_hat, 
158 |   const Eigen::MatrixXd & C_prev, 
159 |   const Eigen::MatrixXi & F,
160 |   const char* Energy,
161 |   Eigen::MatrixXd & grad)
162 | {
163 | 	using namespace std;
164 | 	if (strcmp(Energy,"DispStep")==0)
165 | 	{
166 | 		gradient_displacement(C,C_prev,grad);
167 | 	}
168 | 	else if (strcmp(Energy,"DispInitial")==0)
169 | 	{
170 | 		gradient_displacement(C,C_hat,grad);
171 | 	}
172 | 	else if (strcmp(Energy,"SurfARAP")==0)
173 | 	{
174 | 		gradient_surface_arap(C_hat,F,C,grad);
175 | 	}
176 | 	else if (strcmp(Energy,"VolARAP")==0)
177 | 	{
178 | 		grad.resize(C_prev.rows(),C_prev.cols()); // C_prev is a surface mesh 
179 | 		gradient_volumetric_arap(C_hat,F,C,grad);
180 | 	}
181 | 	else if (strcmp(Energy,"Volume")==0)
182 | 	{
183 | 		gradient_volume(C,F,grad);
184 | 	}
185 | 	else {
186 |     cout << "ERROR: specify one of these energies:" << endl;
187 |     cout << "DispStep, DispInitial, Volume, SurfARAP, VolARAP or None" << endl;
188 |     return false;
189 |   }
190 | 
191 | 	return true;
192 | }


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
  1 | cmake_minimum_required(VERSION 3.1)
  2 | project(nested_cages)
  3 | set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
  4 | 
  5 | # libigl + cgal + tetgen
  6 | option(LIBIGL_USE_PREBUILT_LIBRARIES "Use prebuilt libraries"       OFF)
  7 | option(LIBIGL_USE_STATIC_LIBRARY     "Use libigl as static library" ${LIBIGL_USE_PREBUILT_LIBRARIES})
  8 | option(LIBIGL_WITH_CGAL              "Use CGAL"                     ON)
  9 | option(LIBIGL_WITH_TETGEN            "Use Tetgen"                   ON)
 10 | find_package(LIBIGL REQUIRED QUIET)
 11 | 
 12 | # MeshFix
 13 | option(WITH_MESHFIX "Use meshfix" ON)
 14 | if(WITH_MESHFIX)
 15 |   set(MESHFIX_LIBRARY ON CACHE BOOL "Build MeshFix as library" FORCE)
 16 |   set(MESHFIX_DIR "${CMAKE_CURRENT_SOURCE_DIR}/MeshFix-v2.1")
 17 |   add_subdirectory("${MESHFIX_DIR}")
 18 | endif()
 19 | 
 20 | # build eltopo library
 21 | set(ELTOPO_DIR "${PROJECT_SOURCE_DIR}/eltopo")
 22 | file(GLOB ELTOPO_SRCFILES             "${ELTOPO_DIR}/eltopo3d/*.cpp"
 23 |                                       "${ELTOPO_DIR}/common/*.cpp"
 24 |                                       "${ELTOPO_DIR}/common/newsparse/*.cpp"
 25 |                                       "${ELTOPO_DIR}/tunicate/*.cpp")
 26 | # Don't build the eltopo viewers that depends on OpenGL and GLUT
 27 | list(REMOVE_ITEM ELTOPO_SRCFILES "${ELTOPO_DIR}/common/gluvi.cpp")
 28 | list(REMOVE_ITEM ELTOPO_SRCFILES "${ELTOPO_DIR}/eltopo3d/meshrenderer.cpp")
 29 | add_library(eltopo ${ELTOPO_SRCFILES})
 30 | target_compile_definitions(eltopo PUBLIC -D__LITTLE_ENDIAN__ -DUSE_FORTRAN_BLAS -DNO_GUI -DGRID_100 -DEXTRA_PASSES -DREMOVE_RIZ)
 31 | set_property(TARGET eltopo PROPERTY POSITION_INDEPENDENT_CODE ON)
 32 | # eltopo uses #include <myfile.h> instead of #include "myfile.h"
 33 | target_include_directories(eltopo PUBLIC "${ELTOPO_DIR}/common/" )
 34 | target_include_directories(eltopo PUBLIC "${ELTOPO_DIR}/common/tunicate" )
 35 | target_include_directories(eltopo PUBLIC "${ELTOPO_DIR}/common/newsparse" )
 36 | target_include_directories(eltopo PUBLIC "${ELTOPO_DIR}/eltopo3d/" )
 37 | find_package(BLAS REQUIRED)
 38 | find_package(LAPACK REQUIRED)
 39 | if(APPLE)
 40 |   set(CMAKE_CXX_LINK_FLAGS "-framework Accelerate")
 41 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
 42 | endif()
 43 | 
 44 | # Build collisiondetection library
 45 | set(COLLISIONDETECTION_DIR "${PROJECT_SOURCE_DIR}/collisiondetection")
 46 | file(GLOB COLLISIONDETECTION_SRCFILES "${COLLISIONDETECTION_DIR}/src/*.cpp")
 47 | add_library(collisiondetection ${COLLISIONDETECTION_SRCFILES})
 48 | target_include_directories(collisiondetection PUBLIC "${COLLISIONDETECTION_DIR}/include" )
 49 | target_link_libraries(collisiondetection igl::core)
 50 | 
 51 | file(GLOB SRCFILES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
 52 | add_executable(${PROJECT_NAME} ${SRCFILES})
 53 | option(VERBOSE_DEBUG "VERBOSE_DEBUG" OFF)
 54 | if (VERBOSE_DEBUG)
 55 |   target_compile_definitions(${PROJECT_NAME} PUBLIC "VERBOSE_DEBUG")
 56 | endif ()
 57 | 
 58 | if(WITH_MESHFIX)
 59 |   target_link_libraries(${PROJECT_NAME} MeshFix)
 60 |   target_compile_definitions(${PROJECT_NAME} PUBLIC "WITH_MESHFIX")
 61 |   # for meshfix_eigen.h
 62 |   target_include_directories(${PROJECT_NAME} PUBLIC "${MESHFIX_DIR}/examples")
 63 | endif()
 64 | target_link_libraries(${PROJECT_NAME} eltopo)
 65 | target_link_libraries(${PROJECT_NAME} lapack blas)
 66 | target_link_libraries(${PROJECT_NAME} collisiondetection)
 67 | # For each libigl module, link to target (and flip definition flag)
 68 | target_link_libraries(${PROJECT_NAME} igl::core)
 69 | list(APPEND modules "cgal" "comiso" "cork" "embree" "matlab" "mosek" "opengl" "opengl_glfw" "opengl_glfw_imgui" "png" "tetgen" "triangle" "predicates" "xml")
 70 | foreach(module_name IN LISTS modules)
 71 |   string(TOUPPER "LIBIGL_WITH_${module_name}" option_string)
 72 |   set(option_variable ${${option_string}})
 73 |   if(option_variable)
 74 |     target_compile_definitions(${PROJECT_NAME} PRIVATE -D${option_string})
 75 |     target_link_libraries(${PROJECT_NAME} "igl::${module_name}")
 76 |   endif()
 77 | endforeach()
 78 | 
 79 | option(VERBOSE_DEBUG "VERBOSE_DEBUG" OFF)
 80 | if (VERBOSE_DEBUG)
 81 |   target_compile_definitions(${PROJECT_NAME} PRIVATE -DVERBOSE_DEBUG)
 82 | endif ()
 83 | 
 84 | #cmake_minimum_required(VERSION 2.8.6)
 85 | #
 86 | #SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
 87 | #
 88 | #
 89 | #find_package(BLAS REQUIRED)
 90 | #find_package(LAPACK REQUIRED)
 91 | #if(APPLE)
 92 | #  set(CMAKE_CXX_LINK_FLAGS "-framework Accelerate")
 93 | #  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
 94 | #endif()
 95 | #
 96 | #set(CGAL_DONT_OVERRIDE_CMAKE_FLAGS TRUE CACHE BOOL "CGAL's CMAKE Setup is super annoying ")
 97 | #find_package(CGAL REQUIRED)
 98 | #include(${CGAL_USE_FILE})
 99 | #
100 | ## We need C++11. Put this directive after CGAL's include.
101 | #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g -Wno-deprecated-declarations -march=native")
102 | #if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
103 | #  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
104 | #endif() 
105 | #
106 | #option(WITH_MESHFIX "Use meshfix" ON)
107 | #
108 | #include_directories( "${PROJECT_SOURCE_DIR}/libigl/include/" )
109 | #include_directories( "${PROJECT_SOURCE_DIR}/libigl/external/nanogui/ext/eigen/" )
110 | #include_directories( "${PROJECT_SOURCE_DIR}/cgal/../")
111 | #include_directories( "${PROJECT_SOURCE_DIR}/collisiondetection/include" )
112 | #include_directories( "${PROJECT_SOURCE_DIR}/eltopo/common/" )
113 | #include_directories( "${PROJECT_SOURCE_DIR}/eltopo/common/tunicate" )
114 | #include_directories( "${PROJECT_SOURCE_DIR}/eltopo/common/newsparse" )
115 | #include_directories( "${PROJECT_SOURCE_DIR}/eltopo/eltopo3d/" )
116 | #
117 | #if(WITH_MESHFIX)
118 | #  add_subdirectory("${PROJECT_SOURCE_DIR}/MeshFix-v2.1")
119 | #endif()
120 | #
121 | #option(VERBOSE_DEBUG "VERBOSE_DEBUG" OFF)
122 | #if (VERBOSE_DEBUG)
123 | #  add_definitions(-DVERBOSE_DEBUG)
124 | #endif ()
125 | #
126 | #file(GLOB SRCFILES                    "${PROJECT_SOURCE_DIR}/*.cpp")
127 | #
128 | ## Tetgen, CollisionDetection, and Eltopo don't use CMAKE, so add their source
129 | ## files directly
130 | #file(GLOB TETGEN_SRCFILES             "${TETGEN_DIR}/*.cxx")
131 | #file(GLOB COLLISIONDETECTION_SRCFILES "${PROJECT_SOURCE_DIR}/collisiondetection/src/*.cpp")
132 | #file(GLOB ELTOPO_SRCFILES             "${PROJECT_SOURCE_DIR}/eltopo/eltopo3d/*.cpp"
133 | #                                      "${PROJECT_SOURCE_DIR}/eltopo/common/*.cpp"
134 | #                                      "${PROJECT_SOURCE_DIR}/eltopo/common/newsparse/*.cpp"
135 | #                                      "${PROJECT_SOURCE_DIR}/eltopo/tunicate/*.cpp")
136 | ## Don't build the eltopo viewers that depends on OpenGL and GLUT
137 | #list(REMOVE_ITEM ELTOPO_SRCFILES "${PROJECT_SOURCE_DIR}/eltopo/common/gluvi.cpp")
138 | #list(REMOVE_ITEM ELTOPO_SRCFILES "${PROJECT_SOURCE_DIR}/eltopo/eltopo3d/meshrenderer.cpp")
139 | #add_definitions(-D__LITTLE_ENDIAN__ -DUSE_FORTRAN_BLAS -DNO_GUI -DGRID_100 -DEXTRA_PASSES -DREMOVE_RIZ -fPIC)
140 | #
141 | #add_executable(nested_cages 
142 | #  ${SRCFILES} 
143 | #  ${TETGEN_SRCFILES}
144 | #  ${COLLISIONDETECTION_SRCFILES}
145 | #  ${ELTOPO_SRCFILES})
146 | #
147 | #target_link_libraries(
148 | #  nested_cages 
149 | #  ${CGAL_LIBRARIES} 
150 | #  )
151 | #
152 | #if(WITH_MESHFIX)
153 | #  target_compile_definitions(nested_cages PUBLIC "WITH_MESHFIX")
154 | #target_link_libraries(
155 | #  nested_cages 
156 | #  meshfix 
157 | #  jmesh 
158 | #  jmeshext 
159 | #  nl 
160 | #  superlu
161 | #  ${BLAS_LIBRARIES} 
162 | #  ${LAPACK_LIBRARIES} 
163 | #  )
164 | #endif()
165 | 


--------------------------------------------------------------------------------
/filter.cpp:
--------------------------------------------------------------------------------
  1 | #include "filter.h"
  2 | 
  3 | // common
  4 | #include <array2.h>
  5 | #include <ccd_wrapper.h>
  6 | #include <collisionqueries.h>
  7 | #include <marching_tiles_hires.h>
  8 | #include <util.h>
  9 | #include <vec.h>
 10 | #include <wallclocktime.h>
 11 | 
 12 | // el topo
 13 | #include <collisionpipeline.h>
 14 | #include <eltopo.h>
 15 | #include <meshrenderer.h>
 16 | #include <runstats.h>
 17 | #include <surftrack.h>
 18 | #include <trianglequality.h>
 19 | 
 20 | // ACM
 21 | #include <VelocityFilter.h>
 22 | #include <Distance.h>
 23 | 
 24 | double inflate_ACM(
 25 |    Eigen::MatrixXd & V0, 
 26 |   const Eigen::MatrixXi & F0, 
 27 |   double eps_distance,
 28 |   int numinfinite)
 29 | {
 30 |   using namespace Eigen;
 31 |   using namespace std;
 32 | 
 33 |   Matrix3Xi F0_t(3,F0.rows());
 34 |   for (int k=0; k<F0.rows();k++){
 35 |       F0_t(0,k) = F0(k,0);
 36 |       F0_t(1,k) = F0(k,1);
 37 |       F0_t(2,k) = F0(k,2);
 38 |   }
 39 | 
 40 |   VectorXd q(3*V0.rows());
 41 |   for (int k=0; k<V0.rows();k++){
 42 |       q(3*k) = V0(k,0);
 43 |       q(3*k+1) = V0(k,1);
 44 |       q(3*k+2) = V0(k,2);
 45 |   }
 46 |   VectorXd invmasses(3*V0.rows());
 47 |   for (int k=0; k<3*numinfinite; k++){
 48 |       invmasses(k) = 0.0;
 49 |   }
 50 |   for (int k=3*numinfinite; k<3*V0.rows(); k++){
 51 |       invmasses(k) = 1.0;
 52 |   }
 53 | 
 54 |   set<int> fixedVerts;
 55 |   for(int i=0; i<numinfinite; i++)
 56 |       fixedVerts.insert(i);
 57 | 
 58 |   double distance = Distance::meshSelfDistance(q, F0_t, fixedVerts);
 59 |   double prev_distance = distance;
 60 |   while(distance < eps_distance)
 61 |   {
 62 |       cout << "Distance is " << distance << ". Inflating... " << endl;
 63 |       VectorXd qnew = q;
 64 |       VelocityFilter::velocityFilter(q, qnew, F0_t, invmasses, 2.0*distance, 0.5*distance);
 65 |       q = qnew;
 66 |       distance = Distance::meshSelfDistance(q, F0_t, fixedVerts);
 67 |       if (distance<prev_distance){
 68 |           cout << "Couldn't recah prescribed distance " << eps_distance << ". Returned " << prev_distance;
 69 |           break;
 70 |       }
 71 |       prev_distance = distance;
 72 |   }
 73 | 
 74 |   // overwrite V0
 75 |   for (int k=0; k<V0.rows(); k++){
 76 |       V0(k,0) = q(3*k);
 77 |       V0(k,1) = q(3*k+1);
 78 |       V0(k,2) = q(3*k+2);
 79 |   }
 80 | 
 81 |   if (distance>eps_distance) return eps_distance;
 82 |   else return distance;
 83 | 
 84 | }
 85 | 
 86 | void velocity_filter_ACM(
 87 |   const Eigen::MatrixXd & V0, 
 88 |   Eigen::MatrixXd & V1, 
 89 |   const Eigen::MatrixXi & F0, 
 90 |   double outer,
 91 |   double inner,
 92 |   int numinfinite)
 93 | {
 94 |   using namespace Eigen;
 95 |   using namespace std;
 96 | 
 97 |   Matrix3Xi F0_t(3,F0.rows());
 98 |   for (int k=0; k<F0.rows();k++){
 99 |       F0_t(0,k) = F0(k,0);
100 |       F0_t(1,k) = F0(k,1);
101 |       F0_t(2,k) = F0(k,2);
102 |   }
103 | 
104 |   VectorXd qstart(3*V0.rows());
105 |   VectorXd qend(3*V0.rows());
106 |   for (int k=0; k<V0.rows();k++){
107 |       qstart(3*k) = V0(k,0);
108 |       qstart(3*k+1) = V0(k,1);
109 |       qstart(3*k+2) = V0(k,2);
110 |   }
111 |   for (int k=0; k<V0.rows();k++){
112 |       qend(3*k) = V1(k,0);
113 |       qend(3*k+1) = V1(k,1);
114 |       qend(3*k+2) = V1(k,2);
115 |   }
116 |   VectorXd invmasses(3*V0.rows());
117 |   for (int k=0; k<3*numinfinite; k++){
118 |       invmasses(k) = 0.0;
119 |   }
120 |   for (int k=3*numinfinite; k<3*V0.rows(); k++){
121 |       invmasses(k) = 1.0;
122 |   }
123 | 
124 |   int sim_status = VelocityFilter::velocityFilter(qstart, qend, F0_t, invmasses, outer, inner);
125 |   cout << "simultaion_status = " << sim_status << endl;
126 | 
127 |   for (int k=0; k<V0.rows(); k++){
128 |       V1(k,0) = qend(3*k);
129 |       V1(k,1) = qend(3*k+1);
130 |       V1(k,2) = qend(3*k+2);
131 |   }
132 | 
133 |   return;
134 | }
135 | 
136 | void filter(
137 |   const Eigen::MatrixXd & Vf, 
138 |   const Eigen::MatrixXi & T, 
139 |   const Eigen::MatrixXd & Uf, 
140 |   const Eigen::MatrixXd & C, 
141 |   const Eigen::MatrixXi & F_hat, 
142 |   double eps_prox,
143 |   Eigen::MatrixXd & Uc)
144 | {
145 |   using namespace Eigen;
146 |   using namespace std;
147 |   // Define concataned meshes (treat fine and coarse meshes as a big single mesh)
148 |   MatrixXd V0(Vf.rows()+C.rows(),3);
149 |   MatrixXd V1(Vf.rows()+C.rows(),3);
150 |   // Initial positions
151 |   V0.block(0,0,Vf.rows(),3) = Vf;
152 |   V0.block(Vf.rows(),0,C.rows(),3) = C;
153 |   // Final positions
154 |   V1.block(0,0,Vf.rows(),3) = Vf+Uf;
155 |   V1.block(Vf.rows(),0,C.rows(),3) = C+Uc;
156 |   
157 |   // First part of F
158 |   MatrixXi F_all(T.rows()+F_hat.rows(),3);
159 |   // Second part of F
160 |   F_all.block(0,0,T.rows(),3) = T;
161 |   F_all.block(T.rows(),0,F_hat.rows(),3) = F_hat;
162 |   for (int k=T.rows();k<F_all.rows();k++)
163 |   {
164 |     F_all(k,0) = F_all(k,0)+Vf.rows();
165 |     F_all(k,1) = F_all(k,1)+Vf.rows();
166 |     F_all(k,2) = F_all(k,2)+Vf.rows();
167 |   }
168 | 
169 |   // set vertex masses (= infty for fine mesh vertices 
170 |   // and =1.0 for the last ones)
171 |   double *masses = new double[V0.rows()];
172 |   for (int i=0; i<Vf.rows(); i++){
173 |       masses[i] = std::numeric_limits<double>::infinity();
174 |   }
175 |   for (int i=Vf.rows(); i<V0.rows(); i++){
176 |       masses[i] = 1.0;
177 |   }
178 | 
179 |   // Convert V0 from Eigen matrix to array
180 |   double *V0a = new double[3*V0.rows()];
181 |   for (int k=0; k<V0.rows(); k++)
182 |   {
183 |     V0a[3*k] = V0(k,0);
184 |     V0a[3*k+1] = V0(k,1);
185 |     V0a[3*k+2] = V0(k,2);
186 |   } 
187 | 
188 |   // Convert F_all from Eigen matrix to array
189 |   int *F_alla = new int[3*F_all.rows()];
190 |   for (int k=0; k<F_all.rows(); k++)
191 |   {
192 |     F_alla[3*k] = F_all(k,0);
193 |     F_alla[3*k+1] = F_all(k,1);
194 |     F_alla[3*k+2] = F_all(k,2);
195 |   } 
196 | 
197 |   // encapsulate all data into an ElTopoMesh
198 |   ElTopoMesh eltopo_time0;
199 |   eltopo_time0.num_vertices = V0.rows();
200 |   eltopo_time0.vertex_locations = V0a;
201 |   eltopo_time0.num_triangles = F_all.rows();
202 |   eltopo_time0.triangles = F_alla;
203 |   eltopo_time0.vertex_masses = masses;
204 | 
205 |   // Convert V1 from Eigen matrix to array
206 |   double *V1a = new double[3*V1.rows()];
207 |   for (int k=0; k<V1.rows(); k++)
208 |   {
209 |     V1a[3*k] = V1(k,0);
210 |     V1a[3*k+1] = V1(k,1);
211 |     V1a[3*k+2] = V1(k,2);
212 |   } 
213 | 
214 |   // Set general parameters
215 |   ElTopoGeneralOptions sim_general_options;
216 |   // do not print stuff to the console
217 |   sim_general_options.m_verbose = 0;
218 |   // do avoid self-intersections
219 |   sim_general_options.m_collision_safety = 1;
220 |   // separation between colliding meshes 
221 |   sim_general_options.m_proximity_epsilon = eps_prox; 
222 | 
223 | 
224 |   // Set Simulation parameters
225 |   ElTopoIntegrationOptions sim_integration_options;
226 |   sim_integration_options.m_friction_coefficient = 0.0;
227 |   sim_integration_options.m_dt = 1.0;
228 | 
229 | 
230 |   double* V_final;
231 |   double out_dt = 0.0;
232 |   // We start with 1.0 to step
233 |   double rest_dt = 1.0;
234 |   // While we haven't reached final positions
235 |   while (rest_dt>1e-6)
236 |   {
237 |     // call Eltopo main function
238 |     el_topo_integrate(&eltopo_time0, V1a, &sim_general_options, &sim_integration_options, &V_final, &out_dt);
239 |     // update the rest to go
240 |     rest_dt = (1-out_dt)*rest_dt;
241 |     // if we haven't reached final positions, print how much we have stepped
242 |     // and update vertex positions 
243 |     if (out_dt < 1.0)
244 |     {
245 |       cout << "out_dt = " << out_dt << endl;
246 |       eltopo_time0.vertex_locations = V_final;
247 |     }
248 |     // if stepped too little, give up. To-do: call Asynchronous Contact Mechanincs
249 |     if (out_dt<1e-3){
250 |     	cout << "Eltopo couldn't reach final positions." << endl;
251 |       cout << "It steped " << (1-rest_dt) << "< 1.0" << endl;
252 |       cout << "Calling Asyncronous Contact Mechanics (slower)" << endl;
253 |       double out_proximity = inflate_ACM(V0,F_all,eps_prox,Vf.rows());
254 |       velocity_filter_ACM(V0,V1,F_all,out_proximity,0.01*out_proximity,Vf.rows());
255 |       for (int k=0; k<V1.rows(); k++)
256 |       {
257 |         V_final[3*k] = V1(k,0);
258 |         V_final[3*k+1] = V1(k,1);
259 |         V_final[3*k+2] = V1(k,2);
260 |       } 
261 |     }
262 |   }
263 |   // output corrected velocities
264 |   for (int k=0; k<C.rows(); k++)
265 |   {
266 |     Uc(k,0) = V_final[3*Vf.rows()+3*k]-C(k,0);
267 |     Uc(k,1) = V_final[3*Vf.rows()+3*k+1]-C(k,1);
268 |     Uc(k,2) = V_final[3*Vf.rows()+3*k+2]-C(k,2); 
269 |   }
270 | 
271 |   delete[] masses;
272 |   delete[] V0a;
273 |   delete[] V1a;
274 |   delete[] F_alla;
275 |   
276 | }
277 | 


--------------------------------------------------------------------------------
/nested_cages.cpp:
--------------------------------------------------------------------------------
  1 | // Meshfix include
  2 | #if WITH_MESHFIX
  3 | #include <meshfix.h>
  4 | #include <meshfix_eigen.h>
  5 | #endif
  6 | 
  7 | // Our header files
  8 | #include "io.h"
  9 | #include "cgal.h"
 10 | #include "flow.h"
 11 | #include "reinflate.h"
 12 | 
 13 | // libigl includes
 14 | #include <igl/doublearea.h>
 15 | #include <igl/writeOBJ.h>
 16 | #include <igl/read_triangle_mesh.h>
 17 | #include <igl/write_triangle_mesh.h>
 18 | #include <igl/copyleft/cgal/remesh_self_intersections.h>
 19 | #include <igl/copyleft/cgal/polyhedron_to_mesh.h>
 20 | #include <igl/copyleft/cgal/mesh_to_polyhedron.h>
 21 | #include <igl/copyleft/cgal/intersect_other.h>
 22 |  
 23 | // useful namespaces
 24 | using namespace Eigen;
 25 | using namespace igl;
 26 | using namespace std;
 27 | 
 28 | // For debuggin'
 29 | int at(
 30 |   Eigen::MatrixXi & M,
 31 |   const int i,
 32 |   const int j)
 33 | {
 34 |   return M(i,j);
 35 | }
 36 | 
 37 | // mesh-in, mesh-out wrapper
 38 | void meshfix(
 39 |   const Eigen::MatrixXd & Vin,
 40 |   const Eigen::MatrixXi & Fin,
 41 |   Eigen::MatrixXd & Vout,
 42 |   Eigen::MatrixXi & Fout)
 43 | {
 44 |   /////////////////////////////////////////////////////////////////////////
 45 |   // Convert to meshfix type, call meshfix, convert back from meshfix type
 46 |   T_MESH::TMesh::init(); // This is mandatory // Alec: or is it?
 47 |   T_MESH::Basic_TMesh tin;
 48 |   //igl::write_triangle_mesh("meshfix-input.obj",Vin,Fin);
 49 |   meshfix_from_eigen_matrices(Vin,Fin,tin);
 50 |   meshfix(false,tin);
 51 |   meshfix_to_eigen_matrices(tin,Vout,Fout);
 52 |   //igl::write_triangle_mesh("meshfix-output.obj",Vout,Fout);
 53 |   /////////////////////////////////////////////////////////////////////////
 54 | }
 55 | 
 56 | int main(int argc, char * argv[])
 57 | {
 58 |   using namespace igl::copyleft::cgal;
 59 | 
 60 |   if (argc==1)
 61 |   {
 62 |     cout << R"(Usage: 
 63 | 
 64 |     ./nested_cages input.off q L(1) L(2) ... L(k) EnergyExpansion EnergyFinal output
 65 | 
 66 | input: the program accepts files in the following formats: .off, .obj, .ply, .stl, .wrl .mesh
 67 | 
 68 | output: cages will be saved as output_1.obj, output_2.obj, ..., output_k.obj
 69 | 
 70 | q is the quadrature order for the shrinking flow
 71 | 
 72 | L(1) > L(2) > ... > L(k) is the number of faces for each cage.
 73 | If L(k) is followed by 'r' the initial decimation for this cage will be regular
 74 | (adaptive if no 'r').
 75 | Each L(k) can be replace by a file with an input decimation.
 76 | 
 77 | EnergyExpansion is the energy to be minimized for the re-inflation
 78 | Energies implemented: None, DispStep, DispInitial, Volume, SurfARAP, VolARAP 
 79 | 
 80 | EnergyFinal is the energy to be minimized after the re-inflation (additional processing)
 81 | Energies implemented: None, DispStep, DispInitial, Volume, SurfARAP, VolARAP
 82 | )";
 83 |     return EXIT_FAILURE;
 84 |   }
 85 |   
 86 |   // number of layers
 87 |   int k = argc-6;
 88 |   #ifdef VERBOSE_DEBUG
 89 |     cout << "number of layers = " << k << endl;
 90 |   #endif
 91 | 
 92 |   // quadrature order
 93 |   int quad_order = atoi(argv[2]);
 94 | 
 95 |   // read input mesh
 96 |   Surface_mesh M; 
 97 |   MatrixXd V0;
 98 |   MatrixXi F0;
 99 |   if (!read_triangle_mesh(argv[1],V0,F0)){
100 |     cout << "unable to read input file"  << endl;
101 |     return 0;
102 |   }
103 |   // convert to CGAL format
104 |   mesh_to_polyhedron(V0,F0,M);
105 | 
106 |   // output input mesh as level output_0.off
107 |   char* filename; 
108 |   char *suffix;
109 |   if (asprintf(&filename, "%s%s", argv[argc-1], "_0.obj")!=-1){
110 |     writeOBJ(filename,V0,F0);
111 |   } else {
112 |     cout << "unable to allocate space for output file name"  << endl;
113 |     return 0;
114 |   }
115 | 
116 |   // First fine mesh is the input mesh
117 |   MatrixXd V = V0;
118 |   MatrixXi F = F0;
119 | 
120 |   // vector where each entry is the number of faces for eachj level
121 |   int L[k];
122 |   // standard CGAL decimation is adaptive
123 |   bool adaptive = true;
124 | 
125 |   // declare input decimation
126 |   Surface_mesh M_hat;
127 |   MatrixXd V_coarse;
128 |   MatrixXi F_coarse;
129 | 
130 |   // Loop over levels
131 |   for(int i = 0;i<k;i++){
132 |     // check if argv[i+3] is a valid file. If so, it will be used as input decimation 
133 |     std::ifstream is_file(argv[i+3]);
134 |     if (is_file)
135 |     {
136 |       if (!read_triangle_mesh(argv[i+3],V_coarse,F_coarse)){
137 |         cout << "error: input decimation is an existing file, but couldn't be read"  << endl;
138 |         return 0;
139 |       }
140 |       // convert to CGAL format
141 |       mesh_to_polyhedron(V_coarse,F_coarse,M_hat);
142 |     } 
143 |     // otherwise the input decimation is computed by decimating the previous layer
144 |     // with CGAL decimation (regular or adaptive)
145 |     else
146 |     {
147 |       // first check if last charcater of argv[i+2] is r. If it is, drop the 'r' and adaptive = false
148 |       adaptive = remove_all_chars_and_count(argv[i+3], 'r')==0;
149 |       // check if argv[i+2] is a valid integer (throw an error if it is not)
150 |       if (!legal_int(argv[i+3])){
151 |         cout << "you have to pass integer values or valid input deimatations"  << endl;
152 |         cout << "the invalid argument you have passed is " << argv[i+3] << endl;
153 |         return 0;
154 |       }
155 |       // specified number of faces for this cage
156 |       L[i] = atoi(argv[i+3]);
157 |       // value to pass to the decimator
158 |       float ratio = (1.*L[i])/(1.*M.size_of_facets()); 
159 |       // the previously computed will be decimated
160 |       M_hat = M;
161 |       // decimate
162 |       decimate_CGAL(&M_hat,ratio,adaptive);
163 |     }
164 | 
165 |     // Convert decimation to LibIGL/Eigen format
166 |     polyhedron_to_mesh(M_hat,V_coarse,F_coarse); 
167 |     // Parameters to call function to check for decimation's self-intersections
168 |     RemeshSelfIntersectionsParam params;
169 |     params.detect_only = true;
170 |     params.first_only = true;
171 |     MatrixXd tempV;
172 |     MatrixXi tempF;
173 |     MatrixXi IF;
174 |     VectorXi J;
175 |     VectorXi IM;
176 |     remesh_self_intersections(V_coarse,F_coarse,params,tempV,tempF,IF,J,IM);
177 |     // If input coarse mesh self-intersect, remove self-intersections with Meshfix (to-do)
178 |     if (IF.rows()>0)
179 |     {
180 |       #ifdef VERBOSE_DEBUG
181 |     	  cout << i+1 << "-th input decimation self-intersects. Fixing with Meshfix " << endl;
182 |       #endif
183 | #if WITH_MESHFIX
184 |       cout << "Polishing M" << i+1 << "..." << endl;
185 |       meshfix(MatrixXd(V_coarse),MatrixXi(F_coarse),V_coarse,F_coarse);
186 |       cout << "Success!" << endl;
187 | #else
188 |       cout << "[WITH_MESHFIX not defined] Skipping polishing of M" << i+1 << "..." << endl;
189 | #endif
190 |       remesh_self_intersections(V_coarse,F_coarse,params,tempV,tempF,IF,J,IM);
191 |       if (IF.rows()==0)
192 |       {
193 |         #ifdef VERBOSE_DEBUG
194 |           cout << "Meshfix succesfully removed self-intersections" << endl;  
195 |         #endif
196 |       }
197 |       else{
198 |           cout << "Wasn't able to remove all input self-intersections. Quitting..." << endl; 
199 |     	  return 0;
200 |       }
201 |     }
202 | 
203 | 	  // calculate triangle areas for initial mesh (will be used
204 | 	  // to define the integral at _every_ step - the metric is fixed)
205 | 	  VectorXd area_0;
206 | 	  doublearea(V,F,area_0);
207 | 	  area_0 = 0.5*area_0;
208 |     // Precompute matrix that convert gradients at quadrature points to gradients at mesh vertices
209 |   	SparseMatrix<double> A_qv;
210 |     gradQ_to_gradV(V, F, area_0, quad_order, A_qv);
211 |   	// Flow M inside M_hat and save the result to a stack M of flow meshes
212 |     stack<MatrixXd> H;
213 |     cout << "Flowing M" << i << " inside M" << i+1 << "..." << endl;
214 |     if (!flow_fine_inside_coarse(V,F,V_coarse,F_coarse,A_qv,H))
215 |     {
216 |       cout << "Flow failed to take fine mesh inside coarse mesh after 1000 iterations. Quitting" << endl;
217 |       return 0;
218 |     }
219 |     cout << "Success!" << endl;
220 | 
221 |     // Reinflate and output to cage to C
222 |     MatrixXd C;
223 |     cout << "Reinflating M" << i << ", pushing M" << i+1 << "..." << endl;
224 |     reinflate(H,F,V_coarse,F_coarse,argv[argc-3],argv[argc-2],C);
225 |     cout << "Success!" << endl;
226 | 
227 |     // sanity check: cage should never self-intersect at this stage
228 |     remesh_self_intersections(C,F_coarse,params,tempV,tempF,IF,J,IM);
229 |     if (IF.rows()>0){
230 |       cout << i+1 << "-th output cage self-intersects. ERROR! Quitting...  " << endl;  
231 |       return 0;
232 |     }
233 | 
234 |     // sanity check: cage should never intersect input decimation
235 |     intersect_other(C,F_coarse,V,F,true,IF);
236 |     if (IF.rows()>0){
237 |       cout << i+1 << "-th output cage intersect previous cage. ERROR! Quitting...  " << endl;  
238 |       return 0;
239 |     }
240 | 
241 |     // output cage is the input for the next level
242 |     M.clear();
243 |     mesh_to_polyhedron(C,F_coarse,M); 
244 |     V = C;
245 |     F = F_coarse;
246 | 
247 |     // Output cage to file output_i.obj
248 |     if ((asprintf(&suffix,"_%d.obj",i+1)!=-1) && (asprintf(&filename, "%s%s", argv[argc-1], suffix)!=-1)){
249 |       writeOBJ(filename,C,F_coarse);
250 |     } else {
251 |       cout << "unable to allocate space for output file name"  << endl;
252 |       return 0;
253 |     }
254 |     // back to adaptive decimation (standard)
255 |     adaptive = true;
256 |   }
257 |   
258 |   free(filename);
259 |   return 1;
260 | }
261 | 


--------------------------------------------------------------------------------
/reinflate.cpp:
--------------------------------------------------------------------------------
  1 | #include "reinflate.h"
  2 | #include "filter.h"
  3 | #include "gradient.h"
  4 | #include "energy.h"
  5 | #include "flow.h"
  6 | #include <igl/arap.h>
  7 | #include <stdio.h>
  8 | 
  9 | // Need to include some IGL header to have igl namespace
 10 | #include <igl/signed_distance.h>
 11 | #include <igl/copyleft/tetgen/tetrahedralize.h>
 12 | 
 13 | void reinflate(
 14 |   std::stack<Eigen::MatrixXd> & H, 
 15 |   const Eigen::MatrixXi & T, 
 16 |   const Eigen::MatrixXd & C_hat, 
 17 |   const Eigen::MatrixXi & F_hat, 
 18 |   const char* EnergyInflation,
 19 |   const char* EnergyFinal,
 20 |   Eigen::MatrixXd & C)
 21 | {
 22 |   using namespace Eigen;
 23 |   using namespace std;
 24 |   using namespace igl;
 25 |   using namespace igl::copyleft::tetgen;
 26 | 
 27 |   MatrixXd F = H.top();
 28 |   H.pop();
 29 |   C = C_hat;
 30 |   MatrixXd C_prev = C; // needed for energies that depend on the previous step (e.g. DispStep)
 31 |   int step = 1;
 32 |   int total_steps = H.size();
 33 | 
 34 |   // data needed for Volumetric ARAP
 35 |   MatrixXd TV;
 36 |   MatrixXd TV0;
 37 |   MatrixXi TT;
 38 |   MatrixXi TF;
 39 |   ARAPData data;
 40 |   VectorXi b(C.rows());
 41 |   for (int k=0;k<C.rows();k++) b(k) = k;
 42 | 
 43 |   // reinflation
 44 |   while (!H.empty()){
 45 | 
 46 |     // Intialize energy as infinity
 47 |     double current_energy = std::numeric_limits<double>::infinity();
 48 |     // Initial step size
 49 |     double beta = 1e-2;
 50 | 
 51 |     // Fine mesh velocity
 52 |     MatrixXd Uf = H.top()-F;
 53 |     H.pop();
 54 | 
 55 |     // calculate diameter to scale spearation between meshes
 56 |     double diam = diameter(F,C);
 57 |     
 58 |     // If no energy presecribed, find only a feasible state (by filtering Uc=0)
 59 |     if (strcmp(EnergyInflation,"None")==0)
 60 |     {
 61 |     	MatrixXd Uc = MatrixXd::Zero(C_hat.rows(), 3);
 62 |       // this eps=5e-3 is chosen so that there is space for the final optimization
 63 |       filter(F,T,Uf,C,F_hat,diam*5e-3,Uc);
 64 |       // Update fine mesh
 65 |       F = F+Uf;
 66 |       // Update coarse mesh with filtered velocities
 67 |       C = C+Uc;
 68 |       #ifdef VERBOSE_DEBUG
 69 |         cout << "Reinflation step " << step << "/" << total_steps << ": Energy = None (feasible state only)" << endl;
 70 |       #endif
 71 |     }
 72 |     // If energy for re-inflation is prescribed, minimize it
 73 |     else if (strcmp(EnergyInflation,"None")!=0)
 74 |     {
 75 |       // If Volumetric ARAP, tetrahedralize and precompute ARAP Data
 76 |       if (strcmp(EnergyInflation,"VolARAP")==0)
 77 |       {
 78 |         string tetgen_flags ("q2Y");
 79 |         tetrahedralize(C_hat,F_hat,tetgen_flags,TV0,TT,TF); 
 80 |         if (!arap_precomputation(TV0,TT,3,b,data))
 81 |         {
 82 |           cout << "ARAP Precomputation failed" << endl;
 83 |         }
 84 |         // Initialize deformed tet mesh as initial one
 85 |         TV = TV0;
 86 |       }
 87 |       // Stepping and projecting
 88 |       while (true)
 89 |       {
 90 |         #ifdef VERBOSE_DEBUG
 91 |           cout << "Reinflation step " << step << "/" << total_steps << ": Energy = " << EnergyInflation  << endl;
 92 |         #endif
 93 |         MatrixXd grad;
 94 |         // for Volumetric ARAP, calculate gradient after finding optimal 
 95 |         // deformed tet mesh (with local-globe solver)
 96 |         if (strcmp(EnergyInflation,"VolARAP")==0)
 97 |         {
 98 |           if (!arap_solve(C,data,TV))
 99 |           {
100 |             cout << "ARAP Solve failed" << endl;
101 |             return;
102 |           }
103 |           if (!gradient(TV,TV0,C_prev,TT,EnergyInflation,grad))
104 |           {
105 |             cout << "ERROR calculating gradient " << endl;
106 |             return;
107 |           }
108 | 
109 |         }
110 |         // for other energies, just calculate the gradient
111 |         else
112 |         {
113 |           if (!gradient(C,C_hat,C_prev,F_hat,EnergyInflation,grad))
114 |           {
115 |             cout << "ERROR calculating gradient " << endl;
116 |             return;
117 |           }
118 |         }
119 |         // multiply gradient by current step size
120 |         MatrixXd Uc = -beta*grad;
121 |         // filter coarse mesh velocities
122 |         filter(F,T,Uf,C,F_hat,diam*1e-3,Uc);
123 | 
124 |         // update fine mesh (it has to be bone here, because
125 |         // otherwise the collision solver will check intersections 
126 |         // between new coarse mesh and old fine mesh - they rarely intersect,
127 |         // but can be a problem)
128 |         F = F+Uf;
129 |         Uf = MatrixXd::Zero(F.rows(), 3);
130 | 
131 |         // update energy value
132 |         double new_energy;
133 |         if (strcmp(EnergyInflation,"VolARAP")==0)
134 |         {
135 |           new_energy = energy(TV,TV0,C_prev,TT,EnergyInflation);
136 |         }
137 |         else
138 |         {
139 |           new_energy = energy(C+Uc,C_hat,C_prev,F_hat,EnergyInflation);
140 |         }
141 | 
142 |         // if energy increased, cut step size by half
143 |         if (new_energy>current_energy)
144 |         {
145 |           beta = 0.5*beta;
146 |           #ifdef VERBOSE_DEBUG
147 |             cout << "energy increased, descreasing beta to " << beta << endl;
148 |           #endif
149 |           // If step size is too small, then it has converged. Break
150 |           if (beta<1e-3)
151 |           {
152 |             #ifdef VERBOSE_DEBUG
153 |               cout << "beta too small. Quitting line search loop " << endl;
154 |             #endif
155 |             break;
156 |           }
157 |         }
158 |         // if energy decreased, update coarse mesh, update energy value and 
159 |         // and increase beta 10%
160 |         else{
161 |           C = C+Uc;
162 |           current_energy = new_energy;
163 |           beta = 1.1*beta;
164 |           #ifdef VERBOSE_DEBUG
165 |             cout << "energy decreased to " << current_energy << ", increasing beta to " << beta << endl;
166 |           #endif
167 |         }
168 |         // If tiny step, then it has converged. Break
169 |         if (((Uc).rowwise().norm()).maxCoeff()<diam*1e-5) 
170 |         {
171 |           #ifdef VERBOSE_DEBUG
172 |             cout << "Max change in postion = " << ((Uc).rowwise().norm()).maxCoeff() << " too small. Quitting line search loop " << endl;
173 |           #endif
174 |           break;
175 |         }
176 |       }
177 |     }
178 | 
179 |     // Update step (only for printing purposes)
180 |     step = step+1;
181 |     // Update previous coarse mesh (currently used only for DispStep energy)
182 |     C_prev = C;
183 | 
184 |   }
185 | 
186 |   // final (optional) minimization - Useful especially for volume minimization,
187 |   // when it makes little sense to minimize volume when the fine mesh is not 
188 |   // completely re-inflated
189 |   if (strcmp(EnergyFinal,"None")!=0)
190 |   {
191 | 
192 |     // Intialize energy as infinity
193 |     double current_energy = std::numeric_limits<double>::infinity();
194 |     // Intial step size
195 |     double beta = 1e-2;
196 | 
197 |     // calculate diameter to scale spearation between meshes
198 |     double diam = diameter(F,C);
199 | 
200 |     // At this moment the fine mesh is back to its original
201 |     // (input) positions, so its velocity should be zero
202 |     MatrixXd Uf = MatrixXd::Zero(F.rows(), 3);
203 | 
204 |     // If Volumetric ARAP, tetrahedralize and precompute ARAP Data
205 |     if (strcmp(EnergyFinal,"VolARAP")==0){
206 |       string tetgen_flags ("q2Y");
207 |       tetrahedralize(C_hat,F_hat,tetgen_flags,TV0,TT,TF); 
208 |       arap_precomputation(TV0,TT,3,b,data);
209 |       TV = TV0;
210 |     }
211 |     // Stepping and projecting
212 |     while (true)
213 |       {
214 |         #ifdef VERBOSE_DEBUG
215 |           cout << "Final optimization. Energy = " << EnergyFinal  << endl;
216 |         #endif
217 |         MatrixXd grad;
218 |         // for Volumetric ARAP, calculate gradient after finding optimal 
219 |         // deformed tet mesh (with local-globe solver)
220 |         if (strcmp(EnergyFinal,"VolARAP")==0)
221 |         {
222 |           if (!arap_solve(C,data,TV))
223 |           {
224 |             cout << "ARAP Solve failed " << endl;
225 |             return;
226 |           }
227 |           if (!gradient(TV,TV0,C_prev,TT,EnergyFinal,grad))
228 |           {
229 |             cout << "ERROR calculating gradient " << endl;
230 |             return;
231 |           }
232 |         }
233 |         // for other energies, just calculate the gradient
234 |         else
235 |         {
236 |           if (!gradient(C,C_hat,C_prev,F_hat,EnergyFinal,grad))
237 |           {
238 |             cout << "ERROR calculating gradient " << endl;
239 |             return;
240 |           }
241 |         }
242 |         // multiply gradient by current step size
243 |         MatrixXd Uc = -beta*grad;
244 |         // filter coarse mesh velocities
245 |         // this eps=5e-4 is chosen so that tere's is space for final optimizarion
246 |         filter(F,T,Uf,C,F_hat,diam*5e-4,Uc); 
247 | 
248 |         // update energy value
249 |         double new_energy;
250 |         if (strcmp(EnergyFinal,"VolARAP")==0)
251 |         {
252 |           new_energy = energy(TV,TV0,C_prev,TT,EnergyFinal);
253 |         }
254 |         else
255 |         {
256 |           new_energy = energy(C+Uc,C_hat,C_prev,F_hat,EnergyFinal);
257 |         }
258 |         // if energy increased, cut step size by half
259 |         if (new_energy>current_energy)
260 |         {
261 |           beta = 0.5*beta;
262 |           #ifdef VERBOSE_DEBUG
263 |             cout << "energy increased, descreasing beta to " << beta << endl;
264 |           #endif
265 |           // If step size is too small, then it has converged. Break
266 |           if (beta<1e-3)
267 |           {
268 |             #ifdef VERBOSE_DEBUG
269 |               cout << "beta too small. Quitting line search loop " << endl;
270 |             #endif
271 |             break;
272 |           }
273 |         }
274 |         // if energy decreased, update coarse mesh, update energy value and 
275 |         // and increase beta 10%
276 |         else{
277 |           C = C+Uc;
278 |           current_energy = new_energy;
279 |           beta = 1.1*beta;
280 |           #ifdef VERBOSE_DEBUG
281 |             cout << "energy decreased to " << current_energy << ", increasing beta to " << beta << endl;
282 |           #endif
283 |         }
284 |         // If tiny step, then it has converged. Break
285 |         if (((Uc).rowwise().norm()).norm()<diam*1e-5) break;
286 |       }
287 | 
288 |   }
289 | 
290 |   return;
291 | 
292 | }


--------------------------------------------------------------------------------
/cmake/FindLAPACK.cmake:
--------------------------------------------------------------------------------
  1 | # Find LAPACK library
  2 | #
  3 | # This module finds an installed library that implements the LAPACK
  4 | # linear-algebra interface (see http://www.netlib.org/lapack/).
  5 | # The approach follows mostly that taken for the autoconf macro file, acx_lapack.m4
  6 | # (distributed at http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html).
  7 | #
  8 | # This module sets the following variables:
  9 | #  LAPACK_FOUND - set to true if a library implementing the LAPACK interface
 10 | #    is found
 11 | #  LAPACK_INCLUDE_DIR - Directories containing the LAPACK header files
 12 | #  LAPACK_DEFINITIONS - Compilation options to use LAPACK
 13 | #  LAPACK_LINKER_FLAGS - Linker flags to use LAPACK (excluding -l
 14 | #    and -L).
 15 | #  LAPACK_LIBRARIES_DIR - Directories containing the LAPACK libraries.
 16 | #     May be null if LAPACK_LIBRARIES contains libraries name using full path.
 17 | #  LAPACK_LIBRARIES - List of libraries to link against LAPACK interface.
 18 | #     May be null if the compiler supports auto-link (e.g. VC++).
 19 | #  LAPACK_USE_FILE - The name of the cmake module to include to compile
 20 | #     applications or libraries using LAPACK.
 21 | #
 22 | # This module was modified by CGAL team:
 23 | # - find libraries for a C++ compiler, instead of Fortran
 24 | # - added LAPACK_INCLUDE_DIR, LAPACK_DEFINITIONS and LAPACK_LIBRARIES_DIR
 25 | # - removed LAPACK95_LIBRARIES
 26 | 
 27 | 
 28 | include(CheckFunctionExists)
 29 | 
 30 | # This macro checks for the existence of the combination of fortran libraries
 31 | # given by _list.  If the combination is found, this macro checks (using the
 32 | # check_function_exists macro) whether can link against that library
 33 | # combination using the name of a routine given by _name using the linker
 34 | # flags given by _flags.  If the combination of libraries is found and passes
 35 | # the link test, LIBRARIES is set to the list of complete library paths that
 36 | # have been found and DEFINITIONS to the required definitions.
 37 | # Otherwise, LIBRARIES is set to FALSE.
 38 | # N.B. _prefix is the prefix applied to the names of all cached variables that
 39 | # are generated internally and marked advanced by this macro.
 40 | macro(check_lapack_libraries DEFINITIONS LIBRARIES _prefix _name _flags _list _blas _path)
 41 |   #message("DEBUG: check_lapack_libraries(${_list} in ${_path} with ${_blas})")
 42 | 
 43 |   # Check for the existence of the libraries given by _list
 44 |   set(_libraries_found TRUE)
 45 |   set(_libraries_work FALSE)
 46 |   set(${DEFINITIONS} "")
 47 |   set(${LIBRARIES} "")
 48 |   set(_combined_name)
 49 |   foreach(_library ${_list})
 50 |     set(_combined_name ${_combined_name}_${_library})
 51 | 
 52 |     if(_libraries_found)
 53 |       # search first in ${_path}
 54 |       find_library(${_prefix}_${_library}_LIBRARY
 55 |                   NAMES ${_library}
 56 |                   PATHS ${_path} NO_DEFAULT_PATH
 57 |                   )
 58 |       # if not found, search in environment variables and system
 59 |       if ( WIN32 )
 60 |         find_library(${_prefix}_${_library}_LIBRARY
 61 |                     NAMES ${_library}
 62 |                     PATHS ENV LIB
 63 |                     )
 64 |       elseif ( APPLE )
 65 |         find_library(${_prefix}_${_library}_LIBRARY
 66 |                     NAMES ${_library}
 67 |                     PATHS /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV DYLD_LIBRARY_PATH
 68 |                     )
 69 |       else ()
 70 |         find_library(${_prefix}_${_library}_LIBRARY
 71 |                     NAMES ${_library}
 72 |                     PATHS /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV LD_LIBRARY_PATH
 73 |                     )
 74 |       endif()
 75 |       mark_as_advanced(${_prefix}_${_library}_LIBRARY)
 76 |       set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY})
 77 |       set(_libraries_found ${${_prefix}_${_library}_LIBRARY})
 78 |     endif(_libraries_found)
 79 |   endforeach(_library ${_list})
 80 |   if(_libraries_found)
 81 |     set(_libraries_found ${${LIBRARIES}})
 82 |   endif()
 83 | 
 84 |   # Test this combination of libraries with the Fortran/f2c interface.
 85 |   # We test the Fortran interface first as it is well standardized.
 86 |   if(_libraries_found AND NOT _libraries_work)
 87 |     set(${DEFINITIONS}  "-D${_prefix}_USE_F2C")
 88 |     set(${LIBRARIES}    ${_libraries_found})
 89 |     # Some C++ linkers require the f2c library to link with Fortran libraries.
 90 |     # I do not know which ones, thus I just add the f2c library if it is available.
 91 |     find_package( F2C QUIET )
 92 |     if ( F2C_FOUND )
 93 |       set(${DEFINITIONS}  ${${DEFINITIONS}} ${F2C_DEFINITIONS})
 94 |       set(${LIBRARIES}    ${${LIBRARIES}} ${F2C_LIBRARIES})
 95 |     endif()
 96 |     set(CMAKE_REQUIRED_DEFINITIONS  ${${DEFINITIONS}})
 97 |     set(CMAKE_REQUIRED_LIBRARIES    ${_flags} ${${LIBRARIES}} ${_blas})
 98 |     #message("DEBUG: CMAKE_REQUIRED_DEFINITIONS = ${CMAKE_REQUIRED_DEFINITIONS}")
 99 |     #message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}")
100 |     # Check if function exists with f2c calling convention (ie a trailing underscore)
101 |     check_function_exists(${_name}_ ${_prefix}_${_name}_${_combined_name}_f2c_WORKS)
102 |     set(CMAKE_REQUIRED_DEFINITIONS} "")
103 |     set(CMAKE_REQUIRED_LIBRARIES    "")
104 |     mark_as_advanced(${_prefix}_${_name}_${_combined_name}_f2c_WORKS)
105 |     set(_libraries_work ${${_prefix}_${_name}_${_combined_name}_f2c_WORKS})
106 |   endif(_libraries_found AND NOT _libraries_work)
107 | 
108 |   # If not found, test this combination of libraries with a C interface.
109 |   # A few implementations (ie ACML) provide a C interface. Unfortunately, there is no standard.
110 |   if(_libraries_found AND NOT _libraries_work)
111 |     set(${DEFINITIONS} "")
112 |     set(${LIBRARIES}   ${_libraries_found})
113 |     set(CMAKE_REQUIRED_DEFINITIONS "")
114 |     set(CMAKE_REQUIRED_LIBRARIES   ${_flags} ${${LIBRARIES}} ${_blas})
115 |     #message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}")
116 |     check_function_exists(${_name} ${_prefix}_${_name}${_combined_name}_WORKS)
117 |     set(CMAKE_REQUIRED_LIBRARIES "")
118 |     mark_as_advanced(${_prefix}_${_name}${_combined_name}_WORKS)
119 |     set(_libraries_work ${${_prefix}_${_name}${_combined_name}_WORKS})
120 |   endif(_libraries_found AND NOT _libraries_work)
121 | 
122 |   # on failure
123 |   if(NOT _libraries_work)
124 |     set(${DEFINITIONS} "")
125 |     set(${LIBRARIES}   FALSE)
126 |   endif()
127 |   #message("DEBUG: ${DEFINITIONS} = ${${DEFINITIONS}}")
128 |   #message("DEBUG: ${LIBRARIES} = ${${LIBRARIES}}")
129 | endmacro(check_lapack_libraries)
130 | 
131 | 
132 | #
133 | # main
134 | #
135 | 
136 | # LAPACK requires BLAS
137 | if(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED)
138 |   find_package(BLAS)
139 | else()
140 |   find_package(BLAS REQUIRED)
141 | endif()
142 | 
143 | if (NOT BLAS_FOUND)
144 | 
145 |   message(STATUS "LAPACK requires BLAS.")
146 |   set(LAPACK_FOUND FALSE)
147 | 
148 | # Is it already configured?
149 | elseif (LAPACK_LIBRARIES_DIR OR LAPACK_LIBRARIES)
150 | 
151 |   set(LAPACK_FOUND TRUE)
152 | 
153 | else()
154 | 
155 |   # reset variables
156 |   set( LAPACK_INCLUDE_DIR "" )
157 |   set( LAPACK_DEFINITIONS "" )
158 |   set( LAPACK_LINKER_FLAGS "" ) # unused (yet)
159 |   set( LAPACK_LIBRARIES "" )
160 |   set( LAPACK_LIBRARIES_DIR "" )
161 | 
162 |     #
163 |     # If Unix, search for LAPACK function in possible libraries
164 |     #
165 | 
166 |     #intel mkl lapack?
167 |     if(NOT LAPACK_LIBRARIES)
168 |       check_lapack_libraries(
169 |       LAPACK_DEFINITIONS
170 |       LAPACK_LIBRARIES
171 |       LAPACK
172 |       cheev
173 |       ""
174 |       "mkl_lapack"
175 |       "${BLAS_LIBRARIES}"
176 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR"
177 |       )
178 |     endif()
179 | 
180 |     #acml lapack?
181 |     if(NOT LAPACK_LIBRARIES)
182 |       check_lapack_libraries(
183 |       LAPACK_DEFINITIONS
184 |       LAPACK_LIBRARIES
185 |       LAPACK
186 |       cheev
187 |       ""
188 |       "acml"
189 |       "${BLAS_LIBRARIES}"
190 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR"
191 |       )
192 |     endif()
193 | 
194 |     # Apple LAPACK library?
195 |     if(NOT LAPACK_LIBRARIES)
196 |       check_lapack_libraries(
197 |       LAPACK_DEFINITIONS
198 |       LAPACK_LIBRARIES
199 |       LAPACK
200 |       cheev
201 |       ""
202 |       "Accelerate"
203 |       "${BLAS_LIBRARIES}"
204 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR"
205 |       )
206 |     endif()
207 | 
208 |     if ( NOT LAPACK_LIBRARIES )
209 |       check_lapack_libraries(
210 |       LAPACK_DEFINITIONS
211 |       LAPACK_LIBRARIES
212 |       LAPACK
213 |       cheev
214 |       ""
215 |       "vecLib"
216 |       "${BLAS_LIBRARIES}"
217 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR"
218 |       )
219 |     endif ( NOT LAPACK_LIBRARIES )
220 | 
221 |     # Generic LAPACK library?
222 |     # This configuration *must* be the last try as this library is notably slow.
223 |     if ( NOT LAPACK_LIBRARIES )
224 |       check_lapack_libraries(
225 |       LAPACK_DEFINITIONS
226 |       LAPACK_LIBRARIES
227 |       LAPACK
228 |       cheev
229 |       ""
230 |       "lapack"
231 |       "${BLAS_LIBRARIES}"
232 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR"
233 |       )
234 |     endif()
235 | 
236 |   if(LAPACK_LIBRARIES_DIR OR LAPACK_LIBRARIES)
237 |     set(LAPACK_FOUND TRUE)
238 |   else()
239 |     set(LAPACK_FOUND FALSE)
240 |   endif()
241 | 
242 |   if(NOT LAPACK_FIND_QUIETLY)
243 |     if(LAPACK_FOUND)
244 |       message(STATUS "A library with LAPACK API found.")
245 |     else(LAPACK_FOUND)
246 |       if(LAPACK_FIND_REQUIRED)
247 |         message(FATAL_ERROR "A required library with LAPACK API not found. Please specify library location.")
248 |       else()
249 |         message(STATUS "A library with LAPACK API not found. Please specify library location.")
250 |       endif()
251 |     endif(LAPACK_FOUND)
252 |   endif(NOT LAPACK_FIND_QUIETLY)
253 | 
254 |   # Add variables to cache
255 |   set( LAPACK_INCLUDE_DIR   "${LAPACK_INCLUDE_DIR}"
256 |                             CACHE PATH "Directories containing the LAPACK header files" FORCE )
257 |   set( LAPACK_DEFINITIONS   "${LAPACK_DEFINITIONS}"
258 |                             CACHE STRING "Compilation options to use LAPACK" FORCE )
259 |   set( LAPACK_LINKER_FLAGS  "${LAPACK_LINKER_FLAGS}"
260 |                             CACHE STRING "Linker flags to use LAPACK" FORCE )
261 |   set( LAPACK_LIBRARIES     "${LAPACK_LIBRARIES}"
262 |                             CACHE FILEPATH "LAPACK libraries name" FORCE )
263 |   set( LAPACK_LIBRARIES_DIR "${LAPACK_LIBRARIES_DIR}"
264 |                             CACHE PATH "Directories containing the LAPACK libraries" FORCE )
265 | 
266 |   #message("DEBUG: LAPACK_INCLUDE_DIR = ${LAPACK_INCLUDE_DIR}")
267 |   #message("DEBUG: LAPACK_DEFINITIONS = ${LAPACK_DEFINITIONS}")
268 |   #message("DEBUG: LAPACK_LINKER_FLAGS = ${LAPACK_LINKER_FLAGS}")
269 |   #message("DEBUG: LAPACK_LIBRARIES = ${LAPACK_LIBRARIES}")
270 |   #message("DEBUG: LAPACK_LIBRARIES_DIR = ${LAPACK_LIBRARIES_DIR}")
271 |   #message("DEBUG: LAPACK_FOUND = ${LAPACK_FOUND}")
272 | 
273 | endif(NOT BLAS_FOUND)
274 | 


--------------------------------------------------------------------------------
/flow.cpp:
--------------------------------------------------------------------------------
  1 | #include "flow.h"
  2 | 
  3 | #include <igl/signed_distance.h>
  4 | #include <igl/point_mesh_squared_distance.h>
  5 | #include <igl/per_vertex_normals.h>
  6 | #include <igl/per_edge_normals.h>
  7 | #include <igl/per_face_normals.h>
  8 | #include <igl/normalize_row_lengths.h>
  9 | #include <igl/massmatrix.h>
 10 | #include <igl/invert_diag.h>
 11 | #include <igl/copyleft/cgal/intersect_other.h>
 12 | #include <igl/winding_number.h>
 13 | 
 14 | #include <CGAL/Cartesian.h>
 15 | 
 16 | #include <iostream>
 17 | 
 18 | // compute the matrix that converts gradient at quadrature 
 19 | // points to gradient at mesh vertices
 20 | 
 21 | void gradQ_to_gradV(
 22 |   const Eigen::MatrixXd & V0, 
 23 |   const Eigen::MatrixXi & F0, 
 24 |   const Eigen::VectorXd & area_0, 
 25 |   const int quad_order,
 26 |   Eigen::SparseMatrix<double> & A)
 27 | {
 28 |   using namespace Eigen;
 29 |   using namespace std;
 30 |   using namespace igl;
 31 | 
 32 |   typedef Triplet<double> Tripletd;
 33 | 
 34 |   if (quad_order==1)
 35 |   {
 36 |     A.resize(V0.rows(),F0.rows());
 37 |     A.reserve(3*F0.rows());
 38 | 
 39 |     vector<Triplet<double> > IJV;
 40 |     IJV.reserve(3*F0.rows());
 41 | 
 42 |     for (int k=0;k<F0.rows();k++)
 43 |     {
 44 |       assert(F0(k,0)<V0.rows() && F0(k,1)<V0.rows() && F0(k,2)<V0.rows());
 45 |       assert(k<F0.rows());
 46 |       IJV.push_back(Tripletd(F0(k,0),k,area_0(k)/3));
 47 |       IJV.push_back(Tripletd(F0(k,1),k,area_0(k)/3));
 48 |       IJV.push_back(Tripletd(F0(k,2),k,area_0(k)/3));
 49 |     }
 50 |     A.setFromTriplets(IJV.begin(),IJV.end());
 51 | 
 52 |   } else if (quad_order==2)
 53 |   {
 54 | 
 55 |     A.resize(V0.rows(),3*F0.rows());
 56 | 
 57 |     vector<Triplet<double> > IJV;
 58 |     IJV.reserve(6*F0.rows());
 59 | 
 60 |     for (int k=0;k<F0.rows();k++)
 61 |     {
 62 |       IJV.push_back(Tripletd(F0(k,0),k,area_0(k)/6));
 63 |       IJV.push_back(Tripletd(F0(k,0),2*F0.rows()+k,area_0(k)/6));
 64 | 
 65 |       IJV.push_back(Tripletd(F0(k,1),F0.rows()+k,area_0(k)/6));
 66 |       IJV.push_back(Tripletd(F0(k,1),k,area_0(k)/6));
 67 | 
 68 |       IJV.push_back(Tripletd(F0(k,2),2*F0.rows()+k,area_0(k)/6));
 69 |       IJV.push_back(Tripletd(F0(k,2),F0.rows()+k,area_0(k)/6));
 70 |     }
 71 |     A.setFromTriplets(IJV.begin(),IJV.end());
 72 | 
 73 |   } else if (quad_order==3)
 74 |   {
 75 | 
 76 |     A.resize(V0.rows(),4*F0.rows());
 77 | 
 78 |     vector<Triplet<double> > IJV;
 79 |     IJV.reserve(12*F0.rows());
 80 | 
 81 |     for (int k=0;k<F0.rows();k++)
 82 |     {
 83 |       IJV.push_back(Tripletd(F0(k,0),k,-(3.0/16.0)*area_0(k)));
 84 |       IJV.push_back(Tripletd(F0(k,0),F0.rows()+k,(5.0/72.0)*area_0(k)));
 85 |       IJV.push_back(Tripletd(F0(k,0),2*F0.rows()+k,(5.0/72.0)*area_0(k)));
 86 |       IJV.push_back(Tripletd(F0(k,0),3*F0.rows()+k,(55.0/144.0)*area_0(k)));
 87 | 
 88 |       IJV.push_back(Tripletd(F0(k,1),k,-(3.0/16.0)*area_0(k)));
 89 |       IJV.push_back(Tripletd(F0(k,1),F0.rows()+k,(55.0/144.0)*area_0(k)));
 90 |       IJV.push_back(Tripletd(F0(k,1),2*F0.rows()+k,(5.0/72.0)*area_0(k)));
 91 |       IJV.push_back(Tripletd(F0(k,1),3*F0.rows()+k,(5.0/72.0)*area_0(k)));
 92 | 
 93 |       IJV.push_back(Tripletd(F0(k,2),k,-(3.0/16.0)*area_0(k)));
 94 |       IJV.push_back(Tripletd(F0(k,2),F0.rows()+k,(5.0/72.0)*area_0(k)));
 95 |       IJV.push_back(Tripletd(F0(k,2),2*F0.rows()+k,(55.0/144.0)*area_0(k)));
 96 |       IJV.push_back(Tripletd(F0(k,2),3*F0.rows()+k,(5.0/72.0)*area_0(k)));
 97 |     }
 98 |     A.setFromTriplets(IJV.begin(),IJV.end());
 99 | 
100 |     } else 
101 |     {
102 |       assert(false && "quad_order should be 1, 2, or 3");
103 |       cout << "gradQ_to_gradV, quadrature order " << quad_order << " is not implemented"  << endl;
104 |     }
105 | 
106 | 
107 | }
108 | 
109 | void signed_distance_direction(
110 |   const Eigen::MatrixXd & P, 
111 |   const Eigen::MatrixXd & V, 
112 |   const Eigen::MatrixXi & F, 
113 |   Eigen::MatrixXd & D)
114 | {
115 |   using namespace Eigen;
116 |   using namespace std;
117 |   using namespace igl;
118 |   MatrixXd C,N;
119 |   VectorXi I;
120 |   VectorXd S;
121 |   igl::signed_distance(P,V,F,igl::SIGNED_DISTANCE_TYPE_PSEUDONORMAL,S,I,C,N);
122 |   MatrixXd dif = C-P;
123 |   igl::normalize_row_lengths(dif,D);
124 |   for (int k=0; k<S.rows(); k++){
125 |     if (S(k)<=-1e-5){
126 |       D.row(k) = -D.row(k);
127 |     }
128 |     else if (S(k)<1e-5){
129 |       D.row(k) = -N.row(k);
130 |     }
131 |   }
132 | }
133 | 
134 | 
135 | void grad_energy(
136 |   const Eigen::MatrixXd & V, 
137 |   const Eigen::MatrixXi & F, 
138 |   const Eigen::MatrixXd & V_coarse, 
139 |   const Eigen::MatrixXi & F_coarse, 
140 |   const Eigen::SparseMatrix<double> & A_qv,
141 |   const Eigen::SparseMatrix<double> & M_inv, 
142 |   Eigen::MatrixXd & grad)
143 | {
144 |   using namespace Eigen;
145 |   using namespace std;
146 |   using namespace igl;
147 | 
148 |   // Compute quad_order from A_qv
149 |   int quad_order = [&F,&A_qv]()->int
150 |   {
151 |     if(A_qv.cols() == F.rows())
152 |     {
153 |       return 1;
154 |     }else if(A_qv.cols() == 3*F.rows())
155 |     {
156 |       return 2;
157 |     }else if(A_qv.cols() == 4*F.rows())
158 |     {
159 |       return 3;
160 |     }else
161 |     {
162 |       assert(false && "#A_qv should be multiple of #F");
163 |       return -1;
164 |     }
165 |   }();
166 | 
167 |   if (quad_order==1)
168 |   {
169 |     // quadrature points: barycenters of triangles
170 |     MatrixXd p123(F.rows(),3);
171 |     for (int k=0; k<F.rows(); k++)
172 |     {
173 |       p123(k,0) = (1.0/3.0)*(V(F(k,0),0)+V(F(k,1),0)+V(F(k,2),0));
174 |       p123(k,1) = (1.0/3.0)*(V(F(k,0),1)+V(F(k,1),1)+V(F(k,2),1));
175 |       p123(k,2) = (1.0/3.0)*(V(F(k,0),2)+V(F(k,1),2)+V(F(k,2),2));
176 |     }
177 |     MatrixXd quad_points = p123;
178 | 
179 |     MatrixXd grad_Q(F.rows(),3);
180 |     signed_distance_direction(quad_points,V_coarse,F_coarse,grad_Q);
181 |     grad_Q = -grad_Q;
182 |     grad = M_inv*(A_qv*grad_Q);
183 | 
184 |   } else if (quad_order==2)
185 |   {
186 | 
187 |     MatrixXd p12(F.rows(),3);
188 |     MatrixXd p23(F.rows(),3);
189 |     MatrixXd p31(F.rows(),3);
190 |     for (int k=0; k<F.rows(); k++)
191 |     {
192 |       p12(k,0) = (1.0/2.0)*(V(F(k,0),0)+V(F(k,1),0));
193 |       p12(k,1) = (1.0/2.0)*(V(F(k,0),1)+V(F(k,1),1));
194 |       p12(k,2) = (1.0/2.0)*(V(F(k,0),2)+V(F(k,1),2));
195 | 
196 |       p23(k,0) = (1.0/2.0)*(V(F(k,1),0)+V(F(k,2),0));
197 |       p23(k,1) = (1.0/2.0)*(V(F(k,1),1)+V(F(k,2),1));
198 |       p23(k,2) = (1.0/2.0)*(V(F(k,1),2)+V(F(k,2),2));
199 | 
200 |       p31(k,0) = (1.0/2.0)*(V(F(k,2),0)+V(F(k,0),0));
201 |       p31(k,1) = (1.0/2.0)*(V(F(k,2),1)+V(F(k,0),1));
202 |       p31(k,2) = (1.0/2.0)*(V(F(k,2),2)+V(F(k,0),2));
203 |     }
204 | 
205 |     // concatenate quadrature points
206 |     MatrixXd quad_points(p12.rows()+p23.rows()+p31.rows(), p12.cols());
207 |     quad_points << p12,
208 |          p23,
209 |          p31;
210 | 
211 |     MatrixXd grad_Q(3*F.rows(),3);
212 |     signed_distance_direction(quad_points,V_coarse,F_coarse,grad_Q);
213 |     grad_Q = -grad_Q;
214 |     grad = M_inv*(A_qv*grad_Q);
215 |     // the correct would be grad = M\(A_qv*grad_Q). Ask Alec waht solver he uses
216 | 
217 |   } else if (quad_order==3)
218 |   {
219 | 
220 |     MatrixXd p1(F.rows(),3);
221 |     MatrixXd p2(F.rows(),3);
222 |     MatrixXd p3(F.rows(),3);
223 |     MatrixXd p4(F.rows(),3);
224 |     for (int k=0; k<F.rows(); k++)
225 |     {
226 |       p1(k,0) = (1.0/3.0)*(V(F(k,0),0)+V(F(k,1),0)+V(F(k,2),0));
227 |       p1(k,1) = (1.0/3.0)*(V(F(k,0),1)+V(F(k,1),1)+V(F(k,2),1));
228 |       p1(k,2) = (1.0/3.0)*(V(F(k,0),2)+V(F(k,1),2)+V(F(k,2),2));
229 | 
230 |       p2(k,0) = (2.0/15.0)*V(F(k,0),0) + (11.0/15.0)*V(F(k,1),0)+ (2.0/15.0)*V(F(k,2),0);
231 |       p2(k,1) = (2.0/15.0)*V(F(k,0),1) + (11.0/15.0)*V(F(k,1),1)+ (2.0/15.0)*V(F(k,2),1);
232 |       p2(k,2) = (2.0/15.0)*V(F(k,0),2) + (11.0/15.0)*V(F(k,1),2)+ (2.0/15.0)*V(F(k,2),2);
233 | 
234 |       p3(k,0) = (2.0/15.0)*V(F(k,0),0) + (2.0/15.0)*V(F(k,1),0)+ (11.0/15.0)*V(F(k,2),0);
235 |       p3(k,1) = (2.0/15.0)*V(F(k,0),1) + (2.0/15.0)*V(F(k,1),1)+ (11.0/15.0)*V(F(k,2),1);
236 |       p3(k,2) = (2.0/15.0)*V(F(k,0),2) + (2.0/15.0)*V(F(k,1),2)+ (11.0/15.0)*V(F(k,2),2);
237 | 
238 |       p4(k,0) = (11.0/15.0)*V(F(k,0),0) + (2.0/15.0)*V(F(k,1),0)+ (2.0/15.0)*V(F(k,2),0);
239 |       p4(k,1) = (11.0/15.0)*V(F(k,0),1) + (2.0/15.0)*V(F(k,1),1)+ (2.0/15.0)*V(F(k,2),1);
240 |       p4(k,2) = (11.0/15.0)*V(F(k,0),2) + (2.0/15.0)*V(F(k,1),2)+ (2.0/15.0)*V(F(k,2),2);
241 |     }
242 | 
243 |     // concatenate quadrature points
244 |     MatrixXd quad_points(p1.rows()+p2.rows()+p3.rows()+p4.rows(), p1.cols());
245 |     quad_points << p1,
246 |          p2,
247 |          p3,
248 |          p4;
249 | 
250 |     MatrixXd grad_Q(4*F.rows(),3);
251 |     signed_distance_direction(quad_points,V_coarse,F_coarse,grad_Q);
252 |     grad_Q = -grad_Q;
253 |     grad = M_inv*(A_qv*grad_Q);
254 |     // the correct would be grad = M\(A_qv*grad_Q). Ask Alec waht solver he uses
255 | 
256 |   } else
257 |   {
258 |     assert(false && "quad_order should be 1, 2, or 3");
259 |     cout << "grad_energy, quadrature order " << quad_order << " is not implemented"  << endl;
260 |   }
261 | 
262 | }
263 | 
264 | // one step function
265 | void flow_one_step(
266 |   const Eigen::MatrixXd & V, 
267 |   const Eigen::MatrixXi & F, 
268 |   const Eigen::MatrixXd & V_coarse, 
269 |   const Eigen::MatrixXi & F_coarse, 
270 |   const Eigen::SparseMatrix<double> & A_qv, 
271 |   const Eigen::SparseMatrix<double> & M,
272 |   const double delta_t,  
273 |   Eigen::MatrixXd & V_new)
274 | {
275 |   using namespace Eigen;
276 |   using namespace std;
277 |   using namespace igl;
278 |   MatrixXd grad;
279 |   grad_energy(V, F, V_coarse, F_coarse, A_qv, M, grad);
280 | 
281 |   V_new = V - delta_t*grad;
282 | }
283 | 
284 | double diameter(
285 |   const Eigen::MatrixXd & V0, 
286 |   const Eigen::MatrixXd & V_coarse)
287 | {
288 | 
289 |   using namespace Eigen;
290 |   using namespace std;
291 | 
292 |   double min_x, min_y, min_z, max_x, max_y, max_z;
293 | 
294 |   VectorXd min_V0 = V0.colwise().minCoeff();
295 |   VectorXd min_V_coarse = V_coarse.colwise().minCoeff();
296 |   min_x = fmin(min_V0(0),min_V_coarse(0));
297 |   min_y = fmin(min_V0(1),min_V_coarse(1));
298 |   min_z = fmin(min_V0(2),min_V_coarse(2));
299 | 
300 |   VectorXd max_V0 = V0.colwise().maxCoeff();
301 |   VectorXd max_V_coarse = V_coarse.colwise().maxCoeff();
302 |   max_x = fmax(max_V0(0),max_V_coarse(0));
303 |   max_y = fmax(max_V0(1),max_V_coarse(1));
304 |   max_z = fmax(max_V0(2),max_V_coarse(2));
305 | 
306 |   float diam = fmax(max_x-min_x,max_y-min_y);
307 |   diam = fmax(diam,max_z-min_z);
308 | 
309 |   return diam;
310 | }
311 | 
312 | bool flow_fine_inside_coarse(
313 |   const Eigen::MatrixXd & V0, 
314 |   const Eigen::MatrixXi & F0, 
315 |   const Eigen::MatrixXd & V_coarse, 
316 |   const Eigen::MatrixXi & F_coarse, 
317 |   const Eigen::SparseMatrix<double> & A_qv,
318 |   std::stack<Eigen::MatrixXd> & H)
319 | {
320 |   using namespace Eigen;
321 |   using namespace std;
322 |   using namespace igl;
323 |   using namespace igl::copyleft::cgal;
324 | 
325 |   // while there are intersections or some negative winding number, keep flowing
326 |   SparseMatrix<double> M;
327 |   massmatrix(V0,F0,MASSMATRIX_TYPE_BARYCENTRIC,M);
328 |   SparseMatrix<double> M_inv;
329 |   invert_diag(M,M_inv);
330 | 
331 |   MatrixXd V = V0;
332 |   H.push(V);
333 |   // calculate diameter of the meshes to scale step size
334 |   double diam = diameter(V0,V_coarse);
335 |   double delta_t = diam*1e-3;
336 |   MatrixXi IF;
337 |   intersect_other(V,F0,V_coarse,F_coarse,true,IF);
338 | 
339 |   VectorXd W(1); // winding number of the first point
340 |   winding_number(V_coarse,F_coarse,V.row(0),W);
341 | 
342 |   int step = 1; 
343 | 
344 |   while (IF.rows()>0 || W[0]<1e-10){
345 |     #ifdef VERBOSE_DEBUG
346 |       cout << "Flow step " << step << ":Coarse and fine mesh intersect " << endl;
347 |     #endif
348 |     flow_one_step(MatrixXd(V), F0, V_coarse, F_coarse, A_qv, M_inv, delta_t, V);
349 |     intersect_other(V,F0,V_coarse,F_coarse,true,IF);
350 |     step = step+1;
351 |     // **Alec: notice that we cannot pass V as input and output, instead wrap the 
352 |     // input inside MatrixXd to force compiler to make a copy in this case.
353 |     winding_number(V_coarse,F_coarse,V.row(0),W);
354 |     H.push(V);
355 |     // Quit after 1000 steps of the flow and return false
356 |     if (step>1000) return false; 
357 |   }
358 |   return true;
359 | }
360 | 


--------------------------------------------------------------------------------
/cmake/FindLIBIGL.cmake:
--------------------------------------------------------------------------------
  1 | 
  2 | find_path(LIBIGL_INCLUDE_DIR igl/readOBJ.h
  3 |     HINTS
  4 |         ${LIBIGL_DIR}
  5 |         ENV LIBIGL_DIR
  6 |     PATHS
  7 |         ${CMAKE_SOURCE_DIR}/../..
  8 |         ${CMAKE_SOURCE_DIR}/..
  9 |         ${CMAKE_SOURCE_DIR}
 10 |         ${CMAKE_SOURCE_DIR}/libigl
 11 |         ${CMAKE_SOURCE_DIR}/../libigl
 12 |         ${CMAKE_SOURCE_DIR}/../../libigl
 13 |         /usr
 14 |         /usr/local
 15 |         /usr/local/igl/libigl
 16 |     PATH_SUFFIXES include
 17 |     REQUIRED
 18 | )
 19 | 
 20 | include(FindPackageHandleStandardArgs)
 21 | find_package_handle_standard_args(LIBIGL
 22 |     "\nlibigl not found --- You can download it using:\n\tgit clone https://github.com/libigl/libigl.git ${CMAKE_SOURCE_DIR}/../libigl"
 23 |     LIBIGL_INCLUDE_DIR)
 24 | mark_as_advanced(LIBIGL_INCLUDE_DIR)
 25 | 
 26 | list(APPEND CMAKE_MODULE_PATH "${LIBIGL_INCLUDE_DIR}/../cmake")
 27 | 
 28 | if(LIBIGL_USE_PREBUILT_LIBRARIES)
 29 |   if(DEFINED LIBIGL_USE_STATIC_LIBRARY AND NOT LIBIGL_USE_STATIC_LIBRARY)
 30 |     message(FATAL_ERROR "LIBIGL_USE_PREBUILT_LIBRARIES=ON but LIBIGL_USE_STATIC_LIBRARY=OFF")
 31 |   endif()
 32 | 
 33 |   set(LIBIGL_DIR "${LIBIGL_INCLUDE_DIR}/..")
 34 |   set(LIBIGL_EXTERNAL_DIR "${LIBIGL_DIR}/external")
 35 |   if(NOT DEFINED LIBIGL_BUILD_DIR)
 36 |     find_path(LIBIGL_BUILD_DIR libigl.a libigl.so libigl.dll
 37 |       HINTS
 38 |         ${LIBIGL_BUILD_DIR}
 39 |         ENV LIBIGL_BUILD_DIR
 40 |       PATHS
 41 |         ${LIBIGL_DIR}/build
 42 |       REQUIRED
 43 |     )
 44 |   endif()
 45 |   message(STATUS "Using prebuilt libigl libraries in ${LIBIGL_BUILD_DIR}")
 46 |   
 47 |   # Eigen
 48 |   add_library(igl_eigen INTERFACE)
 49 |   target_include_directories(igl_eigen SYSTEM INTERFACE
 50 |     $<BUILD_INTERFACE:${LIBIGL_EXTERNAL_DIR}/eigen> $<INSTALL_INTERFACE:include>)
 51 |   set_property(TARGET igl_eigen PROPERTY EXPORT_NAME Eigen3::Eigen)
 52 |   add_library(Eigen3::Eigen ALIAS igl_eigen)
 53 |   
 54 |   # libigl.a 
 55 |   add_library(igl_core INTERFACE)
 56 |   target_include_directories(igl_core SYSTEM INTERFACE
 57 |     $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
 58 |   add_library(               igl::core ALIAS igl_core)
 59 |   target_link_libraries(     igl_core INTERFACE Eigen3::Eigen)
 60 |   target_compile_features(   igl_core INTERFACE cxx_std_11)
 61 |   target_compile_definitions(igl_core INTERFACE -DIGL_STATIC_LIBRARY)
 62 |   find_library(LIBIGL_core_LIBRARY NAMES igl HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
 63 |   target_link_libraries(     igl_core INTERFACE ${LIBIGL_core_LIBRARY})
 64 |   
 65 |   # CGAL
 66 |   if(LIBIGL_WITH_CGAL)
 67 |     set(CGAL_DIR "${LIBIGL_EXTERNAL_DIR}/cgal")
 68 |     set(BOOST_ROOT "${LIBIGL_EXTERNAL_DIR}/boost")
 69 |     find_package(CGAL CONFIG COMPONENTS Core PATHS ${CGAL_DIR} NO_DEFAULT_PATH REQUIRED)
 70 |     
 71 |     # libigl_cgal.a
 72 |     add_library(igl_cgal INTERFACE)
 73 |     target_include_directories(igl_cgal SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
 74 |     add_library(               igl::cgal ALIAS igl_cgal)
 75 |     target_link_libraries(     igl_cgal INTERFACE CGAL::CGAL CGAL::CGAL_Core)
 76 |     find_library(LIBIGL_cgal_LIBRARY NAMES igl_cgal HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
 77 |     target_link_libraries(     igl_cgal INTERFACE ${LIBIGL_cgal_LIBRARY})
 78 |   endif()
 79 |   
 80 |   # Embree
 81 |   if(LIBIGL_WITH_EMBREE)
 82 |     find_path(EMBREE_INCLUDE_DIR embree3/rtcore.h PATHS ${LIBIGL_EXTERNAL_DIR}/embree/include REQUIRED)
 83 |     find_library(EMBREE_embree3_LIBRARY     NAMES embree3     HINTS ${LIBIGL_BUILD_DIR}/embree REQUIRED)
 84 |     find_library(EMBREE_embree_avx2_LIBRARY NAMES embree_avx2 HINTS ${LIBIGL_BUILD_DIR}/embree ) # not required (won't exist for debug)
 85 |     if(NOT EMBREE_embree_avx2_LIBRARY)
 86 |       set(EMBREE_embree_avx2_LIBRARY "")
 87 |     endif()
 88 |     find_library(EMBREE_lexers_LIBRARY      NAMES lexers      HINTS ${LIBIGL_BUILD_DIR}/embree REQUIRED)
 89 |     find_library(EMBREE_math_LIBRARY        NAMES math        HINTS ${LIBIGL_BUILD_DIR}/embree REQUIRED)
 90 |     find_library(EMBREE_simd_LIBRARY        NAMES simd        HINTS ${LIBIGL_BUILD_DIR}/embree REQUIRED)
 91 |     find_library(EMBREE_sys_LIBRARY         NAMES sys         HINTS ${LIBIGL_BUILD_DIR}/embree REQUIRED)
 92 |     find_library(EMBREE_tasking_LIBRARY     NAMES tasking     HINTS ${LIBIGL_BUILD_DIR}/embree REQUIRED)
 93 |     set(EMBREE_LIBRARIES ${EMBREE_embree3_LIBRARY} ${EMBREE_embree_avx2_LIBRARY} ${EMBREE_lexers_LIBRARY} ${EMBREE_math_LIBRARY} ${EMBREE_simd_LIBRARY} ${EMBREE_sys_LIBRARY} ${EMBREE_tasking_LIBRARY})
 94 |     
 95 |     # libigl_embree.a
 96 |     add_library(igl_embree INTERFACE)
 97 |     target_include_directories(igl_embree SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
 98 |     target_include_directories(igl_embree INTERFACE ${EMBREE_INCLUDE_DIR})
 99 |     add_library(               igl::embree ALIAS igl_embree)
100 |     target_link_libraries(     igl_embree INTERFACE ${EMBREE_LIBRARIES})
101 |     find_library(LIBIGL_embree_LIBRARY NAMES igl_embree HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
102 |     target_link_libraries(     igl_embree INTERFACE ${LIBIGL_embree_LIBRARY})
103 |   endif()
104 |   
105 |   # MATLAB
106 |   if(LIBIGL_WITH_MATLAB)
107 |     find_package(Matlab REQUIRED COMPONENTS MEX_COMPILER MX_LIBRARY ENG_LIBRARY MAT_LIBRARY)
108 |   
109 |     # libigl_matlab.a
110 |     add_library(igl_matlab INTERFACE)
111 |     target_include_directories(igl_matlab SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
112 |     target_include_directories(igl_matlab INTERFACE ${Matlab_INCLUDE_DIRS})
113 |     add_library(               igl::matlab ALIAS igl_matlab)
114 |     target_link_libraries(     igl_matlab INTERFACE ${Matlab_LIBRARIES})
115 |     find_library(LIBIGL_matlab_LIBRARY NAMES igl_matlab HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
116 |     target_link_libraries(     igl_matlab INTERFACE ${LIBIGL_matlab_LIBRARY})
117 |   endif()
118 |   
119 |   # MOSEK
120 |   if(LIBIGL_WITH_MOSEK)
121 |     find_package(MOSEK REQUIRED)
122 |   
123 |     # libigl_mosek.a
124 |     add_library(igl_mosek INTERFACE)
125 |     target_include_directories(igl_mosek SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
126 |     target_include_directories(igl_mosek INTERFACE ${MOSEK_INCLUDE_DIRS})
127 |     add_library(               igl::mosek ALIAS igl_mosek)
128 |     target_link_libraries(     igl_mosek INTERFACE ${MOSEK_LIBRARIES})
129 |     find_library(LIBIGL_mosek_LIBRARY NAMES igl_mosek HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
130 |     target_link_libraries(     igl_mosek INTERFACE ${LIBIGL_mosek_LIBRARY})
131 |   endif()
132 |   
133 |   # OpenGL
134 |   if(LIBIGL_WITH_OPENGL OR LIBIGL_WITH_OPENGL_GLFW OR LIBIGL_WITH_OPENGL_GLFW_IMGUI)
135 |     find_package(OpenGL REQUIRED)
136 |   
137 |     # Glad
138 |     find_path(GLAD_INCLUDE_DIR glad/glad.h PATHS ${LIBIGL_EXTERNAL_DIR}/glad/include REQUIRED)
139 |     find_library(GLAD_LIBRARY NAMES glad HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
140 |     
141 |     # libigl_opengl.a
142 |     add_library(igl_opengl INTERFACE)
143 |     target_include_directories(igl_opengl SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
144 |     target_include_directories(igl_opengl INTERFACE ${OPENGL_INCLUDE_DIR} ${GLAD_INCLUDE_DIR})
145 |     add_library(               igl::opengl ALIAS igl_opengl)
146 |     target_link_libraries(     igl_opengl INTERFACE ${OPENGL_gl_LIBRARY} ${GLAD_LIBRARY})
147 |     find_library(LIBIGL_opengl_LIBRARY NAMES igl_opengl HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
148 |     target_link_libraries(     igl_opengl INTERFACE ${LIBIGL_opengl_LIBRARY})
149 |     
150 |     # GLFW
151 |     if(LIBIGL_WITH_OPENGL_GLFW OR LIBIGL_WITH_OPENGL_GLFW_IMGUI)
152 |       find_path(GLFW_INCLUDE_DIR GLFW/glfw3.h PATHS ${LIBIGL_EXTERNAL_DIR}/glfw/include REQUIRED)
153 |       find_library(glfw_LIBRARIES NAMES glfw3 HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
154 |       list(APPEND glfw_LIBRARIES
155 |           "-framework Cocoa"
156 |           "-framework IOKit"
157 |           "-framework CoreFoundation")
158 |       
159 |       
160 |       # libigl_opengl_glfw.a
161 |       add_library(igl_opengl_glfw INTERFACE)
162 |       target_include_directories(igl_opengl_glfw SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
163 |       target_include_directories(igl_opengl_glfw INTERFACE ${GLFW_INCLUDE_DIR})
164 |       add_library(               igl::opengl_glfw ALIAS igl_opengl_glfw)
165 |       target_link_libraries(     igl_opengl_glfw INTERFACE ${glfw_LIBRARIES})
166 |       find_library(LIBIGL_opengl_glfw_LIBRARY NAMES igl_opengl_glfw HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
167 |       target_link_libraries(     igl_opengl_glfw INTERFACE ${LIBIGL_opengl_glfw_LIBRARY})
168 |     
169 |       if(LIBIGL_WITH_OPENGL_GLFW_IMGUI)
170 |         # Imgui
171 |         find_path(IMGUI_INCLUDE_DIR imgui/imgui.h PATHS ${LIBIGL_EXTERNAL_DIR}/ REQUIRED)
172 |         find_path(LIBIGL_IMGUI_INCLUDE_DIR imgui_fonts_droid_sans.h PATHS ${LIBIGL_EXTERNAL_DIR}/libigl-imgui REQUIRED)
173 |         set(IMGUI_INCLUDE_DIRS ${IMGUI_INCLUDE_DIR} ${IMGUI_INCLUDE_DIR}/imgui/ ${IMGUI_INCLUDE_DIR}/imgui/examples ${LIBIGL_IMGUI_INCLUDE_DIR})
174 |         find_library(IMGUI_LIBRARY NAMES imgui HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
175 |         
176 |         # Imguizmo
177 |         find_path(IMGUIZMO_INCLUDE_DIR imguizmo/ImGuizmo.h PATHS ${LIBIGL_EXTERNAL_DIR}/ REQUIRED)
178 |         find_library(IMGUIZMO_LIBRARY NAMES imguizmo HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
179 |         
180 |         # libigl_opengl_glfw_imgui.a
181 |         add_library(igl_opengl_glfw_imgui INTERFACE)
182 |         target_include_directories(igl_opengl_glfw_imgui SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
183 |         target_include_directories(igl_opengl_glfw_imgui INTERFACE ${IMGUI_INCLUDE_DIRS} ${IMGUIZMO_INCLUDE_DIR})
184 |         target_compile_definitions(igl_opengl_glfw_imgui INTERFACE -DIMGUI_IMPL_OPENGL_LOADER_GLAD)
185 |         add_library(               igl::opengl_glfw_imgui ALIAS igl_opengl_glfw_imgui)
186 |         target_link_libraries(     igl_opengl_glfw_imgui INTERFACE ${IMGUI_LIBRARY} ${IMGUIZMO_LIBRARY})
187 |         find_library(LIBIGL_opengl_glfw_imgui_LIBRARY NAMES igl_opengl_glfw_imgui HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
188 |         target_link_libraries(     igl_opengl_glfw_imgui INTERFACE ${LIBIGL_opengl_glfw_imgui_LIBRARY})
189 |       endif()
190 |     endif()
191 |   endif()
192 |   
193 |   # stb_image
194 |   if(LIBIGL_WITH_PNG)
195 |     find_path(STB_IMAGE_INCLUDE_DIR igl_stb_image.h PATHS ${LIBIGL_EXTERNAL_DIR}/stb REQUIRED)
196 |   
197 |     # libigl_png.a
198 |     add_library(igl_png INTERFACE)
199 |     target_include_directories(igl_png SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
200 |     target_include_directories(igl_png INTERFACE ${STB_IMAGE_INCLUDE_DIR})
201 |     add_library(               igl::png ALIAS igl_png)
202 |     find_library(LIBIGL_png_LIBRARY NAMES igl_png HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
203 |     find_library(LIBIGL_stb_image_LIBRARY NAMES igl_stb_image HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
204 |     target_link_libraries(     igl_png INTERFACE ${LIBIGL_png_LIBRARY} ${LIBIGL_stb_image_LIBRARY})
205 |   endif()
206 |   
207 |   # Tetgen
208 |   if(LIBIGL_WITH_TETGEN)
209 |     find_path(TETGEN_INCLUDE_DIR tetgen.h PATHS ${LIBIGL_EXTERNAL_DIR}/tetgen/ REQUIRED)
210 |     find_library(TETGEN_LIBRARY NAMES tetgen HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
211 |   
212 |     # libigl_tetgen.a
213 |     add_library(igl_tetgen INTERFACE)
214 |     target_include_directories(igl_tetgen SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
215 |     target_include_directories(igl_tetgen INTERFACE ${TETGEN_INCLUDE_DIR})
216 |     add_library(               igl::tetgen ALIAS igl_tetgen)
217 |     target_link_libraries(     igl_tetgen INTERFACE ${TETGEN_LIBRARY})
218 |     find_library(LIBIGL_tetgen_LIBRARY NAMES igl_tetgen HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
219 |     target_link_libraries(     igl_tetgen INTERFACE ${LIBIGL_tetgen_LIBRARY})
220 |   endif()
221 |     
222 |   # Triangle
223 |   if(LIBIGL_WITH_TRIANGLE)
224 |     find_path(TRIANGLE_INCLUDE_DIR triangle.h PATHS ${LIBIGL_EXTERNAL_DIR}/triangle/ REQUIRED)
225 |     find_library(TRIANGLE_LIBRARY NAMES triangle HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
226 |     
227 |     # libigl_triangle.a
228 |     add_library(igl_triangle INTERFACE)
229 |     target_include_directories(igl_triangle SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
230 |     target_include_directories(igl_triangle INTERFACE ${TRIANGLE_INCLUDE_DIR})
231 |     add_library(               igl::triangle ALIAS igl_triangle)
232 |     target_link_libraries(     igl_triangle INTERFACE ${TRIANGLE_LIBRARY})
233 |     find_library(LIBIGL_triangle_LIBRARY NAMES igl_triangle HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
234 |     target_link_libraries(     igl_triangle INTERFACE ${LIBIGL_triangle_LIBRARY})
235 |   endif()
236 |   
237 |   
238 |   # TinyXML2
239 |   if(LIBIGL_WITH_XML)
240 |     find_path(TINYXML2_INCLUDE_DIR tinyxml2.h PATHS ${LIBIGL_EXTERNAL_DIR}/tinyxml2/ REQUIRED)
241 |     find_library(TINYXML2_LIBRARY NAMES tinyxml2 HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
242 |   
243 |     # libigl_xml.a
244 |     add_library(igl_xml INTERFACE)
245 |     target_include_directories(igl_xml SYSTEM INTERFACE $<BUILD_INTERFACE:${LIBIGL_INCLUDE_DIR}> $<INSTALL_INTERFACE:include>)
246 |     target_include_directories(igl_xml INTERFACE ${TINYXML2_INCLUDE_DIR})
247 |     add_library(               igl::xml ALIAS igl_xml)
248 |     target_link_libraries(     igl_xml INTERFACE ${TINYXML2_LIBRARY})
249 |     find_library(LIBIGL_tinyxml2_LIBRARY NAMES igl_xml HINTS  ${LIBIGL_BUILD_DIR} REQUIRED)
250 |     target_link_libraries(     igl_xml INTERFACE ${LIBIGL_tinyxml2_LIBRARY})
251 |   endif()
252 | 
253 | else()
254 |   include(libigl)
255 | endif()
256 | 


--------------------------------------------------------------------------------
/cmake/FindBLAS.cmake:
--------------------------------------------------------------------------------
  1 | # Find BLAS library
  2 | #
  3 | # This module finds an installed library that implements the BLAS
  4 | # linear-algebra interface (see http://www.netlib.org/blas/).
  5 | # The list of libraries searched for is mainly taken
  6 | # from the autoconf macro file, acx_blas.m4 (distributed at
  7 | # http://ac-archive.sourceforge.net/ac-archive/acx_blas.html).
  8 | #
  9 | # This module sets the following variables:
 10 | #  BLAS_FOUND - set to true if a library implementing the BLAS interface
 11 | #    is found
 12 | #  BLAS_INCLUDE_DIR - Directories containing the BLAS header files
 13 | #  BLAS_DEFINITIONS - Compilation options to use BLAS
 14 | #  BLAS_LINKER_FLAGS - Linker flags to use BLAS (excluding -l
 15 | #    and -L).
 16 | #  BLAS_LIBRARIES_DIR - Directories containing the BLAS libraries.
 17 | #     May be null if BLAS_LIBRARIES contains libraries name using full path.
 18 | #  BLAS_LIBRARIES - List of libraries to link against BLAS interface.
 19 | #     May be null if the compiler supports auto-link (e.g. VC++).
 20 | #  BLAS_USE_FILE - The name of the cmake module to include to compile
 21 | #     applications or libraries using BLAS.
 22 | #
 23 | # This module was modified by CGAL team:
 24 | # - find libraries for a C++ compiler, instead of Fortran
 25 | # - added BLAS_INCLUDE_DIR, BLAS_DEFINITIONS and BLAS_LIBRARIES_DIR
 26 | # - removed BLAS95_LIBRARIES
 27 | 
 28 | include(CheckFunctionExists)
 29 | 
 30 | 
 31 | # This macro checks for the existence of the combination of fortran libraries
 32 | # given by _list.  If the combination is found, this macro checks (using the
 33 | # check_function_exists macro) whether can link against that library
 34 | # combination using the name of a routine given by _name using the linker
 35 | # flags given by _flags.  If the combination of libraries is found and passes
 36 | # the link test, LIBRARIES is set to the list of complete library paths that
 37 | # have been found and DEFINITIONS to the required definitions.
 38 | # Otherwise, LIBRARIES is set to FALSE.
 39 | # N.B. _prefix is the prefix applied to the names of all cached variables that
 40 | # are generated internally and marked advanced by this macro.
 41 | macro(check_fortran_libraries DEFINITIONS LIBRARIES _prefix _name _flags _list _path)
 42 |   #message("DEBUG: check_fortran_libraries(${_list} in ${_path})")
 43 | 
 44 |   # Check for the existence of the libraries given by _list
 45 |   set(_libraries_found TRUE)
 46 |   set(_libraries_work FALSE)
 47 |   set(${DEFINITIONS} "")
 48 |   set(${LIBRARIES} "")
 49 |   set(_combined_name)
 50 |   foreach(_library ${_list})
 51 |     set(_combined_name ${_combined_name}_${_library})
 52 | 
 53 |     if(_libraries_found)
 54 |       # search first in ${_path}
 55 |       find_library(${_prefix}_${_library}_LIBRARY
 56 |                   NAMES ${_library}
 57 |                   PATHS ${_path} NO_DEFAULT_PATH
 58 |                   )
 59 |       # if not found, search in environment variables and system
 60 |       if ( WIN32 )
 61 |         find_library(${_prefix}_${_library}_LIBRARY
 62 |                     NAMES ${_library}
 63 |                     PATHS ENV LIB
 64 |                     )
 65 |       elseif ( APPLE )
 66 |         find_library(${_prefix}_${_library}_LIBRARY
 67 |                     NAMES ${_library}
 68 |                     PATHS /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV DYLD_LIBRARY_PATH
 69 |                     )
 70 |       else ()
 71 |         find_library(${_prefix}_${_library}_LIBRARY
 72 |                     NAMES ${_library}
 73 |                     PATHS /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV LD_LIBRARY_PATH
 74 |                     )
 75 |       endif()
 76 |       mark_as_advanced(${_prefix}_${_library}_LIBRARY)
 77 |       set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY})
 78 |       set(_libraries_found ${${_prefix}_${_library}_LIBRARY})
 79 |     endif(_libraries_found)
 80 |   endforeach(_library ${_list})
 81 |   if(_libraries_found)
 82 |     set(_libraries_found ${${LIBRARIES}})
 83 |   endif()
 84 | 
 85 |   # Test this combination of libraries with the Fortran/f2c interface.
 86 |   # We test the Fortran interface first as it is well standardized.
 87 |   if(_libraries_found AND NOT _libraries_work)
 88 |     set(${DEFINITIONS}  "-D${_prefix}_USE_F2C")
 89 |     set(${LIBRARIES}    ${_libraries_found})
 90 |     # Some C++ linkers require the f2c library to link with Fortran libraries.
 91 |     # I do not know which ones, thus I just add the f2c library if it is available.
 92 |     find_package( F2C QUIET )
 93 |     if ( F2C_FOUND )
 94 |       set(${DEFINITIONS}  ${${DEFINITIONS}} ${F2C_DEFINITIONS})
 95 |       set(${LIBRARIES}    ${${LIBRARIES}} ${F2C_LIBRARIES})
 96 |     endif()
 97 |     set(CMAKE_REQUIRED_DEFINITIONS  ${${DEFINITIONS}})
 98 |     set(CMAKE_REQUIRED_LIBRARIES    ${_flags} ${${LIBRARIES}})
 99 |     #message("DEBUG: CMAKE_REQUIRED_DEFINITIONS = ${CMAKE_REQUIRED_DEFINITIONS}")
100 |     #message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}")
101 |     # Check if function exists with f2c calling convention (ie a trailing underscore)
102 |     check_function_exists(${_name}_ ${_prefix}_${_name}_${_combined_name}_f2c_WORKS)
103 |     set(CMAKE_REQUIRED_DEFINITIONS} "")
104 |     set(CMAKE_REQUIRED_LIBRARIES    "")
105 |     mark_as_advanced(${_prefix}_${_name}_${_combined_name}_f2c_WORKS)
106 |     set(_libraries_work ${${_prefix}_${_name}_${_combined_name}_f2c_WORKS})
107 |   endif(_libraries_found AND NOT _libraries_work)
108 | 
109 |   # If not found, test this combination of libraries with a C interface.
110 |   # A few implementations (ie ACML) provide a C interface. Unfortunately, there is no standard.
111 |   if(_libraries_found AND NOT _libraries_work)
112 |     set(${DEFINITIONS} "")
113 |     set(${LIBRARIES}   ${_libraries_found})
114 |     set(CMAKE_REQUIRED_DEFINITIONS "")
115 |     set(CMAKE_REQUIRED_LIBRARIES   ${_flags} ${${LIBRARIES}})
116 |     #message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}")
117 |     check_function_exists(${_name} ${_prefix}_${_name}${_combined_name}_WORKS)
118 |     set(CMAKE_REQUIRED_LIBRARIES "")
119 |     mark_as_advanced(${_prefix}_${_name}${_combined_name}_WORKS)
120 |     set(_libraries_work ${${_prefix}_${_name}${_combined_name}_WORKS})
121 |   endif(_libraries_found AND NOT _libraries_work)
122 | 
123 |   # on failure
124 |   if(NOT _libraries_work)
125 |     set(${DEFINITIONS} "")
126 |     set(${LIBRARIES}   FALSE)
127 |   endif()
128 |   #message("DEBUG: ${DEFINITIONS} = ${${DEFINITIONS}}")
129 |   #message("DEBUG: ${LIBRARIES} = ${${LIBRARIES}}")
130 | endmacro(check_fortran_libraries)
131 | 
132 | 
133 | #
134 | # main
135 | #
136 | 
137 | # Is it already configured?
138 | if (BLAS_LIBRARIES_DIR OR BLAS_LIBRARIES)
139 | 
140 |   set(BLAS_FOUND TRUE)
141 | 
142 | else()
143 | 
144 |   # reset variables
145 |   set( BLAS_INCLUDE_DIR "" )
146 |   set( BLAS_DEFINITIONS "" )
147 |   set( BLAS_LINKER_FLAGS "" )
148 |   set( BLAS_LIBRARIES "" )
149 |   set( BLAS_LIBRARIES_DIR "" )
150 | 
151 |     #
152 |     # If Unix, search for BLAS function in possible libraries
153 |     #
154 | 
155 |     # BLAS in ATLAS library? (http://math-atlas.sourceforge.net/)
156 |     if(NOT BLAS_LIBRARIES)
157 |       check_fortran_libraries(
158 |       BLAS_DEFINITIONS
159 |       BLAS_LIBRARIES
160 |       BLAS
161 |       sgemm
162 |       ""
163 |       "cblas;f77blas;atlas"
164 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
165 |       )
166 |     endif()
167 | 
168 |     # BLAS in PhiPACK libraries? (requires generic BLAS lib, too)
169 |     if(NOT BLAS_LIBRARIES)
170 |       check_fortran_libraries(
171 |       BLAS_DEFINITIONS
172 |       BLAS_LIBRARIES
173 |       BLAS
174 |       sgemm
175 |       ""
176 |       "sgemm;dgemm;blas"
177 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
178 |       )
179 |     endif()
180 | 
181 |     # BLAS in Alpha CXML library?
182 |     if(NOT BLAS_LIBRARIES)
183 |       check_fortran_libraries(
184 |       BLAS_DEFINITIONS
185 |       BLAS_LIBRARIES
186 |       BLAS
187 |       sgemm
188 |       ""
189 |       "cxml"
190 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
191 |       )
192 |     endif()
193 | 
194 |     # BLAS in Alpha DXML library? (now called CXML, see above)
195 |     if(NOT BLAS_LIBRARIES)
196 |       check_fortran_libraries(
197 |       BLAS_DEFINITIONS
198 |       BLAS_LIBRARIES
199 |       BLAS
200 |       sgemm
201 |       ""
202 |       "dxml"
203 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
204 |       )
205 |     endif()
206 | 
207 |     # BLAS in Sun Performance library?
208 |     if(NOT BLAS_LIBRARIES)
209 |       check_fortran_libraries(
210 |       BLAS_DEFINITIONS
211 |       BLAS_LIBRARIES
212 |       BLAS
213 |       sgemm
214 |       "-xlic_lib=sunperf"
215 |       "sunperf;sunmath"
216 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
217 |       )
218 |       if(BLAS_LIBRARIES)
219 |         # Extra linker flag
220 |         set(BLAS_LINKER_FLAGS "-xlic_lib=sunperf")
221 |       endif()
222 |     endif()
223 | 
224 |     # BLAS in SCSL library?  (SGI/Cray Scientific Library)
225 |     if(NOT BLAS_LIBRARIES)
226 |       check_fortran_libraries(
227 |       BLAS_DEFINITIONS
228 |       BLAS_LIBRARIES
229 |       BLAS
230 |       sgemm
231 |       ""
232 |       "scsl"
233 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
234 |       )
235 |     endif()
236 | 
237 |     # BLAS in SGIMATH library?
238 |     if(NOT BLAS_LIBRARIES)
239 |       check_fortran_libraries(
240 |       BLAS_DEFINITIONS
241 |       BLAS_LIBRARIES
242 |       BLAS
243 |       sgemm
244 |       ""
245 |       "complib.sgimath"
246 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
247 |       )
248 |     endif()
249 | 
250 |     # BLAS in IBM ESSL library? (requires generic BLAS lib, too)
251 |     if(NOT BLAS_LIBRARIES)
252 |       check_fortran_libraries(
253 |       BLAS_DEFINITIONS
254 |       BLAS_LIBRARIES
255 |       BLAS
256 |       sgemm
257 |       ""
258 |       "essl;blas"
259 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
260 |       )
261 |     endif()
262 | 
263 |     #BLAS in intel mkl 10 library? (em64t 64bit)
264 |     if(NOT BLAS_LIBRARIES)
265 |       check_fortran_libraries(
266 |       BLAS_DEFINITIONS
267 |       BLAS_LIBRARIES
268 |       BLAS
269 |       sgemm
270 |       ""
271 |       "mkl_intel_lp64;mkl_intel_thread;mkl_core;guide;pthread"
272 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
273 |       )
274 |     endif()
275 | 
276 |     ### windows version of intel mkl 10?
277 |     if(NOT BLAS_LIBRARIES)
278 |       check_fortran_libraries(
279 |       BLAS_DEFINITIONS
280 |       BLAS_LIBRARIES
281 |       BLAS
282 |       SGEMM
283 |       ""
284 |       "mkl_c_dll;mkl_intel_thread_dll;mkl_core_dll;libguide40"
285 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
286 |       )
287 |     endif()
288 | 
289 |     #older versions of intel mkl libs
290 | 
291 |     # BLAS in intel mkl library? (shared)
292 |     if(NOT BLAS_LIBRARIES)
293 |       check_fortran_libraries(
294 |       BLAS_DEFINITIONS
295 |       BLAS_LIBRARIES
296 |       BLAS
297 |       sgemm
298 |       ""
299 |       "mkl;guide;pthread"
300 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
301 |       )
302 |     endif()
303 | 
304 |     #BLAS in intel mkl library? (static, 32bit)
305 |     if(NOT BLAS_LIBRARIES)
306 |       check_fortran_libraries(
307 |       BLAS_DEFINITIONS
308 |       BLAS_LIBRARIES
309 |       BLAS
310 |       sgemm
311 |       ""
312 |       "mkl_ia32;guide;pthread"
313 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
314 |       )
315 |     endif()
316 | 
317 |     #BLAS in intel mkl library? (static, em64t 64bit)
318 |     if(NOT BLAS_LIBRARIES)
319 |       check_fortran_libraries(
320 |       BLAS_DEFINITIONS
321 |       BLAS_LIBRARIES
322 |       BLAS
323 |       sgemm
324 |       ""
325 |       "mkl_em64t;guide;pthread"
326 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
327 |       )
328 |     endif()
329 | 
330 |     #BLAS in acml library?
331 |     if(NOT BLAS_LIBRARIES)
332 |       check_fortran_libraries(
333 |       BLAS_DEFINITIONS
334 |       BLAS_LIBRARIES
335 |       BLAS
336 |       sgemm
337 |       ""
338 |       "acml"
339 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
340 |       )
341 |     endif()
342 | 
343 |     # Apple BLAS library?
344 |     if(NOT BLAS_LIBRARIES)
345 |       check_fortran_libraries(
346 |       BLAS_DEFINITIONS
347 |       BLAS_LIBRARIES
348 |       BLAS
349 |       sgemm
350 |       ""
351 |       "Accelerate"
352 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
353 |       )
354 |     endif()
355 | 
356 |     if ( NOT BLAS_LIBRARIES )
357 |       check_fortran_libraries(
358 |       BLAS_DEFINITIONS
359 |       BLAS_LIBRARIES
360 |       BLAS
361 |       sgemm
362 |       ""
363 |       "vecLib"
364 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
365 |       )
366 |     endif ( NOT BLAS_LIBRARIES )
367 | 
368 |     # Generic BLAS library?
369 |     # This configuration *must* be the last try as this library is notably slow.
370 |     if ( NOT BLAS_LIBRARIES )
371 |       check_fortran_libraries(
372 |       BLAS_DEFINITIONS
373 |       BLAS_LIBRARIES
374 |       BLAS
375 |       sgemm
376 |       ""
377 |       "blas"
378 |       "${CGAL_TAUCS_LIBRARIES_DIR} ENV BLAS_LIB_DIR"
379 |       )
380 |     endif()
381 | 
382 |   if(BLAS_LIBRARIES_DIR OR BLAS_LIBRARIES)
383 |     set(BLAS_FOUND TRUE)
384 |   else()
385 |     set(BLAS_FOUND FALSE)
386 |   endif()
387 | 
388 |   if(NOT BLAS_FIND_QUIETLY)
389 |     if(BLAS_FOUND)
390 |       message(STATUS "A library with BLAS API found.")
391 |     else(BLAS_FOUND)
392 |       if(BLAS_FIND_REQUIRED)
393 |         message(FATAL_ERROR "A required library with BLAS API not found. Please specify library location.")
394 |       else()
395 |         message(STATUS "A library with BLAS API not found. Please specify library location.")
396 |       endif()
397 |     endif(BLAS_FOUND)
398 |   endif(NOT BLAS_FIND_QUIETLY)
399 | 
400 |   # Add variables to cache
401 |   set( BLAS_INCLUDE_DIR   "${BLAS_INCLUDE_DIR}"
402 |                           CACHE PATH "Directories containing the BLAS header files" FORCE )
403 |   set( BLAS_DEFINITIONS   "${BLAS_DEFINITIONS}"
404 |                           CACHE STRING "Compilation options to use BLAS" FORCE )
405 |   set( BLAS_LINKER_FLAGS  "${BLAS_LINKER_FLAGS}"
406 |                           CACHE STRING "Linker flags to use BLAS" FORCE )
407 |   set( BLAS_LIBRARIES     "${BLAS_LIBRARIES}"
408 |                           CACHE FILEPATH "BLAS libraries name" FORCE )
409 |   set( BLAS_LIBRARIES_DIR "${BLAS_LIBRARIES_DIR}"
410 |                           CACHE PATH "Directories containing the BLAS libraries" FORCE )
411 | 
412 |   #message("DEBUG: BLAS_INCLUDE_DIR = ${BLAS_INCLUDE_DIR}")
413 |   #message("DEBUG: BLAS_DEFINITIONS = ${BLAS_DEFINITIONS}")
414 |   #message("DEBUG: BLAS_LINKER_FLAGS = ${BLAS_LINKER_FLAGS}")
415 |   #message("DEBUG: BLAS_LIBRARIES = ${BLAS_LIBRARIES}")
416 |   #message("DEBUG: BLAS_LIBRARIES_DIR = ${BLAS_LIBRARIES_DIR}")
417 |   #message("DEBUG: BLAS_FOUND = ${BLAS_FOUND}")
418 | 
419 | endif(BLAS_LIBRARIES_DIR OR BLAS_LIBRARIES)
420 | 


--------------------------------------------------------------------------------
/gargo_500.off:
--------------------------------------------------------------------------------
  1 | OFF
  2 | 252 500 0
  3 | 0.0077193399999999999 -0.13652300000000001 0.246785
  4 | 0.050061700000000001 -0.166822 0.25216
  5 | 0.0622331 -0.12635199999999999 0.23121800000000001
  6 | 0.0130682 -0.073352299999999995 0.20663899999999999
  7 | -0.038867800000000001 -0.114399 0.205536
  8 | -0.083603999999999998 -0.14404600000000001 0.177622
  9 | -0.030557000000000001 -0.16156899999999999 0.20086499999999999
 10 | 0.0088293899999999995 -0.196489 0.23186499999999999
 11 | 0.089393700000000006 -0.21401999999999999 0.21046100000000001
 12 | -0.053833100000000002 -0.201296 0.21202399999999999
 13 | 0.038316700000000002 -0.24388599999999999 0.17399700000000001
 14 | 0.12869900000000001 -0.16268299999999999 0.199909
 15 | 0.069081100000000006 -0.11421199999999999 0.18758
 16 | -0.0189537 -0.0548943 0.18449699999999999
 17 | 0.119898 -0.075601100000000004 0.130056
 18 | 0.054527699999999998 -0.30539500000000003 0.078869099999999998
 19 | 0.0204119 -0.26423099999999999 0.139824
 20 | 0.111553 -0.27860800000000002 0.120047
 21 | 0.156918 -0.233963 0.155089
 22 | 0.17002999999999999 -0.177203 0.16381000000000001
 23 | -0.094452499999999995 -0.19200400000000001 0.15610299999999999
 24 | -0.122433 -0.22338 0.12790299999999999
 25 | -0.113492 -0.233158 0.17163800000000001
 26 | -0.095300800000000005 -0.26914300000000002 0.13684499999999999
 27 | 0.14130400000000001 -0.14440500000000001 0.129188
 28 | -0.037552599999999998 -0.024754399999999999 0.149614
 29 | 0.042457599999999998 -0.043319900000000001 0.16955300000000001
 30 | -0.081307199999999996 -0.0767679 0.15579000000000001
 31 | -0.034531899999999997 -0.28800500000000001 0.104934
 32 | -0.117757 -0.17003499999999999 0.12501699999999999
 33 | -0.12066300000000001 -0.090817400000000006 0.122694
 34 | -0.14716599999999999 -0.13156300000000001 0.102295
 35 | -0.085558999999999996 0.064860299999999996 0.14657999999999999
 36 | -0.045901200000000003 0.063315700000000003 0.121976
 37 | -0.100954 0.115289 0.140047
 38 | -0.079350299999999999 0.072519 0.097068799999999997
 39 | -0.110125 0.212841 0.125891
 40 | -0.10872999999999999 0.156501 0.152665
 41 | 0.16942299999999999 -0.28447 0.111362
 42 | 0.054561600000000002 0.11074299999999999 0.113191
 43 | 0.104285 0.094936099999999995 0.11938799999999999
 44 | 0.070967699999999995 0.17399600000000001 0.106599
 45 | -0.143118 -0.27579300000000001 0.094654299999999997
 46 | -0.051518500000000002 -0.25439499999999998 0.156523
 47 | -0.065401600000000004 0.14427499999999999 0.12386900000000001
 48 | -0.0278324 0.1174 0.082120200000000004
 49 | -0.079827200000000001 0.20324400000000001 0.096296000000000007
 50 | -0.068224699999999999 0.22415299999999999 0.058717100000000001
 51 | -0.108718 0.24557699999999999 0.084253599999999998
 52 | -0.16939000000000001 0.26861800000000002 0.089819899999999994
 53 | 0.073075600000000004 0.052409699999999997 0.12248100000000001
 54 | 0.075564199999999998 0.057434899999999997 0.054756899999999997
 55 | 0.15282399999999999 -0.089146600000000006 0.099670099999999998
 56 | 0.172012 -0.104327 0.056560300000000001
 57 | 0.12529499999999999 -0.063306100000000004 0.072572300000000006
 58 | 0.048377400000000001 -0.012822200000000001 0.12645400000000001
 59 | 0.0048411499999999998 0.0013481599999999999 0.139157
 60 | 0.081440200000000004 -0.050998000000000002 0.13916999999999999
 61 | -0.154807 0.210651 0.130549
 62 | 0.080139699999999994 -0.0362081 0.095544199999999996
 63 | -0.102605 0.18281800000000001 0.057487700000000003
 64 | -0.122085 0.17072300000000001 0.107742
 65 | -0.058504 0.0057387100000000002 0.107305
 66 | 0.17219300000000001 -0.18141599999999999 0.090031600000000003
 67 | -0.13789599999999999 -0.087255200000000005 0.067430100000000007
 68 | -0.131383 -0.15431800000000001 0.019295
 69 | -0.019127700000000001 0.036884599999999997 0.091923699999999997
 70 | 0.20058300000000001 -0.185728 0.12575800000000001
 71 | 0.17741999999999999 -0.30456899999999998 0.032433700000000003
 72 | 0.20449100000000001 -0.29368 0.077587600000000007
 73 | 0.20814199999999999 -0.23507800000000001 0.10011399999999999
 74 | 0.18686900000000001 -0.26204 0.045656000000000002
 75 | 0.169375 -0.21892200000000001 0.051132999999999998
 76 | 0.043997399999999999 0.21886900000000001 0.042332700000000001
 77 | 0.024440099999999999 0.17542099999999999 0.046518400000000001
 78 | 0.034526899999999999 0.13541300000000001 0.077542100000000003
 79 | 0.13352 0.173072 0.14537900000000001
 80 | 0.106143 0.23869799999999999 0.095771599999999998
 81 | 0.157914 0.246583 0.101894
 82 | 0.077054800000000007 0.25049500000000002 0.044261500000000002
 83 | -0.090630699999999995 -0.039832899999999997 0.085003800000000004
 84 | 0.122611 -0.033643100000000002 0.041884499999999998
 85 | 0.099935800000000005 -0.0330675 -0.0067941599999999996
 86 | -0.089279999999999998 0.136905 0.069685499999999997
 87 | -0.070668800000000004 0.057692100000000003 0.039890099999999998
 88 | -0.080170599999999995 0.019026700000000001 0.067150899999999999
 89 | -0.122448 0.0143245 0.048571099999999999
 90 | 0.059250799999999999 0.0085089699999999994 0.088969199999999998
 91 | 0.034653200000000002 0.054387199999999997 0.098242399999999994
 92 | -0.038150400000000001 0.177505 0.0479271
 93 | -0.141958 0.29495199999999999 0.046579099999999998
 94 | -0.096070699999999995 0.26666600000000001 0.022387500000000001
 95 | -0.15851199999999999 0.31977 0.0046944400000000002
 96 | -0.156115 0.25861600000000001 0.031475700000000002
 97 | -0.14416399999999999 0.22237599999999999 0.081490199999999999
 98 | -0.12545799999999999 0.228051 0.036740299999999997
 99 | -0.098593500000000001 0.200238 0.014561899999999999
100 | 0.12770300000000001 0.21920999999999999 0.052716600000000002
101 | 0.146868 0.262077 0.025766799999999999
102 | 0.154915 -0.27710299999999999 -0.0146064
103 | 0.11597399999999999 -0.31643199999999999 0.064590300000000003
104 | 0.13247900000000001 -0.33078600000000002 -0.0070559899999999998
105 | 0.0080646499999999996 -0.32230700000000001 0.054428499999999998
106 | 0.020154200000000001 -0.34976699999999999 0.014281200000000001
107 | 0.0080645100000000004 0.084739200000000001 0.057093999999999999
108 | -0.0031026500000000002 0.13078400000000001 0.042400100000000003
109 | 0.090240000000000001 0.12251099999999999 0.067013600000000006
110 | 0.0785806 0.13461200000000001 0.026093000000000002
111 | 0.12521699999999999 0.16771 0.086035799999999996
112 | 0.094936699999999999 0.18288299999999999 0.027327600000000001
113 | 0.10945199999999999 0.23158200000000001 0.012135699999999999
114 | -0.11206000000000001 -0.32706400000000002 0.0459438
115 | -0.15596199999999999 -0.172231 0.059631799999999999
116 | -0.13161400000000001 -0.22095100000000001 0.041188000000000002
117 | -0.14279 -0.21649399999999999 0.083468100000000003
118 | -0.0076715000000000004 0.16042600000000001 0.0067416400000000001
119 | -0.112235 -0.26360099999999997 0.0122509
120 | -0.14032600000000001 -0.29507100000000003 0.050027099999999998
121 | -0.19474900000000001 0.30008299999999999 0.032770000000000001
122 | 0.16072600000000001 -0.16772799999999999 0.029691100000000002
123 | 0.162604 -0.115019 0.0114092
124 | 0.118247 -0.075163999999999995 0.00039068000000000002
125 | -0.076786599999999997 0.067138799999999998 -0.0156776
126 | 0.106375 0.018192 0.076055999999999999
127 | 0.10938299999999999 0.025971600000000001 0.00307501
128 | 0.068028099999999994 0.081532199999999999 0.011297700000000001
129 | 0.10635799999999999 -0.17130899999999999 0.028740000000000002
130 | 0.093136899999999995 -0.13077900000000001 -0.019416900000000001
131 | 0.044895200000000003 -0.17465700000000001 -0.0170469
132 | -0.15989 -0.107779 0.028998699999999999
133 | -0.108933 -0.11423800000000001 0.0094292400000000002
134 | 0.16946600000000001 0.30876999999999999 0.038610899999999997
135 | 0.140958 0.32433400000000001 -0.021320800000000001
136 | 0.10645399999999999 0.29571599999999998 0.016037699999999998
137 | 0.19259899999999999 0.32864100000000002 -0.029222100000000001
138 | -0.19467699999999999 0.326739 -0.029209100000000002
139 | -0.228857 0.31286399999999998 -0.0077176600000000003
140 | 0.15027499999999999 -0.25158900000000001 0.019951699999999999
141 | 0.122267 -0.23780799999999999 -0.022864300000000001
142 | -0.039864400000000001 -0.32721099999999997 0.047364999999999997
143 | 0.023865399999999998 -0.35563899999999998 -0.035764200000000003
144 | 0.072917399999999993 -0.35919899999999999 -0.020223499999999998
145 | -0.091660900000000003 -0.30451299999999998 -0.0253706
146 | -0.054100599999999999 -0.34738400000000003 -0.011443399999999999
147 | -0.077237399999999998 -0.18323800000000001 0.030036799999999999
148 | 0.063416399999999998 0.11061799999999999 -0.028436900000000001
149 | 0.049846399999999999 0.14549799999999999 -0.060629099999999998
150 | 0.119571 -0.29997699999999999 -0.041940499999999999
151 | -0.10997999999999999 -0.047640700000000001 -0.022239499999999999
152 | -0.122558 -0.028333799999999999 0.022256399999999999
153 | -0.085278000000000007 -0.082708900000000002 -0.0247263
154 | -0.078396400000000005 0.10724 0.0200357
155 | -0.076111100000000001 0.149142 0.0097732900000000004
156 | -0.11852799999999999 0.230436 -0.029078699999999999
157 | -0.082499199999999995 0.18315600000000001 -0.039601699999999997
158 | 0.089825799999999997 0.29552600000000001 -0.0378386
159 | -0.053920999999999997 0.22773599999999999 -0.0129027
160 | -0.17682 0.28039900000000001 -0.0160673
161 | -0.196825 0.28466799999999998 -0.0539433
162 | -0.119617 -0.30728699999999998 0.0066730399999999999
163 | -0.0731068 0.117481 -0.042804099999999998
164 | -0.072785100000000005 0.101492 -0.084625099999999995
165 | -0.078231400000000006 0.144483 -0.082004999999999995
166 | -0.081587699999999999 -0.25192599999999998 -0.019273100000000001
167 | -0.082334000000000004 -0.139764 -0.017997599999999999
168 | -0.062740799999999999 -0.18240600000000001 -0.024403500000000002
169 | 0.072322800000000007 -0.053538700000000002 -0.037980699999999999
170 | 0.035236299999999998 0.24260499999999999 -0.0538977
171 | 0.0092171200000000005 0.198764 -0.0122265
172 | -0.018944699999999998 0.16520000000000001 -0.038049899999999998
173 | -0.027353100000000002 -0.12504100000000001 -0.0357308
174 | -0.057767199999999998 -0.073715900000000001 -0.056193300000000002
175 | -0.014908599999999999 -0.184228 -0.0143301
176 | -0.115565 0.022842299999999999 0.0067649800000000003
177 | -0.10567799999999999 -0.00022844599999999999 -0.078620999999999996
178 | 0.077746899999999994 -0.306031 -0.0626834
179 | 0.088440599999999994 -0.25941900000000001 -0.053579799999999997
180 | -0.052552399999999999 -0.21752299999999999 -0.050045699999999999
181 | 0.00057392499999999998 -0.30973600000000001 -0.072580099999999995
182 | -0.045826499999999999 -0.30464400000000003 -0.056120099999999999
183 | 0.023767099999999999 -0.10863200000000001 -0.062710399999999999
184 | 0.034748399999999999 -0.071105699999999994 -0.096098000000000003
185 | -0.112468 0.026718700000000001 -0.043080300000000002
186 | -0.10399799999999999 0.063058500000000003 -0.078161800000000003
187 | 0.081199400000000005 0.21531800000000001 -0.0323513
188 | 0.115781 0.258876 -0.044720200000000002
189 | 0.16416500000000001 0.29555700000000001 -0.033656499999999999
190 | 0.066372299999999995 0.16783799999999999 -0.022039599999999999
191 | -0.13594200000000001 0.30522500000000002 -0.038455700000000002
192 | -0.093004900000000001 0.26768999999999998 -0.055713199999999997
193 | -0.15043000000000001 0.25244699999999998 -0.084612800000000002
194 | 0.048511400000000003 -0.22432299999999999 -0.056505100000000003
195 | 0.096748600000000004 -0.19367000000000001 -0.024686300000000001
196 | 0.053762999999999998 0.25876100000000002 -0.0067628799999999998
197 | -0.048217200000000002 0.19722600000000001 -0.077170299999999997
198 | -0.085377800000000004 -0.0269368 -0.106479
199 | -0.043353799999999998 -0.044896999999999999 -0.138541
200 | -0.034485300000000003 -0.080350699999999997 -0.10550900000000001
201 | 0.0092008300000000001 -0.047514800000000003 -0.144071
202 | 0.0019814799999999999 -0.207014 -0.051277000000000003
203 | 0.030095500000000001 -0.27510200000000001 -0.070452699999999993
204 | -0.026049099999999999 -0.25162800000000002 -0.062840099999999996
205 | 0.086625800000000003 0.0034563200000000001 -0.074894299999999997
206 | 0.0844612 0.045534100000000001 -0.0512443
207 | 0.051918499999999999 0.22916300000000001 -0.106584
208 | 0.0247251 0.170631 -0.122679
209 | 0.049491399999999998 -0.12621499999999999 -0.011880399999999999
210 | 0.075752200000000006 0.050419600000000002 -0.102898
211 | 0.14613399999999999 0.30335299999999998 -0.079844700000000005
212 | 0.12495299999999999 0.26703100000000002 -0.100023
213 | 0.084726800000000005 0.28112799999999999 -0.0849747
214 | -0.089374099999999998 0.17708199999999999 -0.12327
215 | 0.078187099999999995 0.20675099999999999 -0.079851500000000006
216 | -0.095131800000000002 0.039574100000000001 -0.119793
217 | -0.118801 0.196405 -0.088826699999999995
218 | -0.099033300000000005 0.24213100000000001 -0.095106599999999999
219 | -0.014627599999999999 0.16692899999999999 -0.100189
220 | 0.060560900000000001 0.10367700000000001 -0.085122199999999995
221 | 0.0699993 0.182641 -0.123546
222 | -0.055164699999999997 0.13607 -0.14629200000000001
223 | 0.055668000000000002 -0.00057573599999999998 -0.18209800000000001
224 | 0.065666699999999995 0.040182599999999999 -0.15212100000000001
225 | 0.061894600000000001 -0.024982799999999999 -0.11765299999999999
226 | 0.062001000000000001 0.082638500000000004 -0.13733600000000001
227 | 0.063999 0.069826799999999994 -0.19639899999999999
228 | -0.086901699999999998 0.097960800000000001 -0.15157399999999999
229 | -0.089796000000000001 0.048851199999999997 -0.16752500000000001
230 | -0.075589500000000004 0.0020001699999999999 -0.16830999999999999
231 | -0.0015668699999999999 -0.037998200000000003 -0.193333
232 | -0.0081874700000000005 0.14408299999999999 -0.15189900000000001
233 | -0.041011199999999998 0.13086999999999999 -0.19532099999999999
234 | 0.0484968 0.124068 -0.139764
235 | -0.0509919 0.097911799999999993 -0.25699100000000002
236 | -0.069795700000000002 0.080365300000000001 -0.209226
237 | -0.071740600000000002 0.023375699999999999 -0.245308
238 | -0.063024300000000005 -0.0023204300000000001 -0.21207000000000001
239 | 0.014656499999999999 -0.086953699999999995 -0.23316400000000001
240 | 0.030395499999999999 0.124822 -0.18775500000000001
241 | -0.021816200000000001 -0.052551300000000002 -0.24091399999999999
242 | 0.047053400000000002 0.061249999999999999 -0.25511200000000001
243 | 0.031314500000000002 0.103544 -0.24932199999999999
244 | 0.0021623699999999998 0.081478499999999995 -0.271395
245 | 0.055490999999999999 0.019293399999999999 -0.23033699999999999
246 | 0.043423000000000003 -0.0089588900000000006 -0.26652199999999998
247 | 0.034379699999999999 0.037080700000000001 -0.30268699999999998
248 | 0.014905 -0.049514099999999998 -0.304234
249 | -0.019474600000000002 -0.0686475 -0.32624199999999998
250 | -0.053453399999999998 0.047280000000000003 -0.28245500000000001
251 | -0.016852300000000001 0.037051899999999999 -0.318332
252 | -0.048029299999999997 -0.010111999999999999 -0.29515599999999997
253 | -0.0051328199999999997 -0.028393399999999999 -0.35108299999999998
254 | 0.0261143 0.0017903400000000001 -0.32513999999999998
255 | 3 131 186 134
256 | 3 98 186 131
257 | 3 1 0 7
258 | 3 0 1 2
259 | 3 2 1 8
260 | 3 7 0 6
261 | 3 0 2 3
262 | 3 2 12 3
263 | 3 3 4 0
264 | 3 3 13 4
265 | 3 5 6 4
266 | 3 0 4 6
267 | 3 8 1 7
268 | 3 7 10 8
269 | 3 9 7 6
270 | 3 43 16 9
271 | 3 7 9 10
272 | 3 16 10 9
273 | 3 8 18 11
274 | 3 18 19 11
275 | 3 11 19 24
276 | 3 8 11 2
277 | 3 6 5 9
278 | 3 5 20 9
279 | 3 9 20 22
280 | 3 9 22 43
281 | 3 12 11 24
282 | 3 12 2 11
283 | 3 3 12 26
284 | 3 12 57 26
285 | 3 13 3 26
286 | 3 12 14 57
287 | 3 24 14 12
288 | 3 17 10 16
289 | 3 15 16 102
290 | 3 16 15 17
291 | 3 17 15 100
292 | 3 8 10 17
293 | 3 8 17 18
294 | 3 18 70 19
295 | 3 70 67 19
296 | 3 63 24 67
297 | 3 24 19 67
298 | 3 23 22 21
299 | 3 23 43 22
300 | 3 20 21 22
301 | 3 52 14 24
302 | 3 27 25 62
303 | 3 13 25 27
304 | 3 4 13 27
305 | 3 27 5 4
306 | 3 26 56 13
307 | 3 56 25 13
308 | 3 26 55 56
309 | 3 80 27 62
310 | 3 27 30 29
311 | 3 29 5 27
312 | 3 16 43 28
313 | 3 28 102 16
314 | 3 29 20 5
315 | 3 31 29 30
316 | 3 29 31 112
317 | 3 32 33 44
318 | 3 34 32 44
319 | 3 37 34 44
320 | 3 35 32 34
321 | 3 83 35 34
322 | 3 29 112 114
323 | 3 20 29 21
324 | 3 21 29 114
325 | 3 37 44 36
326 | 3 17 38 18
327 | 3 38 17 100
328 | 3 18 38 70
329 | 3 41 39 40
330 | 3 50 40 39
331 | 3 40 51 106
332 | 3 76 41 40
333 | 3 108 76 40
334 | 3 42 23 21
335 | 3 23 42 111
336 | 3 44 46 36
337 | 3 47 48 46
338 | 3 36 46 48
339 | 3 89 46 44
340 | 3 44 45 89
341 | 3 47 46 89
342 | 3 47 91 48
343 | 3 49 48 90
344 | 3 91 90 48
345 | 3 49 58 48
346 | 3 58 36 48
347 | 3 88 50 39
348 | 3 50 88 87
349 | 3 50 87 123
350 | 3 50 123 51
351 | 3 51 40 50
352 | 3 53 54 52
353 | 3 54 53 121
354 | 3 14 52 54
355 | 3 57 14 54
356 | 3 59 57 54
357 | 3 88 56 87
358 | 3 56 55 87
359 | 3 88 66 56
360 | 3 26 57 55
361 | 3 57 59 55
362 | 3 55 59 87
363 | 3 49 94 58
364 | 3 37 36 58
365 | 3 23 111 28
366 | 3 28 43 23
367 | 3 54 81 59
368 | 3 81 123 59
369 | 3 123 87 59
370 | 3 152 83 60
371 | 3 61 60 83
372 | 3 34 37 61
373 | 3 34 61 83
374 | 3 58 61 37
375 | 3 94 61 58
376 | 3 60 61 94
377 | 3 32 35 62
378 | 3 84 85 35
379 | 3 85 62 35
380 | 3 62 66 32
381 | 3 33 32 66
382 | 3 63 119 53
383 | 3 24 63 53
384 | 3 119 120 53
385 | 3 53 52 24
386 | 3 31 30 64
387 | 3 64 129 31
388 | 3 31 129 112
389 | 3 129 65 112
390 | 3 62 25 56
391 | 3 56 66 62
392 | 3 33 66 104
393 | 3 45 33 104
394 | 3 63 67 70
395 | 3 63 72 119
396 | 3 100 68 38
397 | 3 68 69 38
398 | 3 38 69 70
399 | 3 70 72 63
400 | 3 72 137 126
401 | 3 126 119 72
402 | 3 73 74 41
403 | 3 41 74 75
404 | 3 41 75 39
405 | 3 77 41 76
406 | 3 41 77 73
407 | 3 77 79 73
408 | 3 78 77 76
409 | 3 77 78 79
410 | 3 79 78 133
411 | 3 80 30 27
412 | 3 64 30 80
413 | 3 149 64 80
414 | 3 54 121 81
415 | 3 81 121 82
416 | 3 82 124 81
417 | 3 124 123 81
418 | 3 83 152 151
419 | 3 83 151 84
420 | 3 84 35 83
421 | 3 84 151 122
422 | 3 84 122 173
423 | 3 85 84 173
424 | 3 85 80 62
425 | 3 69 68 71
426 | 3 70 69 71
427 | 3 71 72 70
428 | 3 80 85 86
429 | 3 80 86 149
430 | 3 88 104 66
431 | 3 47 89 156
432 | 3 45 44 33
433 | 3 45 105 89
434 | 3 105 115 89
435 | 3 104 88 39
436 | 3 39 75 104
437 | 3 90 91 92
438 | 3 49 90 92
439 | 3 118 49 92
440 | 3 94 49 93
441 | 3 93 95 94
442 | 3 94 95 60
443 | 3 60 95 96
444 | 3 60 96 152
445 | 3 76 108 78
446 | 3 108 97 78
447 | 3 78 97 98
448 | 3 98 131 78
449 | 3 68 101 99
450 | 3 102 103 15
451 | 3 103 100 15
452 | 3 104 105 45
453 | 3 51 125 106
454 | 3 107 106 125
455 | 3 107 109 106
456 | 3 40 106 108
457 | 3 108 106 109
458 | 3 109 97 108
459 | 3 109 110 97
460 | 3 109 184 110
461 | 3 98 97 110
462 | 3 139 28 111
463 | 3 139 102 28
464 | 3 139 111 143
465 | 3 113 114 112
466 | 3 42 114 113
467 | 3 21 114 42
468 | 3 73 168 74
469 | 3 168 115 74
470 | 3 74 115 105
471 | 3 75 74 105
472 | 3 105 104 75
473 | 3 113 116 117
474 | 3 117 42 113
475 | 3 117 159 111
476 | 3 42 117 111
477 | 3 49 118 93
478 | 3 157 93 118
479 | 3 120 119 126
480 | 3 53 120 121
481 | 3 126 127 120
482 | 3 173 86 85
483 | 3 51 123 124
484 | 3 124 125 51
485 | 3 126 192 127
486 | 3 128 127 192
487 | 3 65 129 130
488 | 3 130 129 64
489 | 3 144 65 130
490 | 3 144 113 65
491 | 3 65 113 112
492 | 3 130 64 149
493 | 3 149 148 130
494 | 3 155 133 132
495 | 3 131 132 133
496 | 3 133 78 131
497 | 3 134 132 131
498 | 3 188 92 91
499 | 3 118 92 135
500 | 3 135 92 188
501 | 3 136 118 135
502 | 3 72 71 137
503 | 3 126 137 138
504 | 3 103 102 139
505 | 3 140 141 103
506 | 3 143 140 103
507 | 3 100 103 141
508 | 3 101 68 141
509 | 3 68 100 141
510 | 3 68 99 137
511 | 3 137 71 68
512 | 3 145 107 125
513 | 3 143 111 159
514 | 3 159 142 143
515 | 3 139 143 103
516 | 3 113 144 163
517 | 3 113 163 116
518 | 3 124 203 125
519 | 3 217 145 203
520 | 3 145 217 146
521 | 3 145 146 187
522 | 3 107 145 187
523 | 3 109 107 187
524 | 3 101 147 99
525 | 3 137 99 138
526 | 3 176 138 99
527 | 3 148 150 130
528 | 3 150 164 130
529 | 3 151 152 160
530 | 3 122 151 160
531 | 3 96 95 153
532 | 3 153 95 93
533 | 3 96 153 154
534 | 3 152 96 154
535 | 3 154 160 152
536 | 3 155 193 133
537 | 3 133 193 79
538 | 3 73 79 193
539 | 3 101 141 175
540 | 3 175 147 101
541 | 3 91 47 156
542 | 3 189 91 156
543 | 3 91 189 188
544 | 3 120 127 121
545 | 3 156 89 115
546 | 3 190 153 158
547 | 3 157 158 153
548 | 3 93 157 153
549 | 3 118 136 157
550 | 3 116 159 117
551 | 3 159 116 163
552 | 3 142 159 163
553 | 3 122 160 161
554 | 3 160 154 162
555 | 3 162 161 160
556 | 3 214 211 154
557 | 3 162 154 211
558 | 3 163 179 142
559 | 3 143 142 179
560 | 3 170 164 150
561 | 3 171 170 150
562 | 3 170 165 164
563 | 3 165 144 164
564 | 3 130 164 144
565 | 3 127 206 166
566 | 3 166 121 127
567 | 3 166 82 121
568 | 3 168 73 167
569 | 3 168 216 169
570 | 3 168 169 115
571 | 3 169 156 115
572 | 3 181 180 197
573 | 3 170 171 197
574 | 3 180 170 197
575 | 3 135 158 136
576 | 3 170 172 165
577 | 3 149 86 173
578 | 3 148 149 173
579 | 3 173 182 148
580 | 3 182 174 148
581 | 3 174 195 148
582 | 3 148 195 171
583 | 3 171 150 148
584 | 3 141 140 175
585 | 3 140 178 175
586 | 3 175 176 147
587 | 3 99 147 176
588 | 3 163 177 201
589 | 3 201 179 163
590 | 3 178 140 179
591 | 3 128 199 172
592 | 3 199 177 172
593 | 3 177 165 172
594 | 3 177 163 165
595 | 3 163 144 165
596 | 3 166 206 180
597 | 3 166 180 181
598 | 3 166 181 222
599 | 3 166 124 82
600 | 3 182 173 122
601 | 3 122 161 183
602 | 3 182 122 183
603 | 3 174 182 183
604 | 3 185 98 110
605 | 3 184 185 110
606 | 3 185 184 212
607 | 3 185 209 186
608 | 3 212 209 185
609 | 3 208 186 209
610 | 3 185 186 98
611 | 3 109 187 212
612 | 3 212 184 109
613 | 3 146 212 187
614 | 3 158 135 188
615 | 3 188 190 158
616 | 3 179 140 143
617 | 3 153 190 214
618 | 3 154 153 214
619 | 3 192 138 176
620 | 3 176 191 192
621 | 3 192 126 138
622 | 3 155 132 208
623 | 3 210 155 208
624 | 3 155 210 167
625 | 3 167 193 155
626 | 3 193 167 73
627 | 3 191 128 192
628 | 3 176 175 200
629 | 3 191 176 200
630 | 3 167 210 204
631 | 3 168 167 216
632 | 3 191 199 128
633 | 3 128 206 127
634 | 3 169 216 156
635 | 3 156 216 194
636 | 3 188 189 190
637 | 3 189 215 190
638 | 3 208 134 186
639 | 3 197 171 195
640 | 3 195 196 197
641 | 3 197 196 198
642 | 3 197 198 181
643 | 3 199 191 201
644 | 3 177 199 201
645 | 3 191 200 201
646 | 3 175 178 200
647 | 3 200 178 201
648 | 3 178 179 201
649 | 3 124 166 202
650 | 3 124 202 203
651 | 3 166 222 202
652 | 3 203 145 125
653 | 3 204 218 205
654 | 3 218 231 205
655 | 3 204 205 216
656 | 3 167 204 216
657 | 3 206 128 180
658 | 3 170 180 128
659 | 3 128 172 170
660 | 3 203 202 207
661 | 3 203 207 217
662 | 3 207 223 217
663 | 3 132 134 208
664 | 3 208 209 210
665 | 3 211 194 216
666 | 3 194 215 189
667 | 3 194 189 156
668 | 3 209 212 204
669 | 3 204 210 209
670 | 3 212 218 204
671 | 3 213 174 183
672 | 3 213 183 161
673 | 3 195 174 213
674 | 3 211 214 190
675 | 3 190 215 211
676 | 3 215 194 211
677 | 3 216 205 229
678 | 3 146 217 218
679 | 3 218 212 146
680 | 3 217 223 231
681 | 3 231 218 217
682 | 3 219 211 216
683 | 3 211 219 225
684 | 3 225 161 211
685 | 3 161 162 211
686 | 3 221 220 224
687 | 3 220 242 224
688 | 3 221 207 222
689 | 3 221 223 207
690 | 3 222 207 202
691 | 3 222 220 221
692 | 3 222 198 220
693 | 3 223 221 224
694 | 3 224 237 223
695 | 3 237 231 223
696 | 3 196 195 227
697 | 3 196 227 228
698 | 3 228 198 196
699 | 3 220 198 228
700 | 3 222 181 198
701 | 3 225 226 213
702 | 3 161 225 213
703 | 3 228 227 235
704 | 3 213 226 227
705 | 3 227 195 213
706 | 3 219 229 230
707 | 3 229 219 216
708 | 3 230 229 237
709 | 3 219 230 233
710 | 3 225 219 233
711 | 3 229 205 231
712 | 3 237 229 231
713 | 3 233 226 225
714 | 3 235 227 226
715 | 3 233 235 226
716 | 3 224 240 237
717 | 3 233 232 247
718 | 3 247 234 233
719 | 3 233 234 235
720 | 3 228 235 238
721 | 3 238 236 228
722 | 3 232 233 230
723 | 3 237 240 230
724 | 3 232 230 240
725 | 3 240 241 232
726 | 3 238 243 236
727 | 3 228 236 243
728 | 3 220 228 243
729 | 3 224 239 240
730 | 3 240 239 241
731 | 3 242 239 224
732 | 3 242 244 239
733 | 3 243 244 242
734 | 3 244 243 251
735 | 3 244 241 239
736 | 3 238 235 249
737 | 3 243 242 220
738 | 3 245 243 238
739 | 3 245 238 249
740 | 3 249 246 245
741 | 3 241 248 247
742 | 3 232 241 247
743 | 3 249 247 248
744 | 3 247 249 234
745 | 3 235 234 249
746 | 3 245 246 250
747 | 3 250 246 249
748 | 3 243 245 251
749 | 3 241 244 248
750 | 3 249 248 250
751 | 3 248 244 250
752 | 3 244 251 250
753 | 3 245 250 251
754 | 3 158 157 136
755 | 


--------------------------------------------------------------------------------
/LICENSE.GPL:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <http://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <http://www.gnu.org/philosophy/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------
/gargo_1000.off:
--------------------------------------------------------------------------------
   1 | OFF
   2 | 502 1000 0
   3 | 0.137907 0.26328099999999999 0.010829099999999999
   4 | 0.16441800000000001 0.27263199999999999 0.031460799999999997
   5 | 0.018926200000000001 -0.14549599999999999 0.25484200000000001
   6 | 0.052137999999999997 -0.15132300000000001 0.25551000000000001
   7 | 0.0479855 -0.18232000000000001 0.24881
   8 | 0.046322500000000003 -0.113638 0.227852
   9 | 0.078143699999999996 -0.139066 0.23458399999999999
  10 | 0.0060658800000000001 -0.11683200000000001 0.244806
  11 | -0.013040899999999999 -0.138268 0.232651
  12 | 0.0081505499999999995 -0.0839564 0.21943699999999999
  13 | -0.038867800000000001 -0.114399 0.205536
  14 | -0.081685099999999997 -0.1278 0.18249699999999999
  15 | -0.0154299 -0.15829199999999999 0.202681
  16 | 0.026014499999999999 -0.20091000000000001 0.23225399999999999
  17 | -0.0083557400000000004 -0.19206799999999999 0.23147699999999999
  18 | 0.087078699999999995 -0.235432 0.18653500000000001
  19 | 0.070422499999999999 -0.220165 0.21034600000000001
  20 | 0.094422800000000001 -0.190882 0.23469000000000001
  21 | 0.10565099999999999 -0.20960200000000001 0.21027199999999999
  22 | -0.045684000000000002 -0.16484599999999999 0.199049
  23 | -0.037910800000000001 -0.21262 0.22051000000000001
  24 | 0.038316700000000002 -0.24388599999999999 0.17399700000000001
  25 | 0.13320499999999999 -0.188667 0.20652100000000001
  26 | 0.15001300000000001 -0.16608300000000001 0.18862400000000001
  27 | 0.115789 -0.14799000000000001 0.20224600000000001
  28 | -0.069755300000000006 -0.189971 0.203538
  29 | 0.089421399999999998 -0.14169200000000001 0.17766999999999999
  30 | 0.0179858 -0.062748300000000007 0.19384000000000001
  31 | 0.061583899999999997 -0.13810500000000001 0.194768
  32 | 0.074205999999999994 -0.102758 0.184839
  33 | 0.046930199999999998 -0.088212600000000002 0.19734399999999999
  34 | -0.0189537 -0.0548943 0.18449699999999999
  35 | 0.097786799999999993 -0.113853 0.16906399999999999
  36 | 0.105563 -0.077854999999999994 0.150814
  37 | 0.0034890899999999998 -0.25760100000000002 0.14993200000000001
  38 | 0.054527699999999998 -0.30539500000000003 0.078869099999999998
  39 | 0.037334699999999998 -0.27085999999999999 0.129717
  40 | 0.115462 -0.28782400000000002 0.107331
  41 | 0.107644 -0.26939299999999999 0.13276299999999999
  42 | 0.139379 -0.246472 0.16444600000000001
  43 | 0.174202 -0.22477900000000001 0.14602000000000001
  44 | 0.14772399999999999 -0.20995800000000001 0.17122999999999999
  45 | 0.17002999999999999 -0.177203 0.16381000000000001
  46 | -0.12380099999999999 -0.23303099999999999 0.15943199999999999
  47 | -0.100601 -0.19950799999999999 0.17081299999999999
  48 | -0.13420099999999999 -0.23379900000000001 0.120069
  49 | -0.103182 -0.23328399999999999 0.18384400000000001
  50 | -0.056211799999999999 -0.246091 0.16994200000000001
  51 | -0.107886 -0.26215300000000002 0.14813499999999999
  52 | -0.110666 -0.21296100000000001 0.135738
  53 | 0.13017300000000001 -0.101438 0.13739599999999999
  54 | 0.13028999999999999 -0.143706 0.14554500000000001
  55 | 0.15129899999999999 -0.13005700000000001 0.105722
  56 | -0.030511400000000001 -0.012894600000000001 0.14163100000000001
  57 | -0.044593899999999999 -0.0366142 0.15759799999999999
  58 | 0.042457599999999998 -0.043319900000000001 0.16955300000000001
  59 | 0.0100021 -0.012095399999999999 0.15426100000000001
  60 | -0.099004900000000007 -0.099957299999999999 0.15701000000000001
  61 | -0.0774701 -0.060837299999999997 0.14538300000000001
  62 | -0.071283700000000005 -0.085439600000000004 0.17538500000000001
  63 | -0.021244800000000001 -0.27949600000000002 0.11765
  64 | -0.114283 -0.15388399999999999 0.135384
  65 | -0.12123100000000001 -0.18618499999999999 0.114649
  66 | -0.088303800000000002 -0.1845 0.14139199999999999
  67 | -0.085522899999999999 -0.16029299999999999 0.17274600000000001
  68 | -0.12066300000000001 -0.090817400000000006 0.122694
  69 | -0.139539 -0.122096 0.115672
  70 | -0.15479200000000001 -0.14102999999999999 0.088917800000000005
  71 | -0.094783400000000004 0.078528899999999999 0.14590500000000001
  72 | -0.076103400000000002 0.053740799999999998 0.098633999999999999
  73 | -0.076334600000000002 0.051191599999999997 0.147254
  74 | -0.045901200000000003 0.063315700000000003 0.121976
  75 | -0.0970028 0.111981 0.15834799999999999
  76 | -0.104904 0.11859699999999999 0.12174599999999999
  77 | -0.082597299999999998 0.091297100000000006 0.095503699999999997
  78 | -0.13333400000000001 -0.206181 0.0906222
  79 | -0.096293400000000001 0.16780200000000001 0.14551500000000001
  80 | -0.110125 0.212841 0.125891
  81 | -0.121167 0.14519899999999999 0.15981500000000001
  82 | 0.15612300000000001 -0.29096100000000003 0.1041
  83 | 0.182723 -0.27797899999999998 0.11862399999999999
  84 | 0.16636600000000001 -0.25464399999999998 0.138658
  85 | 0.096272899999999995 0.117157 0.146895
  86 | 0.065710000000000005 0.110639 0.12553700000000001
  87 | 0.095963900000000005 0.085154900000000006 0.145727
  88 | 0.072020600000000004 0.066588499999999995 0.12831200000000001
  89 | 0.097013199999999994 0.083051799999999995 0.103881
  90 | 0.12253 0.094808299999999998 0.15695300000000001
  91 | 0.120492 0.147254 0.150029
  92 | 0.0857681 0.17807100000000001 0.11987100000000001
  93 | 0.056167300000000003 0.16992199999999999 0.093327099999999996
  94 | 0.14942800000000001 0.16295599999999999 0.146652
  95 | 0.13567299999999999 0.14973600000000001 0.11451
  96 | -0.13422200000000001 -0.28313199999999999 0.109029
  97 | -0.082715399999999994 -0.27613300000000002 0.125554
  98 | -0.046825199999999997 -0.26269900000000002 0.14310400000000001
  99 | -0.068219500000000002 0.130215 0.13322100000000001
 100 | -0.062583600000000003 0.158335 0.11451699999999999
 101 | -0.031086599999999999 0.13706399999999999 0.079345600000000002
 102 | -0.079827200000000001 0.20324400000000001 0.096296000000000007
 103 | -0.057647200000000003 0.21756800000000001 0.050213599999999997
 104 | -0.078802300000000006 0.230738 0.067220600000000005
 105 | -0.108718 0.24557699999999999 0.084253599999999998
 106 | -0.159749 0.25753799999999999 0.10234500000000001
 107 | -0.16814399999999999 0.29348099999999999 0.077868199999999999
 108 | -0.147788 0.23300000000000001 0.13215299999999999
 109 | 0.043413199999999999 0.110848 0.100844
 110 | 0.040178499999999999 0.073325199999999993 0.096971000000000002
 111 | 0.074130500000000002 0.038230800000000002 0.116651
 112 | 0.077467999999999995 0.072596099999999997 0.076610899999999996
 113 | 0.15282399999999999 -0.089146600000000006 0.099670099999999998
 114 | 0.170267 -0.088321200000000002 0.065279599999999993
 115 | 0.16356799999999999 -0.084374099999999994 0.033516799999999999
 116 | 0.12529499999999999 -0.063306100000000004 0.072572300000000006
 117 | 0.121929 -0.061555800000000001 0.116007
 118 | 0.090680300000000005 -0.054064800000000003 0.127253
 119 | 0.048377400000000001 -0.012822200000000001 0.12645400000000001
 120 | -0.00031976599999999997 0.0147917 0.124053
 121 | 0.0722 -0.0479312 0.151087
 122 | -0.16053400000000001 0.21645700000000001 0.108305
 123 | -0.15545300000000001 0.196574 0.14087
 124 | -0.0316209 -0.29900900000000002 0.086673899999999998
 125 | -0.064017000000000004 -0.29402 0.097762299999999996
 126 | 0.080139699999999994 -0.0362081 0.095544199999999996
 127 | -0.102605 0.18281800000000001 0.057487700000000003
 128 | -0.122085 0.17072300000000001 0.107742
 129 | -0.134407 0.209953 0.084303500000000003
 130 | -0.058504 0.0057387100000000002 0.107305
 131 | 0.153335 -0.16014999999999999 0.11994100000000001
 132 | 0.16794899999999999 -0.15978500000000001 0.084763900000000003
 133 | 0.17710699999999999 -0.122306 0.063722299999999996
 134 | -0.14729300000000001 -0.098549200000000003 0.094508499999999995
 135 | -0.15337500000000001 -0.091649300000000003 0.065509499999999998
 136 | -0.17116899999999999 -0.12834899999999999 0.0422446
 137 | -0.15870799999999999 -0.170212 0.044566099999999997
 138 | -0.131383 -0.15431800000000001 0.019295
 139 | -0.019127700000000001 0.036884599999999997 0.091923699999999997
 140 | -0.033622899999999997 0.097606200000000004 0.099609699999999995
 141 | 0.20058300000000001 -0.185728 0.12575800000000001
 142 | 0.181229 -0.18940399999999999 0.10011299999999999
 143 | 0.15836500000000001 -0.18707099999999999 0.0751362
 144 | 0.14974299999999999 -0.31897900000000001 0.061620000000000001
 145 | 0.182757 -0.310278 0.047451500000000001
 146 | 0.19358400000000001 -0.30405900000000002 0.078873700000000005
 147 | 0.21539800000000001 -0.2833 0.076301400000000005
 148 | 0.20804 -0.24800700000000001 0.12581200000000001
 149 | 0.20219799999999999 -0.218974 0.093012800000000007
 150 | 0.19325800000000001 -0.24191799999999999 0.070507399999999998
 151 | 0.22013199999999999 -0.25435799999999997 0.088617899999999999
 152 | 0.18686900000000001 -0.26204 0.045656000000000002
 153 | 0.17649799999999999 -0.23126099999999999 0.043303800000000003
 154 | 0.17847299999999999 -0.21562100000000001 0.070392499999999997
 155 | 0.15756700000000001 -0.20782999999999999 0.045389199999999998
 156 | 0.049756700000000001 0.215005 0.056983600000000002
 157 | 0.024440099999999999 0.17542099999999999 0.046518400000000001
 158 | 0.034526899999999999 0.13541300000000001 0.077542100000000003
 159 | 0.13208 0.19103899999999999 0.14241699999999999
 160 | 0.092472100000000002 0.228738 0.091108900000000007
 161 | 0.160026 0.237094 0.117382
 162 | 0.14782200000000001 0.26888600000000001 0.085863900000000007
 163 | 0.16378200000000001 0.24326100000000001 0.086946399999999993
 164 | 0.119813 0.24865799999999999 0.100434
 165 | 0.069266099999999997 0.23997499999999999 0.052194600000000001
 166 | 0.084843600000000005 0.26101400000000002 0.036328399999999997
 167 | -0.094110600000000003 -0.060496599999999998 0.085494200000000006
 168 | -0.12545899999999999 -0.079411200000000001 0.054851200000000003
 169 | -0.15540799999999999 -0.091238600000000003 0.030953999999999999
 170 | 0.12143900000000001 -0.031801900000000001 0.058711899999999997
 171 | 0.12735299999999999 -0.050292000000000003 0.021034299999999999
 172 | 0.120214 -0.020676400000000001 0.029079899999999999
 173 | 0.11271100000000001 -0.066784200000000002 -0.012943100000000001
 174 | 0.099935800000000005 -0.0330675 -0.0067941599999999996
 175 | 0.11791 0.0073028499999999996 0.071067900000000003
 176 | -0.089279999999999998 0.136905 0.069685499999999997
 177 | -0.072546700000000006 0.092623800000000006 0.060636700000000002
 178 | -0.069607100000000005 0.062636600000000001 0.061400700000000002
 179 | -0.072652900000000006 0.039137499999999999 0.032907899999999997
 180 | -0.066292500000000004 0.074863200000000005 0.032725700000000003
 181 | -0.080170599999999995 0.019026700000000001 0.067150899999999999
 182 | -0.073209099999999999 -0.028265499999999999 0.091314400000000004
 183 | -0.101092 -0.010072899999999999 0.077712500000000004
 184 | -0.122448 0.0143245 0.048571099999999999
 185 | 0.059250799999999999 0.0085089699999999994 0.088969199999999998
 186 | 0.029128000000000001 0.0354492 0.099513699999999997
 187 | -0.032479399999999999 0.18054700000000001 0.031394100000000001
 188 | -0.043821300000000001 0.17446400000000001 0.064460199999999995
 189 | 0.019611199999999999 0.098252900000000004 0.062469700000000003
 190 | -0.15464900000000001 0.30734099999999998 0.040203200000000001
 191 | -0.12926699999999999 0.28256399999999998 0.052955099999999998
 192 | -0.106335 0.28782000000000002 0.0023095699999999999
 193 | -0.15851199999999999 0.31977 0.0046944400000000002
 194 | -0.189917 0.26591500000000001 0.0767211
 195 | -0.15536700000000001 0.25448300000000001 0.045657000000000003
 196 | -0.16947300000000001 0.272478 0.0216399
 197 | -0.14425299999999999 0.253021 0.012949199999999999
 198 | -0.153922 0.23480000000000001 0.078676999999999997
 199 | -0.13117999999999999 0.22866500000000001 0.051322399999999997
 200 | -0.119736 0.227436 0.0221581
 201 | -0.098593500000000001 0.200238 0.014561899999999999
 202 | 0.12770300000000001 0.21920999999999999 0.052716600000000002
 203 | 0.14723800000000001 0.249113 0.049948199999999998
 204 | 0.148039 0.312112 0.033595100000000003
 205 | 0.153887 -0.320017 0.030573099999999999
 206 | 0.154915 -0.27710299999999999 -0.0146064
 207 | 0.187555 -0.29424899999999998 0.0180933
 208 | 0.11597399999999999 -0.31643199999999999 0.064590300000000003
 209 | 0.116705 -0.34833900000000001 0.0085108000000000007
 210 | 0.14783199999999999 -0.31911499999999998 -0.0049484799999999999
 211 | 0.0080646499999999996 -0.32230700000000001 0.054428499999999998
 212 | 0.035775099999999997 -0.34528199999999998 0.0200094
 213 | -0.0155335 0.097866999999999996 0.070179900000000003
 214 | -0.0034822099999999999 0.071225399999999994 0.051718300000000002
 215 | -0.015625400000000001 0.137547 0.044298900000000002
 216 | 0.0029213899999999998 0.110778 0.034661200000000003
 217 | 0.090240000000000001 0.12251099999999999 0.067013600000000006
 218 | 0.084016999999999994 0.14136799999999999 0.038875100000000003
 219 | 0.073144200000000006 0.127856 0.013310900000000001
 220 | 0.11552900000000001 0.14360200000000001 0.093020900000000004
 221 | 0.120353 0.110071 0.120675
 222 | 0.14502899999999999 0.18118400000000001 0.10419200000000001
 223 | 0.094936699999999999 0.18288299999999999 0.027327600000000001
 224 | 0.115119 0.17149400000000001 0.068093100000000004
 225 | 0.10945199999999999 0.23158200000000001 0.012135699999999999
 226 | -0.11206000000000001 -0.32706400000000002 0.0459438
 227 | -0.15321499999999999 -0.17424999999999999 0.0746975
 228 | -0.12956799999999999 -0.196848 0.053624999999999999
 229 | -0.141067 -0.23752499999999999 0.0410955
 230 | -0.15224699999999999 -0.22680800000000001 0.076314000000000007
 231 | -0.15201500000000001 -0.26845400000000003 0.080279299999999998
 232 | 0.038238000000000001 0.22273200000000001 0.027681799999999999
 233 | -0.0076715000000000004 0.16042600000000001 0.0067416400000000001
 234 | 0.013770599999999999 0.20275299999999999 0.0052124199999999997
 235 | 0.0159189 0.137262 0.046341199999999999
 236 | -0.097554199999999994 0.25851000000000002 0.041233499999999999
 237 | -0.13922100000000001 -0.28823399999999999 0.036101800000000003
 238 | -0.12257999999999999 -0.25652599999999998 0.0217964
 239 | -0.141432 -0.30190899999999998 0.063952400000000006
 240 | -0.19474900000000001 0.30008299999999999 0.032770000000000001
 241 | 0.16072600000000001 -0.16772799999999999 0.029691100000000002
 242 | 0.174287 -0.12416000000000001 0.018011800000000001
 243 | 0.150921 -0.105877 0.00480664
 244 | 0.123783 -0.083543800000000001 0.013724399999999999
 245 | -0.077359399999999995 0.0638243 0.0015388400000000001
 246 | 0.078909599999999996 0.039581100000000001 0.047839399999999997
 247 | 0.094839499999999993 0.029081099999999999 0.081044000000000005
 248 | 0.061220200000000002 0.060232899999999999 0.0164516
 249 | 0.106942 0.0398482 0.0189345
 250 | 0.066969500000000001 0.077981400000000006 0.046738099999999998
 251 | 0.071296300000000007 0.097327300000000005 0.0197156
 252 | 0.122284 -0.19592300000000001 0.034596599999999998
 253 | 0.10136100000000001 -0.20916599999999999 0.012383399999999999
 254 | 0.100547 -0.18277399999999999 -0.0098118100000000007
 255 | 0.085101800000000005 -0.14691499999999999 -0.024506900000000002
 256 | 0.058246300000000001 -0.17383799999999999 -0.027914700000000001
 257 | 0.113396 -0.152559 0.0223036
 258 | 0.086816199999999996 -0.17757300000000001 0.046863000000000002
 259 | -0.15757599999999999 -0.12028999999999999 0.011842200000000001
 260 | -0.118025 -0.098458900000000002 0.0043126900000000001
 261 | -0.089194399999999993 -0.161408 0.038796400000000002
 262 | -0.099839899999999995 -0.13001699999999999 0.014545799999999999
 263 | 0.184782 0.313857 0.031947000000000003
 264 | 0.16026099999999999 0.29525499999999999 0.056954400000000002
 265 | 0.132053 0.32250699999999999 -0.035621600000000003
 266 | 0.149864 0.32616000000000001 -0.0070200000000000002
 267 | 0.10645399999999999 0.29571599999999998 0.016037699999999998
 268 | 0.18798100000000001 0.326152 -0.0109584
 269 | -0.18585299999999999 0.32194499999999998 -0.041317100000000002
 270 | -0.20350199999999999 0.331534 -0.017101100000000001
 271 | -0.228857 0.31286399999999998 -0.0077176600000000003
 272 | 0.139762 -0.240869 0.0146702
 273 | 0.16078700000000001 -0.26230799999999999 0.025233200000000001
 274 | 0.122267 -0.23780799999999999 -0.022864300000000001
 275 | -0.039864400000000001 -0.32721099999999997 0.047364999999999997
 276 | 0.0045331900000000003 -0.35425200000000001 0.0085530199999999997
 277 | 0.023339499999999999 -0.36636299999999999 -0.021604499999999999
 278 | 0.0585187 -0.36433199999999999 -0.022424400000000001
 279 | 0.087316099999999994 -0.35406700000000002 -0.0180225
 280 | 0.068299799999999994 0.071241100000000002 -0.0106921
 281 | -0.091660900000000003 -0.30451299999999998 -0.0253706
 282 | -0.08344 -0.34393400000000002 0.0066547500000000001
 283 | -0.047022500000000002 -0.352856 0.0064625300000000002
 284 | -0.025878100000000001 -0.35716900000000001 -0.025816599999999999
 285 | -0.068925799999999995 -0.18473400000000001 0.051452100000000001
 286 | -0.114755 -0.21190600000000001 0.028935800000000001
 287 | -0.085083199999999998 -0.23852999999999999 -0.0080167899999999993
 288 | -0.10188999999999999 -0.270675 0.0027053400000000001
 289 | 0.11638 0.0092122000000000002 0.0020306600000000001
 290 | 0.107268 0.014977799999999999 -0.027599599999999998
 291 | 0.0612247 0.092226100000000005 -0.031816700000000003
 292 | 0.065608 0.12901099999999999 -0.025057099999999999
 293 | 0.046304199999999997 0.130158 -0.058771799999999999
 294 | 0.053388600000000001 0.16083700000000001 -0.062486399999999998
 295 | 0.119571 -0.29997699999999999 -0.041940499999999999
 296 | -0.127585 -0.0312067 0.0373145
 297 | -0.116896 -0.058427899999999998 -0.0074835700000000002
 298 | -0.117531 -0.025460900000000002 0.0071982499999999998
 299 | -0.073269799999999996 -0.072119699999999995 -0.024908099999999999
 300 | -0.097286200000000003 -0.093298199999999998 -0.0245446
 301 | -0.078396400000000005 0.10724 0.0200357
 302 | -0.076111100000000001 0.149142 0.0097732900000000004
 303 | -0.070773000000000003 0.130296 -0.035111499999999997
 304 | -0.129471 0.24281900000000001 -0.019505700000000001
 305 | -0.107585 0.218053 -0.038651699999999997
 306 | -0.081879199999999999 0.18681900000000001 -0.020482299999999998
 307 | 0.098561300000000004 0.30191099999999998 -0.0252683
 308 | 0.117546 -0.33657700000000002 -0.026837799999999998
 309 | -0.056809900000000003 0.226659 0.0096360700000000001
 310 | -0.059187499999999997 0.241226 -0.025215000000000001
 311 | -0.082839200000000002 0.261824 0.0047736100000000002
 312 | 0.109906 -0.118602 -0.0020032700000000001
 313 | 0.092438000000000006 -0.11068600000000001 -0.026650500000000001
 314 | -0.040499 0.20183300000000001 -0.010816900000000001
 315 | -0.16314899999999999 0.27205299999999999 -0.020375299999999999
 316 | -0.19048999999999999 0.28874499999999997 -0.0117593
 317 | -0.18082200000000001 0.27365400000000001 -0.058657399999999998
 318 | -0.119617 -0.30728699999999998 0.0066730399999999999
 319 | -0.075440599999999997 0.104666 -0.050496600000000003
 320 | -0.072785100000000005 0.101492 -0.084625099999999995
 321 | -0.062073400000000001 0.077440999999999996 -0.044753099999999997
 322 | -0.079569399999999998 0.091416300000000006 -0.023230000000000001
 323 | -0.081606100000000001 0.056478100000000003 -0.031796400000000002
 324 | -0.083119200000000004 0.17949300000000001 -0.058721099999999998
 325 | -0.078231400000000006 0.144483 -0.082004999999999995
 326 | -0.078092099999999998 -0.265322 -0.030529500000000001
 327 | -0.047964600000000003 -0.10772 -0.027568200000000001
 328 | -0.082334000000000004 -0.139764 -0.017997599999999999
 329 | -0.062740799999999999 -0.18240600000000001 -0.024403500000000002
 330 | -0.075414700000000001 -0.19340599999999999 0.0149494
 331 | 0.068428000000000003 -0.085793900000000006 -0.0265822
 332 | 0.068662699999999993 -0.050991099999999998 -0.023099000000000001
 333 | 0.0244593 0.23138700000000001 -0.043436299999999997
 334 | 0.0046636500000000001 0.194774 -0.029665500000000001
 335 | -0.018944699999999998 0.16520000000000001 -0.038049899999999998
 336 | 0.0113112 -0.112772 -0.072167899999999993
 337 | -0.0026391399999999999 -0.13583999999999999 -0.038544200000000001
 338 | -0.057767199999999998 -0.073715900000000001 -0.056193300000000002
 339 | -0.023818099999999998 -0.11368 -0.063894999999999993
 340 | -0.21282699999999999 0.29568299999999997 -0.049229200000000001
 341 | -0.014908599999999999 -0.184228 -0.0143301
 342 | -0.125191 0.0087548399999999998 0.00066428199999999998
 343 | -0.121267 0.012897799999999999 -0.0295915
 344 | -0.11099100000000001 -0.021792499999999999 -0.031052099999999999
 345 | -0.096491199999999999 -0.0119372 -0.071534100000000003
 346 | -0.095135200000000003 -0.051914599999999998 -0.042938700000000003
 347 | 0.063838400000000003 -0.29506399999999999 -0.072343099999999994
 348 | 0.077225500000000002 -0.31949 -0.058343300000000001
 349 | 0.092698199999999994 -0.29008099999999998 -0.061703899999999999
 350 | 0.088440599999999994 -0.25941900000000001 -0.053579799999999997
 351 | -0.065259899999999996 -0.22694600000000001 -0.048073600000000001
 352 | 0.00057392499999999998 -0.30973600000000001 -0.072580099999999995
 353 | -0.045826499999999999 -0.30464400000000003 -0.056120099999999999
 354 | -0.034990500000000001 -0.14292199999999999 -0.0129158
 355 | 0.0091141 -0.19583500000000001 -0.040927900000000003
 356 | -0.039844900000000003 -0.20810100000000001 -0.052017800000000003
 357 | 0.036222999999999998 -0.104492 -0.053252899999999999
 358 | 0.062459099999999997 -0.046225299999999997 -0.059497399999999999
 359 | 0.046283999999999999 -0.060073599999999998 -0.092014899999999997
 360 | -0.10761900000000001 0.040203299999999997 -0.026355
 361 | -0.10594000000000001 0.036929799999999999 0.012865700000000001
 362 | -0.10399799999999999 0.063058500000000003 -0.078161800000000003
 363 | 0.081199400000000005 0.21531800000000001 -0.0323513
 364 | 0.089816599999999996 0.22639000000000001 -0.076890500000000001
 365 | 0.10979800000000001 0.25205300000000003 -0.067742999999999998
 366 | 0.13211800000000001 0.27081 -0.0572451
 367 | 0.11060300000000001 0.25632100000000002 -0.026946399999999999
 368 | 0.16416500000000001 0.29555700000000001 -0.033656499999999999
 369 | 0.066372299999999995 0.16783799999999999 -0.022039599999999999
 370 | -0.12844 0.30560999999999999 -0.023580799999999999
 371 | -0.14344499999999999 0.30484 -0.053330599999999999
 372 | -0.10335 0.28273700000000002 -0.040921300000000001
 373 | -0.16191900000000001 0.26457799999999998 -0.084975499999999995
 374 | -0.060061900000000001 -0.33557799999999999 -0.033074100000000002
 375 | 0.0061411499999999997 -0.34453899999999998 -0.049956399999999998
 376 | -0.14455799999999999 0.23896999999999999 -0.068753900000000007
 377 | 0.073976500000000001 -0.21778800000000001 -0.060189899999999998
 378 | 0.092950599999999994 -0.204565 -0.039560699999999997
 379 | 0.081090300000000004 0.28914200000000001 -0.0504089
 380 | 0.0460133 0.25382399999999999 -0.064359
 381 | 0.053762999999999998 0.25876100000000002 -0.0067628799999999998
 382 | 0.046032299999999998 -0.20499400000000001 -0.0576956
 383 | 0.0370184 -0.23725399999999999 -0.054067400000000002
 384 | 0.0051647999999999998 0.17616799999999999 -0.078736399999999998
 385 | -0.042511300000000002 0.197131 -0.060824400000000001
 386 | -0.012593 0.151254 -0.0912742
 387 | -0.110045 0.27574100000000001 -0.072207499999999994
 388 | -0.133324 0.24166099999999999 -0.099746100000000004
 389 | 0.042641699999999998 -0.34529100000000001 -0.0498913
 390 | -0.051749499999999997 -0.070523699999999995 -0.104711
 391 | -0.083632600000000001 -0.018305499999999999 -0.11944399999999999
 392 | -0.057427699999999998 -0.046411300000000003 -0.13255900000000001
 393 | -0.029279800000000002 -0.043382700000000003 -0.14452200000000001
 394 | -0.0172211 -0.0901777 -0.106307
 395 | 0.0057363400000000004 -0.061194100000000001 -0.13268099999999999
 396 | 0.023212699999999999 -0.082137799999999997 -0.10018100000000001
 397 | -0.0051511500000000002 -0.218192 -0.061626
 398 | 0.030095500000000001 -0.27510200000000001 -0.070452699999999993
 399 | -0.026049099999999999 -0.25162800000000002 -0.062840099999999996
 400 | 0.089741299999999996 -0.031144600000000001 -0.0427441
 401 | 0.086625800000000003 0.0034563200000000001 -0.074894299999999997
 402 | 0.0844612 0.045534100000000001 -0.0512443
 403 | 0.0378415 0.21795400000000001 -0.10047200000000001
 404 | 0.0247251 0.170631 -0.122679
 405 | 0.049491399999999998 -0.12621499999999999 -0.011880399999999999
 406 | 0.031544000000000003 -0.17547499999999999 -0.0061792100000000001
 407 | 0.075752200000000006 0.050419600000000002 -0.102898
 408 | 0.067118800000000006 0.087107000000000004 -0.073972899999999994
 409 | 0.197217 0.33112900000000001 -0.047485899999999998
 410 | 0.177282 0.30441499999999999 -0.081044699999999997
 411 | 0.152783 0.28725699999999998 -0.090037800000000001
 412 | 0.12723499999999999 0.31086999999999998 -0.074148099999999995
 413 | 0.0955371 0.29247499999999998 -0.081928100000000004
 414 | 0.12495299999999999 0.26703100000000002 -0.100023
 415 | 0.073916499999999996 0.26978099999999999 -0.088021299999999997
 416 | -0.11049399999999999 0.026886799999999999 -0.058187299999999997
 417 | -0.11486499999999999 0.011480300000000001 -0.085708000000000006
 418 | -0.087123000000000006 -0.035568200000000001 -0.093513299999999994
 419 | -0.047004299999999999 0.18364800000000001 -0.092801499999999995
 420 | -0.060841699999999999 0.21099499999999999 -0.094230900000000006
 421 | -0.090986800000000007 0.19715099999999999 -0.122791
 422 | 0.096925899999999995 0.22462799999999999 -0.110156
 423 | 0.065995499999999999 0.240372 -0.112696
 424 | -0.096806400000000001 0.023775399999999999 -0.116452
 425 | -0.087761400000000003 0.15701300000000001 -0.123748
 426 | -0.118801 0.196405 -0.088826699999999995
 427 | -0.099033300000000005 0.24213100000000001 -0.095106599999999999
 428 | -0.079312400000000005 0.25614100000000001 -0.054862000000000001
 429 | -0.025541100000000001 0.17014699999999999 -0.115373
 430 | 0.0540029 0.12024700000000001 -0.096271399999999993
 431 | 0.070282200000000003 0.165161 -0.11784
 432 | 0.069716500000000001 0.20012099999999999 -0.12925200000000001
 433 | 0.083409899999999995 0.19828499999999999 -0.099972099999999994
 434 | 0.066382099999999999 0.194579 -0.068725900000000006
 435 | -0.067176799999999995 0.124833 -0.14838799999999999
 436 | 0.055668000000000002 -0.00057573599999999998 -0.18209800000000001
 437 | 0.065666699999999995 0.040182599999999999 -0.15212100000000001
 438 | 0.069575999999999999 -0.026232100000000001 -0.099886000000000003
 439 | 0.058803500000000002 -0.0055927800000000003 -0.13787199999999999
 440 | 0.062514299999999995 0.087613800000000006 -0.151529
 441 | 0.061487699999999999 0.077663200000000002 -0.123143
 442 | 0.063999 0.069826799999999994 -0.19639899999999999
 443 | -0.023542500000000001 -0.0276846 -0.17605499999999999
 444 | 0.012665300000000001 -0.033835400000000002 -0.15545999999999999
 445 | 0.049623 -0.041874399999999999 -0.132969
 446 | -0.0834839 0.093796400000000002 -0.171153
 447 | -0.0903196 0.10212499999999999 -0.131994
 448 | -0.089796000000000001 0.048851199999999997 -0.16752500000000001
 449 | -0.0648899 -0.010032900000000001 -0.1628
 450 | -0.086289199999999996 0.0140333 -0.17382
 451 | -0.069706799999999999 0.0128659 -0.204487
 452 | 0.0184047 -0.039080299999999998 -0.197101
 453 | -0.0056002600000000001 -0.092355999999999994 -0.219248
 454 | -0.093457200000000004 0.0553728 -0.12313399999999999
 455 | -0.043152599999999999 0.14730699999999999 -0.14419699999999999
 456 | -0.0081874700000000005 0.14408299999999999 -0.15189900000000001
 457 | -0.041011199999999998 0.13086999999999999 -0.19532099999999999
 458 | 0.0484968 0.124068 -0.139764
 459 | 0.0302451 0.13430800000000001 -0.17358199999999999
 460 | -0.084769200000000003 0.069048600000000002 -0.20061100000000001
 461 | 0.043346999999999997 0.103981 -0.19480900000000001
 462 | -0.062876500000000002 0.097787899999999997 -0.20569299999999999
 463 | -0.065146800000000005 0.098825099999999999 -0.264428
 464 | -0.068660499999999999 0.056836699999999997 -0.224909
 465 | -0.071740600000000002 0.023375699999999999 -0.245308
 466 | -0.0195345 -0.046147500000000001 -0.20307800000000001
 467 | -0.056341799999999997 -0.017506799999999999 -0.21965299999999999
 468 | 0.0281543 -0.075552400000000006 -0.23109199999999999
 469 | 0.017744900000000001 0.126692 -0.20904400000000001
 470 | 0.0079177299999999996 -0.104354 -0.25122499999999998
 471 | -0.0286357 -0.069537500000000002 -0.23763999999999999
 472 | -0.0054270899999999999 -0.048384900000000002 -0.24654999999999999
 473 | 0.0264689 -0.018358900000000001 -0.237621
 474 | 0.036839400000000001 0.103546 -0.26554499999999998
 475 | 0.042783000000000002 0.063093999999999997 -0.26951000000000003
 476 | 0.013103800000000001 0.066875299999999999 -0.28275499999999998
 477 | 0.051323800000000003 0.059405899999999998 -0.24071400000000001
 478 | 0.0257895 0.103542 -0.233099
 479 | 0.0059844199999999998 0.092257800000000001 -0.262708
 480 | 0.055490999999999999 0.019293399999999999 -0.23033699999999999
 481 | 0.052502800000000002 0.0014751199999999999 -0.28248499999999999
 482 | 0.049409300000000003 0.038199700000000003 -0.29242099999999999
 483 | 0.042217400000000002 -0.020426900000000001 -0.26349600000000001
 484 | -0.0245661 -0.022745000000000001 -0.24182799999999999
 485 | 0.017222000000000001 -0.045539000000000003 -0.28978900000000002
 486 | -0.059899399999999998 -0.00500352 -0.27751100000000001
 487 | -0.044982899999999999 -0.03288 -0.27554400000000001
 488 | -0.0080006000000000001 -0.031139799999999999 -0.27591399999999999
 489 | -0.013575800000000001 -0.054366299999999999 -0.29485299999999998
 490 | -0.019474600000000002 -0.0686475 -0.32624199999999998
 491 | 0.020385799999999999 -0.069410799999999995 -0.320575
 492 | 0.038393200000000002 -0.0430496 -0.30507499999999999
 493 | -0.0164231 0.074523199999999998 -0.27740799999999999
 494 | -0.036837000000000002 0.096998399999999999 -0.249554
 495 | -0.053453399999999998 0.047280000000000003 -0.28245500000000001
 496 | -0.0199464 0.049737700000000003 -0.310025
 497 | -0.049804099999999997 0.0154848 -0.30714599999999997
 498 | -0.013758299999999999 0.024365999999999999 -0.32663999999999999
 499 | -0.037430900000000003 -0.018049300000000001 -0.32042300000000001
 500 | -0.0090220400000000003 -0.044655100000000003 -0.35148099999999999
 501 | 0.0272079 -0.037657700000000002 -0.33729999999999999
 502 | 0.019350099999999999 0.035961600000000003 -0.31295200000000001
 503 | 0.0261143 0.0017903400000000001 -0.32513999999999998
 504 | -0.0012436000000000001 -0.0121317 -0.350686
 505 | 3 260 365 265
 506 | 3 365 260 1
 507 | 3 0 365 1
 508 | 3 14 13 2
 509 | 3 4 2 13
 510 | 3 4 3 2
 511 | 3 3 4 17
 512 | 3 2 3 5
 513 | 3 6 3 17
 514 | 3 5 3 6
 515 | 3 5 6 28
 516 | 3 5 7 2
 517 | 3 7 8 2
 518 | 3 2 8 14
 519 | 3 8 12 14
 520 | 3 7 5 9
 521 | 3 10 8 7
 522 | 3 5 30 9
 523 | 3 9 10 7
 524 | 3 10 9 31
 525 | 3 10 11 19
 526 | 3 19 12 10
 527 | 3 12 8 10
 528 | 3 12 19 14
 529 | 3 4 13 16
 530 | 3 16 13 21
 531 | 3 21 13 14
 532 | 3 21 15 16
 533 | 3 17 4 16
 534 | 3 16 15 18
 535 | 3 18 17 16
 536 | 3 17 18 22
 537 | 3 19 25 14
 538 | 3 25 20 14
 539 | 3 34 20 47
 540 | 3 14 20 21
 541 | 3 34 21 20
 542 | 3 18 41 22
 543 | 3 41 42 22
 544 | 3 42 23 22
 545 | 3 24 22 23
 546 | 3 51 23 42
 547 | 3 24 23 51
 548 | 3 24 17 22
 549 | 3 17 24 6
 550 | 3 19 64 25
 551 | 3 64 44 25
 552 | 3 25 44 46
 553 | 3 25 46 20
 554 | 3 47 20 46
 555 | 3 51 26 24
 556 | 3 24 28 6
 557 | 3 26 28 24
 558 | 3 30 27 9
 559 | 3 28 30 5
 560 | 3 55 27 30
 561 | 3 29 30 28
 562 | 3 30 29 118
 563 | 3 118 55 30
 564 | 3 9 27 31
 565 | 3 31 27 55
 566 | 3 28 26 29
 567 | 3 26 51 32
 568 | 3 29 26 32
 569 | 3 29 33 118
 570 | 3 51 50 32
 571 | 3 33 29 32
 572 | 3 50 33 32
 573 | 3 38 21 36
 574 | 3 21 34 36
 575 | 3 34 35 36
 576 | 3 35 34 208
 577 | 3 35 38 36
 578 | 3 35 37 38
 579 | 3 205 37 35
 580 | 3 21 38 15
 581 | 3 15 38 39
 582 | 3 18 15 39
 583 | 3 41 18 39
 584 | 3 39 40 41
 585 | 3 81 40 39
 586 | 3 41 40 42
 587 | 3 42 40 145
 588 | 3 145 138 42
 589 | 3 138 139 128
 590 | 3 42 138 128
 591 | 3 128 51 42
 592 | 3 43 46 44
 593 | 3 48 43 45
 594 | 3 48 46 43
 595 | 3 46 48 47
 596 | 3 44 64 63
 597 | 3 63 49 44
 598 | 3 44 49 43
 599 | 3 49 45 43
 600 | 3 50 51 52
 601 | 3 110 50 52
 602 | 3 52 51 128
 603 | 3 128 129 52
 604 | 3 50 110 114
 605 | 3 33 50 114
 606 | 3 114 115 33
 607 | 3 33 115 118
 608 | 3 53 54 31
 609 | 3 58 53 127
 610 | 3 31 54 59
 611 | 3 58 54 53
 612 | 3 58 59 54
 613 | 3 10 31 59
 614 | 3 11 10 59
 615 | 3 55 56 31
 616 | 3 31 56 53
 617 | 3 55 116 56
 618 | 3 117 53 56
 619 | 3 58 127 179
 620 | 3 179 164 58
 621 | 3 57 58 65
 622 | 3 58 57 59
 623 | 3 57 65 61
 624 | 3 57 11 59
 625 | 3 61 11 57
 626 | 3 34 47 95
 627 | 3 34 95 60
 628 | 3 34 60 208
 629 | 3 60 95 122
 630 | 3 61 64 11
 631 | 3 61 62 63
 632 | 3 61 63 64
 633 | 3 19 11 64
 634 | 3 65 66 61
 635 | 3 61 66 67
 636 | 3 62 61 67
 637 | 3 67 224 62
 638 | 3 74 69 70
 639 | 3 70 68 74
 640 | 3 70 71 68
 641 | 3 68 71 96
 642 | 3 96 72 68
 643 | 3 68 72 73
 644 | 3 73 72 78
 645 | 3 78 72 96
 646 | 3 73 74 68
 647 | 3 173 74 73
 648 | 3 62 224 75
 649 | 3 63 62 49
 650 | 3 62 75 45
 651 | 3 45 49 62
 652 | 3 227 45 75
 653 | 3 76 78 96
 654 | 3 77 76 96
 655 | 3 78 76 77
 656 | 3 38 37 79
 657 | 3 38 79 39
 658 | 3 39 79 81
 659 | 3 79 37 205
 660 | 3 79 80 81
 661 | 3 80 145 81
 662 | 3 145 40 81
 663 | 3 218 88 87
 664 | 3 88 82 87
 665 | 3 84 87 82
 666 | 3 83 82 89
 667 | 3 83 84 82
 668 | 3 83 85 84
 669 | 3 85 108 84
 670 | 3 218 84 86
 671 | 3 218 87 84
 672 | 3 109 214 86
 673 | 3 214 218 86
 674 | 3 89 88 156
 675 | 3 82 88 89
 676 | 3 89 90 106
 677 | 3 106 83 89
 678 | 3 92 88 218
 679 | 3 91 88 92
 680 | 3 88 91 156
 681 | 3 91 92 219
 682 | 3 156 91 219
 683 | 3 94 48 93
 684 | 3 48 94 95
 685 | 3 47 48 95
 686 | 3 45 228 48
 687 | 3 228 93 48
 688 | 3 93 228 236
 689 | 3 223 94 93
 690 | 3 97 99 96
 691 | 3 99 77 96
 692 | 3 101 102 99
 693 | 3 77 99 102
 694 | 3 185 99 97
 695 | 3 96 98 97
 696 | 3 185 97 98
 697 | 3 185 184 99
 698 | 3 184 100 99
 699 | 3 100 101 99
 700 | 3 233 102 101
 701 | 3 103 102 188
 702 | 3 102 233 188
 703 | 3 104 103 188
 704 | 3 103 105 102
 705 | 3 102 105 77
 706 | 3 83 106 107
 707 | 3 85 83 107
 708 | 3 107 108 85
 709 | 3 183 108 107
 710 | 3 108 183 182
 711 | 3 108 182 244
 712 | 3 108 244 109
 713 | 3 109 84 108
 714 | 3 109 86 84
 715 | 3 244 243 109
 716 | 3 130 111 110
 717 | 3 110 111 113
 718 | 3 112 111 130
 719 | 3 112 113 111
 720 | 3 113 112 241
 721 | 3 113 114 110
 722 | 3 115 114 113
 723 | 3 123 115 113
 724 | 3 116 117 56
 725 | 3 183 117 182
 726 | 3 116 182 117
 727 | 3 183 136 117
 728 | 3 55 118 116
 729 | 3 118 115 123
 730 | 3 116 118 123
 731 | 3 116 123 182
 732 | 3 104 191 103
 733 | 3 103 119 105
 734 | 3 119 120 105
 735 | 3 195 119 103
 736 | 3 120 77 105
 737 | 3 120 78 77
 738 | 3 94 223 122
 739 | 3 122 95 94
 740 | 3 121 60 122
 741 | 3 122 208 121
 742 | 3 208 60 121
 743 | 3 113 167 123
 744 | 3 172 123 167
 745 | 3 244 182 123
 746 | 3 299 173 124
 747 | 3 125 124 173
 748 | 3 78 125 73
 749 | 3 73 125 173
 750 | 3 125 78 120
 751 | 3 120 119 125
 752 | 3 126 125 119
 753 | 3 124 125 126
 754 | 3 69 74 175
 755 | 3 70 69 127
 756 | 3 69 175 178
 757 | 3 178 127 69
 758 | 3 127 136 70
 759 | 3 71 70 136
 760 | 3 140 129 128
 761 | 3 140 238 129
 762 | 3 128 139 140
 763 | 3 130 129 238
 764 | 3 52 129 130
 765 | 3 238 239 130
 766 | 3 110 52 130
 767 | 3 66 65 131
 768 | 3 67 66 131
 769 | 3 133 67 131
 770 | 3 132 131 65
 771 | 3 132 133 131
 772 | 3 165 132 65
 773 | 3 67 133 224
 774 | 3 133 134 224
 775 | 3 134 133 135
 776 | 3 225 224 134
 777 | 3 127 53 117
 778 | 3 117 136 127
 779 | 3 71 136 211
 780 | 3 137 71 211
 781 | 3 137 211 210
 782 | 3 138 145 146
 783 | 3 139 138 146
 784 | 3 139 152 140
 785 | 3 140 152 238
 786 | 3 205 141 79
 787 | 3 79 141 143
 788 | 3 202 142 141
 789 | 3 142 143 141
 790 | 3 143 80 79
 791 | 3 143 144 80
 792 | 3 145 80 144
 793 | 3 144 148 145
 794 | 3 139 146 151
 795 | 3 145 148 146
 796 | 3 148 147 146
 797 | 3 151 146 147
 798 | 3 147 149 150
 799 | 3 147 150 152
 800 | 3 152 151 147
 801 | 3 152 139 151
 802 | 3 152 269 249
 803 | 3 152 249 238
 804 | 3 154 90 153
 805 | 3 90 154 155
 806 | 3 90 155 106
 807 | 3 89 156 161
 808 | 3 161 157 89
 809 | 3 90 89 157
 810 | 3 157 153 90
 811 | 3 153 157 162
 812 | 3 229 153 162
 813 | 3 158 161 156
 814 | 3 158 159 161
 815 | 3 158 160 159
 816 | 3 161 159 162
 817 | 3 162 157 161
 818 | 3 264 163 159
 819 | 3 163 162 159
 820 | 3 164 65 58
 821 | 3 164 165 65
 822 | 3 293 165 164
 823 | 3 165 166 132
 824 | 3 132 166 133
 825 | 3 113 241 167
 826 | 3 241 168 167
 827 | 3 167 168 169
 828 | 3 241 170 168
 829 | 3 170 169 168
 830 | 3 170 171 169
 831 | 3 171 286 169
 832 | 3 286 172 169
 833 | 3 172 167 169
 834 | 3 172 244 123
 835 | 3 172 286 246
 836 | 3 172 246 244
 837 | 3 173 299 298
 838 | 3 173 298 174
 839 | 3 74 173 174
 840 | 3 174 175 74
 841 | 3 178 175 176
 842 | 3 177 175 174
 843 | 3 176 175 177
 844 | 3 177 242 176
 845 | 3 298 177 174
 846 | 3 242 177 298
 847 | 3 176 242 358
 848 | 3 178 176 358
 849 | 3 178 179 127
 850 | 3 144 143 142
 851 | 3 204 144 142
 852 | 3 144 204 149
 853 | 3 148 144 149
 854 | 3 149 147 148
 855 | 3 164 179 180
 856 | 3 180 179 178
 857 | 3 164 180 181
 858 | 3 181 180 178
 859 | 3 181 293 164
 860 | 3 183 211 136
 861 | 3 183 107 186
 862 | 3 211 183 186
 863 | 3 100 184 306
 864 | 3 71 137 96
 865 | 3 137 98 96
 866 | 3 184 185 98
 867 | 3 98 212 184
 868 | 3 98 137 210
 869 | 3 98 210 212
 870 | 3 230 184 212
 871 | 3 186 107 106
 872 | 3 106 155 186
 873 | 3 211 186 213
 874 | 3 104 188 187
 875 | 3 188 189 187
 876 | 3 190 187 189
 877 | 3 104 187 190
 878 | 3 237 104 190
 879 | 3 191 104 237
 880 | 3 195 103 191
 881 | 3 195 191 192
 882 | 3 191 193 192
 883 | 3 196 192 194
 884 | 3 192 196 195
 885 | 3 124 126 196
 886 | 3 195 196 126
 887 | 3 119 195 126
 888 | 3 197 196 194
 889 | 3 196 197 124
 890 | 3 124 197 198
 891 | 3 124 198 299
 892 | 3 158 156 219
 893 | 3 199 160 158
 894 | 3 219 199 158
 895 | 3 199 200 160
 896 | 3 0 200 199
 897 | 3 159 160 200
 898 | 3 0 1 200
 899 | 3 200 1 261
 900 | 3 261 159 200
 901 | 3 261 201 159
 902 | 3 204 202 207
 903 | 3 204 142 202
 904 | 3 207 203 204
 905 | 3 202 141 206
 906 | 3 207 202 206
 907 | 3 273 209 208
 908 | 3 208 209 35
 909 | 3 209 205 35
 910 | 3 211 213 210
 911 | 3 213 212 210
 912 | 3 213 230 212
 913 | 3 214 109 248
 914 | 3 248 216 214
 915 | 3 216 215 214
 916 | 3 214 215 220
 917 | 3 214 217 218
 918 | 3 214 220 221
 919 | 3 221 217 214
 920 | 3 92 217 221
 921 | 3 218 217 92
 922 | 3 221 199 219
 923 | 3 220 199 221
 924 | 3 221 219 92
 925 | 3 220 222 199
 926 | 3 220 360 222
 927 | 3 222 0 199
 928 | 3 272 122 223
 929 | 3 272 208 122
 930 | 3 272 223 280
 931 | 3 225 75 224
 932 | 3 227 75 225
 933 | 3 226 227 225
 934 | 3 226 225 283
 935 | 3 228 227 226
 936 | 3 45 227 228
 937 | 3 154 153 229
 938 | 3 229 231 154
 939 | 3 230 154 231
 940 | 3 154 230 232
 941 | 3 155 154 232
 942 | 3 232 230 213
 943 | 3 213 186 232
 944 | 3 155 232 186
 945 | 3 101 100 233
 946 | 3 308 233 100
 947 | 3 188 233 308
 948 | 3 189 188 308
 949 | 3 226 235 234
 950 | 3 228 226 234
 951 | 3 236 228 234
 952 | 3 234 315 236
 953 | 3 315 223 236
 954 | 3 93 236 223
 955 | 3 237 193 191
 956 | 3 237 313 193
 957 | 3 313 312 193
 958 | 3 194 192 193
 959 | 3 130 239 112
 960 | 3 240 239 238
 961 | 3 238 254 240
 962 | 3 112 239 240
 963 | 3 240 241 112
 964 | 3 254 309 240
 965 | 3 181 178 358
 966 | 3 181 358 339
 967 | 3 246 243 244
 968 | 3 246 245 243
 969 | 3 243 245 109
 970 | 3 245 247 109
 971 | 3 247 245 248
 972 | 3 109 247 248
 973 | 3 255 249 250
 974 | 3 250 251 255
 975 | 3 254 255 251
 976 | 3 251 252 254
 977 | 3 251 375 252
 978 | 3 253 252 375
 979 | 3 252 310 309
 980 | 3 309 254 252
 981 | 3 254 249 255
 982 | 3 238 249 254
 983 | 3 133 256 135
 984 | 3 166 256 133
 985 | 3 135 256 259
 986 | 3 256 166 165
 987 | 3 165 257 256
 988 | 3 256 257 259
 989 | 3 258 135 259
 990 | 3 135 258 225
 991 | 3 135 225 134
 992 | 3 257 165 293
 993 | 3 293 294 257
 994 | 3 260 261 1
 995 | 3 260 201 261
 996 | 3 304 264 262
 997 | 3 263 262 264
 998 | 3 201 263 264
 999 | 3 264 159 201
1000 | 3 265 263 260
1001 | 3 263 201 260
1002 | 3 265 406 263
1003 | 3 262 263 406
1004 | 3 190 189 367
1005 | 3 190 266 267
1006 | 3 237 190 267
1007 | 3 190 367 368
1008 | 3 266 190 368
1009 | 3 267 266 337
1010 | 3 268 237 267
1011 | 3 150 149 269
1012 | 3 269 152 150
1013 | 3 270 269 149
1014 | 3 250 249 269
1015 | 3 269 271 250
1016 | 3 208 272 273
1017 | 3 209 273 274
1018 | 3 274 276 209
1019 | 3 274 273 280
1020 | 3 274 275 276
1021 | 3 281 274 280
1022 | 3 205 209 276
1023 | 3 276 206 141
1024 | 3 141 205 276
1025 | 3 204 203 270
1026 | 3 270 149 204
1027 | 3 269 270 203
1028 | 3 248 245 277
1029 | 3 277 288 248
1030 | 3 216 248 288
1031 | 3 220 215 216
1032 | 3 223 315 279
1033 | 3 315 278 279
1034 | 3 278 371 279
1035 | 3 371 280 279
1036 | 3 279 280 223
1037 | 3 371 281 280
1038 | 3 272 280 273
1039 | 3 225 327 283
1040 | 3 282 327 225
1041 | 3 258 282 225
1042 | 3 327 284 283
1043 | 3 226 283 284
1044 | 3 235 226 284
1045 | 3 284 285 235
1046 | 3 246 286 287
1047 | 3 287 399 246
1048 | 3 246 399 277
1049 | 3 277 245 246
1050 | 3 288 405 427
1051 | 3 399 405 288
1052 | 3 288 427 290
1053 | 3 290 289 288
1054 | 3 288 289 216
1055 | 3 290 291 366
1056 | 3 289 290 366
1057 | 3 216 289 366
1058 | 3 220 216 366
1059 | 3 203 207 292
1060 | 3 203 271 269
1061 | 3 347 271 203
1062 | 3 294 293 295
1063 | 3 294 296 297
1064 | 3 294 297 257
1065 | 3 297 296 324
1066 | 3 297 325 257
1067 | 3 259 257 325
1068 | 3 298 299 300
1069 | 3 298 300 319
1070 | 3 242 298 319
1071 | 3 242 319 320
1072 | 3 198 197 302
1073 | 3 301 197 194
1074 | 3 301 302 197
1075 | 3 198 302 303
1076 | 3 302 321 303
1077 | 3 299 198 303
1078 | 3 321 300 303
1079 | 3 300 299 303
1080 | 3 264 304 378
1081 | 3 264 378 163
1082 | 3 378 229 163
1083 | 3 162 163 229
1084 | 3 276 305 206
1085 | 3 305 207 206
1086 | 3 305 276 345
1087 | 3 292 305 345
1088 | 3 308 100 306
1089 | 3 306 307 308
1090 | 3 308 307 425
1091 | 3 308 425 369
1092 | 3 425 384 369
1093 | 3 189 308 369
1094 | 3 189 369 367
1095 | 3 240 309 241
1096 | 3 309 310 170
1097 | 3 170 241 309
1098 | 3 311 306 184
1099 | 3 184 230 311
1100 | 3 307 306 311
1101 | 3 314 370 301
1102 | 3 301 312 314
1103 | 3 193 312 301
1104 | 3 194 193 301
1105 | 3 301 370 373
1106 | 3 237 268 313
1107 | 3 314 312 313
1108 | 3 314 313 337
1109 | 3 315 234 235
1110 | 3 235 285 315
1111 | 3 315 285 323
1112 | 3 278 315 323
1113 | 3 317 316 300
1114 | 3 300 316 319
1115 | 3 316 317 318
1116 | 3 318 319 316
1117 | 3 320 318 317
1118 | 3 319 318 320
1119 | 3 300 321 322
1120 | 3 322 317 300
1121 | 3 423 422 321
1122 | 3 322 321 422
1123 | 3 284 323 285
1124 | 3 323 350 278
1125 | 3 350 371 278
1126 | 3 297 324 325
1127 | 3 335 324 296
1128 | 3 335 336 324
1129 | 3 336 334 324
1130 | 3 334 351 324
1131 | 3 325 324 351
1132 | 3 351 326 325
1133 | 3 326 327 325
1134 | 3 259 325 327
1135 | 3 258 259 327
1136 | 3 402 328 310
1137 | 3 170 310 328
1138 | 3 328 329 170
1139 | 3 170 329 171
1140 | 3 230 231 331
1141 | 3 231 229 330
1142 | 3 331 231 330
1143 | 3 331 383 332
1144 | 3 331 332 230
1145 | 3 332 311 230
1146 | 3 333 391 393
1147 | 3 334 336 333
1148 | 3 334 333 354
1149 | 3 335 391 336
1150 | 3 335 387 391
1151 | 3 333 336 391
1152 | 3 268 267 337
1153 | 3 337 266 314
1154 | 3 326 351 338
1155 | 3 327 282 258
1156 | 3 295 293 181
1157 | 3 181 339 295
1158 | 3 341 295 339
1159 | 3 339 340 341
1160 | 3 340 339 358
1161 | 3 413 342 340
1162 | 3 342 341 340
1163 | 3 294 295 341
1164 | 3 343 294 341
1165 | 3 296 294 343
1166 | 3 341 342 415
1167 | 3 415 343 341
1168 | 3 415 335 343
1169 | 3 335 296 343
1170 | 3 276 275 386
1171 | 3 386 345 276
1172 | 3 349 345 386
1173 | 3 344 345 349
1174 | 3 347 346 344
1175 | 3 345 344 346
1176 | 3 292 345 346
1177 | 3 347 292 346
1178 | 3 207 305 292
1179 | 3 203 292 347
1180 | 3 323 284 348
1181 | 3 348 396 323
1182 | 3 396 350 323
1183 | 3 349 372 350
1184 | 3 338 403 352
1185 | 3 338 352 353
1186 | 3 352 394 353
1187 | 3 326 338 353
1188 | 3 353 348 326
1189 | 3 348 284 326
1190 | 3 284 327 326
1191 | 3 396 348 353
1192 | 3 328 402 354
1193 | 3 354 333 393
1194 | 3 356 354 393
1195 | 3 328 354 356
1196 | 3 328 356 355
1197 | 3 328 355 329
1198 | 3 356 435 355
1199 | 3 329 355 397
1200 | 3 329 397 171
1201 | 3 397 355 435
1202 | 3 397 286 171
1203 | 3 320 413 357
1204 | 3 413 340 357
1205 | 3 358 357 340
1206 | 3 358 320 357
1207 | 3 242 320 358
1208 | 3 317 359 320
1209 | 3 359 413 320
1210 | 3 414 413 359
1211 | 3 414 342 413
1212 | 3 364 0 222
1213 | 3 360 364 222
1214 | 3 360 431 361
1215 | 3 361 362 360
1216 | 3 364 360 362
1217 | 3 362 363 364
1218 | 3 361 419 362
1219 | 3 362 411 363
1220 | 3 365 363 411
1221 | 3 419 411 362
1222 | 3 411 408 365
1223 | 3 364 363 365
1224 | 3 0 364 365
1225 | 3 220 366 431
1226 | 3 360 220 431
1227 | 3 291 431 366
1228 | 3 266 368 314
1229 | 3 368 370 314
1230 | 3 368 367 369
1231 | 3 368 369 384
1232 | 3 281 371 372
1233 | 3 274 281 372
1234 | 3 350 372 371
1235 | 3 372 386 274
1236 | 3 386 275 274
1237 | 3 302 301 373
1238 | 3 370 385 373
1239 | 3 302 373 385
1240 | 3 423 302 385
1241 | 3 423 321 302
1242 | 3 375 271 347
1243 | 3 347 374 375
1244 | 3 379 374 347
1245 | 3 271 375 250
1246 | 3 376 304 262
1247 | 3 376 378 304
1248 | 3 262 409 376
1249 | 3 409 410 376
1250 | 3 412 376 410
1251 | 3 376 412 377
1252 | 3 378 376 377
1253 | 3 377 330 378
1254 | 3 378 330 229
1255 | 3 379 253 374
1256 | 3 375 374 253
1257 | 3 375 251 250
1258 | 3 347 344 395
1259 | 3 380 379 347
1260 | 3 347 395 380
1261 | 3 379 380 352
1262 | 3 377 412 400
1263 | 3 400 330 377
1264 | 3 381 331 330
1265 | 3 253 379 352
1266 | 3 403 253 352
1267 | 3 403 402 253
1268 | 3 252 253 402
1269 | 3 310 252 402
1270 | 3 332 383 311
1271 | 3 311 383 307
1272 | 3 307 383 382
1273 | 3 417 382 383
1274 | 3 307 382 417
1275 | 3 424 384 425
1276 | 3 370 368 384
1277 | 3 424 385 384
1278 | 3 385 370 384
1279 | 3 408 407 365
1280 | 3 365 407 406
1281 | 3 406 265 365
1282 | 3 349 386 372
1283 | 3 415 387 335
1284 | 3 415 388 389
1285 | 3 387 415 389
1286 | 3 389 390 387
1287 | 3 391 387 390
1288 | 3 392 391 390
1289 | 3 391 392 393
1290 | 3 396 394 380
1291 | 3 394 352 380
1292 | 3 353 394 396
1293 | 3 380 395 396
1294 | 3 349 395 344
1295 | 3 395 349 396
1296 | 3 349 350 396
1297 | 3 287 286 397
1298 | 3 397 398 287
1299 | 3 287 398 399
1300 | 3 435 398 397
1301 | 3 399 288 277
1302 | 3 400 412 420
1303 | 3 400 420 429
1304 | 3 401 400 429
1305 | 3 401 429 455
1306 | 3 400 401 381
1307 | 3 381 330 400
1308 | 3 383 381 401
1309 | 3 381 383 331
1310 | 3 402 403 354
1311 | 3 354 403 334
1312 | 3 403 338 334
1313 | 3 338 351 334
1314 | 3 399 398 404
1315 | 3 399 404 405
1316 | 3 404 438 405
1317 | 3 435 356 442
1318 | 3 406 409 262
1319 | 3 407 408 409
1320 | 3 409 406 407
1321 | 3 411 409 408
1322 | 3 409 411 410
1323 | 3 411 412 410
1324 | 3 415 342 414
1325 | 3 388 415 414
1326 | 3 383 426 416
1327 | 3 426 422 417
1328 | 3 383 416 417
1329 | 3 417 416 426
1330 | 3 422 418 417
1331 | 3 417 424 425
1332 | 3 417 425 307
1333 | 3 431 430 361
1334 | 3 419 361 430
1335 | 3 411 419 420
1336 | 3 411 420 412
1337 | 3 419 429 420
1338 | 3 421 414 359
1339 | 3 359 317 451
1340 | 3 451 421 359
1341 | 3 421 388 414
1342 | 3 422 423 418
1343 | 3 423 385 418
1344 | 3 385 424 418
1345 | 3 424 417 418
1346 | 3 426 383 401
1347 | 3 401 453 426
1348 | 3 290 427 291
1349 | 3 427 428 291
1350 | 3 428 431 291
1351 | 3 427 438 455
1352 | 3 455 428 427
1353 | 3 429 428 455
1354 | 3 429 419 428
1355 | 3 419 430 428
1356 | 3 428 430 431
1357 | 3 426 452 422
1358 | 3 422 432 444
1359 | 3 444 317 422
1360 | 3 317 322 422
1361 | 3 434 433 439
1362 | 3 433 477 439
1363 | 3 434 404 436
1364 | 3 434 438 404
1365 | 3 404 398 435
1366 | 3 435 436 404
1367 | 3 433 434 436
1368 | 3 442 436 435
1369 | 3 433 436 442
1370 | 3 442 441 433
1371 | 3 434 437 438
1372 | 3 434 439 437
1373 | 3 427 405 438
1374 | 3 438 437 455
1375 | 3 439 458 437
1376 | 3 455 437 458
1377 | 3 389 388 446
1378 | 3 390 389 446
1379 | 3 441 392 390
1380 | 3 446 440 390
1381 | 3 390 440 441
1382 | 3 441 440 449
1383 | 3 433 441 449
1384 | 3 392 441 442
1385 | 3 442 356 392
1386 | 3 356 393 392
1387 | 3 422 452 432
1388 | 3 443 444 432
1389 | 3 454 432 452
1390 | 3 444 443 445
1391 | 3 445 451 444
1392 | 3 317 444 451
1393 | 3 440 446 464
1394 | 3 446 447 448
1395 | 3 448 464 446
1396 | 3 464 463 440
1397 | 3 440 463 449
1398 | 3 421 451 445
1399 | 3 445 446 421
1400 | 3 446 388 421
1401 | 3 445 447 446
1402 | 3 452 453 454
1403 | 3 453 452 426
1404 | 3 454 453 466
1405 | 3 454 459 432
1406 | 3 443 432 459
1407 | 3 453 401 455
1408 | 3 455 456 453
1409 | 3 453 456 466
1410 | 3 458 456 455
1411 | 3 458 466 456
1412 | 3 445 443 457
1413 | 3 457 461 445
1414 | 3 448 447 445
1415 | 3 461 448 445
1416 | 3 439 475 458
1417 | 3 475 466 458
1418 | 3 459 457 443
1419 | 3 461 457 459
1420 | 3 491 461 459
1421 | 3 491 460 461
1422 | 3 460 492 461
1423 | 3 492 462 461
1424 | 3 461 462 448
1425 | 3 464 448 462
1426 | 3 463 464 468
1427 | 3 450 463 468
1428 | 3 467 450 468
1429 | 3 467 465 450
1430 | 3 465 449 450
1431 | 3 449 463 450
1432 | 3 491 459 454
1433 | 3 466 475 454
1434 | 3 491 454 475
1435 | 3 491 475 476
1436 | 3 465 467 470
1437 | 3 469 467 468
1438 | 3 470 467 469
1439 | 3 465 470 449
1440 | 3 433 449 470
1441 | 3 439 474 475
1442 | 3 471 475 474
1443 | 3 474 472 471
1444 | 3 471 472 473
1445 | 3 471 473 476
1446 | 3 475 471 476
1447 | 3 477 474 439
1448 | 3 477 479 474
1449 | 3 478 479 477
1450 | 3 479 472 474
1451 | 3 479 478 500
1452 | 3 472 479 473
1453 | 3 479 499 473
1454 | 3 500 499 479
1455 | 3 464 481 468
1456 | 3 468 481 469
1457 | 3 484 481 464
1458 | 3 433 470 477
1459 | 3 470 480 477
1460 | 3 478 477 480
1461 | 3 470 469 481
1462 | 3 470 481 485
1463 | 3 482 470 485
1464 | 3 464 483 484
1465 | 3 484 483 496
1466 | 3 496 483 494
1467 | 3 487 484 496
1468 | 3 486 485 484
1469 | 3 485 481 484
1470 | 3 487 486 484
1471 | 3 485 486 482
1472 | 3 487 488 486
1473 | 3 488 482 486
1474 | 3 480 470 482
1475 | 3 482 488 480
1476 | 3 489 480 488
1477 | 3 489 478 480
1478 | 3 493 490 473
1479 | 3 476 473 490
1480 | 3 490 491 476
1481 | 3 492 490 493
1482 | 3 491 490 492
1483 | 3 492 460 491
1484 | 3 493 494 492
1485 | 3 492 494 483
1486 | 3 492 483 462
1487 | 3 483 464 462
1488 | 3 494 493 495
1489 | 3 496 494 495
1490 | 3 488 487 498
1491 | 3 487 497 498
1492 | 3 497 487 496
1493 | 3 497 496 501
1494 | 3 497 501 498
1495 | 3 498 489 488
1496 | 3 489 498 500
1497 | 3 478 489 500
1498 | 3 473 499 493
1499 | 3 495 493 499
1500 | 3 495 501 496
1501 | 3 501 495 499
1502 | 3 501 499 500
1503 | 3 498 501 500
1504 | 3 268 337 313
1505 | 


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