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

Additions and changes to the manual

This commit is contained in:
Fernando Cacciola 2006-09-20 16:14:49 +00:00
parent 0627b993c8
commit 8fcf87d644
31 changed files with 350 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Cached_cost.tex
View File

@ -21,11 +21,14 @@
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccCreationVariable{d}
\ccCreationVariable{gc}
\ccDefinition
The class \ccRefName\ provides a model for the \ccc{GetCost} concept.
It directly returns the cost stored in the {\em collapse-data}.
It has one template argument: the type of surface being simplified,
which must be a model of the \ccc{TriangulatedSurfaceMesh} concept.
This model directly returns the cost stored in the cache.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Cached_cost.h}
@ -40,22 +43,22 @@ It directly returns the cost stored in the {\em collapse-data}.
\ccConstructor{Cached_cost<TSM>();}{Default constructor}
\ccHeading{Methods}
\ccMethod{template<class Collapse_data>
\ccMethod{template<class Cache>
result_type operator()( edge_descriptor const& edge
, TSM& surface
, Collapse_data const& data
, Cache const& cache
, Params const* params
) const;
}
{Returns the {\em cost} stored in \ccc{data}, whose type must be a model of
\ccc{PartialCollapseData} or \ccc{FullCollapseData}. All arguments
except \ccc{data} are ignored.
{Returns the {\em cost} stored in \ccc{cache}, whose type must be a model of
\ccc{CostCache} or \ccc{FullCache}. All arguments
except \ccc{cache} are ignored.
}
\ccSeeAlso
\ccc{PartialCollapseData}\\
\ccc{FullCollapseData}\\
\ccc{SetCollapseData}
\ccc{CostCache}\\
\ccc{FullCache}\\
\ccc{SetCache}
\end{ccRefClass}

24
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Cached_placement.tex
View File

@ -21,36 +21,42 @@
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccCreationVariable{d}
\ccCreationVariable{gp}
\ccDefinition
The class \ccRefName\ provides a model for the \ccc{GetPlacement} concept.
It directly returns the placement stored in the {\em collapse-data}.
It has one template argument: the type of surface being simplified,
which must be a model of the \ccc{TriangulatedSurfaceMesh} concept.
This model directly returns the placement stored in the cache.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Cached_placement.h}
\ccIsModel
\ccc{GetPlacement}
\ccTypes
\ccTypedef{void Params;}{The type of the parameters. (\ccc{void} since no parameters are needed).}
\ccCreation
\ccCreationVariable{gc} %% choose variable name
\ccConstructor{Cached_cost<TSM>();}{Default constructor}
\ccConstructor{Cached_placement<TSM>();}{Default constructor}
\ccHeading{Methods}
\ccMethod{template<class Collapse_data>
\ccMethod{template<class Cache>
result_type operator()( edge_descriptor const& edge
, TSM& surface
, Collapse_data const& data
, Cache const& cache
, Params const* params
) const;
}
{Returns the {\em placement} (vertex position) stored in \ccc{data}, whose type must be
a model of \ccc{FullCollapseData}. All arguments except \ccc{data} are ignored.
{Returns the {\em placement} (vertex position) stored in \ccc{cache}, whose type must be
a model of \ccc{FullCache}. All arguments except \ccc{cache} are ignored.
}
\ccSeeAlso
\ccc{FullCollapseData}\\
\ccc{SetCollapseData}
\ccc{FullCache}\\
\ccc{SetCache}
\end{ccRefClass}

22
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/CostAndPlacementCache.tex
View File

@ -14,7 +14,7 @@
%%
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefConcept}{FullCollapseData}
\begin{ccRefConcept}{CostAndPlacementCache}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[concept]{} %% add further index entries
@ -31,27 +31,27 @@ The cost and placement are stored as \ccc{boost::optional} values (i.e. they can
\ccc{Assignable}
\ccTypes
\ccNestedType{TSM}{The type of the surface to simplify}{}
\ccNestedType{TSM}{The type of the surface to simplify. Must be a \ccc{TriangulatedSurfaceMesh}.}{}
\ccGlue
\ccTypedef{typename Surface_geometric_traits<TSM>::FT FT ;}{The field type that represents the collapse cost}
\ccNestedType{FT}{A field type that represents the collapse cost.}{}
\ccGlue
\ccTypedef{typename Surface_geometric_traits<TSM>::Point Point ;}{The point type of the surface vertex}
\ccTypedef{typename halfedge_graph_traits<TSM>::Point Point ;}{The point type of the surface vertex}
\ccCreation
\ccCreationVariable{d} %% choose variable name
\ccCreationVariable{c} %% choose variable name
\ccConstructor{FullCollapseData();}{Default constructor}
\ccConstructor{CostAndPlacementCache();}{Default constructor}
\ccGlue
\ccConstructor{FullCollapseData( boost::optional<FT> const& cost, boost::optional<Point> const& placement );}
{Constructs a (full) collapse data caching the specified \ccc{cost} and \ccc{placement}}
\ccConstructor{CostAndPlacementCache( boost::optional<FT> const& cost, boost::optional<Point> const& placement );}
{Constructs a full cache storing the specified \ccc{cost} and \ccc{placement}}
\ccAccessFunctions
\ccMethod{boost::optional<FT> cost() const;}{The cached cost.}
\ccMethod{boost::optional<FT> cost() const;}{The stored cost.}
\ccGlue
\ccMethod{boost::optional<Point> placement() const;}{The cached placement.}
\ccMethod{boost::optional<Point> placement() const;}{The stored placement.}
\ccHasModels
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Full_collapse_data<TSM>}.
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Cost_and_placement_cache<TSM>}.
\end{ccRefConcept}

18
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/CostCache.tex
View File

@ -14,14 +14,14 @@
%%
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefConcept}{PartialCollapseData}
\begin{ccRefConcept}{CostCache}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[concept]{} %% add further index entries
\ccDefinition
The concept \ccRefName\ describes the requirements for the data structure that caches the {\em cost} of an {\em edge-collapse} but not its {\em placement}.
The concept \ccRefName\ describes the requirements for the data structure that caches the {\em cost} of an edge collapse but not its {\em placement}.
The cached cost is stored as an \ccc{boost::optional} value (i.e., it can be absent) because the cost function might be unable to compute it (or intentionally wants to prevent a certain edge to be collapsed).
@ -31,22 +31,22 @@ The cached cost is stored as an \ccc{boost::optional} value (i.e., it can be abs
\ccc{Assignable}
\ccTypes
\ccNestedType{TSM}{The type of the surface to simplify}{}
\ccNestedType{TSM}{The type of the surface to simplify. Must be a \ccc{TriangulatedSurfaceMesh}.}{}
\ccGlue
\ccTypedef{typename Surface_geometric_traits<TSM>::FT FT;}{The field type that represents the collapse cost}
\ccNestedType{FT}{The field type that represents the collapse cost.}{}
\ccCreation
\ccCreationVariable{d} %% choose variable name
\ccCreationVariable{c} %% choose variable name
\ccConstructor{PartialCollapseData();}{Default constructor}
\ccConstructor{CostCache();}{Default constructor}
\ccGlue
\ccConstructor{PartialCollapseData( boost::optional<FT> cost );}{Constructs a (partial) collapse data caching the specified \ccc{cost} }
\ccConstructor{CostCache( boost::optional<FT> cost );}{Constructs a partial cache storing only the specified \ccc{cost}. }
\ccAccessFunctions
\ccMethod{boost::optional<FT> cost() const;}{The cached cost.}
\ccMethod{boost::optional<FT> cost() const;}{The stored cost.}
\ccHasModels
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Partial_collapse_data<TSM>}.
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Cost_cache<TSM>}.
\end{ccRefConcept}

17
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Cost_and_placement_cache.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Surface_mesh_simplification::Full_collapse_data<TSM>}
\begin{ccRefClass}{Surface_mesh_simplification::Cost_and_placement_cache<TSM>}
%% add template arg's if necessary
@ -24,18 +24,19 @@
\ccCreationVariable{d}
\ccDefinition
The class \ccRefName\ provides a model for the \ccc{FullCollapseData} concept
which caches the {\em cost} and {\em placement} of an {\em edge-collapse}.
The class \ccRefName\ provides a model for the \ccc{CostAndPlacementCache} concept.
It has one template argument: the type of surface being simplified,
which must be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Full_collapse_data.h}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Cost_and_placement_cache.h}
\ccIsModel
\ccc{FullCollapseData}
\ccc{CostAndPlacementCache}
\ccSeeAlso
\ccc{EmptyCollapseData}\\
\ccc{PartialCollapseData}\\
\ccc{SetCollapseData}\\
\ccc{NoCache}\\
\ccc{CostCache}\\
\ccc{SetCache}\\
\ccc{GetCost}\\
\ccc{GetPlacement}\\

16
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Cost_cache.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Surface_mesh_simplification::Partial_collapse_data<TSM>}
\begin{ccRefClass}{Surface_mesh_simplification::Cost_cache<TSM>}
%% add template arg's if necessary
@ -24,18 +24,18 @@
\ccCreationVariable{d}
\ccDefinition
The class \ccRefName\ provides a model for the \ccc{PartialCollapseData} concept
which caches the {\em cost} (but not the {\em placement}) of an {\em edge-collapse}.
The class \ccRefName\ provides a model for the \ccc{CostCache} concept
which stores the {\em cost} (but not the {\em placement}) of an edge collapse.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Partial_collapse_data.h}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Cost_cache.h}
\ccIsModel
\ccc{PartialCollapseData}
\ccc{CostCache}
\ccSeeAlso
\ccc{EmptyCollapseData}\\
\ccc{FullCollapseData}\\
\ccc{SetCollapseData}\\
\ccc{NoCache}\\
\ccc{FullCache}\\
\ccc{SetCache}\\
\ccc{GetCost}\\
\ccc{GetPlacement}\\

5
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Count_ratio_stop_predicate.tex
View File

@ -24,7 +24,8 @@
\ccDefinition
The class \ccRefName\ provides a model for the \ccc{StopPredicate} concept.
It returns \ccc{true} when the number of current edges drops below a certain threshold.
It returns \ccc{true} when the relation between the initial and current number
of edges drops below a certain ratio.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_ratio_stop_pred.h}
@ -46,7 +47,7 @@ It returns \ccc{true} when the number of current edges drops below a certain thr
, size_type current_count
) const ;
}
{Returns ( $((double)current_count/ (double)initial_count) < ratio$. All other parameters ignored.}
{Returns ( $((double)current_count/ (double)initial_count) < ratio$. All other parameters are ignored.}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::Count_stop_predicate<TSM>}

2
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Count_stop_predicate.tex
View File

@ -46,7 +46,7 @@ It returns \ccc{true} when the number of current edges drops below a certain thr
, size_type current_count
) const ;
}
{Returns \ccc{current_count} $<$ \ccc{threshold}. All other parameters ignored.}
{Returns $current_count<threshold$. All other parameters are ignored.}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::Count_ratio_stop_predicate<TSM>}

10
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/EdgeCollapseSimplificationVisitor.tex
View File

@ -21,7 +21,7 @@
\ccDefinition
The concept \ccRefName\ describes the requirements for the {\em visitor object} which is used to track the edge-collapse simplification algorithm.
The concept \ccRefName\ describes the requirements for the {\em visitor object} which is used to track the edge collapse simplification algorithm.
The several callbacks given as member functions in the visitor are called from certain places in the algorithm implementation.
@ -29,15 +29,15 @@ The several callbacks given as member functions in the visitor are called from c
\ccNestedType{TSM}
{The type of the surface to simplify. Must be a model of the \ccc{TriangulatedSurfaceMesh} concept.}{}
\ccGlue
\ccNestedType{FT}{A \ccc{FieldType} representing the collapse cost}{}
\ccNestedType{FT}{A field type representing the collapse cost}{}
\ccGlue
\ccTypedef{typename boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an undirected edge of the surface.}
\ccGlue
\ccTypedef{typename CGAL::embedded_graph_traits<TSM>::Point Point;}
\ccTypedef{typename CGAL::halfedge_graph_traits<TSM>::Point Point;}
{The point type of the vertex.}
\ccGlue
\ccNestedType{size_type}{An \ccc{IntegerType} representing the number of edges}{}
\ccNestedType{size_type}{An integer type representing the number of edges}{}
\ccCreation
\ccCreationVariable{v} %% choose variable name
@ -55,7 +55,7 @@ The several callbacks given as member functions in the visitor are called from c
\ccMethod
{void OnStopConditionReached( TSM& surface ) ; }
{Called when the \ccc{StopPredicate} returned true
(but not if the algorithm terminates because the surface couldn't be simplified any futher)
(but not if the algorithm terminates because the surface couldn't be simplified any futher).
}
\ccMethod

6
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Edge_length_cost.tex
View File

@ -37,14 +37,14 @@ It computes the collapse cost as the squared length of the edge.
\ccConstructor{Edge_length_cost<TSM>();}{Default constructor}
\ccHeading{Methods}
\ccMethod{template<class Collapse_data>
\ccMethod{template<class Cache>
result_type operator()( edge_descriptor const& edge
, TSM& surface
, Collapse_data const& data
, Cache const& cache
, Params const* params
) const;
}
{Returns the {\em collaspe cost} as the squared distance between the points
{Returns the {\em collapse cost} as the squared distance between the points
of the source and target vertices of \ccc{edge}. All arguments
except \ccc{edge} and \ccc{surface} are ignored.
}

22
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/GetCost.tex
View File

@ -19,25 +19,30 @@
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[concept]{} %% add further index entries
\ccCreationVariable{gc} %% choose variable name
\ccDefinition
The concept \ccRefName\ describes the requirements for the {\em policy function object} which gets the {\em collapse cost} of an edge.
The cost returned is an \ccc{boost::optional} value (i.e. it can be absent). An {\em absent} cost could be the result of a computational limitation (such as overflow), or can be intentionally returned to prevent the edge from being collapsed.
A model of this concept can simply return the cost stored in the
passed cache object, if any, or perform the actual computation.
\ccRefines
\ccc{DefaultConstructible}
\ccc{CopyConstructible}
\ccTypes
\ccNestedType{TSM}{The type of the surface to simplify. Must be a model of the \ccc{TriangulatedSurfaceMesh} concept.}{}
\ccNestedType{TSM}{The type of the surface to simplify.
Must be a model of the \ccc{TriangulatedSurfaceMesh} concept.}{}
\ccGlue
\ccNestedType{Params}{The type of the model-specific parameters needed. Can be \ccc{void}.}{}
\ccGlue
\ccNestedType{FT}{A \ccc{FieldType} representing the collapse cost}{}
\ccNestedType{FT}{A field type representing the collapse cost}{}
\ccGlue
\ccTypedef{typename boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an {\em undirected edge} of the surface.}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}
\ccGlue
\ccTypedef{boost::optional<FT> result_type;}{The type of the result (an optional cost value).}
@ -48,19 +53,18 @@ The cost returned is an \ccc{boost::optional} value (i.e. it can be absent). An
\ccOperations
\ccMethod{template<class Collapse_data>
\ccMethod{template<class Cache>
result_type operator()( edge_descriptor const& edge
, TSM& surface
, Collapse_data const& data
, Cache const& cache
, Params const* params
) const;
}
{Computes and returns the cost of collapsing \ccc{edge} using the model-specific \ccc{params}.\\
\ccc{edge} is required to be in the \ccc{surface}.\\
The generic type \ccc{Collapse_data} must be a model of the \ccc{CollapseData} meta concept.\\
If \ccc{Collapse_data} is a model of \ccc{PartialCollapseData} or \ccc{FullCollapseData}, which means that
\ccc{data} stores a cache of the cost, a model can simply return the cost cached
in \ccc{data} (but is not required to do so).\\
If \ccc{Cache} is a model of \ccc{CostCache} or \ccc{CostAndPlacementCache},
which means that \ccc{cache} stores the cost, a model of this \ccc{GetCost} concept
can simply return the cached cost (but is not required to do so).\\
\ccc{params} can be a \ccStyle{NULL} pointer.
}

32
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/GetPlacement.tex
View File

@ -19,6 +19,7 @@
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[concept]{} %% add further index entries
\ccCreationVariable{gp} %% choose variable name
\ccDefinition
The concept \ccRefName\ describes the requirements for the {\em policy
@ -32,45 +33,46 @@ computational limitation (such as overflow), or can be intentionally
returned to prevent the edge from being collapsed.
A model of this concept can simply return the placement stored in the
passed collapse data, if any, or perform the actual computation.
passed cache object, if any, or perform the actual computation.
\ccRefines
\ccc{DefaultConstructible}
\ccc{CopyConstructible}
\ccTypes
\ccNestedType{TSM}{The type of the surface to simplify. Must be a model of the \ccc{TriangulatedSurfaceMesh} concept.}{}
\ccNestedType{TSM}{The type of the surface to simplify.
Must be a model of the \ccc{TriangulatedSurfaceMesh} concept.}{}
\ccGlue
\ccNestedType{Params}{The type of the model-specific parameters needed. Can be \ccc{void}.}{}
\ccGlue
\ccTypedef{typename Surface_geometric_traits<TSM>::Point Point;}{The point type for the surface vertex.}
\ccTypedef{typename CGAL::halfedge_graph_traits<TSM>::Point Point;}{The point type for the surface vertex.}
\ccGlue
\ccTypedef{typename boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}{A {\sc Bgl} edge descriptor representing an undirected edge of the surface.}
\ccTypedef{typename boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}
\ccGlue
\ccTypedef{boost::optional<Point> result_type;}{The type of the result (an optional point).}
\ccCreation
\ccCreationVariable{gp} %% choose variable name
\ccConstructor{GetCost();}{Default constructor}
\ccConstructor{GetPlacement();}{Default constructor}
\ccOperations
\ccMethod{template<class Collapse_data>
\ccMethod{template<class Cache>
result_type operator()( edge_descriptor const& edge
, TSM& surface
, Collapse_data const& data
, Cache const& cache
, Params const* params
) const;
}
{Computes and returns the placement, that is, the position of the vertex which replaces the collapsing \ccc{edge},
using the model-specific \ccc{params}.\\
\ccc{edge} is required to be in the \ccc{surface}.\\
The generic type \ccc{Collapse_data} must be a model of the \ccc{CollapseData} meta concept.\\
If \ccc{Collapse_data} is a model of \ccc{FullCollapseData}, which means that
\ccc{data} stores a cache of the placement, a model can simply return the placement cached
in \ccc{data} (but is not required to do so).\\
\ccc{params} can be a \ccc{NULL} pointer.
{Computes and returns the placement, that is, the position of the vertex
which replaces the collapsing \ccc{edge}, using the model-specific \ccc{params}.\\
\ccc{edge} is required to be in the \ccc{surface}.\\
If \ccc{Cache} is a model of \ccc{CostAndPlacementCache}, which means that
\ccc{cache} stores the placement, a model can simply return that
(but is not required to do so).\\
\ccc{params} can be a \ccc{NULL} pointer.
}
\ccHasModels

14
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/LindstromTurk_cost.tex
View File

@ -27,7 +27,8 @@ The class \ccRefName\ provides a model for the \ccc{GetCost} concept.
It computes the collapse cost following the Lindstrom-Turk strategy
(Section~\ref{SurfaceMeshSimplification:LindstromTurkStrategy})
as the squared length of the edge.
The class \ccRefName\ has one template arguments: the type of surface being simplified.
It be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_cost.h}
@ -39,20 +40,19 @@ as the squared length of the edge.
\ccConstructor{LindstromTurk_cost<TSM>();}{Default constructor}
\ccHeading{Methods}
\ccMethod{template<class Collapse_data>
\ccMethod{template<class Cache>
result_type operator()( edge_descriptor const& edge
, TSM& surface
, Collapse_data const& data
, Cache const& cache
, LindstromTurk_Params const* params
) const;
}
{Returns the cost of collapsing \ccc{edge}.}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_partial_collapse_data<TSM>}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_full_partial_collapse_data<TSM>}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_cost<TSM>}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_placement<TSM>}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_placement<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_params}
\end{ccRefClass}

7
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/LindstromTurk_params.tex
View File

@ -36,11 +36,10 @@ cost strategy (Section~\ref{SurfaceMeshSimplification:LindstromTurkStrategy})
{Initializes an instance which stores the given weights.}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_partial_collapse_data<TSM>}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_full_partial_collapse_data<TSM>}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_cost<TSM>}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_cost<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_placement<TSM>}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_params}
\end{ccRefClass}

11
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/LindstromTurk_placement.tex
View File

@ -27,6 +27,9 @@ The class \ccRefName\ provides a model for the \ccc{GetPlacement} concept.
It computes the collapse cost following the Lindstrom-Turk strategy
(Section~\ref{SurfaceMeshSimplification:LindstromTurkStrategy}).
The class \ccRefName\ has one template arguments: the type of surface being simplified.
It be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_placement.h}
\ccIsModel
@ -37,15 +40,19 @@ It computes the collapse cost following the Lindstrom-Turk strategy
\ccConstructor{LindstromTurk_placement<TSM>();}{Default constructor}
\ccHeading{Methods}
\ccMethod{template<class Collapse_data>
\ccMethod{template<class Cache>
result_type operator()( edge_descriptor const& edge
, TSM& surface
, Collapse_data const& data
, Cache const& cache
, LindstromTurk_params const* params
) const;
}
{Returns the position of the vertex that replaces the collapsed \ccc{edge}.}
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_cost<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_params}\\
\end{ccRefClass}
% +------------------------------------------------------------------------+

37
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/LindstromTurk_set_cost_and_placement_cache.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Surface_mesh_simplification::LindstromTurk_set_full_collapse_data<TSM>}
\begin{ccRefClass}{Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}
%% add template arg's if necessary
@ -24,27 +24,26 @@
\ccDefinition
The class \ccRefName\ provides a model for the
\ccc{SetCollpaseData} where the \ccc{CollapseData} it assigns is \ccc{Full\_collapse\_data<TSM>}
storing a cost and placement calculated following the Lindstrom-Turk strategy
\ccc{SetCache} which assigns a \ccc{Cost_and_placement_cache<TSM>} record.
The cost and placement values are calculated following the Lindstrom-Turk strategy
(Section~\ref{SurfaceMeshSimplification:LindstromTurkStrategy}).
The class \ccRefName\ has one template arguments: the type of surface being simplified.
It be a model of the \ccc{TriangulatedSurfaceMesh} concept.
It must be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccIsModel
\ccc{SetCollapseData}
\ccc{SetCache}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_set_full_collapse_data.h}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_set_cost_and_placement_cache.h}
\ccTypes
\ccTypedef{TSM TSM;}{The type of the surface to simplify. Is a model of \ccc{TriangulatedSurfaceMesh}.}
\ccGlue
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}{A {\sc Bgl} edge descriptor
representing an undirected edge of the surface.
}
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}
\ccGlue
\ccTypedef{Full_collapse_data<TSM> Collapse_data;}
{A type of collapse data which caches both the cost and placement.}
\ccTypedef{Cost_and_placement_cache<TSM> Cache;}
{A concrete type of cache assigned by this class.}
\ccGlue
\ccTypedef{typename LindstromTurk_params Cost_params;}
{The type of the parameters used by the cost computation}
@ -55,27 +54,27 @@ It be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccCreation
\ccCreationVariable{sd} %% choose variable name
\ccConstructor{LindstromTurk_set_full_collapse_data<TSM>(); }
\ccConstructor{LindstromTurk_set_cost_and_placement_cache<TSM>(); }
{Default constructor.}
\ccOperations
\ccMethod
{void operator()( Collapse_data& data
{void operator()( Cache& cache
, edge_descriptor const& edge
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
);
}
{Computes the cost \ccc{c} and placement \ccc{p}
of collapsing \ccc{edge}, using \ccc{cparams} and \ccc{pparams}.
Then constructs a \ccc{Full_collapse_data<TSM>(c,p)}
and assigns it to \ccc{data}.
Then constructs a \ccc{Cost_and_placement_cache<TSM>(c,p)}
and assigns it to \ccc{cache}.
}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_partial_collapse_data<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_cost<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_placement<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_params}

35
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/LindstromTurk_set_cost_cache.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Surface_mesh_simplification::LindstromTurk_set_partial_collapse_data<TSM>}
\begin{ccRefClass}{Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}
%% add template arg's if necessary
@ -24,7 +24,7 @@
\ccDefinition
The class \ccRefName\ provides a model for the
\ccc{SetCollpaseData} where the \ccc{CollapseData} it assigns is \ccc{Partial\_collapse\_data<TSM>}.
\ccc{SetCollpaseData} where the \ccc{Cache} it assigns is \ccc{Partial\_collapse\_cache<TSM>}.
storing a cost calculated following the Lindstrom-Turk strategy
(Section~\ref{SurfaceMeshSimplification:LindstromTurkStrategy}).
@ -32,19 +32,18 @@ The class \ccRefName\ has one template arguments: the type of surface being simp
It be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccIsModel
\ccc{SetCollapseData}
\ccc{SetCache}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_set_partial_collapse_data.h}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_set_cost_cache.h}
\ccTypes
\ccTypedef{TSM TSM;}{The type of the surface to simplify. Is a model of \ccc{TriangulatedSurfaceMesh}.}
\ccGlue
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}{A {\sc Bgl} edge descriptor
representing an {\em undirected edge} of the surface.
}
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}
\ccGlue
\ccTypedef{Partial_collapse_data<TSM> Collapse_data;}
{A type of collapse data which caches both the cost and placement.}
\ccTypedef{Cost_cache<TSM> Cache;}
{A concrete type of cache assigned by this class.}
\ccGlue
\ccTypedef{typename LindstromTurk_params Cost_params;}
{The type of the parameters used by the cost computation}
@ -55,30 +54,30 @@ It be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccCreation
\ccCreationVariable{sd} %% choose variable name
\ccConstructor{LindstromTurk_set_partial_collapse_data<TSM>(); }
\ccConstructor{LindstromTurk_set_cost_cache<TSM>(); }
{Default constructor.}
\ccOperations
\ccMethod
{void operator()( Collapse_data& data
{void operator()( Cache& cache
, edge_descriptor const& edge
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
);
}
{Computes the cost \ccc{c} and placement \ccc{p}
of collapsing \ccc{edge}, using \ccc{cparams} and \ccc{pparams}.
Then constructs a \ccc{Partial_collapse_data<TSM>(c)}
and assigns it to \ccc{data}.\\
Then constructs a \ccc{Cost_cache<TSM>(c)}
and assigns it to \ccc{cache}.\\
(Note: the LindstromTurk strategy computes the cost as a function
of the placement, that's why the placement is computed even
though is not in the data.)
though is not in the cache.)
}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_full_collapse_data<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_cost<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_placement<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_params}

7
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Midpoint_placement.tex
View File

@ -27,6 +27,9 @@
The class \ccRefName\ provides a model for the \ccc{GetPlacement} concept.
It computes the placement as the midpoint position along the edge.
The class \ccRefName\ has one template arguments: the type of surface being simplified.
It be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Midpoint_placement.h}
\ccIsModel
@ -37,10 +40,10 @@ It computes the placement as the midpoint position along the edge.
\ccConstructor{Midpoint_placement<TSM>();}{Default constructor}
\ccHeading{Methods}
\ccMethod{template<class Collapse_data>
\ccMethod{template<class Cache>
result_type operator()( edge_descriptor const& edge
, TSM& surface
, Collapse_data const& data
, Cache const& cache
, Params const* params
) const;
}

6
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/NoCache.tex
View File

@ -14,14 +14,14 @@
%%
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefConcept}{EmptyCollapseData}
\begin{ccRefConcept}{NoCache}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[concept]{} %% add further index entries
\ccDefinition
The concept \ccRefName\ describes the requirements for the data structure that caches {\em nothing} about of an {\em edge-collapse}. That is, it doesn't cache the {\em cost} nor the {\em placement}.
The concept \ccRefName\ describes the requirements for the data structure that caches {\em nothing} about of an edge collapse. That is, it doesn't cache the {\em cost} nor the {\em placement}.
The concept corresponds to an empty struct with no nested types nor members.
@ -32,7 +32,7 @@ The concept corresponds to an empty struct with no nested types nor members.
\ccHasModels
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Empty_collapse_data}.
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::No_cache}.
\end{ccRefConcept}

16
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/No_cache.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Surface_mesh_simplification::Empty_collapse_data}
\begin{ccRefClass}{Surface_mesh_simplification::No_cache}
%% add template arg's if necessary
@ -24,18 +24,18 @@
\ccCreationVariable{d}
\ccDefinition
The class \ccRefName\ provides a model for the \ccc{EmptyCollapseData} concept.
It is an empty struct which caches {\em nothing} about an {\em edge-collapse}.
The class \ccRefName\ provides a model for the \ccc{NoCache} concept.
It is an empty struct which caches {\em nothing}.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Empty_collapse_data.h}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/No_cache.h}
\ccIsModel
\ccc{EmptyCollapseData}
\ccc{NoCache}
\ccSeeAlso
\ccc{PartialCollapseData}\\
\ccc{FullCollapseData}\\
\ccc{SetCollapseData}\\
\ccc{CostCache}\\
\ccc{FullCache}\\
\ccc{SetCache}\\
\ccc{GetCost}\\
\ccc{GetPlacement}\\

51
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/SetCache.tex
View File

@ -14,7 +14,7 @@
%%
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefConcept}{SetCollapseData}
\begin{ccRefConcept}{SetCache}
%% \ccHtmlCrossLink{} %% add further rules for cross referencing links
%% \ccHtmlIndexC[concept]{} %% add further index entries
@ -22,45 +22,52 @@
\ccDefinition
The concept \ccRefName\ describes the requirements for the {\em policy function object} which assigns the {\em collapse data} of an edge.
The concept \ccRefName\ describes the requirements for the {\em policy function object} which assigns the the cache object associated to each edge.
\ccTypes
\ccNestedType{TSM}{The type of the surface to simplify. Must be a model of the \ccc{TriangulatedSurfaceMesh} concept.}{}
\ccNestedType{TSM}{The type of the surface to simplify.
Must be a model of the \ccc{TriangulatedSurfaceMesh} concept.}{}
\ccGlue
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}{A {\sc Bgl} edge descriptor representing an undirected edge of the surface.}{}
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}{}
\ccGlue
\ccNestedType{Collapse_data}{The concrete type of collapse data being assigned by this policy.}{}
\ccNestedType{Cache}{The concrete type of cache record being assigned by this policy.}{}
\ccGlue
\ccNestedType{Cost_params}{The type of the parameters to the cost subfunction. Can be \ccc{void}.}{}
\ccNestedType{Cost_params}{The type of the parameters to the cost subfunction.
Can be \ccc{void}.}{}
\ccGlue
\ccNestedType{Placement_params}{The type of the parameters to the placement subfunction. Can be \ccc{void}.}{}
\ccNestedType{Placement_params}{The type of the parameters to the placement subfunction.
Can be \ccc{void}.}{}
\ccOperations
\ccMethod
{void operator()( Collapse_data& data
{void operator()( Cache& cache
, edge_descriptor const& edge
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
);
}
{Assigns a \ccc{Collapse_data} object to \ccc{data}.\\
If \ccc{Collapse_data} is a model of \ccc{FullCollapseData}, the object assigned holds {\em cost} and {\em placement} values computed
for the given \ccc{edge} using the model-specific parameters \ccc{cparams} and \ccc{pparams}.\\
If \ccc{Collapse_data} is a model of \ccc{PartialCollapseData}, the object assigned holds only the {\em cost}, computed
using \ccc{cparams}. \ccc{pparams} is ignored and can be a null pointer.\\
If \ccc{Collapse_data} is a model of \ccc{EmptyCollapseData}, the objects assigned is a default constructed empty objects holding no values. In this case, only the \ccc{data} argument is used and the cost/placement
{Assigns a \ccc{Cache} object to \ccc{cache}.\\
If \ccc{Cache} is a model of \ccc{CostAndPlacementCache}, \ccc{cache}
holds {\em cost} and {\em placement} values precomputed for the given
\ccc{edge} using the model-specific parameters \ccc{cparams} and \ccc{pparams}.\\
If \ccc{Cache} is a model of \ccc{CostCache}, \ccc{cache} holds only
the {\em cost} precomputed using \ccc{cparams}. \ccc{pparams} is ignored
and can be a null pointer.\\
If \ccc{Cache} is a model of \ccc{NoCache}, \ccc{cache} is an
default-constructed empty struct holding no values. In this case,
only the \ccc{cache} argument is used and the cost/placement
\ccc{params} can be null pointers.\\
\ccc{edge} is required to belong to the \ccc{surface}.\\
The concrete model specifies whether \ccc{cparams} or \ccc{pparams}, when not ignored, can be null pointers.
\ccc{edge} is required to belong to the \ccc{surface}.
}
\ccHasModels
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_empty_collapse_data<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_partial_collapse_data<TSM,GetCost>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_full_collapse_data<TSM,GetCost,GetPlacement>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_no_cache<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_cost_cache<TSM,GetCost>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_cost_and_placement<TSM,GetCost,GetPlacement>}\\
\end{ccRefConcept}

55
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Set_cost_and_placement_cache.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Surface_mesh_simplification::Set_full_collapse_data<TSM,GetCost,GetPlacement>}
\begin{ccRefClass}{Surface_mesh_simplification::Set_cost_cost_and_placement_cache<TSM,GetCost,GetPlacement>}
%% add template arg's if necessary
@ -23,62 +23,61 @@
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
The class \ccRefName\ provides a model for the
\ccc{SetCollpaseData} where the \ccc{CollapseData} it assigns is \ccc{Full\_collapse\_data<TSM>}.\\
The class \ccRefName\ has three template arguments: The first is the type of surface being simplified
and must be a model of the \ccc{TriangulatedSurfaceMesh} concept. The second is the policy which actually computes the cached
cost and must be a model of the \ccc{GetCost} concept. The third is the policy computing the placement
The class \ccRefName\ provides a model for
\ccc{SetCache} which assigns a \ccc{Cost_and_placement_cache<TSM>} record.\\
The class \ccRefName\ has three template arguments: The first is the type of surface
being simplified and must be a model of the \ccc{TriangulatedSurfaceMesh} concept.
The second is the policy which actually computes the cost and must be a model
of the \ccc{GetCost} concept. The third is the policy computing the placement
and must be a model of \ccc{GetPlacement}.
\ccIsModel
\ccc{SetCollapseData}
\ccc{SetCache}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Set_partial_collapse_data.h}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Set_cost_cache.h}
\ccTypes
\ccTypedef{TSM TSM;}{The type of the surface to simplify.}
\ccGlue
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}{A {\sc Bgl} edge descriptor
representing an {\em undirected edge} of the surface.
}
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}
\ccGlue
\ccTypedef{Full_collapse_data<TSM> Collapse_data;}
{A type of collapse data which caches both the cost and placement.}
\ccTypedef{Cost_and_placement_cache<TSM> Cache;}
{A concrete type of cache assigned by this policy.}
\ccGlue
\ccTypedef{typename GetCost::Params Cost_params;}
{The type of the parameters to the \ccc{GetCost} policy.
It must be \ccc{DefaultConstructible} so it cannot be \ccc{void}.
}
It must be \ccc{DefaultConstructible} so it cannot be \ccc{void}.}
\ccGlue
\ccTypedef{typename GetPlacement::Params Placement_params;}{The type of the parameters to the
\ccc{GetPlacement} policy. It must be \ccc{DefaultConstructible} so it cannot be \ccc{void}.
}
\ccTypedef{typename GetPlacement::Params Placement_params;}
{The type of the parameters to the \ccc{GetPlacement} policy.
It must be \ccc{DefaultConstructible} so it cannot be \ccc{void}.}
\ccCreation
\ccCreationVariable{sd} %% choose variable name
\ccConstructor{Set_full_collapse_data<TSM,GetCost,GetPlacement>( GetCost const& get_cost, GetPlacement const& get_placemet); }
\ccConstructor{Set_cost_and_placement_cache<TSM,GetCost,GetPlacement>( GetCost const& get_cost, GetPlacement const& get_placemet); }
{Initializes an instance storing a const reference to the \ccc{get_cost} and \ccc{get_placement} policies which are used to actually compute the cost and placement.}
\ccOperations
\ccMethod
{void operator()( Collapse_data& data
{void operator()( Cache& cache
, edge_descriptor const& edge
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
);
}
{Calls \ccc{GetCost(edge,surface,data,cparams)} to obtain the actual cost \ccc{c}, and \ccc{GetPlacement(edge,surface,data,pparams)} to obtain the actual placement \ccc{p}. Then constructs a \ccc{Full_collapse_data<TSM>(c,p)} and assigns it to \ccc{data}.
{Calls \ccc{get_cost(edge,surface,cache,cparams)} to obtain the actual cost \ccc{c}, and \ccc{get_placement(edge,surface,cache,pparams)} to obtain the actual placement \ccc{p}. Then constructs a \ccc{Cost_and_placement_cache<TSM>(c,p)} and assigns it to \ccc{cache}.
}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::Set_empty_collapse_data<TSM,GetCost>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_partial_collapse_data<TSM,GetCost,GetPlacement>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_partial_collapse_data_LindstromTurk<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_full_collapse_data_LindstromTurk<TSM>}
\ccc{CGAL::Surface_mesh_simplification::Set_no_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_cost_cache<TSM,GetCost>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}
\end{ccRefClass}

47
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Set_cost_cache.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Surface_mesh_simplification::Set_partial_collapse_data<TSM,GetCost>}
\begin{ccRefClass}{Surface_mesh_simplification::Set_cost_cache<TSM,GetCost>}
%% add template arg's if necessary
@ -23,55 +23,60 @@
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
The class \ccRefName\ provides a model for the \ccc{SetCollpaseData}
where the \ccc{CollapseData} it assigns is
\ccc{Partial_collapse_data<TSM>}.\\ The class \ccRefName\ has two
The class \ccRefName\ provides a model for \ccc{SetCache}
which assigns a \ccc{Cost_cache<TSM>} record.\\
The class \ccRefName\ has two
template arguments: The first is the type of surface being simplified
and must be a model of the \ccc{TriangulatedSurfaceMesh} concept. The
second is the policy which actually computes the cached cost and must
second is the policy which actually computes the cost and must
be a model of the \ccc{GetCost} concept.
\ccIsModel
\ccc{SetCollapseData}
\ccc{SetCache}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Set_partial_collapse_data.h}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Set_cost_cache.h}
\ccTypes
\ccTypedef{TSM TSM;}{The type of the surface to simplify.}
\ccGlue
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}{A {\sc Bgl} edge descriptor representing an {\em undirected edge} of the surface.}
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}
\ccGlue
\ccTypedef{Partial_collapse_data<TSM> Collapse_data;}{A type of collapse data which caches only the cost.}
\ccTypedef{Cost_cache<TSM> Cache;}
{A concrete type of cache record assigned by this class.}
\ccGlue
\ccTypedef{typename GetCost::Params Cost_params;}{The type of the parameters to the \ccc{GetCost} policy. It must be \ccc{DefaultConstructible} so it cannot be \ccc{void}.}
\ccTypedef{typename GetCost::Params Cost_params;}
{The type of the parameters to the \ccc{GetCost} policy.
It must be \ccc{DefaultConstructible} so it cannot be \ccc{void}.}
\ccGlue
\ccTypedef{void Placement_params;}{The type of the unused parameters to the non-existing placement subfunction.}
\ccTypedef{void Placement_params;}
{An unused type required by the \ccc{SetCache} concept.}
\ccCreation
\ccCreationVariable{sd} %% choose variable name
\ccConstructor{Set_partial_collapse_data<TSM,GetCost>( GetCost const& get_cost); }
\ccConstructor{Set_cost_cache<TSM,GetCost>( GetCost const& get_cost); }
{Initializes an instance storing a const reference to the \ccc{get_cost} policy which is used to actually compute the cost.}
\ccOperations
\ccMethod
{void operator()( Collapse_data& data
{void operator()( Cache& cache
, edge_descriptor const& edge
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
);
}
{Calls \ccc{GetCost(edge,surface,data,cparams)} to obtain the actual collapse cost \ccc{c}. Then constructs a \ccc{Partial_collapse_data<TSM>(c)} and assigns it to \ccc{data}.
{Calls \ccc{get_cost(edge,surface,cache,cparams)} to obtain the actual collapse cost \ccc{c}. Then constructs a \ccc{Cost_cache<TSM>(c)} and assigns it to \ccc{cache}.
}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::Set_empty_collapse_data<TSM,GetCost>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_full_collapse_data<TSM,GetCost,GetPlacement>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_partial_collapse_data_LindstromTurk<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_full_collapse_data_LindstromTurk<TSM>}
\ccc{CGAL::Surface_mesh_simplification::Set_no_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_cost_and_placement_cache<TSM,GetCost,GetPlacement>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}
\end{ccRefClass}

42
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Set_no_cache.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Surface_mesh_simplification::Set_empty_collapse_data<TSM>}
\begin{ccRefClass}{Surface_mesh_simplification::Set_no_cache<TSM>}
%% add template arg's if necessary
@ -23,45 +23,47 @@
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
The class \ccRefName\ provides a model for the
\ccc{SetCollpaseData} where the \ccc{CollapseData} it assigns is \ccc{Empty_collapse_data}.\\
The class \ccRefName\ provides a model for
\ccc{SetCache} which assigns a \ccc{No_cache} record.\\
The class \ccRefName\ has one template argument: the type of surface being simplified, must be a model of the \ccc{TriangulatedSurfaceMesh} concept.
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Set_empty_collapse_data.h}
\ccInclude{CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Set_no_cache.h}
\ccTypes
\ccTypedef{TSM TSM;}{The type of the surface to simplify.}
\ccGlue
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}{A {\sc Bgl} edge descriptor
representing an undirected edge of the surface.}
\ccTypedef{boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}
\ccGlue
\ccTypedef{Empty_collapse_data<TSM> Collapse_data;}{A type of collapse data which caches nothing.}
\ccTypedef{No_cache<TSM> Cache;}
{The concrete type of cache record assigned by this class.}
\ccGlue
\ccTypedef{void Cost_params;}{The type of the unused parameters to the non-existing cost subfunction.}
\ccTypedef{void Cost_params;}
{An unused type required by the \ccc{SetCache} concept.}
\ccGlue
\ccTypedef{void Placement_params;}{The type of the unused parameters to the non-existing placement subfunction.}
\ccTypedef{void Placement_params;}
{An unused type required by the \ccc{SetCache} concept.}
\ccOperations
\ccMethod
{void operator()( Collapse_data& data
{void operator()( Cache& cache
, edge_descriptor const& edge
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
, TSM& surface
, CostParams const* cparams
, PlacementParam const* pparams
);
}
{Default constructs an instance of \ccc{Empty_collapse_data} and assigns it to \ccc{data}. All other parameters are ignored.
}
{Default constructs an instance of \ccc{No_cache} and assigns it to \ccc{cache}.}
\ccIsModel
\ccc{SetCollapseData}
\ccc{SetCache}
\ccSeeAlso
\ccc{CGAL::Surface_mesh_simplification::Set_partial_collapse_data<TSM,GetCost>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_full_collapse_data<TSM,GetCost,GetPlacement>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_partial_collapse_data_LindstromTurk<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_full_collapse_data_LindstromTurk<TSM>}
\ccc{CGAL::Surface_mesh_simplification::Set_cost_cache<TSM,GetCost>}\\
\ccc{CGAL::Surface_mesh_simplification::Set_cost_and_placement_cache<TSM,GetCost,GetPlacement>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}\\
\ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}
\end{ccRefClass}

6
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/StopPredicate.tex
View File

@ -27,12 +27,12 @@ The concept \ccRefName\ describes the requirements for the predicate which indic
\ccNestedType{TSM}
{The type of the surface to simplify. Must be a model of the \ccc{TriangulatedSurfaceMesh} concept.}{}
\ccGlue
\ccNestedType{FT}{A \ccc{FieldType} representing the collapse cost}{}
\ccNestedType{FT}{A field type representing the collapse cost}{}
\ccGlue
\ccNestedType{size_type}{An \ccc{IntegerType} representing the number of edges}{}
\ccNestedType{size_type}{An integer type representing the number of edges}{}
\ccGlue
\ccTypedef{typename boost::graph_traits<TSM>::edge_descriptor edge_descriptor;}
{A {\sc Bgl} edge descriptor representing an undirected edge of the surface.}
{A {\sc Bgl} edge descriptor representing an edge of the surface.}
\ccCreation
\ccCreationVariable{should_stop} %% choose variable name

2
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/TriangulatedSurfaceMesh.tex
View File

@ -21,7 +21,7 @@
\ccDefinition
The concept \ccRefName\ describes the requirements for the Triangulated Surface Mesh data structure.
The concept \ccRefName\ describes the requirements for the Triangulated Surface Mesh cache structure.
\ccRefines
\ccc{HalfedgeGraph}

22
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Vertex_is_fixed_property_map_always_false.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Vertex_is_fixed_property_map_always_false<TSM>}
\begin{ccRefClass}{Vertex_is_fixed_property_map_always_false<Graph>}
%% add template arg's if necessary
@ -23,15 +23,23 @@
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
The class \ccRefName\ provides a model for the concept \ccc{VertexIsFixedPropertyMap}.
It always returns false.
The class \ccRefName\ provides a model for the concept
\ccAnchor{http://www.boost.org/libs/property_map/ReadablePropertyMap.html}{ReadablePropertyMap}
that maps a vertex in a {\sc Bgl}
\ccAnchor{http://www.boost.org/libs/graph/doc/Graph.html}{graph}
to the boolean value \ccc{false}.
The template parameter \ccc{Graph} must be a model of a {\sc Bgl}
\ccAnchor{http://www.boost.org/libs/graph/doc/Graph.html}{graph}
The mapping indicates that no vertex in the surface is to be considered fixed by the \ccc{edge_collapse} algoithm.
\ccInclude{CGAL/Surface_mesh_simplification/Vertex_is_fixed_property_map_always_false.h}
\ccTypes
\ccNestedType{TSM}{The TSM template parameter.}
\ccTypedef{Graph Graph;}{The template parameter corresponding to the graph type.}
\ccTypedef{typename boost::graph_traits<TSM const>::vertex_descriptor key_type;}
\ccTypedef{typename boost::graph_traits<Graph const>::vertex_descriptor key_type;}
{The type of {\sc Bgl} vertex descriptor used as key.}
\ccCreation
@ -47,10 +55,10 @@ It always returns false.
{Returns \ccc{false}.}
\ccIsModel
\ccc{VertexIsFixedMapPropertyMap}
\ccAnchor{http://www.boost.org/libs/property_map/ReadablePropertyMap.html}{ReadablePropertyMap}
\ccSeeAlso
\ccRefIdfierPage{CGAL::Vertex_is_fixed_property_map_always_false<TSM>}\\
\ccRefIdfierPage{CGAL::Vertex_is_fixed_property_map_stored<TSM>}\\
\end{ccRefClass}

23
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/Vertex_is_fixed_property_map_stored.tex
View File

@ -15,7 +15,7 @@
%% Author(s) : Fernando Cacciola <fernando_cacciola@hotmail.com>
\begin{ccRefClass}{Vertex_is_fixed_property_map_stored<TSM>}
\begin{ccRefClass}{Vertex_is_fixed_property_map_stored<Graph>}
%% add template arg's if necessary
@ -23,15 +23,24 @@
%% \ccHtmlIndexC[class]{} %% add further index entries
\ccDefinition
The class \ccRefName\ provides a model for the concept \ccc{VertexIsFixedPropertyMap}.
It returns a flag directly stored in the surface vertex.
The class \ccRefName\ provides a model for the concept
\ccAnchor{http://www.boost.org/libs/property_map/ReadablePropertyMap.html}{ReadablePropertyMap}
that maps a vertex in a {\sc Bgl}
\ccAnchor{http://www.boost.org/libs/graph/doc/Graph.html}{graph}
to the boolean value.
The template parameter \ccc{Graph} must be a model of a {\sc Bgl}
\ccAnchor{http://www.boost.org/libs/graph/doc/Graph.html}{graph}
The mapping indicates which vertices in the surface are to be considered fixed by the \ccc{edge_collapse} algoithm.
The actual value is given by the vertex itself via its \ccc{is_fixed()} member function.
\ccInclude{CGAL/Surface_mesh_simplification/Vertex_is_fixed_property_map_stored.h}
\ccTypes
\ccNestedType{TSM}{The TSM template parameter.}
\ccTypedef{Graph Graph;}{The template parameter corresponding to the graph type.}
\ccTypedef{typename boost::graph_traits<TSM const>::vertex_descriptor key_type;}
\ccTypedef{typename boost::graph_traits<Graph const>::vertex_descriptor key_type;}
{The type of {\sc Bgl} vertex descriptor used as key.}
\ccCreation
@ -44,10 +53,10 @@ It returns a flag directly stored in the surface vertex.
\ccMethod
{reference operator[]( key_type const& vertex ) const;}
{Returns \ccc{vertex->is_fixed()}.}
{Returns \ccc{vertex->is_fixed()}}
\ccIsModel
\ccc{VertexIsFixedMapPropertyMap}
\ccAnchor{http://www.boost.org/libs/property_map/ReadablePropertyMap.html}{ReadablePropertyMap}
\ccSeeAlso
\ccRefIdfierPage{CGAL::Vertex_is_fixed_property_map_always_false<TSM>}\\

10
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/edge_collapse.tex
View File

@ -33,7 +33,7 @@ template<class TriangulatedSurfaceMesh
,class StopPredicate
,class EdgeExtraPtrMap
,class VertexIsFixedPropertyMap
,class SetCollapseData
,class SetCache
,class GetCost
,class GetPlacement
,class CostParams
@ -44,7 +44,7 @@ int edge_collapse ( TriangulatedSurfaceMesh& surface
, StopPredicate const& should_stop
, EdgeExtraPtrMap const& edge_extra_ptr_map
, VertexIsFixedPropertyMap const& vertex_is_fixed_map
, SetCollapseData const& set_collapse_data
, SetCache const& set_collapse_cache
, GetCost const& get_cost
, GetPlacement const& get_placement
, CostParams const* cost_params
@ -68,7 +68,7 @@ to a \ccc{void*&} extra-pointer per edge, as needed by the algorithm.
collapsed. The property map indicates whether a vertex is fixed or not,
and any edge incident upon a fixed vertex is not collapsed.
\ccc{set_collapse_data}, along with \ccc{get_cost} and \ccc{get_placement},
\ccc{set_collapse_cache}, along with \ccc{get_cost} and \ccc{get_placement},
are the policies which control the {\em cost-strategy}, that is,
the order in which edges are collapsed and the replacement vertex positioned.\\
\ccc{get_cost_params} and \ccc{get_placement_params} are the runtime
@ -97,7 +97,7 @@ It must be a model of \ccc{EdgeExtraPointerMap} concept
indicates whether a vertex is fixed or not.
It must be a model of \ccc{VertexIsFixedPropertyMap} concept
\ccc{SetCollaspeData} defines the type of set-collapse-data policy.
\ccc{SetCollaspeData} defines the type of set-collapse-cache policy.
It must be a model of \ccc{SetCollaspeData} concept
\ccc{GetCost} defines the type of get-cost policy.
@ -124,7 +124,7 @@ Only the first two parameters are mandatory, the rest have default values as des
\ccc{VertexIsFixedPropertyMap} defaults to \ccc{CGAL::Vertex_is_fixed_property_map_always_false<TriangulatedSurfaceMesh>()}.
\ccc{SetCollaspeData} defauls to \ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_partial_collapse_data<TriangulatedSurfaceMesh>}.
\ccc{SetCollaspeData} defauls to \ccc{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TriangulatedSurfaceMesh>}.
\ccc{GetCost} defaults to \ccc{CGAL::Surface_mesh_simplification::Cached_cost<TriangulatedSurfaceMesh>}.

29
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/intro.tex
View File

@ -27,32 +27,33 @@ by iterative edge-collapsing.
\ccHeading{Concepts}
\ccRefConceptPage{TriangulatedSurfaceMesh} \\
\ccRefConceptPage{StopPredicate} \\
\ccRefConceptPage{EmptyCollapseData} \\
\ccRefConceptPage{PartialCollapseData} \\
\ccRefConceptPage{FullCollapseData} \\
\ccRefConceptPage{SetCollapseData} \\
\ccRefConceptPage{NoCache} \\
\ccRefConceptPage{CostCache} \\
\ccRefConceptPage{CostAndPlacementCache} \\
\ccRefConceptPage{SetCache} \\
\ccRefConceptPage{GetCost} \\
\ccRefConceptPage{GetPlacement} \\
\ccRefConceptPage{VertexIsFixedPropertyMap} \\
\ccRefConceptPage{EdgeCollaspeSimplificationVisitor}
\ccHeading{Classes}
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::edge_collapse}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Count_stop_predicate<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Count_ratio_stop_predicate<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Empty_collapse_data}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Partial_collapse_data<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Full_collapse_data<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_empty_collapse_data}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::LindstromTurk_set_partial_collapse_data<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::LindstromTurk_set_full_collapse_data<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_partial_collapse_data<TSM,GetCost>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_full_collapse_data<TSM,GetCost,GetPlacement>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::No_cache}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Cost_cache<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Cost_and_placement_cache<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_no_cache}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_cost_cache<TSM,GetCost>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Set_cost_and_placement_cache<TSM,GetCost,GetPlacement>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Cached_cost<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Cached_placement<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Edge_length_cost<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Midpoint_placement<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_cache<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::LindstromTurk_set_cost_and_placement_cache<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::LindstromTurk_cost<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::LindstromTurk_placement<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::Edge_length_cost<TSM>}\\
\ccRefIdfierPage{CGAL::Surface_mesh_simplification::LindstromTurk_params}\\
\ccRefIdfierPage{CGAL::Vertex_is_fixed_property_map_always_false<TSM>}\\
\ccRefIdfierPage{CGAL::Vertex_is_fixed_property_map_stored<TSM>}\\

30
Surface_mesh_simplification/doc_tex/Surface_mesh_simplification_ref/main.tex
View File

@ -9,35 +9,33 @@
\input{Surface_mesh_simplification_ref/TriangulatedSurfaceMesh.tex}
\input{Surface_mesh_simplification_ref/StopPredicate.tex}
\input{Surface_mesh_simplification_ref/CollapseData.tex}
\input{Surface_mesh_simplification_ref/EmptyCollapseData.tex}
\input{Surface_mesh_simplification_ref/PartialCollapseData.tex}
\input{Surface_mesh_simplification_ref/FullCollapseData.tex}
\input{Surface_mesh_simplification_ref/SetCollapseData.tex}
\input{Surface_mesh_simplification_ref/NoCache.tex}
\input{Surface_mesh_simplification_ref/CostCache.tex}
\input{Surface_mesh_simplification_ref/CostAndPlacementCache.tex}
\input{Surface_mesh_simplification_ref/SetCache.tex}
\input{Surface_mesh_simplification_ref/GetCost.tex}
\input{Surface_mesh_simplification_ref/GetPlacement.tex}
\input{Surface_mesh_simplification_ref/VertexIsFixedPropertyMap.tex}
\input{Surface_mesh_simplification_ref/EdgeCollapseSimplificationVisitor.tex}
\input{Surface_mesh_simplification_ref/edge_collapse.tex}
\input{Surface_mesh_simplification_ref/Count_stop_predicate.tex}
\input{Surface_mesh_simplification_ref/Count_ratio_stop_predicate.tex}
\input{Surface_mesh_simplification_ref/Empty_collapse_data.tex}
\input{Surface_mesh_simplification_ref/Partial_collapse_data.tex}
\input{Surface_mesh_simplification_ref/Full_collapse_data.tex}
\input{Surface_mesh_simplification_ref/LindstromTurk_set_partial_collapse_data.tex}
\input{Surface_mesh_simplification_ref/LindstromTurk_set_full_collapse_data.tex}
\input{Surface_mesh_simplification_ref/Set_empty_collapse_data.tex}
\input{Surface_mesh_simplification_ref/Set_partial_collapse_data.tex}
\input{Surface_mesh_simplification_ref/Set_full_collapse_data.tex}
\input{Surface_mesh_simplification_ref/No_cache.tex}
\input{Surface_mesh_simplification_ref/Cost_cache.tex}
\input{Surface_mesh_simplification_ref/Cost_and_placement_cache.tex}
\input{Surface_mesh_simplification_ref/Set_no_cache.tex}
\input{Surface_mesh_simplification_ref/Set_cost_cache.tex}
\input{Surface_mesh_simplification_ref/Set_cost_and_placement_cache.tex}
\input{Surface_mesh_simplification_ref/Cached_cost.tex}
\input{Surface_mesh_simplification_ref/Cached_placement.tex}
\input{Surface_mesh_simplification_ref/Edge_length_cost.tex}
\input{Surface_mesh_simplification_ref/Midpoint_placement.tex}
\input{Surface_mesh_simplification_ref/LindstromTurk_params.tex}
\input{Surface_mesh_simplification_ref/LindstromTurk_cost.tex}
\input{Surface_mesh_simplification_ref/LindstromTurk_placement.tex}
\input{Surface_mesh_simplification_ref/Edge_length_cost.tex}
\input{Surface_mesh_simplification_ref/Midpoint_placement.tex}
\input{Surface_mesh_simplification_ref/LindstromTurk_set_cost_cache.tex}
\input{Surface_mesh_simplification_ref/LindstromTurk_set_cost_and_placement_cache.tex}
\input{Surface_mesh_simplification_ref/Vertex_is_fixed_property_map_always_false.tex}
\input{Surface_mesh_simplification_ref/Vertex_is_fixed_property_map_stored.tex}