h o m e d o c u m e n t a t i o n c l a s s h i e r a r c h y

Operators Class Reference

#include <Operators.h>

List of all members.

Detailed Description

Class defining the operators used in a style module. There are 4 classes of operators: Selection, Chaining, Splitting and Creating. All these operators are user controlled in the scripting language through Functors, Predicates and Shaders that are taken as arguments.


Static Public Member Functions

void select (UnaryPredicate1D &pred)
void chain (ViewEdgeInternal::ViewEdgeIterator &it, UnaryPredicate1D &pred, UnaryFunction1D< void > &modifier)
void chain (ViewEdgeInternal::ViewEdgeIterator &it, UnaryPredicate1D &pred)
void bidirectionalChain (ChainingIterator &it, UnaryPredicate1D &pred)
void bidirectionalChain (ChainingIterator &it)
void sequentialSplit (UnaryPredicate0D &startingPred, UnaryPredicate0D &stoppingPred, float sampling=0.f)
void sequentialSplit (UnaryPredicate0D &pred, float sampling=0.f)
void recursiveSplit (UnaryFunction0D< double > &func, UnaryPredicate1D &pred, float sampling=0)
void recursiveSplit (UnaryFunction0D< double > &func, UnaryPredicate0D &pred0d, UnaryPredicate1D &pred, float sampling=0)
void sort (BinaryPredicate1D &pred)
void create (UnaryPredicate1D &pred, vector< StrokeShader * > shaders)

Member Function Documentation

void bidirectionalChain (  ChainingIterator &  it  )  [static]
 

The only difference with the above bidirectional chaining algorithm is that we don't need to pass a stopping criterion. This might be desirable when the stopping criterion is already contained in the iterator definition. Builds a set of chains from the current set of ViewEdges. Each ViewEdge of the current list potentially starts a new chain. The chaining operator then iterates over the ViewEdges of the ViewMap using the user specified iterator. This operator iterates both using the increment and decrement operators and is therefore bidirectional. This operator works with a ChainingIterator which contains the chaining rules. It is this last one which can be told to chain only edges that belong to the selection or not to process twice a ViewEdge during the chaining. Each time a ViewEdge is added to a chain, its chaining time stamp is incremented. This allows you to keep track of the number of chains to which a ViewEdge belongs to.

Parameters:
it The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule.

void bidirectionalChain (  ChainingIterator &  it,
UnaryPredicate1D &  pred
)  [static]
 

Builds a set of chains from the current set of ViewEdges. Each ViewEdge of the current list potentially starts a new chain. The chaining operator then iterates over the ViewEdges of the ViewMap using the user specified iterator. This operator iterates both using the increment and decrement operators and is therefore bidirectional. This operator works with a ChainingIterator which contains the chaining rules. It is this last one which can be told to chain only edges that belong to the selection or not to process twice a ViewEdge during the chaining. Each time a ViewEdge is added to a chain, its chaining time stamp is incremented. This allows you to keep track of the number of chains to which a ViewEdge belongs to.

Parameters:
it The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule.
pred The predicate on the ViewEdge that expresses the stopping condition.

void chain (  ViewEdgeInternal::ViewEdgeIterator &  it,
UnaryPredicate1D &  pred
)  [static]
 

Builds a set of chains from the current set of ViewEdges. Each ViewEdge of the current list starts a new chain. The chaining operator then iterates over the ViewEdges of the ViewMap using the user specified iterator. This operator only iterates using the increment operator and is therefore unidirectional. This chaining operator is different from the previous one because it doesn't take any modifier as argument. Indeed, the time stamp (insuring that a ViewEdge is processed one time) is automatically managed in this case.

Parameters:
it The iterator on the ViewEdges of the ViewMap. It contains the chaining rule.
pred The predicate on the ViewEdge that expresses the stopping condition.

void chain (  ViewEdgeInternal::ViewEdgeIterator &  it,
UnaryPredicate1D &  pred,
UnaryFunction1D< void > &  modifier
)  [static]
 

Builds a set of chains from the current set of ViewEdges. Each ViewEdge of the current list starts a new chain. The chaining operator then iterates over the ViewEdges of the ViewMap using the user specified iterator. This operator only iterates using the increment operator and is therefore unidirectional.

Parameters:
it The iterator on the ViewEdges of the ViewMap. It contains the chaining rule.
pred The predicate on the ViewEdge that expresses the stopping condition.
modifier A function that takes a ViewEdge as argument and that is used to modify the processed ViewEdge state (the timestamp incrementation is a typical illustration of such a modifier)

void create (  UnaryPredicate1D &  pred,
vector< StrokeShader * >  shaders
)  [static]
 

Creates and shades the strokes from the current set of chains. A predicate can be specified to make a selection pass on the chains.

Parameters:
pred The predicate that a chain must verify in order to be transform as a stroke
shaders The list of shaders used to shade the strokes

void recursiveSplit (  UnaryFunction0D< double > &  func,
UnaryPredicate0D &  pred0d,
UnaryPredicate1D &  pred,
float  sampling = 0
)  [static]
 

Splits the current set of chains in a recursive way. We process the points of each chain (with a specified sampling) to find the point minimizing a specified function. The chain is split in two at this point and the two new chains are processed in the same way. The user can specify a 0D predicate to make a first selection on the points that can potentially be split. A point that doesn't verify the 0D predicate won't be candidate in realizing the min. The recursivity level is controlled through a predicate 1D that expresses a stopping condition on the chain that is about to be processed.

Parameters:
func The Unary Function evaluated at each point of the chain. The splitting point is the point minimizing this function
pred0d The Unary Predicate 0D used to select the candidate points where the split can occur. For example, it is very likely that would rather have your chain splitting around its middle point than around one of its extremities. A 0D predicate working on the curvilinear abscissa allows to add this kind of constraints.
pred The Unary Predicate ex pressing the recursivity stopping condition. This predicate is evaluated for each curve before it actually gets split. If pred(chain) is true, the curve won't be split anymore.
sampling The resolution used to sample the chain for the predicates evaluation. (The chain is not actually resampled, a virtual point only progresses along the curve using this resolution)

void recursiveSplit (  UnaryFunction0D< double > &  func,
UnaryPredicate1D &  pred,
float  sampling = 0
)  [static]
 

Splits the current set of chains in a recursive way. We process the points of each chain (with a specified sampling) to find the point minimizing a specified function. The chain is split in two at this point and the two new chains are processed in the same way. The recursivity level is controlled through a predicate 1D that expresses a stopping condition on the chain that is about to be processed.

Parameters:
func The Unary Function evaluated at each point of the chain. The splitting point is the point minimizing this function
pred The Unary Predicate ex pressing the recursivity stopping condition. This predicate is evaluated for each curve before it actually gets split. If pred(chain) is true, the curve won't be split anymore.
sampling The resolution used to sample the chain for the predicates evaluation. (The chain is not actually resampled, a virtual point only progresses along the curve using this resolution)

void select (  UnaryPredicate1D &  pred  )  [static]
 

Selects the ViewEdges of the ViewMap verifying a specified condition.

Parameters:
pred The predicate expressing this condition

void sequentialSplit (  UnaryPredicate0D &  pred,
float  sampling = 0.f
)  [static]
 

Splits each chain of the current set of chains in a sequential way. The points of each chain are processed (with a specified sampling) sequentially and each time a user specified condition is verified, the chain is split into two chains. The resulting set of chains is a partition of the initial chain

Parameters:
pred The predicate on a point that expresses the splitting condition
sampling The resolution used to sample the chain for the predicate evaluation. (The chain is not actually resampled, a virtual point only progresses along the curve using this resolution)

void sequentialSplit (  UnaryPredicate0D &  startingPred,
UnaryPredicate0D &  stoppingPred,
float  sampling = 0.f
)  [static]
 

Splits each chain of the current set of chains in a sequential way. The points of each chain are processed (with a specified sampling) sequentially. Each time a user specified starting condition is verified, a new chain begins and ends as soon as a user-defined stopping predicate is verified. This allows chains overlapping rather than chains partitioning. The first point of the initial chain is the first point of one of the resulting chains. The splitting ends when no more chain can start.

Parameters:
startingPred The predicate on a point that expresses the starting condition
stoppingPred The predicate on a point that expresses the stopping condition
sampling The resolution used to sample the chain for the predicates evaluation. (The chain is not actually resampled, a virtual point only progresses along the curve using this resolution)

void sort (  BinaryPredicate1D &  pred  )  [static]
 

Sorts the current set of chains (or viewedges) according to the comparison predicate given as argument.

Parameters:
pred The binary predicate used for the comparison
The documentation for this class was generated from the following file: