ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 720 insertions, 627 deletions

diff --git a/source/blender/freestyle/intern/python/BPy_Operators.cpp b/source/blender/freestyle/intern/python/BPy_Operators.cpp
index 6bbdcd72052..e2afda63e14 100644
--- a/source/blender/freestyle/intern/python/BPy_Operators.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Operators.cpp
@@ -41,724 +41,817 @@ extern "C" {
 //-------------------MODULE INITIALIZATION--------------------------------
 int Operators_Init(PyObject *module)
 {
-	if (module == NULL)
-		return -1;
+  if (module == NULL)
+    return -1;
 
-	if (PyType_Ready(&Operators_Type) < 0)
-		return -1;
-	Py_INCREF(&Operators_Type);
-	PyModule_AddObject(module, "Operators", (PyObject *)&Operators_Type);
+  if (PyType_Ready(&Operators_Type) < 0)
+    return -1;
+  Py_INCREF(&Operators_Type);
+  PyModule_AddObject(module, "Operators", (PyObject *)&Operators_Type);
 
-	return 0;
+  return 0;
 }
 
 //------------------------INSTANCE METHODS ----------------------------------
 
 PyDoc_STRVAR(Operators_doc,
-"Class defining the operators used in a style module.  There are five\n"
-"types of operators: Selection, chaining, splitting, sorting and\n"
-"creation.  All these operators are user controlled through functors,\n"
-"predicates and shaders that are taken as arguments.");
+             "Class defining the operators used in a style module.  There are five\n"
+             "types of operators: Selection, chaining, splitting, sorting and\n"
+             "creation.  All these operators are user controlled through functors,\n"
+             "predicates and shaders that are taken as arguments.");
 
 static void Operators_dealloc(BPy_Operators *self)
 {
-	Py_TYPE(self)->tp_free((PyObject *)self);
+  Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
 PyDoc_STRVAR(Operators_select_doc,
-".. staticmethod:: select(pred)\n"
-"\n"
-"   Selects the ViewEdges of the ViewMap verifying a specified\n"
-"   condition.\n"
-"\n"
-"   :arg pred: The predicate expressing this condition.\n"
-"   :type pred: :class:`UnaryPredicate1D`");
+             ".. staticmethod:: select(pred)\n"
+             "\n"
+             "   Selects the ViewEdges of the ViewMap verifying a specified\n"
+             "   condition.\n"
+             "\n"
+             "   :arg pred: The predicate expressing this condition.\n"
+             "   :type pred: :class:`UnaryPredicate1D`");
 
 static PyObject *Operators_select(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
 {
-	static const char *kwlist[] = {"pred", NULL};
-	PyObject *obj = 0;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &UnaryPredicate1D_Type, &obj))
-		return NULL;
-	if (!((BPy_UnaryPredicate1D *)obj)->up1D) {
-		PyErr_SetString(PyExc_TypeError, "Operators.select(): 1st argument: invalid UnaryPredicate1D object");
-		return NULL;
-	}
-	if (Operators::select(*(((BPy_UnaryPredicate1D *)obj)->up1D)) < 0) {
-		if (!PyErr_Occurred())
-			PyErr_SetString(PyExc_RuntimeError, "Operators.select() failed");
-		return NULL;
-	}
-	Py_RETURN_NONE;
+  static const char *kwlist[] = {"pred", NULL};
+  PyObject *obj = 0;
+
+  if (!PyArg_ParseTupleAndKeywords(
+          args, kwds, "O!", (char **)kwlist, &UnaryPredicate1D_Type, &obj))
+    return NULL;
+  if (!((BPy_UnaryPredicate1D *)obj)->up1D) {
+    PyErr_SetString(PyExc_TypeError,
+                    "Operators.select(): 1st argument: invalid UnaryPredicate1D object");
+    return NULL;
+  }
+  if (Operators::select(*(((BPy_UnaryPredicate1D *)obj)->up1D)) < 0) {
+    if (!PyErr_Occurred())
+      PyErr_SetString(PyExc_RuntimeError, "Operators.select() failed");
+    return NULL;
+  }
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Operators_chain_doc,
-".. staticmethod:: chain(it, pred, modifier)\n"
-"\n"
-"   Builds a set of chains from the current set of ViewEdges.  Each\n"
-"   ViewEdge of the current list starts a new chain.  The chaining\n"
-"   operator then iterates over the ViewEdges of the ViewMap using the\n"
-"   user specified iterator.  This operator only iterates using the\n"
-"   increment operator and is therefore unidirectional.\n"
-"\n"
-"   :arg it: The iterator on the ViewEdges of the ViewMap. It contains\n"
-"      the chaining rule.\n"
-"   :type it: :class:`ViewEdgeIterator`\n"
-"   :arg pred: The predicate on the ViewEdge that expresses the\n"
-"      stopping condition.\n"
-"   :type pred: :class:`UnaryPredicate1D`\n"
-"   :arg modifier: A function that takes a ViewEdge as argument and\n"
-"      that is used to modify the processed ViewEdge state (the\n"
-"      timestamp incrementation is a typical illustration of such a\n"
-"      modifier).\n"
-"   :type modifier: :class:`UnaryFunction1DVoid`\n"
-"\n"
-".. staticmethod:: chain(it, pred)\n"
-"\n"
-"   Builds a set of chains from the current set of ViewEdges.  Each\n"
-"   ViewEdge of the current list starts a new chain.  The chaining\n"
-"   operator then iterates over the ViewEdges of the ViewMap using the\n"
-"   user specified iterator.  This operator only iterates using the\n"
-"   increment operator and is therefore unidirectional.  This chaining\n"
-"   operator is different from the previous one because it doesn't take\n"
-"   any modifier as argument.  Indeed, the time stamp (insuring that a\n"
-"   ViewEdge is processed one time) is automatically managed in this\n"
-"   case.\n"
-"\n"
-"   :arg it: The iterator on the ViewEdges of the ViewMap. It contains\n"
-"      the chaining rule. \n"
-"   :type it: :class:`ViewEdgeIterator`\n"
-"   :arg pred: The predicate on the ViewEdge that expresses the\n"
-"      stopping condition.\n"
-"   :type pred: :class:`UnaryPredicate1D`");
+             ".. staticmethod:: chain(it, pred, modifier)\n"
+             "\n"
+             "   Builds a set of chains from the current set of ViewEdges.  Each\n"
+             "   ViewEdge of the current list starts a new chain.  The chaining\n"
+             "   operator then iterates over the ViewEdges of the ViewMap using the\n"
+             "   user specified iterator.  This operator only iterates using the\n"
+             "   increment operator and is therefore unidirectional.\n"
+             "\n"
+             "   :arg it: The iterator on the ViewEdges of the ViewMap. It contains\n"
+             "      the chaining rule.\n"
+             "   :type it: :class:`ViewEdgeIterator`\n"
+             "   :arg pred: The predicate on the ViewEdge that expresses the\n"
+             "      stopping condition.\n"
+             "   :type pred: :class:`UnaryPredicate1D`\n"
+             "   :arg modifier: A function that takes a ViewEdge as argument and\n"
+             "      that is used to modify the processed ViewEdge state (the\n"
+             "      timestamp incrementation is a typical illustration of such a\n"
+             "      modifier).\n"
+             "   :type modifier: :class:`UnaryFunction1DVoid`\n"
+             "\n"
+             ".. staticmethod:: chain(it, pred)\n"
+             "\n"
+             "   Builds a set of chains from the current set of ViewEdges.  Each\n"
+             "   ViewEdge of the current list starts a new chain.  The chaining\n"
+             "   operator then iterates over the ViewEdges of the ViewMap using the\n"
+             "   user specified iterator.  This operator only iterates using the\n"
+             "   increment operator and is therefore unidirectional.  This chaining\n"
+             "   operator is different from the previous one because it doesn't take\n"
+             "   any modifier as argument.  Indeed, the time stamp (insuring that a\n"
+             "   ViewEdge is processed one time) is automatically managed in this\n"
+             "   case.\n"
+             "\n"
+             "   :arg it: The iterator on the ViewEdges of the ViewMap. It contains\n"
+             "      the chaining rule. \n"
+             "   :type it: :class:`ViewEdgeIterator`\n"
+             "   :arg pred: The predicate on the ViewEdge that expresses the\n"
+             "      stopping condition.\n"
+             "   :type pred: :class:`UnaryPredicate1D`");
 
 static PyObject *Operators_chain(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
 {
-	static const char *kwlist[] = {"it", "pred", "modifier", NULL};
-	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|O!", (char **)kwlist,
-	                                 &ChainingIterator_Type, &obj1,
-	                                 &UnaryPredicate1D_Type, &obj2,
-	                                 &UnaryFunction1DVoid_Type, &obj3))
-	{
-		return NULL;
-	}
-	if (!((BPy_ChainingIterator *)obj1)->c_it) {
-		PyErr_SetString(PyExc_TypeError, "Operators.chain(): 1st argument: invalid ChainingIterator object");
-		return NULL;
-	}
-	if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
-		PyErr_SetString(PyExc_TypeError, "Operators.chain(): 2nd argument: invalid UnaryPredicate1D object");
-		return NULL;
-	}
-	if (!obj3) {
-		if (Operators::chain(*(((BPy_ChainingIterator *)obj1)->c_it),
-		                     *(((BPy_UnaryPredicate1D *)obj2)->up1D)) < 0)
-		{
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
-			return NULL;
-		}
-	}
-	else {
-		if (!((BPy_UnaryFunction1DVoid *)obj3)->uf1D_void) {
-			PyErr_SetString(PyExc_TypeError, "Operators.chain(): 3rd argument: invalid UnaryFunction1DVoid object");
-			return NULL;
-		}
-		if (Operators::chain(*(((BPy_ChainingIterator *)obj1)->c_it),
-		                     *(((BPy_UnaryPredicate1D *)obj2)->up1D),
-		                     *(((BPy_UnaryFunction1DVoid *)obj3)->uf1D_void)) < 0)
-		{
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
-			return NULL;
-		}
-	}
-	Py_RETURN_NONE;
+  static const char *kwlist[] = {"it", "pred", "modifier", NULL};
+  PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
+
+  if (!PyArg_ParseTupleAndKeywords(args,
+                                   kwds,
+                                   "O!O!|O!",
+                                   (char **)kwlist,
+                                   &ChainingIterator_Type,
+                                   &obj1,
+                                   &UnaryPredicate1D_Type,
+                                   &obj2,
+                                   &UnaryFunction1DVoid_Type,
+                                   &obj3)) {
+    return NULL;
+  }
+  if (!((BPy_ChainingIterator *)obj1)->c_it) {
+    PyErr_SetString(PyExc_TypeError,
+                    "Operators.chain(): 1st argument: invalid ChainingIterator object");
+    return NULL;
+  }
+  if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
+    PyErr_SetString(PyExc_TypeError,
+                    "Operators.chain(): 2nd argument: invalid UnaryPredicate1D object");
+    return NULL;
+  }
+  if (!obj3) {
+    if (Operators::chain(*(((BPy_ChainingIterator *)obj1)->c_it),
+                         *(((BPy_UnaryPredicate1D *)obj2)->up1D)) < 0) {
+      if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
+      return NULL;
+    }
+  }
+  else {
+    if (!((BPy_UnaryFunction1DVoid *)obj3)->uf1D_void) {
+      PyErr_SetString(PyExc_TypeError,
+                      "Operators.chain(): 3rd argument: invalid UnaryFunction1DVoid object");
+      return NULL;
+    }
+    if (Operators::chain(*(((BPy_ChainingIterator *)obj1)->c_it),
+                         *(((BPy_UnaryPredicate1D *)obj2)->up1D),
+                         *(((BPy_UnaryFunction1DVoid *)obj3)->uf1D_void)) < 0) {
+      if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "Operators.chain() failed");
+      return NULL;
+    }
+  }
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Operators_bidirectional_chain_doc,
-".. staticmethod:: bidirectional_chain(it, pred)\n"
-"\n"
-"   Builds a set of chains from the current set of ViewEdges.  Each\n"
-"   ViewEdge of the current list potentially starts a new chain.  The\n"
-"   chaining operator then iterates over the ViewEdges of the ViewMap\n"
-"   using the user specified iterator.  This operator iterates both using\n"
-"   the increment and decrement operators and is therefore bidirectional.\n"
-"   This operator works with a ChainingIterator which contains the\n"
-"   chaining rules.  It is this last one which can be told to chain only\n"
-"   edges that belong to the selection or not to process twice a ViewEdge\n"
-"   during the chaining.  Each time a ViewEdge is added to a chain, its\n"
-"   chaining time stamp is incremented.  This allows you to keep track of\n"
-"   the number of chains to which a ViewEdge belongs to.\n"
-"\n"
-"   :arg it: The ChainingIterator on the ViewEdges of the ViewMap.  It\n"
-"      contains the chaining rule.\n"
-"   :type it: :class:`ChainingIterator`\n"
-"   :arg pred: The predicate on the ViewEdge that expresses the\n"
-"      stopping condition.\n"
-"   :type pred: :class:`UnaryPredicate1D`\n"
-"\n"
-".. staticmethod:: bidirectional_chain(it)\n"
-"\n"
-"   The only difference with the above bidirectional chaining algorithm\n"
-"   is that we don't need to pass a stopping criterion.  This might be\n"
-"   desirable when the stopping criterion is already contained in the\n"
-"   iterator definition.  Builds a set of chains from the current set of\n"
-"   ViewEdges.  Each ViewEdge of the current list potentially starts a new\n"
-"   chain.  The chaining operator then iterates over the ViewEdges of the\n"
-"   ViewMap using the user specified iterator.  This operator iterates\n"
-"   both using the increment and decrement operators and is therefore\n"
-"   bidirectional.  This operator works with a ChainingIterator which\n"
-"   contains the chaining rules.  It is this last one which can be told to\n"
-"   chain only edges that belong to the selection or not to process twice\n"
-"   a ViewEdge during the chaining.  Each time a ViewEdge is added to a\n"
-"   chain, its chaining time stamp is incremented.  This allows you to\n"
-"   keep track of the number of chains to which a ViewEdge belongs to.\n"
-"\n"
-"   :arg it: The ChainingIterator on the ViewEdges of the ViewMap.  It\n"
-"      contains the chaining rule.\n"
-"   :type it: :class:`ChainingIterator`");
-
-static PyObject *Operators_bidirectional_chain(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
+             ".. staticmethod:: bidirectional_chain(it, pred)\n"
+             "\n"
+             "   Builds a set of chains from the current set of ViewEdges.  Each\n"
+             "   ViewEdge of the current list potentially starts a new chain.  The\n"
+             "   chaining operator then iterates over the ViewEdges of the ViewMap\n"
+             "   using the user specified iterator.  This operator iterates both using\n"
+             "   the increment and decrement operators and is therefore bidirectional.\n"
+             "   This operator works with a ChainingIterator which contains the\n"
+             "   chaining rules.  It is this last one which can be told to chain only\n"
+             "   edges that belong to the selection or not to process twice a ViewEdge\n"
+             "   during the chaining.  Each time a ViewEdge is added to a chain, its\n"
+             "   chaining time stamp is incremented.  This allows you to keep track of\n"
+             "   the number of chains to which a ViewEdge belongs to.\n"
+             "\n"
+             "   :arg it: The ChainingIterator on the ViewEdges of the ViewMap.  It\n"
+             "      contains the chaining rule.\n"
+             "   :type it: :class:`ChainingIterator`\n"
+             "   :arg pred: The predicate on the ViewEdge that expresses the\n"
+             "      stopping condition.\n"
+             "   :type pred: :class:`UnaryPredicate1D`\n"
+             "\n"
+             ".. staticmethod:: bidirectional_chain(it)\n"
+             "\n"
+             "   The only difference with the above bidirectional chaining algorithm\n"
+             "   is that we don't need to pass a stopping criterion.  This might be\n"
+             "   desirable when the stopping criterion is already contained in the\n"
+             "   iterator definition.  Builds a set of chains from the current set of\n"
+             "   ViewEdges.  Each ViewEdge of the current list potentially starts a new\n"
+             "   chain.  The chaining operator then iterates over the ViewEdges of the\n"
+             "   ViewMap using the user specified iterator.  This operator iterates\n"
+             "   both using the increment and decrement operators and is therefore\n"
+             "   bidirectional.  This operator works with a ChainingIterator which\n"
+             "   contains the chaining rules.  It is this last one which can be told to\n"
+             "   chain only edges that belong to the selection or not to process twice\n"
+             "   a ViewEdge during the chaining.  Each time a ViewEdge is added to a\n"
+             "   chain, its chaining time stamp is incremented.  This allows you to\n"
+             "   keep track of the number of chains to which a ViewEdge belongs to.\n"
+             "\n"
+             "   :arg it: The ChainingIterator on the ViewEdges of the ViewMap.  It\n"
+             "      contains the chaining rule.\n"
+             "   :type it: :class:`ChainingIterator`");
+
+static PyObject *Operators_bidirectional_chain(BPy_Operators * /*self*/,
+                                               PyObject *args,
+                                               PyObject *kwds)
 {
-	static const char *kwlist[] = {"it", "pred", NULL};
-	PyObject *obj1 = 0, *obj2 = 0;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O!", (char **)kwlist,
-	                                 &ChainingIterator_Type, &obj1, &UnaryPredicate1D_Type, &obj2))
-	{
-		return NULL;
-	}
-	if (!((BPy_ChainingIterator *)obj1)->c_it) {
-		PyErr_SetString(PyExc_TypeError,
-		                "Operators.bidirectional_chain(): 1st argument: invalid ChainingIterator object");
-		return NULL;
-	}
-	if (!obj2) {
-		if (Operators::bidirectionalChain(*(((BPy_ChainingIterator *)obj1)->c_it)) < 0) {
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectional_chain() failed");
-			return NULL;
-		}
-	}
-	else {
-		if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.bidirectional_chain(): 2nd argument: invalid UnaryPredicate1D object");
-			return NULL;
-		}
-		if (Operators::bidirectionalChain(*(((BPy_ChainingIterator *)obj1)->c_it),
-		                                  *(((BPy_UnaryPredicate1D *)obj2)->up1D)) < 0)
-		{
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectional_chain() failed");
-			return NULL;
-		}
-	}
-	Py_RETURN_NONE;
+  static const char *kwlist[] = {"it", "pred", NULL};
+  PyObject *obj1 = 0, *obj2 = 0;
+
+  if (!PyArg_ParseTupleAndKeywords(args,
+                                   kwds,
+                                   "O!|O!",
+                                   (char **)kwlist,
+                                   &ChainingIterator_Type,
+                                   &obj1,
+                                   &UnaryPredicate1D_Type,
+                                   &obj2)) {
+    return NULL;
+  }
+  if (!((BPy_ChainingIterator *)obj1)->c_it) {
+    PyErr_SetString(
+        PyExc_TypeError,
+        "Operators.bidirectional_chain(): 1st argument: invalid ChainingIterator object");
+    return NULL;
+  }
+  if (!obj2) {
+    if (Operators::bidirectionalChain(*(((BPy_ChainingIterator *)obj1)->c_it)) < 0) {
+      if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectional_chain() failed");
+      return NULL;
+    }
+  }
+  else {
+    if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.bidirectional_chain(): 2nd argument: invalid UnaryPredicate1D object");
+      return NULL;
+    }
+    if (Operators::bidirectionalChain(*(((BPy_ChainingIterator *)obj1)->c_it),
+                                      *(((BPy_UnaryPredicate1D *)obj2)->up1D)) < 0) {
+      if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "Operators.bidirectional_chain() failed");
+      return NULL;
+    }
+  }
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Operators_sequential_split_doc,
-".. staticmethod:: sequential_split(starting_pred, stopping_pred, sampling=0.0)\n"
-"\n"
-"   Splits each chain of the current set of chains in a sequential way.\n"
-"   The points of each chain are processed (with a specified sampling)\n"
-"   sequentially. Each time a user specified starting condition is\n"
-"   verified, a new chain begins and ends as soon as a user-defined\n"
-"   stopping predicate is verified. This allows chains overlapping rather\n"
-"   than chains partitioning. The first point of the initial chain is the\n"
-"   first point of one of the resulting chains. The splitting ends when\n"
-"   no more chain can start.\n"
-"\n"
-"   :arg starting_pred: The predicate on a point that expresses the\n"
-"      starting condition.\n"
-"   :type starting_pred: :class:`UnaryPredicate0D`\n"
-"   :arg stopping_pred: The predicate on a point that expresses the\n"
-"      stopping condition.\n"
-"   :type stopping_pred: :class:`UnaryPredicate0D`\n"
-"   :arg sampling: The resolution used to sample the chain for the\n"
-"      predicates evaluation. (The chain is not actually resampled;\n"
-"      a virtual point only progresses along the curve using this\n"
-"      resolution.)\n"
-"   :type sampling: float\n"
-"\n"
-".. staticmethod:: sequential_split(pred, sampling=0.0)\n"
-"\n"
-"   Splits each chain of the current set of chains in a sequential way.\n"
-"   The points of each chain are processed (with a specified sampling)\n"
-"   sequentially and each time a user specified condition is verified,\n"
-"   the chain is split into two chains.  The resulting set of chains is a\n"
-"   partition of the initial chain\n"
-"\n"
-"   :arg pred: The predicate on a point that expresses the splitting\n"
-"      condition.\n"
-"   :type pred: :class:`UnaryPredicate0D`\n"
-"   :arg sampling: The resolution used to sample the chain for the\n"
-"      predicate evaluation. (The chain is not actually resampled; a\n"
-"      virtual point only progresses along the curve using this\n"
-"      resolution.)\n"
-"   :type sampling: float");
-
-static PyObject *Operators_sequential_split(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
+             ".. staticmethod:: sequential_split(starting_pred, stopping_pred, sampling=0.0)\n"
+             "\n"
+             "   Splits each chain of the current set of chains in a sequential way.\n"
+             "   The points of each chain are processed (with a specified sampling)\n"
+             "   sequentially. Each time a user specified starting condition is\n"
+             "   verified, a new chain begins and ends as soon as a user-defined\n"
+             "   stopping predicate is verified. This allows chains overlapping rather\n"
+             "   than chains partitioning. The first point of the initial chain is the\n"
+             "   first point of one of the resulting chains. The splitting ends when\n"
+             "   no more chain can start.\n"
+             "\n"
+             "   :arg starting_pred: The predicate on a point that expresses the\n"
+             "      starting condition.\n"
+             "   :type starting_pred: :class:`UnaryPredicate0D`\n"
+             "   :arg stopping_pred: The predicate on a point that expresses the\n"
+             "      stopping condition.\n"
+             "   :type stopping_pred: :class:`UnaryPredicate0D`\n"
+             "   :arg sampling: The resolution used to sample the chain for the\n"
+             "      predicates evaluation. (The chain is not actually resampled;\n"
+             "      a virtual point only progresses along the curve using this\n"
+             "      resolution.)\n"
+             "   :type sampling: float\n"
+             "\n"
+             ".. staticmethod:: sequential_split(pred, sampling=0.0)\n"
+             "\n"
+             "   Splits each chain of the current set of chains in a sequential way.\n"
+             "   The points of each chain are processed (with a specified sampling)\n"
+             "   sequentially and each time a user specified condition is verified,\n"
+             "   the chain is split into two chains.  The resulting set of chains is a\n"
+             "   partition of the initial chain\n"
+             "\n"
+             "   :arg pred: The predicate on a point that expresses the splitting\n"
+             "      condition.\n"
+             "   :type pred: :class:`UnaryPredicate0D`\n"
+             "   :arg sampling: The resolution used to sample the chain for the\n"
+             "      predicate evaluation. (The chain is not actually resampled; a\n"
+             "      virtual point only progresses along the curve using this\n"
+             "      resolution.)\n"
+             "   :type sampling: float");
+
+static PyObject *Operators_sequential_split(BPy_Operators * /*self*/,
+                                            PyObject *args,
+                                            PyObject *kwds)
 {
-	static const char *kwlist_1[] = {"starting_pred", "stopping_pred", "sampling", NULL};
-	static const char *kwlist_2[] = {"pred", "sampling", NULL};
-	PyObject *obj1 = 0, *obj2 = 0;
-	float f = 0.0f;
-
-	if (PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|f", (char **)kwlist_1,
-	                                &UnaryPredicate0D_Type, &obj1, &UnaryPredicate0D_Type, &obj2, &f))
-	{
-		if (!((BPy_UnaryPredicate0D *)obj1)->up0D) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.sequential_split(): 1st argument: invalid UnaryPredicate0D object");
-			return NULL;
-		}
-		if (!((BPy_UnaryPredicate0D *)obj2)->up0D) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.sequential_split(): 2nd argument: invalid UnaryPredicate0D object");
-			return NULL;
-		}
-		if (Operators::sequentialSplit(*(((BPy_UnaryPredicate0D *)obj1)->up0D),
-		                               *(((BPy_UnaryPredicate0D *)obj2)->up0D),
-		                               f) < 0)
-		{
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.sequential_split() failed");
-			return NULL;
-		}
-	}
-	else if (PyErr_Clear(), (f = 0.0f),
-	         PyArg_ParseTupleAndKeywords(args, kwds, "O!|f", (char **)kwlist_2,
-	                                     &UnaryPredicate0D_Type, &obj1, &f))
-	{
-		if (!((BPy_UnaryPredicate0D *)obj1)->up0D) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.sequential_split(): 1st argument: invalid UnaryPredicate0D object");
-			return NULL;
-		}
-		if (Operators::sequentialSplit(*(((BPy_UnaryPredicate0D *)obj1)->up0D), f) < 0) {
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.sequential_split() failed");
-			return NULL;
-		}
-	}
-	else {
-		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
-		return NULL;
-	}
-	Py_RETURN_NONE;
+  static const char *kwlist_1[] = {"starting_pred", "stopping_pred", "sampling", NULL};
+  static const char *kwlist_2[] = {"pred", "sampling", NULL};
+  PyObject *obj1 = 0, *obj2 = 0;
+  float f = 0.0f;
+
+  if (PyArg_ParseTupleAndKeywords(args,
+                                  kwds,
+                                  "O!O!|f",
+                                  (char **)kwlist_1,
+                                  &UnaryPredicate0D_Type,
+                                  &obj1,
+                                  &UnaryPredicate0D_Type,
+                                  &obj2,
+                                  &f)) {
+    if (!((BPy_UnaryPredicate0D *)obj1)->up0D) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.sequential_split(): 1st argument: invalid UnaryPredicate0D object");
+      return NULL;
+    }
+    if (!((BPy_UnaryPredicate0D *)obj2)->up0D) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.sequential_split(): 2nd argument: invalid UnaryPredicate0D object");
+      return NULL;
+    }
+    if (Operators::sequentialSplit(*(((BPy_UnaryPredicate0D *)obj1)->up0D),
+                                   *(((BPy_UnaryPredicate0D *)obj2)->up0D),
+                                   f) < 0) {
+      if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "Operators.sequential_split() failed");
+      return NULL;
+    }
+  }
+  else if (PyErr_Clear(),
+           (f = 0.0f),
+           PyArg_ParseTupleAndKeywords(
+               args, kwds, "O!|f", (char **)kwlist_2, &UnaryPredicate0D_Type, &obj1, &f)) {
+    if (!((BPy_UnaryPredicate0D *)obj1)->up0D) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.sequential_split(): 1st argument: invalid UnaryPredicate0D object");
+      return NULL;
+    }
+    if (Operators::sequentialSplit(*(((BPy_UnaryPredicate0D *)obj1)->up0D), f) < 0) {
+      if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "Operators.sequential_split() failed");
+      return NULL;
+    }
+  }
+  else {
+    PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
+    return NULL;
+  }
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Operators_recursive_split_doc,
-".. staticmethod:: recursive_split(func, pred_1d, sampling=0.0)\n"
-"\n"
-"   Splits the current set of chains in a recursive way.  We process the\n"
-"   points of each chain (with a specified sampling) to find the point\n"
-"   minimizing a specified function.  The chain is split in two at this\n"
-"   point and the two new chains are processed in the same way.  The\n"
-"   recursivity level is controlled through a predicate 1D that expresses\n"
-"   a stopping condition on the chain that is about to be processed.\n"
-"\n"
-"   :arg func: The Unary Function evaluated at each point of the chain.\n"
-"     The splitting point is the point minimizing this function.\n"
-"   :type func: :class:`UnaryFunction0DDouble`\n"
-"   :arg pred_1d: The Unary Predicate expressing the recursivity stopping\n"
-"      condition.  This predicate is evaluated for each curve before it\n"
-"      actually gets split.  If pred_1d(chain) is true, the curve won't be\n"
-"      split anymore.\n"
-"   :type pred_1d: :class:`UnaryPredicate1D`\n"
-"   :arg sampling: The resolution used to sample the chain for the\n"
-"      predicates evaluation. (The chain is not actually resampled, a\n"
-"      virtual point only progresses along the curve using this\n"
-"      resolution.)\n"
-"   :type sampling: float\n"
-"\n"
-".. staticmethod:: recursive_split(func, pred_0d, pred_1d, sampling=0.0)\n"
-"\n"
-"   Splits the current set of chains in a recursive way.  We process the\n"
-"   points of each chain (with a specified sampling) to find the point\n"
-"   minimizing a specified function.  The chain is split in two at this\n"
-"   point and the two new chains are processed in the same way.  The user\n"
-"   can specify a 0D predicate to make a first selection on the points\n"
-"   that can potentially be split.  A point that doesn't verify the 0D\n"
-"   predicate won't be candidate in realizing the min.  The recursivity\n"
-"   level is controlled through a predicate 1D that expresses a stopping\n"
-"   condition on the chain that is about to be processed.\n"
-"\n"
-"   :arg func: The Unary Function evaluated at each point of the chain.\n"
-"      The splitting point is the point minimizing this function.\n"
-"   :type func: :class:`UnaryFunction0DDouble`\n"
-"   :arg pred_0d: The Unary Predicate 0D used to select the candidate\n"
-"      points where the split can occur.  For example, it is very likely\n"
-"      that would rather have your chain splitting around its middle\n"
-"      point than around one of its extremities.  A 0D predicate working\n"
-"      on the curvilinear abscissa allows to add this kind of constraints.\n"
-"   :type pred_0d: :class:`UnaryPredicate0D`\n"
-"   :arg pred_1d: The Unary Predicate expressing the recursivity stopping\n"
-"      condition. This predicate is evaluated for each curve before it\n"
-"      actually gets split.  If pred_1d(chain) is true, the curve won't be\n"
-"      split anymore.\n"
-"   :type pred_1d: :class:`UnaryPredicate1D`\n"
-"   :arg sampling: The resolution used to sample the chain for the\n"
-"      predicates evaluation. (The chain is not actually resampled; a\n"
-"      virtual point only progresses along the curve using this\n"
-"      resolution.)\n"
-"   :type sampling: float");
-
-static PyObject *Operators_recursive_split(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
+             ".. staticmethod:: recursive_split(func, pred_1d, sampling=0.0)\n"
+             "\n"
+             "   Splits the current set of chains in a recursive way.  We process the\n"
+             "   points of each chain (with a specified sampling) to find the point\n"
+             "   minimizing a specified function.  The chain is split in two at this\n"
+             "   point and the two new chains are processed in the same way.  The\n"
+             "   recursivity level is controlled through a predicate 1D that expresses\n"
+             "   a stopping condition on the chain that is about to be processed.\n"
+             "\n"
+             "   :arg func: The Unary Function evaluated at each point of the chain.\n"
+             "     The splitting point is the point minimizing this function.\n"
+             "   :type func: :class:`UnaryFunction0DDouble`\n"
+             "   :arg pred_1d: The Unary Predicate expressing the recursivity stopping\n"
+             "      condition.  This predicate is evaluated for each curve before it\n"
+             "      actually gets split.  If pred_1d(chain) is true, the curve won't be\n"
+             "      split anymore.\n"
+             "   :type pred_1d: :class:`UnaryPredicate1D`\n"
+             "   :arg sampling: The resolution used to sample the chain for the\n"
+             "      predicates evaluation. (The chain is not actually resampled, a\n"
+             "      virtual point only progresses along the curve using this\n"
+             "      resolution.)\n"
+             "   :type sampling: float\n"
+             "\n"
+             ".. staticmethod:: recursive_split(func, pred_0d, pred_1d, sampling=0.0)\n"
+             "\n"
+             "   Splits the current set of chains in a recursive way.  We process the\n"
+             "   points of each chain (with a specified sampling) to find the point\n"
+             "   minimizing a specified function.  The chain is split in two at this\n"
+             "   point and the two new chains are processed in the same way.  The user\n"
+             "   can specify a 0D predicate to make a first selection on the points\n"
+             "   that can potentially be split.  A point that doesn't verify the 0D\n"
+             "   predicate won't be candidate in realizing the min.  The recursivity\n"
+             "   level is controlled through a predicate 1D that expresses a stopping\n"
+             "   condition on the chain that is about to be processed.\n"
+             "\n"
+             "   :arg func: The Unary Function evaluated at each point of the chain.\n"
+             "      The splitting point is the point minimizing this function.\n"
+             "   :type func: :class:`UnaryFunction0DDouble`\n"
+             "   :arg pred_0d: The Unary Predicate 0D used to select the candidate\n"
+             "      points where the split can occur.  For example, it is very likely\n"
+             "      that would rather have your chain splitting around its middle\n"
+             "      point than around one of its extremities.  A 0D predicate working\n"
+             "      on the curvilinear abscissa allows to add this kind of constraints.\n"
+             "   :type pred_0d: :class:`UnaryPredicate0D`\n"
+             "   :arg pred_1d: The Unary Predicate expressing the recursivity stopping\n"
+             "      condition. This predicate is evaluated for each curve before it\n"
+             "      actually gets split.  If pred_1d(chain) is true, the curve won't be\n"
+             "      split anymore.\n"
+             "   :type pred_1d: :class:`UnaryPredicate1D`\n"
+             "   :arg sampling: The resolution used to sample the chain for the\n"
+             "      predicates evaluation. (The chain is not actually resampled; a\n"
+             "      virtual point only progresses along the curve using this\n"
+             "      resolution.)\n"
+             "   :type sampling: float");
+
+static PyObject *Operators_recursive_split(BPy_Operators * /*self*/,
+                                           PyObject *args,
+                                           PyObject *kwds)
 {
-	static const char *kwlist_1[] = {"func", "pred_1d", "sampling", NULL};
-	static const char *kwlist_2[] = {"func", "pred_0d", "pred_1d", "sampling", NULL};
-	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
-	float f = 0.0f;
-
-	if (PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|f", (char **)kwlist_1,
-	                                &UnaryFunction0DDouble_Type, &obj1, &UnaryPredicate1D_Type, &obj2, &f))
-	{
-		if (!((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.recursive_split(): 1st argument: invalid UnaryFunction0DDouble object");
-			return NULL;
-		}
-		if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.recursive_split(): 2nd argument: invalid UnaryPredicate1D object");
-			return NULL;
-		}
-		if (Operators::recursiveSplit(*(((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double),
-		                              *(((BPy_UnaryPredicate1D *)obj2)->up1D),
-		                              f) < 0)
-		{
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.recursive_split() failed");
-			return NULL;
-		}
-	}
-	else if (PyErr_Clear(), (f = 0.0f),
-	         PyArg_ParseTupleAndKeywords(args, kwds, "O!O!O!|f", (char **)kwlist_2,
-	                                &UnaryFunction0DDouble_Type, &obj1, &UnaryPredicate0D_Type, &obj2,
-	                                &UnaryPredicate1D_Type, &obj3, &f))
-	{
-		if (!((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.recursive_split(): 1st argument: invalid UnaryFunction0DDouble object");
-			return NULL;
-		}
-		if (!((BPy_UnaryPredicate0D *)obj2)->up0D) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.recursive_split(): 2nd argument: invalid UnaryPredicate0D object");
-			return NULL;
-		}
-		if (!((BPy_UnaryPredicate1D *)obj3)->up1D) {
-			PyErr_SetString(PyExc_TypeError,
-			                "Operators.recursive_split(): 3rd argument: invalid UnaryPredicate1D object");
-			return NULL;
-		}
-		if (Operators::recursiveSplit(*(((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double),
-		                              *(((BPy_UnaryPredicate0D *)obj2)->up0D),
-		                              *(((BPy_UnaryPredicate1D *)obj3)->up1D),
-		                              f) < 0)
-		{
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_RuntimeError, "Operators.recursive_split() failed");
-			return NULL;
-		}
-	}
-	else {
-		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
-		return NULL;
-	}
-	Py_RETURN_NONE;
+  static const char *kwlist_1[] = {"func", "pred_1d", "sampling", NULL};
+  static const char *kwlist_2[] = {"func", "pred_0d", "pred_1d", "sampling", NULL};
+  PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0;
+  float f = 0.0f;
+
+  if (PyArg_ParseTupleAndKeywords(args,
+                                  kwds,
+                                  "O!O!|f",
+                                  (char **)kwlist_1,
+                                  &UnaryFunction0DDouble_Type,
+                                  &obj1,
+                                  &UnaryPredicate1D_Type,
+                                  &obj2,
+                                  &f)) {
+    if (!((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.recursive_split(): 1st argument: invalid UnaryFunction0DDouble object");
+      return NULL;
+    }
+    if (!((BPy_UnaryPredicate1D *)obj2)->up1D) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.recursive_split(): 2nd argument: invalid UnaryPredicate1D object");
+      return NULL;
+    }
+    if (Operators::recursiveSplit(*(((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double),
+                                  *(((BPy_UnaryPredicate1D *)obj2)->up1D),
+                                  f) < 0) {
+      if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "Operators.recursive_split() failed");
+      return NULL;
+    }
+  }
+  else if (PyErr_Clear(),
+           (f = 0.0f),
+           PyArg_ParseTupleAndKeywords(args,
+                                       kwds,
+                                       "O!O!O!|f",
+                                       (char **)kwlist_2,
+                                       &UnaryFunction0DDouble_Type,
+                                       &obj1,
+                                       &UnaryPredicate0D_Type,
+                                       &obj2,
+                                       &UnaryPredicate1D_Type,
+                                       &obj3,
+                                       &f)) {
+    if (!((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.recursive_split(): 1st argument: invalid UnaryFunction0DDouble object");
+      return NULL;
+    }
+    if (!((BPy_UnaryPredicate0D *)obj2)->up0D) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.recursive_split(): 2nd argument: invalid UnaryPredicate0D object");
+      return NULL;
+    }
+    if (!((BPy_UnaryPredicate1D *)obj3)->up1D) {
+      PyErr_SetString(
+          PyExc_TypeError,
+          "Operators.recursive_split(): 3rd argument: invalid UnaryPredicate1D object");
+      return NULL;
+    }
+    if (Operators::recursiveSplit(*(((BPy_UnaryFunction0DDouble *)obj1)->uf0D_double),
+                                  *(((BPy_UnaryPredicate0D *)obj2)->up0D),
+                                  *(((BPy_UnaryPredicate1D *)obj3)->up1D),
+                                  f) < 0) {
+      if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "Operators.recursive_split() failed");
+      return NULL;
+    }
+  }
+  else {
+    PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
+    return NULL;
+  }
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Operators_sort_doc,
-".. staticmethod:: sort(pred)\n"
-"\n"
-"   Sorts the current set of chains (or viewedges) according to the\n"
-"   comparison predicate given as argument.\n"
-"\n"
-"   :arg pred: The binary predicate used for the comparison.\n"
-"   :type pred: :class:`BinaryPredicate1D`");
+             ".. staticmethod:: sort(pred)\n"
+             "\n"
+             "   Sorts the current set of chains (or viewedges) according to the\n"
+             "   comparison predicate given as argument.\n"
+             "\n"
+             "   :arg pred: The binary predicate used for the comparison.\n"
+             "   :type pred: :class:`BinaryPredicate1D`");
 
 static PyObject *Operators_sort(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
 {
-	static const char *kwlist[] = {"pred", NULL};
-	PyObject *obj = 0;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &BinaryPredicate1D_Type, &obj))
-		return NULL;
-	if (!((BPy_BinaryPredicate1D *)obj)->bp1D) {
-		PyErr_SetString(PyExc_TypeError, "Operators.sort(): 1st argument: invalid BinaryPredicate1D object");
-		return NULL;
-	}
-	if (Operators::sort(*(((BPy_BinaryPredicate1D *)obj)->bp1D)) < 0) {
-		if (!PyErr_Occurred())
-			PyErr_SetString(PyExc_RuntimeError, "Operators.sort() failed");
-		return NULL;
-	}
-	Py_RETURN_NONE;
+  static const char *kwlist[] = {"pred", NULL};
+  PyObject *obj = 0;
+
+  if (!PyArg_ParseTupleAndKeywords(
+          args, kwds, "O!", (char **)kwlist, &BinaryPredicate1D_Type, &obj))
+    return NULL;
+  if (!((BPy_BinaryPredicate1D *)obj)->bp1D) {
+    PyErr_SetString(PyExc_TypeError,
+                    "Operators.sort(): 1st argument: invalid BinaryPredicate1D object");
+    return NULL;
+  }
+  if (Operators::sort(*(((BPy_BinaryPredicate1D *)obj)->bp1D)) < 0) {
+    if (!PyErr_Occurred())
+      PyErr_SetString(PyExc_RuntimeError, "Operators.sort() failed");
+    return NULL;
+  }
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Operators_create_doc,
-".. staticmethod:: create(pred, shaders)\n"
-"\n"
-"   Creates and shades the strokes from the current set of chains.  A\n"
-"   predicate can be specified to make a selection pass on the chains.\n"
-"\n"
-"   :arg pred: The predicate that a chain must verify in order to be\n"
-"      transform as a stroke.\n"
-"   :type pred: :class:`UnaryPredicate1D`\n"
-"   :arg shaders: The list of shaders used to shade the strokes.\n"
-"   :type shaders: list of :class:`StrokeShader` objects");
+             ".. staticmethod:: create(pred, shaders)\n"
+             "\n"
+             "   Creates and shades the strokes from the current set of chains.  A\n"
+             "   predicate can be specified to make a selection pass on the chains.\n"
+             "\n"
+             "   :arg pred: The predicate that a chain must verify in order to be\n"
+             "      transform as a stroke.\n"
+             "   :type pred: :class:`UnaryPredicate1D`\n"
+             "   :arg shaders: The list of shaders used to shade the strokes.\n"
+             "   :type shaders: list of :class:`StrokeShader` objects");
 
 static PyObject *Operators_create(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
 {
-	static const char *kwlist[] = {"pred", "shaders", NULL};
-	PyObject *obj1 = 0, *obj2 = 0;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", (char **)kwlist,
-	                                 &UnaryPredicate1D_Type, &obj1, &PyList_Type, &obj2))
-	{
-		return NULL;
-	}
-	if (!((BPy_UnaryPredicate1D *)obj1)->up1D) {
-		PyErr_SetString(PyExc_TypeError, "Operators.create(): 1st argument: invalid UnaryPredicate1D object");
-		return NULL;
-	}
-	vector<StrokeShader *> shaders;
-	shaders.reserve(PyList_Size(obj2));
-	for (int i = 0; i < PyList_Size(obj2); i++) {
-		PyObject *py_ss = PyList_GET_ITEM(obj2, i);
-		if (!BPy_StrokeShader_Check(py_ss)) {
-			PyErr_SetString(PyExc_TypeError, "Operators.create(): 2nd argument must be a list of StrokeShader objects");
-			return NULL;
-		}
-		StrokeShader *shader = ((BPy_StrokeShader *)py_ss)->ss;
-		if (!shader) {
-			stringstream ss;
-			ss << "Operators.create(): item " << (i + 1)
-			   << " of the shaders list is invalid likely due to missing call of StrokeShader.__init__()";
-			PyErr_SetString(PyExc_TypeError, ss.str().c_str());
-			return NULL;
-		}
-		shaders.push_back(shader);
-	}
-	if (Operators::create(*(((BPy_UnaryPredicate1D *)obj1)->up1D), shaders) < 0) {
-		if (!PyErr_Occurred())
-			PyErr_SetString(PyExc_RuntimeError, "Operators.create() failed");
-		return NULL;
-	}
-	Py_RETURN_NONE;
+  static const char *kwlist[] = {"pred", "shaders", NULL};
+  PyObject *obj1 = 0, *obj2 = 0;
+
+  if (!PyArg_ParseTupleAndKeywords(args,
+                                   kwds,
+                                   "O!O!",
+                                   (char **)kwlist,
+                                   &UnaryPredicate1D_Type,
+                                   &obj1,
+                                   &PyList_Type,
+                                   &obj2)) {
+    return NULL;
+  }
+  if (!((BPy_UnaryPredicate1D *)obj1)->up1D) {
+    PyErr_SetString(PyExc_TypeError,
+                    "Operators.create(): 1st argument: invalid UnaryPredicate1D object");
+    return NULL;
+  }
+  vector<StrokeShader *> shaders;
+  shaders.reserve(PyList_Size(obj2));
+  for (int i = 0; i < PyList_Size(obj2); i++) {
+    PyObject *py_ss = PyList_GET_ITEM(obj2, i);
+    if (!BPy_StrokeShader_Check(py_ss)) {
+      PyErr_SetString(PyExc_TypeError,
+                      "Operators.create(): 2nd argument must be a list of StrokeShader objects");
+      return NULL;
+    }
+    StrokeShader *shader = ((BPy_StrokeShader *)py_ss)->ss;
+    if (!shader) {
+      stringstream ss;
+      ss << "Operators.create(): item " << (i + 1)
+         << " of the shaders list is invalid likely due to missing call of "
+            "StrokeShader.__init__()";
+      PyErr_SetString(PyExc_TypeError, ss.str().c_str());
+      return NULL;
+    }
+    shaders.push_back(shader);
+  }
+  if (Operators::create(*(((BPy_UnaryPredicate1D *)obj1)->up1D), shaders) < 0) {
+    if (!PyErr_Occurred())
+      PyErr_SetString(PyExc_RuntimeError, "Operators.create() failed");
+    return NULL;
+  }
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Operators_reset_doc,
-".. staticmethod:: reset(delete_strokes=True)\n"
-"\n"
-"   Resets the line stylization process to the initial state.  The results of\n"
-"   stroke creation are accumulated if **delete_strokes** is set to False.\n"
-"\n"
-"   :arg delete_strokes: Delete the strokes that are currently stored.\n"
-"   :type delete_strokes: bool\n");
+             ".. staticmethod:: reset(delete_strokes=True)\n"
+             "\n"
+             "   Resets the line stylization process to the initial state.  The results of\n"
+             "   stroke creation are accumulated if **delete_strokes** is set to False.\n"
+             "\n"
+             "   :arg delete_strokes: Delete the strokes that are currently stored.\n"
+             "   :type delete_strokes: bool\n");
 
 static PyObject *Operators_reset(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
 {
-	static const char *kwlist[] = {"delete_strokes", NULL};
-	PyObject *obj1 = 0;
-	if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist, &PyBool_Type, &obj1)) {
-		// true is the default
-		Operators::reset(obj1 ? bool_from_PyBool(obj1) : true);
-	}
-	else {
-		PyErr_SetString(PyExc_RuntimeError, "Operators.reset() failed");
-		return NULL;
-	}
-	Py_RETURN_NONE;
+  static const char *kwlist[] = {"delete_strokes", NULL};
+  PyObject *obj1 = 0;
+  if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist, &PyBool_Type, &obj1)) {
+    // true is the default
+    Operators::reset(obj1 ? bool_from_PyBool(obj1) : true);
+  }
+  else {
+    PyErr_SetString(PyExc_RuntimeError, "Operators.reset() failed");
+    return NULL;
+  }
+  Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(Operators_get_viewedge_from_index_doc,
-".. staticmethod:: get_viewedge_from_index(i)\n"
-"\n"
-"   Returns the ViewEdge at the index in the current set of ViewEdges.\n"
-"\n"
-"   :arg i: index (0 <= i < Operators.get_view_edges_size()).\n"
-"   :type i: int\n"
-"   :return: The ViewEdge object.\n"
-"   :rtype: :class:`ViewEdge`");
-
-static PyObject *Operators_get_viewedge_from_index(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
+             ".. staticmethod:: get_viewedge_from_index(i)\n"
+             "\n"
+             "   Returns the ViewEdge at the index in the current set of ViewEdges.\n"
+             "\n"
+             "   :arg i: index (0 <= i < Operators.get_view_edges_size()).\n"
+             "   :type i: int\n"
+             "   :return: The ViewEdge object.\n"
+             "   :rtype: :class:`ViewEdge`");
+
+static PyObject *Operators_get_viewedge_from_index(BPy_Operators * /*self*/,
+                                                   PyObject *args,
+                                                   PyObject *kwds)
 {
-	static const char *kwlist[] = {"i", NULL};
-	unsigned int i;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
-		return NULL;
-	if (i >= Operators::getViewEdgesSize()) {
-		PyErr_SetString(PyExc_IndexError, "index out of range");
-		return NULL;
-	}
-	return BPy_ViewEdge_from_ViewEdge(*(Operators::getViewEdgeFromIndex(i)));
+  static const char *kwlist[] = {"i", NULL};
+  unsigned int i;
+
+  if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
+    return NULL;
+  if (i >= Operators::getViewEdgesSize()) {
+    PyErr_SetString(PyExc_IndexError, "index out of range");
+    return NULL;
+  }
+  return BPy_ViewEdge_from_ViewEdge(*(Operators::getViewEdgeFromIndex(i)));
 }
 
 PyDoc_STRVAR(Operators_get_chain_from_index_doc,
-".. staticmethod:: get_chain_from_index(i)\n"
-"\n"
-"   Returns the Chain at the index in the current set of Chains.\n"
-"\n"
-"   :arg i: index (0 <= i < Operators.get_chains_size()).\n"
-"   :type i: int\n"
-"   :return: The Chain object.\n"
-"   :rtype: :class:`Chain`");
-
-static PyObject *Operators_get_chain_from_index(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
+             ".. staticmethod:: get_chain_from_index(i)\n"
+             "\n"
+             "   Returns the Chain at the index in the current set of Chains.\n"
+             "\n"
+             "   :arg i: index (0 <= i < Operators.get_chains_size()).\n"
+             "   :type i: int\n"
+             "   :return: The Chain object.\n"
+             "   :rtype: :class:`Chain`");
+
+static PyObject *Operators_get_chain_from_index(BPy_Operators * /*self*/,
+                                                PyObject *args,
+                                                PyObject *kwds)
 {
-	static const char *kwlist[] = {"i", NULL};
-	unsigned int i;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
-		return NULL;
-	if (i >= Operators::getChainsSize()) {
-		PyErr_SetString(PyExc_IndexError, "index out of range");
-		return NULL;
-	}
-	return BPy_Chain_from_Chain(*(Operators::getChainFromIndex(i)));
+  static const char *kwlist[] = {"i", NULL};
+  unsigned int i;
+
+  if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
+    return NULL;
+  if (i >= Operators::getChainsSize()) {
+    PyErr_SetString(PyExc_IndexError, "index out of range");
+    return NULL;
+  }
+  return BPy_Chain_from_Chain(*(Operators::getChainFromIndex(i)));
 }
 
 PyDoc_STRVAR(Operators_get_stroke_from_index_doc,
-".. staticmethod:: get_stroke_from_index(i)\n"
-"\n"
-"   Returns the Stroke at the index in the current set of Strokes.\n"
-"\n"
-"   :arg i: index (0 <= i < Operators.get_strokes_size()).\n"
-"   :type i: int\n"
-"   :return: The Stroke object.\n"
-"   :rtype: :class:`Stroke`");
-
-static PyObject *Operators_get_stroke_from_index(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
+             ".. staticmethod:: get_stroke_from_index(i)\n"
+             "\n"
+             "   Returns the Stroke at the index in the current set of Strokes.\n"
+             "\n"
+             "   :arg i: index (0 <= i < Operators.get_strokes_size()).\n"
+             "   :type i: int\n"
+             "   :return: The Stroke object.\n"
+             "   :rtype: :class:`Stroke`");
+
+static PyObject *Operators_get_stroke_from_index(BPy_Operators * /*self*/,
+                                                 PyObject *args,
+                                                 PyObject *kwds)
 {
-	static const char *kwlist[] = {"i", NULL};
-	unsigned int i;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
-		return NULL;
-	if (i >= Operators::getStrokesSize()) {
-		PyErr_SetString(PyExc_IndexError, "index out of range");
-		return NULL;
-	}
-	return BPy_Stroke_from_Stroke(*(Operators::getStrokeFromIndex(i)));
+  static const char *kwlist[] = {"i", NULL};
+  unsigned int i;
+
+  if (!PyArg_ParseTupleAndKeywords(args, kwds, "I", (char **)kwlist, &i))
+    return NULL;
+  if (i >= Operators::getStrokesSize()) {
+    PyErr_SetString(PyExc_IndexError, "index out of range");
+    return NULL;
+  }
+  return BPy_Stroke_from_Stroke(*(Operators::getStrokeFromIndex(i)));
 }
 
 PyDoc_STRVAR(Operators_get_view_edges_size_doc,
-".. staticmethod:: get_view_edges_size()\n"
-"\n"
-"   Returns the number of ViewEdges.\n"
-"\n"
-"   :return: The number of ViewEdges.\n"
-"   :rtype: int");
+             ".. staticmethod:: get_view_edges_size()\n"
+             "\n"
+             "   Returns the number of ViewEdges.\n"
+             "\n"
+             "   :return: The number of ViewEdges.\n"
+             "   :rtype: int");
 
 static PyObject *Operators_get_view_edges_size(BPy_Operators * /*self*/)
 {
-	return PyLong_FromLong(Operators::getViewEdgesSize());
+  return PyLong_FromLong(Operators::getViewEdgesSize());
 }
 
 PyDoc_STRVAR(Operators_get_chains_size_doc,
-".. staticmethod:: get_chains_size()\n"
-"\n"
-"   Returns the number of Chains.\n"
-"\n"
-"   :return: The number of Chains.\n"
-"   :rtype: int");
+             ".. staticmethod:: get_chains_size()\n"
+             "\n"
+             "   Returns the number of Chains.\n"
+             "\n"
+             "   :return: The number of Chains.\n"
+             "   :rtype: int");
 
 static PyObject *Operators_get_chains_size(BPy_Operators * /*self*/)
 {
-	return PyLong_FromLong(Operators::getChainsSize());
+  return PyLong_FromLong(Operators::getChainsSize());
 }
 
 PyDoc_STRVAR(Operators_get_strokes_size_doc,
-".. staticmethod:: get_strokes_size()\n"
-"\n"
-"   Returns the number of Strokes.\n"
-"\n"
-"   :return: The number of Strokes.\n"
-"   :rtype: int");
+             ".. staticmethod:: get_strokes_size()\n"
+             "\n"
+             "   Returns the number of Strokes.\n"
+             "\n"
+             "   :return: The number of Strokes.\n"
+             "   :rtype: int");
 
 static PyObject *Operators_get_strokes_size(BPy_Operators * /*self*/)
 {
-	return PyLong_FromLong(Operators::getStrokesSize());
+  return PyLong_FromLong(Operators::getStrokesSize());
 }
 
 /*----------------------Operators instance definitions ----------------------------*/
 static PyMethodDef BPy_Operators_methods[] = {
-	{"select", (PyCFunction) Operators_select, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_select_doc},
-	{"chain", (PyCFunction) Operators_chain, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_chain_doc},
-	{"bidirectional_chain", (PyCFunction) Operators_bidirectional_chain, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
-	                        Operators_bidirectional_chain_doc},
-	{"sequential_split", (PyCFunction) Operators_sequential_split, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
-	                     Operators_sequential_split_doc},
-	{"recursive_split", (PyCFunction) Operators_recursive_split, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
-	                    Operators_recursive_split_doc},
-	{"sort", (PyCFunction) Operators_sort, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_sort_doc},
-	{"create", (PyCFunction) Operators_create, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_create_doc},
-	{"reset", (PyCFunction) Operators_reset, METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_reset_doc},
-	{"get_viewedge_from_index", (PyCFunction) Operators_get_viewedge_from_index,
-	                            METH_VARARGS | METH_KEYWORDS | METH_STATIC, Operators_get_viewedge_from_index_doc},
-	{"get_chain_from_index", (PyCFunction) Operators_get_chain_from_index, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
-	                         Operators_get_chain_from_index_doc},
-	{"get_stroke_from_index", (PyCFunction) Operators_get_stroke_from_index, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
-	                          Operators_get_stroke_from_index_doc},
-	{"get_view_edges_size", (PyCFunction) Operators_get_view_edges_size, METH_NOARGS | METH_STATIC,
-	                        Operators_get_view_edges_size_doc},
-	{"get_chains_size", (PyCFunction) Operators_get_chains_size, METH_NOARGS | METH_STATIC,
-	                    Operators_get_chains_size_doc},
-	{"get_strokes_size", (PyCFunction) Operators_get_strokes_size, METH_NOARGS | METH_STATIC,
-	                     Operators_get_strokes_size_doc},
-	{NULL, NULL, 0, NULL},
+    {"select",
+     (PyCFunction)Operators_select,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_select_doc},
+    {"chain",
+     (PyCFunction)Operators_chain,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_chain_doc},
+    {"bidirectional_chain",
+     (PyCFunction)Operators_bidirectional_chain,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_bidirectional_chain_doc},
+    {"sequential_split",
+     (PyCFunction)Operators_sequential_split,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_sequential_split_doc},
+    {"recursive_split",
+     (PyCFunction)Operators_recursive_split,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_recursive_split_doc},
+    {"sort",
+     (PyCFunction)Operators_sort,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_sort_doc},
+    {"create",
+     (PyCFunction)Operators_create,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_create_doc},
+    {"reset",
+     (PyCFunction)Operators_reset,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_reset_doc},
+    {"get_viewedge_from_index",
+     (PyCFunction)Operators_get_viewedge_from_index,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_get_viewedge_from_index_doc},
+    {"get_chain_from_index",
+     (PyCFunction)Operators_get_chain_from_index,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_get_chain_from_index_doc},
+    {"get_stroke_from_index",
+     (PyCFunction)Operators_get_stroke_from_index,
+     METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+     Operators_get_stroke_from_index_doc},
+    {"get_view_edges_size",
+     (PyCFunction)Operators_get_view_edges_size,
+     METH_NOARGS | METH_STATIC,
+     Operators_get_view_edges_size_doc},
+    {"get_chains_size",
+     (PyCFunction)Operators_get_chains_size,
+     METH_NOARGS | METH_STATIC,
+     Operators_get_chains_size_doc},
+    {"get_strokes_size",
+     (PyCFunction)Operators_get_strokes_size,
+     METH_NOARGS | METH_STATIC,
+     Operators_get_strokes_size_doc},
+    {NULL, NULL, 0, NULL},
 };
 
 /*-----------------------BPy_Operators type definition ------------------------------*/
 
 PyTypeObject Operators_Type = {
-	PyVarObject_HEAD_INIT(NULL, 0)
-	"Operators",                    /* tp_name */
-	sizeof(BPy_Operators),          /* tp_basicsize */
-	0,                              /* tp_itemsize */
-	(destructor)Operators_dealloc,  /* tp_dealloc */
-	0,                              /* tp_print */
-	0,                              /* tp_getattr */
-	0,                              /* tp_setattr */
-	0,                              /* tp_reserved */
-	0,                              /* tp_repr */
-	0,                              /* tp_as_number */
-	0,                              /* tp_as_sequence */
-	0,                              /* tp_as_mapping */
-	0,                              /* tp_hash  */
-	0,                              /* tp_call */
-	0,                              /* tp_str */
-	0,                              /* tp_getattro */
-	0,                              /* tp_setattro */
-	0,                              /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT,             /* tp_flags */
-	Operators_doc,                  /* tp_doc */
-	0,                              /* tp_traverse */
-	0,                              /* tp_clear */
-	0,                              /* tp_richcompare */
-	0,                              /* tp_weaklistoffset */
-	0,                              /* tp_iter */
-	0,                              /* tp_iternext */
-	BPy_Operators_methods,          /* tp_methods */
-	0,                              /* tp_members */
-	0,                              /* tp_getset */
-	0,                              /* tp_base */
-	0,                              /* tp_dict */
-	0,                              /* tp_descr_get */
-	0,                              /* tp_descr_set */
-	0,                              /* tp_dictoffset */
-	0,                              /* tp_init */
-	0,                              /* tp_alloc */
-	PyType_GenericNew,              /* tp_new */
+    PyVarObject_HEAD_INIT(NULL, 0) "Operators", /* tp_name */
+    sizeof(BPy_Operators),                      /* tp_basicsize */
+    0,                                          /* tp_itemsize */
+    (destructor)Operators_dealloc,              /* tp_dealloc */
+    0,                                          /* tp_print */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_reserved */
+    0,                                          /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash  */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                                          /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                         /* tp_flags */
+    Operators_doc,                              /* tp_doc */
+    0,                                          /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    BPy_Operators_methods,                      /* tp_methods */
+    0,                                          /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                                          /* tp_init */
+    0,                                          /* tp_alloc */
+    PyType_GenericNew,                          /* tp_new */
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////