From e5791cf48e10ec1336f463b7fccff6b302621eb9 Mon Sep 17 00:00:00 2001 From: Tamito Kajiyama Date: Fri, 28 Dec 2012 20:21:05 +0000 Subject: Another mega (literally :p) code clean-up patch by Bastien Montagne, thanks again! --- source/blender/freestyle/intern/stroke/Operators.h | 561 ++++++++++----------- 1 file changed, 262 insertions(+), 299 deletions(-) (limited to 'source/blender/freestyle/intern/stroke/Operators.h') diff --git a/source/blender/freestyle/intern/stroke/Operators.h b/source/blender/freestyle/intern/stroke/Operators.h index d705d5af5b2..aafbc2350d9 100644 --- a/source/blender/freestyle/intern/stroke/Operators.h +++ b/source/blender/freestyle/intern/stroke/Operators.h @@ -1,311 +1,274 @@ -// -// Filename : Operators.h -// Author(s) : Stephane Grabli, Emmanuel Turquin -// Purpose : Class gathering stroke creation algorithms -// Date of creation : 01/07/2003 -// -/////////////////////////////////////////////////////////////////////////////// - - -// -// Copyright (C) : Please refer to the COPYRIGHT file distributed -// with this source distribution. -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of the GNU General Public License -// as published by the Free Software Foundation; either version 2 -// of the License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -// -/////////////////////////////////////////////////////////////////////////////// - -#ifndef OPERATORS_H -# define OPERATORS_H - -# include "../view_map/Interface1D.h" -# include -# include -# include "Predicates1D.h" -# include "Predicates0D.h" -# include "../view_map/ViewMap.h" -# include "Chain.h" -# include "ChainingIterators.h" -# include "../system/TimeStamp.h" -# include "StrokeShader.h" +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2010 Blender Foundation. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef __FREESTYLE_OPERATORS_H__ +#define __FREESTYLE_OPERATORS_H__ + +/** \file blender/freestyle/intern/stroke/Operators.h + * \ingroup freestyle + * \brief Class gathering stroke creation algorithms + * \author Stephane Grabli + * \author Emmanuel Turquin + * \date 01/07/2003 + */ + +#include +#include + +#include "Chain.h" +#include "ChainingIterators.h" +#include "Predicates0D.h" +#include "Predicates1D.h" +#include "StrokeShader.h" + +#include "../system/TimeStamp.h" + +#include "../view_map/Interface1D.h" +#include "../view_map/ViewMap.h" /*! 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. + * 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. */ class LIB_STROKE_EXPORT Operators { public: + typedef vector I1DContainer; + typedef vector StrokesContainer; - typedef vector I1DContainer; - typedef vector StrokesContainer; - - - // - // Operators - // - //////////////////////////////////////////////// - - /*! Selects the ViewEdges of the ViewMap verifying - * a specified condition. - * \param pred The predicate expressing this condition - */ - static int select(UnaryPredicate1D& pred); - - /*! 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. - * \param it - * The iterator on the ViewEdges of the ViewMap. It contains - * the chaining rule. - * \param pred - * The predicate on the ViewEdge that expresses the stopping - * condition. - * \param 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) - */ - static int chain(ViewEdgeInternal::ViewEdgeIterator& it, - UnaryPredicate1D& pred, - UnaryFunction1D_void& modifier); - - /*! 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. - * \param it - * The iterator on the ViewEdges of the ViewMap. It contains - * the chaining rule. - * \param pred - * The predicate on the ViewEdge that expresses the stopping - * condition. - */ - static int chain(ViewEdgeInternal::ViewEdgeIterator& it, - UnaryPredicate1D& pred); - - /*! 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. - * \param it - * The ChainingIterator on the ViewEdges of the ViewMap. It contains - * the chaining rule. - * \param pred - * The predicate on the ViewEdge that expresses the stopping - * condition. - */ - static int bidirectionalChain(ChainingIterator& it, UnaryPredicate1D& pred); - - /*! 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. - * \param it - * The ChainingIterator on the ViewEdges of the ViewMap. It contains - * the chaining rule. - */ - static int bidirectionalChain(ChainingIterator& it); - - /*! 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. - * \param startingPred - * The predicate on a point that expresses the starting - * condition - * \param stoppingPred - * The predicate on a point that expresses the stopping - * condition - * \param 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) - */ - static int sequentialSplit(UnaryPredicate0D& startingPred, UnaryPredicate0D& stoppingPred, - float sampling = 0.f); - - /*! 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 - * \param pred - * The predicate on a point that expresses the splitting - * condition - * \param 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) - */ - static int sequentialSplit(UnaryPredicate0D& pred, - float sampling = 0.f); - - /*! 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. - * \param func - * The Unary Function evaluated at each point of the chain. - * The splitting point is the point minimizing this function - * \param 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. - * \param 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) - */ - static int recursiveSplit(UnaryFunction0D& func, UnaryPredicate1D& pred, float sampling = 0); - - /*! 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. - * \param func - * The Unary Function evaluated at each point of the chain. - * The splitting point is the point minimizing this function - * \param 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. - * \param 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. - * \param 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) - * - */ - static int recursiveSplit(UnaryFunction0D& func, UnaryPredicate0D& pred0d, UnaryPredicate1D& pred, float sampling = 0); - - /*! Sorts the current set of chains (or viewedges) according to the - * comparison predicate given as argument. - * \param pred - * The binary predicate used for the comparison - */ - static int sort(BinaryPredicate1D& pred); - - /*! Creates and shades the strokes from the current set of chains. - * A predicate can be specified to make a selection pass on the - * chains. - * \param pred - * The predicate that a chain must verify in order to - * be transform as a stroke - * \param shaders - * The list of shaders used to shade the strokes - */ - static int create(UnaryPredicate1D& pred, vector shaders); - - // - // Data access - // - //////////////////////////////////////////////// - - static ViewEdge* getViewEdgeFromIndex(unsigned i) { - return dynamic_cast(_current_view_edges_set[i]); - } - - static Chain* getChainFromIndex(unsigned i) { - return dynamic_cast(_current_chains_set[i]); - } - - static Stroke* getStrokeFromIndex(unsigned i) { - return _current_strokes_set[i]; - } - - static unsigned getViewEdgesSize() { - return _current_view_edges_set.size(); - } - - static unsigned getChainsSize() { - return _current_chains_set.size(); - } - - static unsigned getStrokesSize() { - return _current_strokes_set.size(); - } - - // - // Not exported in Python - // - ////////////////////////////////////////////////// - - static StrokesContainer* getStrokesSet() { - return &_current_strokes_set; - } - - static void reset(); + // + // Operators + // + //////////////////////////////////////////////// -private: + /*! Selects the ViewEdges of the ViewMap verifying a specified condition. + * \param pred The predicate expressing this condition + */ + static int select(UnaryPredicate1D& pred); + + /*! 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. + * \param it + * The iterator on the ViewEdges of the ViewMap. It contains the chaining rule. + * \param pred + * The predicate on the ViewEdge that expresses the stopping condition. + * \param 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) + */ + static int chain(ViewEdgeInternal::ViewEdgeIterator& it, UnaryPredicate1D& pred, UnaryFunction1D_void& modifier); + + /*! 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. + * \param it + * The iterator on the ViewEdges of the ViewMap. It contains the chaining rule. + * \param pred + * The predicate on the ViewEdge that expresses the stopping condition. + */ + static int chain(ViewEdgeInternal::ViewEdgeIterator& it, UnaryPredicate1D& pred); + + /*! 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. + * \param it + * The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule. + * \param pred + * The predicate on the ViewEdge that expresses the stopping condition. + */ + static int bidirectionalChain(ChainingIterator& it, UnaryPredicate1D& pred); + + /*! 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. + * \param it + * The ChainingIterator on the ViewEdges of the ViewMap. It contains the chaining rule. + */ + static int bidirectionalChain(ChainingIterator& it); + + /*! 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. + * \param startingPred + * The predicate on a point that expresses the starting condition + * \param stoppingPred + * The predicate on a point that expresses the stopping condition + * \param 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) + */ + static int sequentialSplit(UnaryPredicate0D& startingPred, UnaryPredicate0D& stoppingPred, float sampling = 0.0f); + + /*! 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 + * \param pred + * The predicate on a point that expresses the splitting condition + * \param 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) + */ + static int sequentialSplit(UnaryPredicate0D& pred, float sampling = 0.0f); - Operators() {} + /*! 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. + * \param func + * The Unary Function evaluated at each point of the chain. + * The splitting point is the point minimizing this function + * \param 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. + * \param 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) + */ + static int recursiveSplit(UnaryFunction0D& func, UnaryPredicate1D& pred, float sampling = 0); + + /*! 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. + * \param func + * The Unary Function evaluated at each point of the chain. + * The splitting point is the point minimizing this function + * \param 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. + * \param 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. + * \param 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) + */ + static int recursiveSplit(UnaryFunction0D& func, UnaryPredicate0D& pred0d, UnaryPredicate1D& pred, + float sampling = 0.0f); + + /*! Sorts the current set of chains (or viewedges) according to the comparison predicate given as argument. + * \param pred + * The binary predicate used for the comparison + */ + static int sort(BinaryPredicate1D& pred); + + /*! Creates and shades the strokes from the current set of chains. + * A predicate can be specified to make a selection pass on the chains. + * \param pred + * The predicate that a chain must verify in order to be transform as a stroke + * \param shaders + * The list of shaders used to shade the strokes + */ + static int create(UnaryPredicate1D& pred, vector shaders); + + // + // Data access + // + //////////////////////////////////////////////// + + static ViewEdge *getViewEdgeFromIndex(unsigned i) + { + return dynamic_cast(_current_view_edges_set[i]); + } + + static Chain *getChainFromIndex(unsigned i) + { + return dynamic_cast(_current_chains_set[i]); + } + + static Stroke *getStrokeFromIndex(unsigned i) + { + return _current_strokes_set[i]; + } + + static unsigned getViewEdgesSize() + { + return _current_view_edges_set.size(); + } + + static unsigned getChainsSize() + { + return _current_chains_set.size(); + } + + static unsigned getStrokesSize() + { + return _current_strokes_set.size(); + } + + // + // Not exported in Python + // + ////////////////////////////////////////////////// + + static StrokesContainer *getStrokesSet() + { + return &_current_strokes_set; + } + + static void reset(); + +private: + Operators() {} - static I1DContainer _current_view_edges_set; - static I1DContainer _current_chains_set; - static I1DContainer* _current_set; - static StrokesContainer _current_strokes_set; + static I1DContainer _current_view_edges_set; + static I1DContainer _current_chains_set; + static I1DContainer *_current_set; + static StrokesContainer _current_strokes_set; }; -#endif // OPERATORS_H +#endif // __FREESTYLE_OPERATORS_H__ -- cgit v1.2.3