decimate.h File Reference

igl::decimate implements a customizable greedy edge collapser using a priority-queue: More...

#include "igl_inline.h"
#include "decimate_callback_types.h"
#include <Eigen/Core>
#include "decimate.cpp"

Go to the source code of this file.

Namespaces
namespace	igl

Functions
bool	igl::decimate (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const size_t max_m, Eigen::MatrixXd &U, Eigen::MatrixXi &G, Eigen::VectorXi &J, Eigen::VectorXi &I)
	Assumes (V,F) is a manifold mesh (possibly with boundary) collapses edges until desired number of faces is achieved.
bool	igl::decimate (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const size_t max_m, Eigen::MatrixXd &U, Eigen::MatrixXi &G, Eigen::VectorXi &J)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
bool	igl::decimate (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const decimate_cost_and_placement_callback &cost_and_placement, const decimate_stopping_condition_callback &stopping_condition, const decimate_pre_collapse_callback &pre_collapse, const decimate_post_collapse_callback &post_collapse, const Eigen::MatrixXi &E, const Eigen::VectorXi &EMAP, const Eigen::MatrixXi &EF, const Eigen::MatrixXi &EI, Eigen::MatrixXd &U, Eigen::MatrixXi &G, Eigen::VectorXi &J, Eigen::VectorXi &I)
	Collapses edges of a closed manifold mesh (V,F) using user defined callbacks in a priority queue.
bool	igl::decimate (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const decimate_cost_and_placement_callback &cost_and_placement, const decimate_stopping_condition_callback &stopping_condition, const decimate_pre_collapse_callback &pre_collapse, const decimate_post_collapse_callback &post_collapse, Eigen::MatrixXd &U, Eigen::MatrixXi &G, Eigen::VectorXi &J, Eigen::VectorXi &I)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
bool	igl::decimate (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const decimate_cost_and_placement_callback &cost_and_placement, const decimate_stopping_condition_callback &stopping_condition, Eigen::MatrixXd &U, Eigen::MatrixXi &G, Eigen::VectorXi &J, Eigen::VectorXi &I)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Detailed Description

igl::decimate implements a customizable greedy edge collapser using a priority-queue:

 Q ← {}
 for each edge e
   cost[e], placement[e] ← cost_and_placement(e)
   Q.update( e, cost[e] )

 while Q not empty
    e ← Q.pop()
    if cost[e] is finite 
       collapse_happened_flag = false
       if pre_collapse( e ) 
         collapse_happened_flag = collapse_edge( e )
       post_collapse( e, collapse_happened_flag )
       if collapse_happened_flag
         for each neighbor edge f
           cost[f], placement[f] ← cost_and_placement(f)
           Q.update( f, cost[f] )
         if stopping_condition()
           break
       else
          cost[ e ] = ∞
           Q.update( e, cost[e] )

There are four important callbacks that can be customized (decimate_callback_types.h). Note that any of these functions can capture user-defined book-keeping variables.

cost_and_placement This function is called for every original edge before the queue processing starts and then on the “neighbors” (edges in the two-ring) of a successfully collapsed edge. The function should output a cost that would be paid if the given edge were to be collapsed to a single vertex and the positional placement of that new vertex. Outputting a cost of ∞ guarantees that the edge will not be collapsed.

pre_collapse This function is called just before collapse_edge is attempted. If this function returns false then the collapse is aborted. This callback is an opportunity for callers to conduct a final check whether the collapse should really take place (e.g., based on the most current information, which may not be available at the time that cost_and_placement was called). This is rarely necessary and its preferred to use cost_and_placement to assign uncollapsible edges ∞ cost if possible.

post_collapse This function is called after collapse_edge is attempted. Since this collapse may have failed (e.g., it would create a non-manifold mesh). This callback is provided a flag whether the attempted collapse actually occurred. This callback is an opportunity for callers to update any data-structures/book-keeping to acknowledge the successful (or failed) collapse.

stopping_condition This function is called after a successful call to collapse_edge. If this function returns true then the entire queue-processing ends (e.g., if the number of remaining faces is below a user’s threshold).

See also

collapse_edge qslim