archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Pydoc: Fix sphinx compile warnings about freestyle

Browse Source 
Sphinx expects functions and methods with the same name and different
parameters to be written using one directive. See:
https://www.sphinx-doc.org/en/master/usage/restructuredtext/domains.html#basic-markup

Unfortunately this makes giving different descriptions for each harder.
This was already a request for better support for this in sphinx, see:
https://github.com/sphinx-doc/sphinx/issues/7787

Reviewed By: campbellbarton

Differential Revision: https://developer.blender.org/D9170
This commit is contained in:
Aaron Carlisle
2020-10-22 17:20:57 -04:00
committed by Aaron Carlisle
parent 956af16189
commit baa24f1c91
35 changed files with 305 additions and 540 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp
View File

@@ -55,21 +55,14 @@ PyDoc_STRVAR(
"Class defining a material.\n" "Class defining a material.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(line, diffuse, ambient, specular, emission, shininess, priority)\n"
"\n" "\n"
" Default constructor.\n" " Creates a :class:`FrsMaterial` using either default constructor,\n"
" copy constructor, or an overloaded constructor\n"
"\n" "\n"
".. method:: __init__(brother)\n" " :arg brother: A Material object to be used as a copy constructor.\n"
"\n"
" Copy constructor.\n"
"\n"
" :arg brother: A Material object.\n"
" :type brother: :class:`Material`\n" " :type brother: :class:`Material`\n"
"\n"
".. method:: __init__(line, diffuse, ambient, specular, emission, shininess, priority)\n"
"\n"
" Builds a Material from its line, diffuse, ambient, specular, emissive\n"
" colors, a shininess coefficient and line color priority.\n"
"\n"
" :arg line: The line color.\n" " :arg line: The line color.\n"
" :type line: :class:`mathutils.Vector`, list or tuple of 4 float values\n" " :type line: :class:`mathutils.Vector`, list or tuple of 4 float values\n"
" :arg diffuse: The diffuse color.\n" " :arg diffuse: The diffuse color.\n"

33
source/blender/freestyle/intern/python/BPy_Id.cpp
View File

@@ -46,24 +46,21 @@ int Id_Init(PyObject *module)
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(Id_doc, PyDoc_STRVAR(
"Class for representing an object Id.\n" Id_doc,
"\n" "Class for representing an object Id.\n"
".. method:: __init__(first=0, second=0)\n" "\n"
"\n" ".. method:: __init__(brother)\n"
" Build the Id from two numbers.\n" " __init__(first=0, second=0)\n"
"\n" "\n"
" :arg first: The first number.\n" " Build the Id from two numbers or another :class:`Id` using the copy constructor.\n"
" :type first: int\n" "\n"
" :arg second: The second number.\n" " :arg brother: An Id object.\n"
" :type second: int\n" " :type brother: :class:`Id`"
"\n" " :arg first: The first number.\n"
".. method:: __init__(brother)\n" " :type first: int\n"
"\n" " :arg second: The second number.\n"
" Copy constructor.\n" " :type second: int\n");
"\n"
" :arg brother: An Id object.\n"
" :type brother: :class:`Id`");
static int Id_init(BPy_Id *self, PyObject *args, PyObject *kwds) static int Id_init(BPy_Id *self, PyObject *args, PyObject *kwds)
{ {

183
source/blender/freestyle/intern/python/BPy_Operators.cpp
View File

@@ -101,6 +101,7 @@ static PyObject *Operators_select(BPy_Operators * /*self*/, PyObject *args, PyOb
PyDoc_STRVAR(Operators_chain_doc, PyDoc_STRVAR(Operators_chain_doc,
".. staticmethod:: chain(it, pred, modifier)\n" ".. staticmethod:: chain(it, pred, modifier)\n"
" chain(it, pred)\n"
"\n" "\n"
" Builds a set of chains from the current set of ViewEdges. Each\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" " ViewEdge of the current list starts a new chain. The chaining\n"
@@ -116,28 +117,9 @@ PyDoc_STRVAR(Operators_chain_doc,
" :type pred: :class:`UnaryPredicate1D`\n" " :type pred: :class:`UnaryPredicate1D`\n"
" :arg modifier: A function that takes a ViewEdge as argument and\n" " :arg modifier: A function that takes a ViewEdge as argument and\n"
" that is used to modify the processed ViewEdge state (the\n" " that is used to modify the processed ViewEdge state (the\n"
" timestamp incrementation is a typical illustration of such a\n" " timestamp incrementation is a typical illustration of such a modifier).\n"
" modifier).\n" " If this argument is not given, the time stamp is automatically managed.\n"
" :type modifier: :class:`UnaryFunction1DVoid`\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 PyObject *Operators_chain(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
{ {
@@ -195,6 +177,7 @@ static PyObject *Operators_chain(BPy_Operators * /*self*/, PyObject *args, PyObj
PyDoc_STRVAR(Operators_bidirectional_chain_doc, PyDoc_STRVAR(Operators_bidirectional_chain_doc,
".. staticmethod:: bidirectional_chain(it, pred)\n" ".. staticmethod:: bidirectional_chain(it, pred)\n"
" bidirectional_chain(it)\n"
"\n" "\n"
" Builds a set of chains from the current set of ViewEdges. Each\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" " ViewEdge of the current list potentially starts a new chain. The\n"
@@ -211,30 +194,10 @@ PyDoc_STRVAR(Operators_bidirectional_chain_doc,
" :arg it: The ChainingIterator on the ViewEdges of the ViewMap. It\n" " :arg it: The ChainingIterator on the ViewEdges of the ViewMap. It\n"
" contains the chaining rule.\n" " contains the chaining rule.\n"
" :type it: :class:`ChainingIterator`\n" " :type it: :class:`ChainingIterator`\n"
" :arg pred: The predicate on the ViewEdge that expresses the\n" " :arg pred: The predicate on the ViewEdge that expresses the stopping condition.\n"
" stopping condition.\n" " This parameter is optional, you make not want to pass a stopping criterion\n"
" :type pred: :class:`UnaryPredicate1D`\n" " when the stopping criterion is already contained in the iterator definition.\n"
"\n" " :type pred: :class:`UnaryPredicate1D`\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*/, static PyObject *Operators_bidirectional_chain(BPy_Operators * /*self*/,
PyObject *args, PyObject *args,
@@ -287,44 +250,34 @@ static PyObject *Operators_bidirectional_chain(BPy_Operators * /*self*/,
PyDoc_STRVAR(Operators_sequential_split_doc, PyDoc_STRVAR(Operators_sequential_split_doc,
".. staticmethod:: sequential_split(starting_pred, stopping_pred, sampling=0.0)\n" ".. staticmethod:: sequential_split(starting_pred, stopping_pred, sampling=0.0)\n"
" sequential_split(pred, sampling=0.0)\n"
"\n" "\n"
" Splits each chain of the current set of chains in a sequential way.\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" " The points of each chain are processed (with a specified sampling)\n"
" sequentially. Each time a user specified starting condition is\n" " sequentially. The first point of the initial chain is the\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" " first point of one of the resulting chains. The splitting ends when\n"
" no more chain can start.\n" " no more chain can start.\n"
"\n" "\n"
" .. tip::\n"
"\n"
" By specifiying a starting and stopping predicate allows\n"
" the chains to overlapp rather than chains partitioning.\n"
"\n"
" :arg starting_pred: The predicate on a point that expresses the\n" " :arg starting_pred: The predicate on a point that expresses the\n"
" starting condition.\n" " starting condition. Each time this condition is verified, a new chain begins\n"
" :type starting_pred: :class:`UnaryPredicate0D`\n" " :type starting_pred: :class:`UnaryPredicate0D`\n"
" :arg stopping_pred: The predicate on a point that expresses the\n" " :arg stopping_pred: The predicate on a point that expresses the\n"
" stopping condition.\n" " stopping condition. The chain ends as soon as this predicate is verified.\n"
" :type stopping_pred: :class:`UnaryPredicate0D`\n" " :type stopping_pred: :class:`UnaryPredicate0D`\n"
" :arg pred: The predicate on a point that expresses the splitting condition.\n"
" Each time the condition is verified, the chain is split into two chains.\n"
" The resulting set of chains is a partition of the initial chain\n"
" :type pred: :class:`UnaryPredicate0D`\n"
" :arg sampling: The resolution used to sample the chain for the\n" " :arg sampling: The resolution used to sample the chain for the\n"
" predicates evaluation. (The chain is not actually resampled;\n" " predicates evaluation. (The chain is not actually resampled;\n"
" a virtual point only progresses along the curve using this\n" " a virtual point only progresses along the curve using this\n"
" resolution.)\n" " resolution.)\n"
" :type sampling: float\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*/, static PyObject *Operators_sequential_split(BPy_Operators * /*self*/,
PyObject *args, PyObject *args,
@@ -389,61 +342,41 @@ static PyObject *Operators_sequential_split(BPy_Operators * /*self*/,
Py_RETURN_NONE; Py_RETURN_NONE;
} }
PyDoc_STRVAR(Operators_recursive_split_doc, PyDoc_STRVAR(
".. staticmethod:: recursive_split(func, pred_1d, sampling=0.0)\n" Operators_recursive_split_doc,
"\n" ".. staticmethod:: recursive_split(func, pred_1d, sampling=0.0)\n"
" Splits the current set of chains in a recursive way. We process the\n" " recursive_split(func, pred_0d, pred_1d, sampling=0.0)\n"
" points of each chain (with a specified sampling) to find the point\n" "\n"
" minimizing a specified function. The chain is split in two at this\n" " Splits the current set of chains in a recursive way. We process the\n"
" point and the two new chains are processed in the same way. The\n" " points of each chain (with a specified sampling) to find the point\n"
" recursivity level is controlled through a predicate 1D that expresses\n" " minimizing a specified function. The chain is split in two at this\n"
" a stopping condition on the chain that is about to be processed.\n" " point and the two new chains are processed in the same way. The\n"
"\n" " recursivity level is controlled through a predicate 1D that expresses\n"
" :arg func: The Unary Function evaluated at each point of the chain.\n" " a stopping condition on the chain that is about to be processed.\n"
" The splitting point is the point minimizing this function.\n" "\n"
" :type func: :class:`UnaryFunction0DDouble`\n" " The user can also specify a 0D predicate to make a first selection on the points\n"
" :arg pred_1d: The Unary Predicate expressing the recursivity stopping\n" " that can potentially be split. A point that doesn't verify the 0D\n"
" condition. This predicate is evaluated for each curve before it\n" " predicate won't be candidate in realizing the min.\n"
" actually gets split. If pred_1d(chain) is true, the curve won't be\n" "\n"
" split anymore.\n" " :arg func: The Unary Function evaluated at each point of the chain.\n"
" :type pred_1d: :class:`UnaryPredicate1D`\n" " The splitting point is the point minimizing this function.\n"
" :arg sampling: The resolution used to sample the chain for the\n" " :type func: :class:`UnaryFunction0DDouble`\n"
" predicates evaluation. (The chain is not actually resampled, a\n" " :arg pred_0d: The Unary Predicate 0D used to select the candidate\n"
" virtual point only progresses along the curve using this\n" " points where the split can occur. For example, it is very likely\n"
" resolution.)\n" " that would rather have your chain splitting around its middle\n"
" :type sampling: float\n" " point than around one of its extremities. A 0D predicate working\n"
"\n" " on the curvilinear abscissa allows to add this kind of constraints.\n"
".. staticmethod:: recursive_split(func, pred_0d, pred_1d, sampling=0.0)\n" " :type pred_0d: :class:`UnaryPredicate0D`\n"
"\n" " :arg pred_1d: The Unary Predicate expressing the recursivity stopping\n"
" Splits the current set of chains in a recursive way. We process the\n" " condition. This predicate is evaluated for each curve before it\n"
" points of each chain (with a specified sampling) to find the point\n" " actually gets split. If pred_1d(chain) is true, the curve won't be\n"
" minimizing a specified function. The chain is split in two at this\n" " split anymore.\n"
" point and the two new chains are processed in the same way. The user\n" " :type pred_1d: :class:`UnaryPredicate1D`\n"
" can specify a 0D predicate to make a first selection on the points\n" " :arg sampling: The resolution used to sample the chain for the\n"
" that can potentially be split. A point that doesn't verify the 0D\n" " predicates evaluation. (The chain is not actually resampled; a\n"
" predicate won't be candidate in realizing the min. The recursivity\n" " virtual point only progresses along the curve using this\n"
" level is controlled through a predicate 1D that expresses a stopping\n" " resolution.)\n"
" condition on the chain that is about to be processed.\n" " :type sampling: float\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*/, static PyObject *Operators_recursive_split(BPy_Operators * /*self*/,
PyObject *args, PyObject *args,

26
source/blender/freestyle/intern/python/BPy_SShape.cpp
View File

@@ -50,20 +50,18 @@ int SShape_Init(PyObject *module)
/*----------------------SShape methods ----------------------------*/ /*----------------------SShape methods ----------------------------*/
PyDoc_STRVAR(SShape_doc, PyDoc_STRVAR(
"Class to define a feature shape. It is the gathering of feature\n" SShape_doc,
"elements from an identified input shape.\n" "Class to define a feature shape. It is the gathering of feature\n"
"\n" "elements from an identified input shape.\n"
".. method:: __init__()\n" "\n"
"\n" ".. method:: __init__()\n"
" Default constructor.\n" " __init__(brother)\n"
"\n" "\n"
".. method:: __init__(brother)\n" " Creates a :class:`SShape` class using either a default constructor or copy constructor.\n"
"\n" "\n"
" Copy constructor.\n" " :arg brother: An SShape object.\n"
"\n" " :type brother: :class:`SShape`");
" :arg brother: An SShape object.\n"
" :type brother: :class:`SShape`");
static int SShape_init(BPy_SShape *self, PyObject *args, PyObject *kwds) static int SShape_init(BPy_SShape *self, PyObject *args, PyObject *kwds)
{ {

24
source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
View File

@@ -53,20 +53,16 @@ PyDoc_STRVAR(StrokeAttribute_doc,
"Vertex.\n" "Vertex.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(red, green, blue, alpha, thickness_right, thickness_left)\n"
" __init__(attribute1, attribute2, t)\n"
"\n" "\n"
" Default constructor.\n" " Creates a :class:`StrokeAttribute` object using either a default constructor,\n"
" copy constructor, overloaded constructor, or and interpolation constructor\n"
" to interpolate between two :class:`StrokeAttribute` objects.\n"
"\n" "\n"
".. method:: __init__(brother)\n" " :arg brother: A StrokeAttribute object to be used as a copy constructor.\n"
"\n"
" Copy constructor.\n"
"\n"
" :arg brother: A StrokeAttribute object.\n"
" :type brother: :class:`StrokeAttribute`\n" " :type brother: :class:`StrokeAttribute`\n"
"\n"
".. method:: __init__(red, green, blue, alpha, thickness_right, thickness_left)\n"
"\n"
" Build a stroke vertex attribute from a set of parameters.\n"
"\n"
" :arg red: Red component of a stroke color.\n" " :arg red: Red component of a stroke color.\n"
" :type red: float\n" " :type red: float\n"
" :arg green: Green component of a stroke color.\n" " :arg green: Green component of a stroke color.\n"
@@ -79,12 +75,6 @@ PyDoc_STRVAR(StrokeAttribute_doc,
" :type thickness_right: float\n" " :type thickness_right: float\n"
" :arg thickness_left: Stroke thickness on the left.\n" " :arg thickness_left: Stroke thickness on the left.\n"
" :type thickness_left: float\n" " :type thickness_left: float\n"
"\n"
".. method:: __init__(attribute1, attribute2, t)\n"
"\n"
" Interpolation constructor. Build a StrokeAttribute from two\n"
" StrokeAttribute objects and an interpolation parameter.\n"
"\n"
" :arg attribute1: The first StrokeAttribute object.\n" " :arg attribute1: The first StrokeAttribute object.\n"
" :type attribute1: :class:`StrokeAttribute`\n" " :type attribute1: :class:`StrokeAttribute`\n"
" :arg attribute2: The second StrokeAttribute object.\n" " :arg attribute2: The second StrokeAttribute object.\n"

14
source/blender/freestyle/intern/python/BPy_ViewShape.cpp
View File

@@ -55,20 +55,14 @@ PyDoc_STRVAR(ViewShape_doc,
"and :class:`ViewEdge`) that are issued from the same input shape.\n" "and :class:`ViewEdge`) that are issued from the same input shape.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(sshape)\n"
"\n" "\n"
" Default constructor.\n" " Builds a :class:`ViewShape` using the default constructor,\n"
"\n" " copy constructor, or from a :class:`SShape`.\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: A ViewShape object.\n" " :arg brother: A ViewShape object.\n"
" :type brother: :class:`ViewShape`\n" " :type brother: :class:`ViewShape`\n"
"\n"
".. method:: __init__(sshape)\n"
"\n"
" Builds a ViewShape from an SShape.\n"
"\n"
" :arg sshape: An SShape object.\n" " :arg sshape: An SShape object.\n"
" :type sshape: :class:`SShape`"); " :type sshape: :class:`SShape`");

32
source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp
View File

@@ -44,40 +44,28 @@ PyDoc_STRVAR(CurvePoint_doc,
"given resolution.\n" "given resolution.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex, t2d)\n"
" __init__(first_point, second_point, t2d)\n"
"\n" "\n"
" Default constructor.\n" " Builds a CurvePoint using the default constructor, copy constructor,\n"
"\n" " or one of the overloaded constructors. The over loaded constructors\n"
".. method:: __init__(brother)\n" " can either take two :class:`SVertex` or two :class:`CurvePoint`\n"
"\n" " objects and an interpolation parameter\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: A CurvePoint object.\n" " :arg brother: A CurvePoint object.\n"
" :type brother: :class:`CurvePoint`\n" " :type brother: :class:`CurvePoint`\n"
"\n"
".. method:: __init__(first_vertex, second_vertex, t2d)\n"
"\n"
" Builds a CurvePoint from two SVertex objects and an interpolation parameter.\n"
"\n"
" :arg first_vertex: The first SVertex.\n" " :arg first_vertex: The first SVertex.\n"
" :type first_vertex: :class:`SVertex`\n" " :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex.\n" " :arg second_vertex: The second SVertex.\n"
" :type second_vertex: :class:`SVertex`\n" " :type second_vertex: :class:`SVertex`\n"
" :arg t2d: A 2D interpolation parameter used to linearly interpolate\n"
" first_vertex and second_vertex.\n"
" :type t2d: float\n"
"\n"
".. method:: __init__(first_point, second_point, t2d)\n"
"\n"
" Builds a CurvePoint from two CurvePoint objects and an interpolation\n"
" parameter.\n"
"\n"
" :arg first_point: The first CurvePoint.\n" " :arg first_point: The first CurvePoint.\n"
" :type first_point: :class:`CurvePoint`\n" " :type first_point: :class:`CurvePoint`\n"
" :arg second_point: The second CurvePoint.\n" " :arg second_point: The second CurvePoint.\n"
" :type second_point: :class:`CurvePoint`\n" " :type second_point: :class:`CurvePoint`\n"
" :arg t2d: The 2D interpolation parameter used to linearly interpolate\n" " :arg t2d: A 2D interpolation parameter used to linearly interpolate\n"
" first_point and second_point.\n" " first_vertex and second_vertex or first_point and second_point.\n"
" :type t2d: float"); " :type t2d: float\n");
static int CurvePoint_init(BPy_CurvePoint *self, PyObject *args, PyObject *kwds) static int CurvePoint_init(BPy_CurvePoint *self, PyObject *args, PyObject *kwds)
{ {

15
source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
View File

@@ -38,20 +38,15 @@ PyDoc_STRVAR(SVertex_doc,
"Class to define a vertex of the embedding.\n" "Class to define a vertex of the embedding.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(point_3d, id)\n"
"\n" "\n"
" Default constructor.\n" " Builds a :class:`SVertex` using the default constructor,\n"
"\n" " copy constructor or the overloaded constructor which builds"
".. method:: __init__(brother)\n" " a :class:`SVertex` from 3D coordinates and an Id.\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: A SVertex object.\n" " :arg brother: A SVertex object.\n"
" :type brother: :class:`SVertex`\n" " :type brother: :class:`SVertex`\n"
"\n"
".. method:: __init__(point_3d, id)\n"
"\n"
" Builds a SVertex from 3D coordinates and an Id.\n"
"\n"
" :arg point_3d: A three-dimensional vector.\n" " :arg point_3d: A three-dimensional vector.\n"
" :type point_3d: :class:`mathutils.Vector`\n" " :type point_3d: :class:`mathutils.Vector`\n"
" :arg id: An Id object.\n" " :arg id: An Id object.\n"

35
source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp
View File

@@ -40,46 +40,29 @@ PyDoc_STRVAR(
"Class to define a stroke vertex.\n" "Class to define a stroke vertex.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex, t3d)\n"
" __init__(point)\n"
" __init__(svertex)\n"
" __init__(svertex, attribute)\n"
"\n" "\n"
" Default constructor.\n" " Builds a :class:`StrokeVertex` using the default constructor,\n"
"\n" " copy constructor, from 2 :class:`StrokeVertex` and an interpolation parameter,\n"
".. method:: __init__(brother)\n" " from a CurvePoint, from a SVertex, or a :class:`SVertex`"
"\n" " and a :class:`StrokeAttribute` object.\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: A StrokeVertex object.\n" " :arg brother: A StrokeVertex object.\n"
" :type brother: :class:`StrokeVertex`\n" " :type brother: :class:`StrokeVertex`\n"
"\n"
".. method:: __init__(first_vertex, second_vertex, t3d)\n"
"\n"
" Build a stroke vertex from 2 stroke vertices and an interpolation\n"
" parameter.\n"
"\n"
" :arg first_vertex: The first StrokeVertex.\n" " :arg first_vertex: The first StrokeVertex.\n"
" :type first_vertex: :class:`StrokeVertex`\n" " :type first_vertex: :class:`StrokeVertex`\n"
" :arg second_vertex: The second StrokeVertex.\n" " :arg second_vertex: The second StrokeVertex.\n"
" :type second_vertex: :class:`StrokeVertex`\n" " :type second_vertex: :class:`StrokeVertex`\n"
" :arg t3d: An interpolation parameter.\n" " :arg t3d: An interpolation parameter.\n"
" :type t3d: float\n" " :type t3d: float\n"
"\n"
".. method:: __init__(point)\n"
"\n"
" Build a stroke vertex from a CurvePoint\n"
"\n"
" :arg point: A CurvePoint object.\n" " :arg point: A CurvePoint object.\n"
" :type point: :class:`CurvePoint`\n" " :type point: :class:`CurvePoint`\n"
"\n"
".. method:: __init__(svertex)\n"
"\n"
" Build a stroke vertex from a SVertex\n"
"\n"
" :arg svertex: An SVertex object.\n" " :arg svertex: An SVertex object.\n"
" :type svertex: :class:`SVertex`\n" " :type svertex: :class:`SVertex`\n"
"\n"
".. method:: __init__(svertex, attribute)\n"
"\n"
" Build a stroke vertex from an SVertex and a StrokeAttribute object.\n"
"\n"
" :arg svertex: An SVertex object.\n" " :arg svertex: An SVertex object.\n"
" :type svertex: :class:`SVertex`\n" " :type svertex: :class:`SVertex`\n"
" :arg attribute: A StrokeAttribute object.\n" " :arg attribute: A StrokeAttribute object.\n"

30
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp
View File

@@ -31,22 +31,20 @@ extern "C" {
/*----------------------NonTVertex methods ----------------------------*/ /*----------------------NonTVertex methods ----------------------------*/
PyDoc_STRVAR(NonTVertex_doc, PyDoc_STRVAR(
"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`NonTVertex`\n" NonTVertex_doc,
"\n" "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`NonTVertex`\n"
"View vertex for corners, cusps, etc. associated to a single SVertex.\n" "\n"
"Can be associated to 2 or more view edges.\n" "View vertex for corners, cusps, etc. associated to a single SVertex.\n"
"\n" "Can be associated to 2 or more view edges.\n"
".. method:: __init__()\n" "\n"
"\n" ".. method:: __init__()\n"
" Default constructor.\n" " __init__(svertex)\n"
"\n" "\n"
".. method:: __init__(svertex)\n" " Builds a :class:`NonTVertex` using the default constructor or a :class:`SVertex`.\n"
"\n" "\n"
" Build a NonTVertex from a SVertex.\n" " :arg svertex: An SVertex object.\n"
"\n" " :type svertex: :class:`SVertex`");
" :arg svertex: An SVertex object.\n"
" :type svertex: :class:`SVertex`");
/* Note: No copy constructor in Python because the C++ copy constructor is 'protected'. */ /* Note: No copy constructor in Python because the C++ copy constructor is 'protected'. */

13
source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp
View File

@@ -48,20 +48,13 @@ PyDoc_STRVAR(FEdge_doc,
"from one to the other.\n" "from one to the other.\n"
"\n" "\n"
".. method:: FEdge()\n" ".. method:: FEdge()\n"
" FEdge(brother)\n"
"\n" "\n"
" Default constructor.\n" " Builds an :class:`FEdge` using the default constructor,\n"
"\n" " copy constructor, or between two :class:`SVertex` objects.\n"
".. method:: FEdge(brother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: An FEdge object.\n" " :arg brother: An FEdge object.\n"
" :type brother: :class:`FEdge`\n" " :type brother: :class:`FEdge`\n"
"\n"
".. method:: FEdge(first_vertex, second_vertex)\n"
"\n"
" Builds an FEdge going from the first vertex to the second.\n"
"\n"
" :arg first_vertex: The first SVertex.\n" " :arg first_vertex: The first SVertex.\n"
" :type first_vertex: :class:`SVertex`\n" " :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex.\n" " :arg second_vertex: The second SVertex.\n"

14
source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp
View File

@@ -41,20 +41,14 @@ PyDoc_STRVAR(FrsCurve_doc,
"specialization of a Curve.\n" "specialization of a Curve.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(id)\n"
"\n" "\n"
" Default Constructor.\n" " Builds a :class:`FrsCurve` using a default constructor,\n"
"\n" " copy constructor or from an :class:`Id`.\n"
".. method:: __init__(brother)\n"
"\n"
" Copy Constructor.\n"
"\n" "\n"
" :arg brother: A Curve object.\n" " :arg brother: A Curve object.\n"
" :type brother: :class:`Curve`\n" " :type brother: :class:`Curve`\n"
"\n"
".. method:: __init__(id)\n"
"\n"
" Builds a Curve from its Id.\n"
"\n"
" :arg id: An Id object.\n" " :arg id: An Id object.\n"
" :type id: :class:`Id`"); " :type id: :class:`Id`");

28
source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp
View File

@@ -50,12 +50,9 @@ PyDoc_STRVAR(Stroke_doc,
"defines the stroke's shape and appearance at this vertex position.\n" "defines the stroke's shape and appearance at this vertex position.\n"
"\n" "\n"
".. method:: Stroke()\n" ".. method:: Stroke()\n"
" Stroke(brother)\n"
"\n" "\n"
" Default constructor\n" " Creates a :class:`Stroke` using the default constructor or copy constructor\n");
"\n"
".. method:: Stroke(brother)\n"
"\n"
" Copy constructor");
static int Stroke_init(BPy_Stroke *self, PyObject *args, PyObject *kwds) static int Stroke_init(BPy_Stroke *self, PyObject *args, PyObject *kwds)
{ {
@@ -127,21 +124,18 @@ static PyObject *Stroke_compute_sampling(BPy_Stroke *self, PyObject *args, PyObj
PyDoc_STRVAR(Stroke_resample_doc, PyDoc_STRVAR(Stroke_resample_doc,
".. method:: resample(n)\n" ".. method:: resample(n)\n"
" resample(sampling)\n"
"\n" "\n"
" Resamples the stroke so that it eventually has N points. That means\n" " Resamples the stroke so using one of two methods with the goal\n"
" it is going to add N-vertices_size, where vertices_size is the\n" " of creating a stroke with fewer points and the same shape.\n"
" number of points we already have. If vertices_size >= N, no\n"
" resampling is done.\n"
"\n" "\n"
" :arg n: The number of vertices we eventually want in our stroke.\n" " :arg n: Resamples the stroke so that it eventually has N points. That means\n"
" it is going to add N-vertices_size, where vertices_size is the\n"
" number of points we already have. If vertices_size >= N, no\n"
" resampling is done.\n"
" :type n: int\n" " :type n: int\n"
"\n" " :arg sampling: Resamples the stroke with a given sampling value. If the\n"
".. method:: resample(sampling)\n" " sampling is smaller than the actual sampling value, no resampling is done.\n"
"\n"
" Resamples the stroke with a given sampling. If the sampling is\n"
" smaller than the actual sampling value, no resampling is done.\n"
"\n"
" :arg sampling: The new sampling value.\n"
" :type sampling: float"); " :type sampling: float");
static PyObject *Stroke_resample(BPy_Stroke *self, PyObject *args, PyObject *kwds) static PyObject *Stroke_resample(BPy_Stroke *self, PyObject *args, PyObject *kwds)

32
source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
View File

@@ -36,23 +36,21 @@ extern "C" {
/*----------------------ViewEdge methods ----------------------------*/ /*----------------------ViewEdge methods ----------------------------*/
PyDoc_STRVAR(ViewEdge_doc, PyDoc_STRVAR(
"Class hierarchy: :class:`Interface1D` > :class:`ViewEdge`\n" ViewEdge_doc,
"\n" "Class hierarchy: :class:`Interface1D` > :class:`ViewEdge`\n"
"Class defining a ViewEdge. A ViewEdge in an edge of the image graph.\n" "\n"
"it connects two :class:`ViewVertex` objects. It is made by connecting\n" "Class defining a ViewEdge. A ViewEdge in an edge of the image graph.\n"
"a set of FEdges.\n" "it connects two :class:`ViewVertex` objects. It is made by connecting\n"
"\n" "a set of FEdges.\n"
".. method:: __init__()\n" "\n"
"\n" ".. method:: __init__()\n"
" Default constructor.\n" " __init__(brother)\n"
"\n" "\n"
".. method:: __init__(brother)\n" " Builds a :class:`ViewEdge` using the default constructor or the copy constructor.\n"
"\n" "\n"
" Copy constructor.\n" " :arg brother: A ViewEdge object.\n"
"\n" " :type brother: :class:`ViewEdge`");
" :arg brother: A ViewEdge object.\n"
" :type brother: :class:`ViewEdge`");
static int ViewEdge_init(BPy_ViewEdge *self, PyObject *args, PyObject *kwds) static int ViewEdge_init(BPy_ViewEdge *self, PyObject *args, PyObject *kwds)
{ {

14
source/blender/freestyle/intern/python/Interface1D/Curve/BPy_Chain.cpp
View File

@@ -40,20 +40,14 @@ PyDoc_STRVAR(Chain_doc,
"Splitting and Creation processes.\n" "Splitting and Creation processes.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(id)\n"
"\n" "\n"
" Default constructor.\n" " Builds a :class:`Chain` using the default constructor,\n"
"\n" " copy constructor or from an :class:`Id`.\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: A Chain object.\n" " :arg brother: A Chain object.\n"
" :type brother: :class:`Chain`\n" " :type brother: :class:`Chain`\n"
"\n"
".. method:: __init__(id)\n"
"\n"
" Builds a chain from its Id.\n"
"\n"
" :arg id: An Id object.\n" " :arg id: An Id object.\n"
" :type id: :class:`Id`"); " :type id: :class:`Id`");

14
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp
View File

@@ -42,20 +42,14 @@ PyDoc_STRVAR(FEdgeSharp_doc,
"a is None.\n" "a is None.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex)\n"
"\n" "\n"
" Default constructor.\n" " Builds an :class:`FEdgeSharp` using the default constructor,\n"
"\n" " copy constructor, or between two :class:`SVertex` objects.\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: An FEdgeSharp object.\n" " :arg brother: An FEdgeSharp object.\n"
" :type brother: :class:`FEdgeSharp`\n" " :type brother: :class:`FEdgeSharp`\n"
"\n"
".. method:: __init__(first_vertex, second_vertex)\n"
"\n"
" Builds an FEdgeSharp going from the first vertex to the second.\n"
"\n"
" :arg first_vertex: The first SVertex object.\n" " :arg first_vertex: The first SVertex object.\n"
" :type first_vertex: :class:`SVertex`\n" " :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex object.\n" " :arg second_vertex: The second SVertex object.\n"

14
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp
View File

@@ -39,20 +39,14 @@ PyDoc_STRVAR(FEdgeSmooth_doc,
"a suggestive contour.\n" "a suggestive contour.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex)\n"
"\n" "\n"
" Default constructor.\n" " Builds an :class:`FEdgeSmooth` using the default constructor,\n"
"\n" " copy constructor, or between two :class:`SVertex`.\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: An FEdgeSmooth object.\n" " :arg brother: An FEdgeSmooth object.\n"
" :type brother: :class:`FEdgeSmooth`\n" " :type brother: :class:`FEdgeSmooth`\n"
"\n"
".. method:: __init__(first_vertex, second_vertex)\n"
"\n"
" Builds an FEdgeSmooth going from the first to the second.\n"
"\n"
" :arg first_vertex: The first SVertex object.\n" " :arg first_vertex: The first SVertex object.\n"
" :type first_vertex: :class:`SVertex`\n" " :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex object.\n" " :arg second_vertex: The second SVertex object.\n"

14
source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp
View File

@@ -41,20 +41,14 @@ PyDoc_STRVAR(
"traverse() method of the ChainingIterator.\n" "traverse() method of the ChainingIterator.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(vertex, restrict_to_selection=True, restrict_to_unvisited=True)\n"
"\n" "\n"
" Default constructor.\n" " Builds an :class:`AdjacencyIterator` using the default constructor,\n"
"\n" " copy constructor or the overloaded constructor.\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: An AdjacencyIterator object.\n" " :arg brother: An AdjacencyIterator object.\n"
" :type brother: :class:`AdjacencyIterator`\n" " :type brother: :class:`AdjacencyIterator`\n"
"\n"
".. method:: __init__(vertex, restrict_to_selection=True, restrict_to_unvisited=True)\n"
"\n"
" Builds a AdjacencyIterator object.\n"
"\n"
" :arg vertex: The vertex which is the next crossing.\n" " :arg vertex: The vertex which is the next crossing.\n"
" :type vertex: :class:`ViewVertex`\n" " :type vertex: :class:`ViewVertex`\n"
" :arg restrict_to_selection: Indicates whether to force the chaining\n" " :arg restrict_to_selection: Indicates whether to force the chaining\n"

93
source/blender/freestyle/intern/python/Iterator/BPy_ChainPredicateIterator.cpp
View File

@@ -33,55 +33,52 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(ChainPredicateIterator_doc, PyDoc_STRVAR(
ChainPredicateIterator_doc,
"Class hierarchy: :class:`freestyle.types.Iterator` >\n" "Class hierarchy: :class:`freestyle.types.Iterator` >\n"
":class:`freestyle.types.ViewEdgeIterator` >\n" ":class:`freestyle.types.ViewEdgeIterator` >\n"
":class:`freestyle.types.ChainingIterator` >\n" ":class:`freestyle.types.ChainingIterator` >\n"
":class:`ChainPredicateIterator`\n" ":class:`ChainPredicateIterator`\n"
"\n" "\n"
"A \"generic\" user-controlled ViewEdge iterator. This iterator is in\n" "A \"generic\" user-controlled ViewEdge iterator. This iterator is in\n"
"particular built from a unary predicate and a binary predicate.\n" "particular built from a unary predicate and a binary predicate.\n"
"First, the unary predicate is evaluated for all potential next\n" "First, the unary predicate is evaluated for all potential next\n"
"ViewEdges in order to only keep the ones respecting a certain\n" "ViewEdges in order to only keep the ones respecting a certain\n"
"constraint. Then, the binary predicate is evaluated on the current\n" "constraint. Then, the binary predicate is evaluated on the current\n"
"ViewEdge together with each ViewEdge of the previous selection. The\n" "ViewEdge together with each ViewEdge of the previous selection. The\n"
"first ViewEdge respecting both the unary predicate and the binary\n" "first ViewEdge respecting both the unary predicate and the binary\n"
"predicate is kept as the next one. If none of the potential next\n" "predicate is kept as the next one. If none of the potential next\n"
"ViewEdge respects these two predicates, None is returned.\n" "ViewEdge respects these two predicates, None is returned.\n"
"\n" "\n"
".. method:: __init__(upred, bpred, restrict_to_selection=True, " ".. method:: __init__(upred, bpred, restrict_to_selection=True, "
"restrict_to_unvisited=True, begin=None, " " restrict_to_unvisited=True, begin=None, "
"orientation=True)\n" " orientation=True)\n"
"\n" " __init__(brother)\n"
" Builds a ChainPredicateIterator from a unary predicate, a binary\n" "\n"
" predicate, a starting ViewEdge and its orientation.\n" " Builds a ChainPredicateIterator from a unary predicate, a binary\n"
"\n" " predicate, a starting ViewEdge and its orientation or using the copy constructor.\n"
" :arg upred: The unary predicate that the next ViewEdge must satisfy.\n" "\n"
" :type upred: :class:`freestyle.types.UnaryPredicate1D`\n" " :arg upred: The unary predicate that the next ViewEdge must satisfy.\n"
" :arg bpred: The binary predicate that the next ViewEdge must\n" " :type upred: :class:`freestyle.types.UnaryPredicate1D`\n"
" satisfy together with the actual pointed ViewEdge.\n" " :arg bpred: The binary predicate that the next ViewEdge must\n"
" :type bpred: :class:`freestyle.types.BinaryPredicate1D`\n" " satisfy together with the actual pointed ViewEdge.\n"
" :arg restrict_to_selection: Indicates whether to force the chaining\n" " :type bpred: :class:`freestyle.types.BinaryPredicate1D`\n"
" to stay within the set of selected ViewEdges or not.\n" " :arg restrict_to_selection: Indicates whether to force the chaining\n"
" :type restrict_to_selection: bool\n" " to stay within the set of selected ViewEdges or not.\n"
" :arg restrict_to_unvisited: Indicates whether a ViewEdge that has\n" " :type restrict_to_selection: bool\n"
" already been chained must be ignored ot not.\n" " :arg restrict_to_unvisited: Indicates whether a ViewEdge that has\n"
" :type restrict_to_unvisited: bool\n" " already been chained must be ignored ot not.\n"
" :arg begin: The ViewEdge from where to start the iteration.\n" " :type restrict_to_unvisited: bool\n"
" :type begin: :class:`freestyle.types.ViewEdge` or None\n" " :arg begin: The ViewEdge from where to start the iteration.\n"
" :arg orientation: If true, we'll look for the next ViewEdge among\n" " :type begin: :class:`freestyle.types.ViewEdge` or None\n"
" the ViewEdges that surround the ending ViewVertex of begin. If\n" " :arg orientation: If true, we'll look for the next ViewEdge among\n"
" false, we'll search over the ViewEdges surrounding the ending\n" " the ViewEdges that surround the ending ViewVertex of begin. If\n"
" ViewVertex of begin.\n" " false, we'll search over the ViewEdges surrounding the ending\n"
" :type orientation: bool\n" " ViewVertex of begin.\n"
"\n" " :type orientation: bool\n"
".. method:: __init__(brother)\n" " :arg brother: A ChainPredicateIterator object.\n"
"\n" " :type brother: :class:`ChainPredicateIterator`");
" Copy constructor.\n"
"\n"
" :arg brother: A ChainPredicateIterator object.\n"
" :type brother: :class:`ChainPredicateIterator`");
static int check_begin(PyObject *obj, void *v) static int check_begin(PyObject *obj, void *v)
{ {

8
source/blender/freestyle/intern/python/Iterator/BPy_ChainSilhouetteIterator.cpp
View File

@@ -48,9 +48,10 @@ PyDoc_STRVAR(ChainSilhouetteIterator_doc,
"precedence of the silhouette over the crease criterion.\n" "precedence of the silhouette over the crease criterion.\n"
"\n" "\n"
".. method:: __init__(restrict_to_selection=True, begin=None, orientation=True)\n" ".. method:: __init__(restrict_to_selection=True, begin=None, orientation=True)\n"
" __init__(brother)\n"
"\n" "\n"
" Builds a ChainSilhouetteIterator from the first ViewEdge used for\n" " Builds a ChainSilhouetteIterator from the first ViewEdge used for\n"
" iteration and its orientation.\n" " iteration and its orientation or the copy constructor.\n"
"\n" "\n"
" :arg restrict_to_selection: Indicates whether to force the chaining\n" " :arg restrict_to_selection: Indicates whether to force the chaining\n"
" to stay within the set of selected ViewEdges or not.\n" " to stay within the set of selected ViewEdges or not.\n"
@@ -62,11 +63,6 @@ PyDoc_STRVAR(ChainSilhouetteIterator_doc,
" false, we'll search over the ViewEdges surrounding the ending\n" " false, we'll search over the ViewEdges surrounding the ending\n"
" ViewVertex of begin.\n" " ViewVertex of begin.\n"
" :type orientation: bool\n" " :type orientation: bool\n"
"\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n"
" :arg brother: A ChainSilhouetteIterator object.\n" " :arg brother: A ChainSilhouetteIterator object.\n"
" :type brother: :class:`ChainSilhouetteIterator`"); " :type brother: :class:`ChainSilhouetteIterator`");

12
source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp
View File

@@ -46,11 +46,12 @@ PyDoc_STRVAR(
"they will be included in the adjacency iterator (i.e, the adjacent\n" "they will be included in the adjacency iterator (i.e, the adjacent\n"
"iterator will only stop on \"valid\" edges).\n" "iterator will only stop on \"valid\" edges).\n"
"\n" "\n"
".. method:: __init__(restrict_to_selection=True, restrict_to_unvisited=True, begin=None, " ".. method:: __init__(restrict_to_selection=True, restrict_to_unvisited=True,"
"orientation=True)\n" " begin=None, orientation=True)\n"
" __init__(brother)\n"
"\n" "\n"
" Builds a Chaining Iterator from the first ViewEdge used for\n" " Builds a Chaining Iterator from the first ViewEdge used for\n"
" iteration and its orientation.\n" " iteration and its orientation or by using the copy constructor.\n"
"\n" "\n"
" :arg restrict_to_selection: Indicates whether to force the chaining\n" " :arg restrict_to_selection: Indicates whether to force the chaining\n"
" to stay within the set of selected ViewEdges or not.\n" " to stay within the set of selected ViewEdges or not.\n"
@@ -63,11 +64,6 @@ PyDoc_STRVAR(
" :arg orientation: The direction to follow to explore the graph. If\n" " :arg orientation: The direction to follow to explore the graph. If\n"
" true, the direction indicated by the first ViewEdge is used.\n" " true, the direction indicated by the first ViewEdge is used.\n"
" :type orientation: bool\n" " :type orientation: bool\n"
"\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n"
" :arg brother: \n" " :arg brother: \n"
" :type brother: ChainingIterator"); " :type brother: ChainingIterator");

14
source/blender/freestyle/intern/python/Iterator/BPy_CurvePointIterator.cpp
View File

@@ -39,20 +39,14 @@ PyDoc_STRVAR(CurvePointIterator_doc,
"through the .object attribute.\n" "through the .object attribute.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(step=0.0)\n"
"\n" "\n"
" Default constructor.\n" " Builds a CurvePointIterator object using either the default constructor,\n"
"\n" " copy constructor, or the overloaded constructor.\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: A CurvePointIterator object.\n" " :arg brother: A CurvePointIterator object.\n"
" :type brother: :class:`CurvePointIterator`\n" " :type brother: :class:`CurvePointIterator`\n"
"\n"
".. method:: __init__(step=0.0)\n"
"\n"
" Builds a CurvePointIterator object.\n"
"\n"
" :arg step: A resampling resolution with which the curve is resampled.\n" " :arg step: A resampling resolution with which the curve is resampled.\n"
" If zero, no resampling is done (i.e., the iterator iterates over\n" " If zero, no resampling is done (i.e., the iterator iterates over\n"
" initial vertices).\n" " initial vertices).\n"

10
source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.cpp
View File

@@ -38,17 +38,13 @@ PyDoc_STRVAR(Interface0DIterator_doc,
"this iterator is always obtained from a 1D element.\n" "this iterator is always obtained from a 1D element.\n"
"\n" "\n"
".. method:: __init__(brother)\n" ".. method:: __init__(brother)\n"
" __init__(it)\n"
"\n" "\n"
" Copy constructor.\n" " Construct a nested Interface0DIterator using either the copy constructor\n"
" or the constructor that takes an he argument of a Function0D.\n"
"\n" "\n"
" :arg brother: An Interface0DIterator object.\n" " :arg brother: An Interface0DIterator object.\n"
" :type brother: :class:`Interface0DIterator`\n" " :type brother: :class:`Interface0DIterator`\n"
"\n"
".. method:: __init__(it)\n"
"\n"
" Construct a nested Interface0DIterator that can be the argument of\n"
" a Function0D.\n"
"\n"
" :arg it: An iterator object to be nested.\n" " :arg it: An iterator object to be nested.\n"
" :type it: :class:`SVertexIterator`, :class:`CurvePointIterator`, or\n" " :type it: :class:`SVertexIterator`, :class:`CurvePointIterator`, or\n"
" :class:`StrokeVertexIterator`"); " :class:`StrokeVertexIterator`");

60
source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.cpp
View File

@@ -32,39 +32,33 @@ extern "C" {
//------------------------INSTANCE METHODS ---------------------------------- //------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(SVertexIterator_doc, PyDoc_STRVAR(
"Class hierarchy: :class:`Iterator` > :class:`SVertexIterator`\n" SVertexIterator_doc,
"\n" "Class hierarchy: :class:`Iterator` > :class:`SVertexIterator`\n"
"Class representing an iterator over :class:`SVertex` of a\n" "\n"
":class:`ViewEdge`. An instance of an SVertexIterator can be obtained\n" "Class representing an iterator over :class:`SVertex` of a\n"
"from a ViewEdge by calling verticesBegin() or verticesEnd().\n" ":class:`ViewEdge`. An instance of an SVertexIterator can be obtained\n"
"\n" "from a ViewEdge by calling verticesBegin() or verticesEnd().\n"
".. method:: __init__()\n" "\n"
"\n" ".. method:: __init__()\n"
" Default constructor.\n" " __init__(brother)\n"
"\n" " __init__(vertex, begin, previous_edge, next_edge, t)"
".. method:: __init__(brother)\n" "\n"
"\n" " Build an SVertexIterator using either the default constructor, copy constructor,\n"
" Copy constructor.\n" " or the overloaded constructor that starts iteration from an SVertex object vertex.\n"
"\n" "\n"
" :arg brother: An SVertexIterator object.\n" " :arg brother: An SVertexIterator object.\n"
" :type brother: :class:`SVertexIterator`\n" " :type brother: :class:`SVertexIterator`\n"
"\n" " :arg vertex: The SVertex from which the iterator starts iteration.\n"
".. method:: __init__(vertex, begin, previous_edge, next_edge, t)\n" " :type vertex: :class:`SVertex`\n"
"\n" " :arg begin: The first SVertex of a ViewEdge.\n"
" Build an SVertexIterator that starts iteration from an SVertex\n" " :type begin: :class:`SVertex`\n"
" object v.\n" " :arg previous_edge: The previous FEdge coming to vertex.\n"
"\n" " :type previous_edge: :class:`FEdge`\n"
" :arg vertex: The SVertex from which the iterator starts iteration.\n" " :arg next_edge: The next FEdge going out from vertex.\n"
" :type vertex: :class:`SVertex`\n" " :type next_edge: :class:`FEdge`\n"
" :arg begin: The first SVertex of a ViewEdge.\n" " :arg t: The curvilinear abscissa at vertex.\n"
" :type begin: :class:`SVertex`\n" " :type t: float");
" :arg previous_edge: The previous FEdge coming to vertex.\n"
" :type previous_edge: :class:`FEdge`\n"
" :arg next_edge: The next FEdge going out from vertex.\n"
" :type next_edge: :class:`FEdge`\n"
" :arg t: The curvilinear abscissa at vertex.\n"
" :type t: float");
static int SVertexIterator_init(BPy_SVertexIterator *self, PyObject *args, PyObject *kwds) static int SVertexIterator_init(BPy_SVertexIterator *self, PyObject *args, PyObject *kwds)
{ {

8
source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.cpp
View File

@@ -48,12 +48,10 @@ PyDoc_STRVAR(StrokeVertexIterator_doc,
"by calling Interface0DIterator(it).\n" "by calling Interface0DIterator(it).\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(brother)\n"
"\n" "\n"
" Default constructor.\n" " Creates a :class:`StrokeVertexIterator` using either the\n"
"\n" " default constructor or the copy constructor.\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg brother: A StrokeVertexIterator object.\n" " :arg brother: A StrokeVertexIterator object.\n"
" :type brother: :class:`StrokeVertexIterator`"); " :type brother: :class:`StrokeVertexIterator`");

8
source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.cpp
View File

@@ -40,9 +40,10 @@ PyDoc_STRVAR(ViewEdgeIterator_doc,
"on a given ViewEdge.\n" "on a given ViewEdge.\n"
"\n" "\n"
".. method:: __init__(begin=None, orientation=True)\n" ".. method:: __init__(begin=None, orientation=True)\n"
" __init__(brother)\n"
"\n" "\n"
" Builds a ViewEdgeIterator from a starting ViewEdge and its\n" " Builds a ViewEdgeIterator from a starting ViewEdge and its\n"
" orientation.\n" " orientation or the copy constructor.\n"
"\n" "\n"
" :arg begin: The ViewEdge from where to start the iteration.\n" " :arg begin: The ViewEdge from where to start the iteration.\n"
" :type begin: :class:`ViewEdge` or None\n" " :type begin: :class:`ViewEdge` or None\n"
@@ -51,11 +52,6 @@ PyDoc_STRVAR(ViewEdgeIterator_doc,
" false, we'll search over the ViewEdges surrounding the ending\n" " false, we'll search over the ViewEdges surrounding the ending\n"
" ViewVertex of begin.\n" " ViewVertex of begin.\n"
" :type orientation: bool\n" " :type orientation: bool\n"
"\n"
".. method:: __init__(brother)\n"
"\n"
" Copy constructor.\n"
"\n"
" :arg brother: A ViewEdgeIterator object.\n" " :arg brother: A ViewEdgeIterator object.\n"
" :type brother: :class:`ViewEdgeIterator`"); " :type brother: :class:`ViewEdgeIterator`");

8
source/blender/freestyle/intern/python/Iterator/BPy_orientedViewEdgeIterator.cpp
View File

@@ -39,12 +39,10 @@ PyDoc_STRVAR(orientedViewEdgeIterator_doc,
"obtained from a ViewVertex by calling edges_begin() or edges_end().\n" "obtained from a ViewVertex by calling edges_begin() or edges_end().\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(iBrother)\n"
"\n" "\n"
" Default constructor.\n" " Creates an :class:`orientedViewEdgeIterator` using either the\n"
"\n" " default constructor or the copy constructor.\n"
".. method:: __init__(iBrother)\n"
"\n"
" Copy constructor.\n"
"\n" "\n"
" :arg iBrother: An orientedViewEdgeIterator object.\n" " :arg iBrother: An orientedViewEdgeIterator object.\n"
" :type iBrother: :class:`orientedViewEdgeIterator`"); " :type iBrother: :class:`orientedViewEdgeIterator`");

9
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp
View File

@@ -160,13 +160,10 @@ static char UnaryFunction1DDouble___doc__[] =
":class:`Interface1D` and return a float value.\n" ":class:`Interface1D` and return a float value.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(integration_type)\n"
"\n" "\n"
" Default constructor.\n" " Builds a unary 1D function using the default constructor\n"
"\n" " or the integration method given as an argument.\n"
".. method:: __init__(integration_type)\n"
"\n"
" Builds a unary 1D function using the integration method given as\n"
" argument.\n"
"\n" "\n"
" :arg integration_type: An integration method.\n" " :arg integration_type: An integration method.\n"
" :type integration_type: :class:`IntegrationType`\n"; " :type integration_type: :class:`IntegrationType`\n";

9
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp
View File

@@ -65,13 +65,10 @@ static char UnaryFunction1DEdgeNature___doc__[] =
":class:`Interface1D` and return a :class:`Nature` object.\n" ":class:`Interface1D` and return a :class:`Nature` object.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(integration_type)\n"
"\n" "\n"
" Default constructor.\n" " Builds a unary 1D function using the default constructor\n"
"\n" " or the integration method given as an argument.\n"
".. method:: __init__(integration_type)\n"
"\n"
" Builds a unary 1D function using the integration method given as\n"
" argument.\n"
"\n" "\n"
" :arg integration_type: An integration method.\n" " :arg integration_type: An integration method.\n"
" :type integration_type: :class:`IntegrationType`\n"; " :type integration_type: :class:`IntegrationType`\n";

9
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp
View File

@@ -56,13 +56,10 @@ static char UnaryFunction1DFloat___doc__[] =
":class:`Interface1D` and return a float value.\n" ":class:`Interface1D` and return a float value.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(integration_type)\n"
"\n" "\n"
" Default constructor.\n" " Builds a unary 1D function using the default constructor\n"
"\n" " or the integration method given as an argument.\n"
".. method:: __init__(integration_type)\n"
"\n"
" Builds a unary 1D function using the integration method given as\n"
" argument.\n"
"\n" "\n"
" :arg integration_type: An integration method.\n" " :arg integration_type: An integration method.\n"
" :type integration_type: :class:`IntegrationType`\n"; " :type integration_type: :class:`IntegrationType`\n";

9
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp
View File

@@ -65,13 +65,10 @@ static char UnaryFunction1DUnsigned___doc__[] =
":class:`Interface1D` and return an int value.\n" ":class:`Interface1D` and return an int value.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(integration_type)\n"
"\n" "\n"
" Default constructor.\n" " Builds a unary 1D function using the default constructor\n"
"\n" " or the integration method given as an argument.\n"
".. method:: __init__(integration_type)\n"
"\n"
" Builds a unary 1D function using the integration method given as\n"
" argument.\n"
"\n" "\n"
" :arg integration_type: An integration method.\n" " :arg integration_type: An integration method.\n"
" :type integration_type: :class:`IntegrationType`\n"; " :type integration_type: :class:`IntegrationType`\n";

9
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp
View File

@@ -71,13 +71,10 @@ static char UnaryFunction1DVec2f___doc__[] =
":class:`Interface1D` and return a 2D vector.\n" ":class:`Interface1D` and return a 2D vector.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(integration_type)\n"
"\n" "\n"
" Default constructor.\n" " Builds a unary 1D function using the default constructor\n"
"\n" " or the integration method given as an argument.\n"
".. method:: __init__(integration_type)\n"
"\n"
" Builds a unary 1D function using the integration method given as\n"
" argument.\n"
"\n" "\n"
" :arg integration_type: An integration method.\n" " :arg integration_type: An integration method.\n"
" :type integration_type: :class:`IntegrationType`\n"; " :type integration_type: :class:`IntegrationType`\n";

9
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp
View File

@@ -64,13 +64,10 @@ static char UnaryFunction1DVec3f___doc__[] =
":class:`Interface1D` and return a 3D vector.\n" ":class:`Interface1D` and return a 3D vector.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(integration_type)\n"
"\n" "\n"
" Default constructor.\n" " Builds a unary 1D function using the default constructor\n"
"\n" " or the integration method given as an argument.\n"
".. method:: __init__(integration_type)\n"
"\n"
" Builds a unary 1D function using the integration method given as\n"
" argument.\n"
"\n" "\n"
" :arg integration_type: An integration method.\n" " :arg integration_type: An integration method.\n"
" :type integration_type: :class:`IntegrationType`\n"; " :type integration_type: :class:`IntegrationType`\n";

9
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp
View File

@@ -80,13 +80,10 @@ static char UnaryFunction1DVectorViewShape___doc__[] =
"objects.\n" "objects.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(integration_type)\n"
"\n" "\n"
" Default constructor.\n" " Builds a unary 1D function using the default constructor\n"
"\n" " or the integration method given as an argument.\n"
".. method:: __init__(integration_type)\n"
"\n"
" Builds a unary 1D function using the integration method given as\n"
" argument.\n"
"\n" "\n"
" :arg integration_type: An integration method.\n" " :arg integration_type: An integration method.\n"
" :type integration_type: :class:`IntegrationType`\n"; " :type integration_type: :class:`IntegrationType`\n";

9
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.cpp
View File

@@ -79,13 +79,10 @@ static char UnaryFunction1DVoid___doc__[] =
":class:`Interface1D`.\n" ":class:`Interface1D`.\n"
"\n" "\n"
".. method:: __init__()\n" ".. method:: __init__()\n"
" __init__(integration_type)\n"
"\n" "\n"
" Default constructor.\n" " Builds a unary 1D function using either a default constructor\n"
"\n" " or the integration method given as an argument.\n"
".. method:: __init__(integration_type)\n"
"\n"
" Builds a unary 1D function using the integration method given as\n"
" argument.\n"
"\n" "\n"
" :arg integration_type: An integration method.\n" " :arg integration_type: An integration method.\n"
" :type integration_type: :class:`IntegrationType`\n"; " :type integration_type: :class:`IntegrationType`\n";