songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

remove last things mentionning taucs in the documentation

This commit is contained in:
Sébastien Loriot 2012-10-18 14:10:30 +00:00
parent ba2b7aef65
commit 44f980f5c9
17 changed files with 5 additions and 886 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization/extensions_and_reuse.tex
View File

@ -15,7 +15,7 @@ It may be easily generalized.
\subsection{Reusing Sparse Linear Algebra}
The \ccc{SparseLinearAlgebraTraits_d} concept and the traits classes
for \eigen, OpenNL and {\sc Taucs} are independent of the rest of the
for \eigen\ and OpenNL are independent of the rest of the
\ccc{Surface_mesh_parameterization} package, and may be reused by
\cgal\ developers for other purposes.

2
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization/introduction.tex
View File

@ -29,7 +29,7 @@ data structure.
Since parameterizing meshes require efficient representation of sparse
matrices and efficient iterative or direct linear solvers, we provide
a unified interface to linear solver libraries (\eigen\ and {\sc Taucs}),
a unified interface to a linear solver library (\eigen),
and propose a separate package devoted to OpenNL sparse
linear solver.

2
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization/solvers.tex
View File

@ -2,7 +2,7 @@
Parameterizing triangle meshes requires both efficient representation
of sparse matrices and efficient iterative or direct linear
solvers. We provide links to libraries (\eigen, {\sc Taucs})
solvers. We provide links to \eigen\ library
and include a separate package devoted to OpenNL sparse linear solver.
\subsection{List of Solvers}

2
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/Circular_border_arc_length_parameterizer_3.tex
View File

@ -114,7 +114,7 @@ Arc-length border parameterization: (u, v) values are proportional to the length
\ccExample
See \ccc{Taucs_parameterization.cpp} example.
See \ccc{Eigen_parameterization.cpp} example.
\end{ccRefClass}

2
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/Matrix.tex
View File

@ -117,10 +117,8 @@ Optimization: Caller can optimize this call by setting \ccc{new_coef} to true if
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccHasModels)
\ccc{Taucs_matrix<T>} \\
\ccc{Eigen_sparse_matrix<T>} \\
\ccc{Eigen_sparse_symmetric_matrix<T>}\\
\ccc{Taucs_symmetric_matrix<T>} \\
\ccc{OpenNL::SparseMatrix<T>} in \ccc{OpenNL} package
%END-AUTO(\ccHasModels)

2
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/SparseLinearAlgebraTraits_d.tex
View File

@ -93,8 +93,6 @@ A.\ccc{row_dimension}() == B.dimension(). A.\ccc{column_dimension}() == X.dimens
\ccHasModels
\ccRefIdfierPage{CGAL::Eigen_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_solver_traits<T>} \\
\ccc{OpenNL::DefaultLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\ccc{OpenNL::SymmetricLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\

166
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/Taucs_matrix.tex
View File

@ -1,166 +0,0 @@
% +------------------------------------------------------------------------+
% | Reference manual page: Taucs_matrix.tex
% +------------------------------------------------------------------------+
% | 21.09.2005 Laurent Saboret, Pierre Alliez, Bruno Levy
% | Package: Surface_mesh_parameterization
% |
\RCSdef{\RCSTaucsmatrixRev}{$Id$}
\RCSdefDate{\RCSTaucsmatrixDate}{$Date$}
% |
\ccRefPageBegin
%%RefPage: end of header, begin of main body
% +------------------------------------------------------------------------+
\begin{ccRefClass}{Taucs_matrix<T>}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccDefinition)
The class \ccc{Taucs_matrix} is a C++ wrapper around TAUCS' matrix type \ccc{taucs_ccs_matrix}.
This kind of matrix can be either symmetric or not. Symmetric matrices store only the lower triangle.
%END-AUTO(\ccDefinition)
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccInclude)
\ccInclude{CGAL/Taucs_matrix.h}
%END-AUTO(\ccInclude)
\ccIsModel
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccIsModel)
Model of the \ccc{SparseLinearAlgebraTraits_d::Matrix} concept.
%END-AUTO(\ccIsModel)
\ccParameters
The full template declaration is:
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccParameters)
template$<$class T$>$ \\
struct \ccc{Taucs_matrix};
\ccCommentHeading{Parameters} \\
\ccc{T}: Number type. Tested with T = \ccc{taucs_single} or \ccc{taucs_double}. May also work with T = \ccc{taucs_dcomplex} and \ccc{taucs_scomplex}.
%END-AUTO(\ccParameters)
\ccTypes
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccTypes)
\ccNestedType{NT}
{
}
\ccGlue
%END-AUTO(\ccTypes)
\ccCreation
\ccCreationVariable{M} %% choose variable name for \ccMethod
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccCreation)
\ccConstructor{Taucs_matrix(int dim, bool is_symmetric = false);}
{
Create a square matrix initialized with zeros.
\ccCommentHeading{Parameters} \\
\ccc{dim}: Matrix dimension. \ccc{is_symmetric}: Symmetric/hermitian?.
}
\ccGlue
\ccConstructor{Taucs_matrix(int rows, int columns, bool is_symmetric = false);}
{
Create a rectangular matrix initialized with zeros.
\ccPrecond rows == columns if \ccc{is_symmetric} is true.
\ccCommentHeading{Parameters} \\
\ccc{rows}: Number of rows. \ccc{columns}: Number of columns. \ccc{is_symmetric}: Symmetric/hermitian?.
}
\ccGlue
%END-AUTO(\ccCreation)
\ccOperations
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccOperations)
\ccMethod{int row_dimension() const;}
{
Return the matrix number of rows.
}
\ccGlue
\ccMethod{int column_dimension() const;}
{
Return the matrix number of columns.
}
\ccGlue
\ccMethod{T get_coef(int i, int j) const;}
{
Read access to a matrix coefficient.
\ccCommentHeading{Preconditions} \\
0 $<$= i $<$ \ccc{row_dimension}(). 0 $<$= j $<$ \ccc{column_dimension}().
}
\ccGlue
\ccMethod{void set_coef(int i, int j, T val, bool new_coef = false);}
{
Write access to a matrix coefficient: \ccc{a_ij} $<$- val. \\
Optimizations: For symmetric matrices, \ccc{Taucs_matrix} stores only the lower triangle \ccc{set_coef}() does nothing if (i, j) belongs to the upper triangle. Caller can optimize this call by setting \ccc{new_coef} to true if the coefficient does not already exist in the matrix.
\ccCommentHeading{Preconditions} \\
0 $<$= i $<$ \ccc{row_dimension}(). 0 $<$= j $<$ \ccc{column_dimension}().
}
\ccGlue
\ccMethod{void add_coef(int i, int j, T val);}
{
Write access to a matrix coefficient: \ccc{a_ij} $<$- \ccc{a_ij} + val. \\
Optimization: For symmetric matrices, \ccc{Taucs_matrix} stores only the lower triangle \ccc{add_coef}() does nothing if (i, j) belongs to the upper triangle.
\ccCommentHeading{Preconditions} \\
0 $<$= i $<$ \ccc{row_dimension}(). 0 $<$= j $<$ \ccc{column_dimension}().
}
\ccGlue
\ccMethod{const taucs_ccs_matrix* get_taucs_matrix() const;}
{
Construct and return the TAUCS matrix wrapped by this object. The TAUCS matrix returned by this method is valid only until the next call to \ccc{get_coef}(), \ccc{set_coef}() or \ccc{add_coef}().
}
\ccGlue
%END-AUTO(\ccOperations)
\ccSeeAlso
\ccRefIdfierPage{CGAL::Taucs_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_matrix<T>} \\
\ccRefIdfierPage{CGAL::Taucs_vector<T>} \\
\end{ccRefClass}
% +------------------------------------------------------------------------+
%%RefPage: end of main body, begin of footer
\ccRefPageEnd
% EOF
% +------------------------------------------------------------------------+

135
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/Taucs_solver_traits.tex
View File

@ -1,135 +0,0 @@
% +------------------------------------------------------------------------+
% | Reference manual page: Taucs_solver_traits.tex
% +------------------------------------------------------------------------+
% | 21.09.2005 Laurent Saboret, Pierre Alliez, Bruno Levy
% | Package: Surface_mesh_parameterization
% |
\RCSdef{\RCSTaucssolvertraitsRev}{$Id$}
\RCSdefDate{\RCSTaucssolvertraitsDate}{$Date$}
% |
\ccRefPageBegin
%%RefPage: end of header, begin of main body
% +------------------------------------------------------------------------+
\begin{ccRefClass}{Taucs_solver_traits<T>}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccDefinition)
The class \ccc{Taucs_solver_traits} is a traits class for solving GENERAL (aka unsymmetric) sparse linear systems using TAUCS out-of-core LU factorization.
%END-AUTO(\ccDefinition)
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccInclude)
\ccInclude{CGAL/Taucs_solver_traits.h}
%END-AUTO(\ccInclude)
\ccIsModel
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccIsModel)
Model of the \ccc{SparseLinearAlgebraTraits_d} concept.
%END-AUTO(\ccIsModel)
\ccParameters
The full template declaration is:
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccParameters)
template$<$class T$>$ \\
class \ccc{Taucs_solver_traits};
%END-AUTO(\ccParameters)
\ccTypes
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccTypes)
\ccNestedType{Matrix}
{
}
\ccGlue
\ccNestedType{Vector}
{
}
\ccGlue
\ccNestedType{NT}
{
}
\ccGlue
%END-AUTO(\ccTypes)
\ccCreation
\ccCreationVariable{solver} %% choose variable name for \ccMethod
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccCreation)
\ccConstructor{Taucs_solver_traits();}
{
Create a TAUCS sparse linear solver for GENERAL (aka unsymmetric) matrices.
}
\ccGlue
%END-AUTO(\ccCreation)
\ccOperations
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccOperations)
\ccMethod{bool linear_solver(const Matrix& A, const Vector& B, Vector& X, NT& D);}
{
Solve the sparse linear system {\em A$\ast$X = B}. Return true on success. The solution is then (1/D) $\ast$ X.
\ccCommentHeading{Preconditions} \\
A.\ccc{row_dimension}() == B.dimension(). A.\ccc{column_dimension}() == X.dimension().
}
\ccGlue
%END-AUTO(\ccOperations)
\ccSeeAlso
\ccRefIdfierPage{CGAL::Taucs_symmetric_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_matrix<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_matrix<T>} \\
\ccRefIdfierPage{CGAL::Taucs_vector<T>} \\
\ccc{OpenNL::DefaultLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\ccc{OpenNL::SymmetricLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\ccExample
See \ccc{Taucs_parameterization.cpp} example.
\end{ccRefClass}
% +------------------------------------------------------------------------+
%%RefPage: end of main body, begin of footer
\ccRefPageEnd
% EOF
% +------------------------------------------------------------------------+

131
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/Taucs_symmetric_matrix.tex
View File

@ -1,131 +0,0 @@
% +------------------------------------------------------------------------+
% | Reference manual page: Taucs_symmetric_matrix.tex
% +------------------------------------------------------------------------+
% | 21.09.2005 Laurent Saboret, Pierre Alliez, Bruno Levy
% | Package: Surface_mesh_parameterization
% |
\RCSdef{\RCSTaucssymmetricmatrixRev}{$Id$}
\RCSdefDate{\RCSTaucssymmetricmatrixDate}{$Date$}
% |
\ccRefPageBegin
%%RefPage: end of header, begin of main body
% +------------------------------------------------------------------------+
\begin{ccRefClass}{Taucs_symmetric_matrix<T>}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccDefinition)
The class \ccc{Taucs_symmetric_matrix} is a C++ wrapper around a TAUCS {\bf symmetric} matrix (type \ccc{taucs_ccs_matrix}).
Symmetric matrices store only the lower triangle.
%END-AUTO(\ccDefinition)
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccInclude)
\ccInclude{CGAL/Taucs_matrix.h}
%END-AUTO(\ccInclude)
\ccInheritsFrom
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccInheritsFrom)
\ccc{Taucs_matrix<T>}
%END-AUTO(\ccInheritsFrom)
\ccIsModel
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccIsModel)
Model of the \ccc{SparseLinearAlgebraTraits_d::Matrix} concept.
%END-AUTO(\ccIsModel)
\ccParameters
The full template declaration is:
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccParameters)
template$<$class T$>$ \\
struct \ccc{Taucs_symmetric_matrix};
\ccCommentHeading{Parameters} \\
\ccc{T}: Number type. Tested with T = \ccc{taucs_single} or \ccc{taucs_double}. May also work with T = \ccc{taucs_dcomplex} and \ccc{taucs_scomplex}.
%END-AUTO(\ccParameters)
\ccTypes
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccTypes)
\ccNestedType{NT}
{
}
\ccGlue
%END-AUTO(\ccTypes)
\ccCreation
\ccCreationVariable{M} %% choose variable name for \ccMethod
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccCreation)
\ccConstructor{Taucs_symmetric_matrix(int dim);}
{
Create a square {\bf symmetric} matrix initialized with zeros.
\ccCommentHeading{Parameters} \\
\ccc{dim}: Matrix dimension.
}
\ccGlue
\ccConstructor{Taucs_symmetric_matrix(int rows, int columns);}
{
Create a square {\bf symmetric} matrix initialized with zeros.
\ccPrecond rows == columns.
\ccCommentHeading{Parameters} \\
\ccc{rows}: Number of rows. \ccc{columns}: Number of columns.
}
\ccGlue
%END-AUTO(\ccCreation)
\ccSeeAlso
\ccRefIdfierPage{CGAL::Taucs_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_matrix<T>} \\
\ccRefIdfierPage{CGAL::Taucs_vector<T>} \\
\ccc{OpenNL::DefaultLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\ccc{OpenNL::SymmetricLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\end{ccRefClass}
% +------------------------------------------------------------------------+
%%RefPage: end of main body, begin of footer
\ccRefPageEnd
% EOF
% +------------------------------------------------------------------------+

132
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/Taucs_symmetric_solver_traits.tex
View File

@ -1,132 +0,0 @@
% +------------------------------------------------------------------------+
% | Reference manual page: Taucs_symmetric_solver_traits.tex
% +------------------------------------------------------------------------+
% | 21.09.2005 Laurent Saboret, Pierre Alliez, Bruno Levy
% | Package: Surface_mesh_parameterization
% |
\RCSdef{\RCSTaucssymmetricsolvertraitsRev}{$Id$}
\RCSdefDate{\RCSTaucssymmetricsolvertraitsDate}{$Date$}
% |
\ccRefPageBegin
%%RefPage: end of header, begin of main body
% +------------------------------------------------------------------------+
\begin{ccRefClass}{Taucs_symmetric_solver_traits<T>}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccDefinition)
The class \ccc{Taucs_symmetric_solver_traits} is a traits class for solving symmetric positive definite sparse linear systems using TAUCS solvers family. The default solver is the Multifrontal Supernodal Cholesky Factorization.
%END-AUTO(\ccDefinition)
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccInclude)
\ccInclude{CGAL/Taucs_solver_traits.h}
%END-AUTO(\ccInclude)
\ccIsModel
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccIsModel)
Model of the \ccc{SparseLinearAlgebraTraits_d} concept.
%END-AUTO(\ccIsModel)
\ccParameters
The full template declaration is:
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccParameters)
template$<$class T$>$ \\
class \ccc{Taucs_symmetric_solver_traits};
%END-AUTO(\ccParameters)
\ccTypes
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccTypes)
\ccNestedType{Matrix}
{
}
\ccGlue
\ccNestedType{Vector}
{
}
\ccGlue
\ccNestedType{NT}
{
}
\ccGlue
%END-AUTO(\ccTypes)
\ccCreation
\ccCreationVariable{solver} %% choose variable name for \ccMethod
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccCreation)
\ccConstructor{Taucs_symmetric_solver_traits(const char * options[] = NULL, const void * arguments[] = NULL);}
{
Create a TAUCS sparse linear solver for symmetric positive definite matrices. The default solver is the Multifrontal Supernodal Cholesky Factorization. See \ccc{taucs_linsolve}() documentation for the meaning of the \ccc{options} and \ccc{arguments} parameters.
\ccCommentHeading{Parameters} \\
\ccc{options}: must be persistent. \ccc{arguments}: must be persistent.
}
\ccGlue
%END-AUTO(\ccCreation)
\ccOperations
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccOperations)
\ccMethod{bool linear_solver(const Matrix& A, const Vector& B, Vector& X, NT& D);}
{
Solve the sparse linear system {\em A$\ast$X = B}. Return true on success. The solution is then (1/D) $\ast$ X.
\ccCommentHeading{Preconditions} \\
A.\ccc{row_dimension}() == B.dimension(). A.\ccc{column_dimension}() == X.dimension().
}
\ccGlue
%END-AUTO(\ccOperations)
\ccSeeAlso
\ccRefIdfierPage{CGAL::Taucs_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_matrix<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_matrix<T>} \\
\ccRefIdfierPage{CGAL::Taucs_vector<T>} \\
\ccc{OpenNL::DefaultLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\ccc{OpenNL::SymmetricLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\end{ccRefClass}
% +------------------------------------------------------------------------+
%%RefPage: end of main body, begin of footer
\ccRefPageEnd
% EOF
% +------------------------------------------------------------------------+

144
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/Taucs_vector.tex
View File

@ -1,144 +0,0 @@
% +------------------------------------------------------------------------+
% | Reference manual page: Taucs_vector.tex
% +------------------------------------------------------------------------+
% | 21.09.2005 Laurent Saboret, Pierre Alliez, Bruno Levy
% | Package: Surface_mesh_parameterization
% |
\RCSdef{\RCSTaucsvectorRev}{$Id$}
\RCSdefDate{\RCSTaucsvectorDate}{$Date$}
% |
\ccRefPageBegin
%%RefPage: end of header, begin of main body
% +------------------------------------------------------------------------+
\begin{ccRefClass}{Taucs_vector<T>}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccDefinition)
The class \ccc{Taucs_vector} is a C++ wrapper around TAUCS' vector type, which is a simple array.
%END-AUTO(\ccDefinition)
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccInclude)
\ccInclude{CGAL/Taucs_vector.h}
%END-AUTO(\ccInclude)
\ccIsModel
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccIsModel)
Model of the \ccc{SparseLinearAlgebraTraits_d::Vector} concept.
%END-AUTO(\ccIsModel)
\ccParameters
The full template declaration is:
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccParameters)
template$<$class T$>$ \\
class \ccc{Taucs_vector};
%END-AUTO(\ccParameters)
\ccTypes
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccTypes)
\ccNestedType{NT}
{
}
\ccGlue
%END-AUTO(\ccTypes)
\ccCreation
\ccCreationVariable{v} %% variable name for \ccMethod
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccCreation)
\ccConstructor{Taucs_vector(int dimension);}
{
Create a vector initialized with zeros.
}
\ccGlue
\ccConstructor{Taucs_vector(const Taucs_vector<T>& toCopy);}
{
Copy constructor.
}
\ccGlue
%END-AUTO(\ccCreation)
\ccOperations
% The section below is automatically generated. Do not edit!
%START-AUTO(\ccOperations)
\ccMethod{int dimension() const;}
{
Return the vector's number of coefficients.
}
\ccGlue
\ccMethod{T operator[](int i) const;}
{
Read/write access to a vector coefficient.
\ccCommentHeading{Preconditions} 0 $<$= i $<$ dimension().
}
\ccGlue
\ccMethod{T& operator[](int i);}
{
}
\ccGlue
\ccMethod{const T* get_taucs_vector() const;}
{
Get TAUCS vector wrapped by this object.
}
\ccGlue
\ccMethod{T* get_taucs_vector();}
{
}
\ccGlue
%END-AUTO(\ccOperations)
\ccSeeAlso
\ccRefIdfierPage{CGAL::Taucs_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_matrix<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_matrix<T>} \\
\ccc{OpenNL::DefaultLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\ccc{OpenNL::SymmetricLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\end{ccRefClass}
% +------------------------------------------------------------------------+
%%RefPage: end of main body, begin of footer
\ccRefPageEnd
% EOF
% +------------------------------------------------------------------------+

1
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/Vector.tex
View File

@ -98,7 +98,6 @@ Read/write access to a vector coefficient.
%START-AUTO(\ccHasModels)
\ccc{Eigen_vector<T>} \\
\ccc{Taucs_vector<T>} \\
\ccc{OpenNL::FullVector<T>} in \ccc{OpenNL} package
%END-AUTO(\ccHasModels)

6
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/intro.tex
View File

@ -185,17 +185,11 @@ sparse linear solvers:
\item \eigen\ 3.1 (or greater) is the library recommended by \cgal for solving sparse systems.
\item
OpenNL (authored by Bruno L{\'e}vy) is shipped with \cgal and is the default solver.
\item
{\sc Taucs} is a direct solver for sparse symmetric matrices.
It also includes an out-of-core general solver.
\end{itemize}
\ccc{OpenNL::DefaultLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\ccc{OpenNL::SymmetricLinearSolverTraits<COEFFTYPE, MATRIX, VECTOR, SOLVER>} in OpenNL package \\
\ccRefIdfierPage{CGAL::Eigen_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_solver_traits<T>} \\
\ccRefIdfierPage{CGAL::Taucs_symmetric_solver_traits<T>} \\
\ccHeading{Helper Classes}

5
Surface_mesh_parameterization/doc_tex/Surface_mesh_parameterization_ref/main.tex
View File

@ -34,11 +34,6 @@
\input{Surface_mesh_parameterization_ref/Eigen_matrix.tex}
\input{Surface_mesh_parameterization_ref/Eigen_vector.tex}
\input{Surface_mesh_parameterization_ref/Eigen_solver_traits.tex}
\input{Surface_mesh_parameterization_ref/Taucs_matrix.tex}
\input{Surface_mesh_parameterization_ref/Taucs_solver_traits.tex}
\input{Surface_mesh_parameterization_ref/Taucs_symmetric_matrix.tex}
\input{Surface_mesh_parameterization_ref/Taucs_symmetric_solver_traits.tex}
\input{Surface_mesh_parameterization_ref/Taucs_vector.tex}
\input{Surface_mesh_parameterization_ref/Two_vertices_parameterizer_3.tex}
\input{Surface_mesh_parameterization_ref/Vector.tex}

1
Surface_reconstruction_points_3/doc_tex/Surface_reconstruction_points_3/main.tex
View File

@ -13,4 +13,3 @@
\input{Surface_reconstruction_points_3/contouring}
\input{Surface_reconstruction_points_3/output}
\input{Surface_reconstruction_points_3/case_studies}
% \input{Surface_reconstruction_points_3/performances}

155
Surface_reconstruction_points_3/doc_tex/Surface_reconstruction_points_3/performances.tex
View File

@ -1,155 +0,0 @@
\section{Performances}
\label{surface_reconstruction_section_performances}
We provide some performance numbers for scanning data. We measure the Poisson implicit function computation time, the contouring time for a range of approximation distances, the memory occupancy as well as the influence of the point set simplification. The machine used is a PC running Linux 32 bits with an Intel CPU Core 2 processor clocked at 3 GHz and with 3 GB of RAM. The software is compiled with g++ 4.3.1 compiler with the 03 option which maximizes speed. All measurements were done using the \ccThirdPartyTaucs\ library even if we now recommend to use the \ccThirdPartyEigen\ library.
\subsection{Poisson implicit function}
The point set chosen for benchmarking the Poisson implicit function is the Bimba con Nastrino point set (1.6 million points) depicted by Figure~\ref{Surface_reconstruction_points_3-fig-poisson_bench}. We measure the Poisson implicit function computation (i.e., the call to \ccc{Poisson_reconstruction_function::compute_implicit_function()} denoted by Poisson solve hereafter) for this point set as well as for simplified versions obtained through random simplification. The following table provides Poisson solve computation times in seconds for an increasing number of points.
\begin{tabular}{|c|c|}
\hline
Number of points (x1000) & Poisson solve duration (in s) \\
\hline
60 & 65 \\
120 & 137 \\
250 & 282 \\
500 & 566 \\
1,000 & 1,130 \\
1,500 & 1,777 \\
1,600 & 1,919 \\
\hline
\end{tabular}
% Insert image poisson_bench.jpg/.eps
\begin{center}
\begin{ccTexOnly}
\includegraphics[width=1.0\textwidth]{Surface_reconstruction_points_3/poisson_bench}
\end{ccTexOnly}
\begin{ccHtmlOnly}
<img style="max-width: 100%;" border=0 src="./poisson_bench.jpg"><P>
\end{ccHtmlOnly}
\begin{figure}[h]
\caption{Poisson implicit function computation duration (in s)
against the number of points for the Bimba con Nastrino
point set with 1.6M points (shown)
as well as for simplified versions.}
\label{Surface_reconstruction_points_3-fig-poisson_bench}
\end{figure}
\end{center}
\subsection{Contouring}
The point set chosen for benchmarking the contouring stage is the Bimba con Nastrino point set simplified to 120k points. We measure the contouring (i.e. the call to \ccc{make_surface_mesh()}) duration and the reconstruction error for a range of approximation distances.
The reconstruction error is expressed as the average distance from input points to the reconstructed surface in mm (the Bimba con Nastrino statue is 324 mm tall).
\begin{tabular}{|c|c|c|}
\hline
Approx. distance (*average spacing) & Contouring duration (in s) & Reconstruction error (mm) \\
\hline
0.1 & 177 & 0.13 \\
0.25 & 47 & 0.155 \\
0.5 & 21 & 0.23 \\
1 & 10 & 0.4 \\
2 & 5 & 0.78 \\
\hline
\end{tabular}
% Insert image contouring_bench.jpg/.eps
\begin{center}
\begin{ccTexOnly}
\includegraphics[width=1.0\textwidth]{Surface_reconstruction_points_3/contouring_bench}
\end{ccTexOnly}
\begin{ccHtmlOnly}
<img style="max-width: 100%;" border=0 src="./contouring_bench.jpg"><P>
\end{ccHtmlOnly}
\begin{figure}[h]
\caption{Contouring duration (in s) and reconstruction error (mm)
against several approximation distance parameters
for the Bimba con Nastrino point set simplified to 120k points.}
\label{Surface_reconstruction_points_3-fig-contouring_bench}
\end{figure}
\end{center}
\subsection{Memory}
We measure the memory occupancy for the reconstruction of the full Bimba con Nastrino point set (3.8 millions points) as well as for simplified versions.\\
The Poisson implicit function computation has a memory peak when solving the Poisson linear system using the {\sc Taucs} sparse linear solver. For large point sets, it may fail to allocate big chunks of memory due to memory fragmentation.\\
The exact limit depends of the allocation scheme used by the compiler. In our experiments, a PC running Linux 32 bits can reconstruct the Bimba con Nastrino point set up to 1.6M points while Windows 32 bits is limited to 1.3M points.\\
\begin{tabular}{|c|c|}
\hline
Number of points (x1000) & Memory occupancy (MBytes) \\
\hline
60 & 330 \\
120 & 660 \\
250 & 630 \\
500 & 980 \\
1000 & 1570 \\
1200 & 1939 \\
\hline
\end{tabular}
% Insert image memory_bench.jpg/.eps
\begin{center}
\begin{ccTexOnly}
\includegraphics[width=1.0\textwidth]{Surface_reconstruction_points_3/memory_bench}
\end{ccTexOnly}
\begin{ccHtmlOnly}
<img style="max-width: 100%;" border=0 src="./memory_bench.jpg"><P>
\end{ccHtmlOnly}
\begin{figure}[h]
\caption{Memory occupancy (in MBytes) against number of points
for the Bimba con Nastrino point set with 1.2M points
as well as for simplified versions.
The best fitting line is shown.}
\label{Surface_reconstruction_points_3-fig-memory_bench}
\end{figure}
\end{center}
\subsection{Point Set Simplification}
Due to the memory limitations described above, we recommend to simplify the point sets captured by laser scanners.\\
We measure the reconstruction error for the Bimba con Nastrino point set (1.6M points) as well as for simplified versions. All reconstructions use the recommended contouring parameter approximation distance = 0.25 * the input point set's average spacing.
The reconstruction error is expressed as the average distance from input points to the reconstructed surface in mm (the Bimba con Nastrino statue is 324 mm tall).
\begin{tabular}{|c|c|}
\hline
Number of points (x1000) & Reconstruction error (mm) \\
\hline
60 & 0.27 \\
120 & 0.15 \\
250 & 0.11 \\
500 & 0.079 \\
1,000 & 0.066 \\
1,500 & 0.061 \\
1,600 & 0.06 \\
\hline
\end{tabular}
% Insert image simplification_bench.jpg/.eps
\begin{center}
\begin{ccTexOnly}
\includegraphics[width=1.0\textwidth]{Surface_reconstruction_points_3/simplification_bench}
\end{ccTexOnly}
\begin{ccHtmlOnly}
<img style="max-width: 100%;" border=0 src="./simplification_bench.jpg"><P>
\end{ccHtmlOnly}
\begin{figure}[h]
\caption{Reconstruction error (mm) against number of points
for the Bimba con Nastrino point set with 1.6M points
as well as for simplified versions.}
\label{Surface_reconstruction_points_3-fig-simplification_bench}
\end{figure}
\end{center}

3
Surface_reconstruction_points_3/doc_tex/Surface_reconstruction_points_3_ref/Poisson_reconstruction_function.tex
View File

@ -136,8 +136,7 @@ Returns a sphere bounding the inferred surface.
The function \ccc{compute_implicit_function}() must be called after the insertion of oriented points. It computes the piecewise linear scalar function operator() by: applying Delaunay refinement, solving for operator() at each vertex of the triangulation with a sparse linear solver, and shifting and orienting operator() such that it is 0 at all input points and negative inside the inferred surface.
\ccCommentHeading{Template parameters} \\
\ccc{SparseLinearAlgebraTraits_d}: Symmetric definite positive sparse linear solver.
If \eigen\ 3.1 (or greater) is available and \ccc{CGAL_EIGEN3_ENABLED} is defined, the default solver is \ccc{Eigen::ConjugateGradient},
otherwise, it is TAUCS Multifrontal Supernodal Cholesky Factorization.
If \eigen\ 3.1 (or greater) is available and \ccc{CGAL_EIGEN3_ENABLED} is defined, the default solver is \ccc{Eigen::ConjugateGradient}.
\ccCommentHeading{Returns} false if the linear solver fails.
\ccCommentHeading{Parameters} \\
\ccc{solver}: sparse linear solver.