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

Freestyle Python API improvements - part 4.

Browse Source 
Major API updates were made as in part 3 to address code review comments.
This revision focuses on Python wrappers of C++ iterators.

* Most getter/setter methods were reimplemented as attributes using PyGetSetDef.

* The naming of methods and attributes was fixed to follow the naming conventions
of the Blender Python API (i.e., lower case + underscores for methods and attributes,
and CamelCase for classes).  The only irregular naming change is the following, to
better indicate the functionality:

- ChainingIterator: getVertex --> next_vertex

* In addition, some code clean-up was done in both C++ and Python.  Also duplicated
definitions of predicate classes were removed.
This commit is contained in:
Tamito Kajiyama
2013-02-16 14:21:40 +00:00
parent aa9c01f384
commit b35a893249
17 changed files with 1001 additions and 1074 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
source/blender/freestyle/intern/python/BPy_Iterator.cpp
View File

@@ -12,8 +12,6 @@
#include "Iterator/BPy_ChainPredicateIterator.h"
#include "Iterator/BPy_ChainSilhouetteIterator.h"
#ifdef __cplusplus
extern "C" {
#endif
@@ -21,64 +19,64 @@ extern "C" {
///////////////////////////////////////////////////////////////////////////////////////////
//-------------------MODULE INITIALIZATION--------------------------------
int Iterator_Init( PyObject *module )
{
if( module == NULL )
int Iterator_Init(PyObject *module)
{
if (module == NULL)
return -1;
if( PyType_Ready( &Iterator_Type ) < 0 )
if (PyType_Ready(&Iterator_Type) < 0)
return -1;
Py_INCREF( &Iterator_Type );
Py_INCREF(&Iterator_Type);
PyModule_AddObject(module, "Iterator", (PyObject *)&Iterator_Type);
if( PyType_Ready( &AdjacencyIterator_Type ) < 0 )
if (PyType_Ready(&AdjacencyIterator_Type) < 0)
return -1;
Py_INCREF( &AdjacencyIterator_Type );
Py_INCREF(&AdjacencyIterator_Type);
PyModule_AddObject(module, "AdjacencyIterator", (PyObject *)&AdjacencyIterator_Type);
if( PyType_Ready( &Interface0DIterator_Type ) < 0 )
if (PyType_Ready(&Interface0DIterator_Type) < 0)
return -1;
Py_INCREF( &Interface0DIterator_Type );
Py_INCREF(&Interface0DIterator_Type);
PyModule_AddObject(module, "Interface0DIterator", (PyObject *)&Interface0DIterator_Type);
if( PyType_Ready( &CurvePointIterator_Type ) < 0 )
if (PyType_Ready(&CurvePointIterator_Type) < 0)
return -1;
Py_INCREF( &CurvePointIterator_Type );
Py_INCREF(&CurvePointIterator_Type);
PyModule_AddObject(module, "CurvePointIterator", (PyObject *)&CurvePointIterator_Type);
if( PyType_Ready( &StrokeVertexIterator_Type ) < 0 )
if (PyType_Ready(&StrokeVertexIterator_Type) < 0)
return -1;
Py_INCREF( &StrokeVertexIterator_Type );
Py_INCREF(&StrokeVertexIterator_Type);
PyModule_AddObject(module, "StrokeVertexIterator", (PyObject *)&StrokeVertexIterator_Type);
if( PyType_Ready( &SVertexIterator_Type ) < 0 )
if (PyType_Ready(&SVertexIterator_Type) < 0)
return -1;
Py_INCREF( &SVertexIterator_Type );
Py_INCREF(&SVertexIterator_Type);
PyModule_AddObject(module, "SVertexIterator", (PyObject *)&SVertexIterator_Type);
if( PyType_Ready( &orientedViewEdgeIterator_Type ) < 0 )
if (PyType_Ready(&orientedViewEdgeIterator_Type) < 0)
return -1;
Py_INCREF( &orientedViewEdgeIterator_Type );
Py_INCREF(&orientedViewEdgeIterator_Type);
PyModule_AddObject(module, "orientedViewEdgeIterator", (PyObject *)&orientedViewEdgeIterator_Type);
if( PyType_Ready( &ViewEdgeIterator_Type ) < 0 )
if (PyType_Ready(&ViewEdgeIterator_Type) < 0)
return -1;
Py_INCREF( &ViewEdgeIterator_Type );
Py_INCREF(&ViewEdgeIterator_Type);
PyModule_AddObject(module, "ViewEdgeIterator", (PyObject *)&ViewEdgeIterator_Type);
if( PyType_Ready( &ChainingIterator_Type ) < 0 )
if (PyType_Ready(&ChainingIterator_Type) < 0)
return -1;
Py_INCREF( &ChainingIterator_Type );
Py_INCREF(&ChainingIterator_Type);
PyModule_AddObject(module, "ChainingIterator", (PyObject *)&ChainingIterator_Type);
if( PyType_Ready( &ChainPredicateIterator_Type ) < 0 )
if (PyType_Ready(&ChainPredicateIterator_Type) < 0)
return -1;
Py_INCREF( &ChainPredicateIterator_Type );
Py_INCREF(&ChainPredicateIterator_Type);
PyModule_AddObject(module, "ChainPredicateIterator", (PyObject *)&ChainPredicateIterator_Type);
if( PyType_Ready( &ChainSilhouetteIterator_Type ) < 0 )
if (PyType_Ready(&ChainSilhouetteIterator_Type) < 0)
return -1;
Py_INCREF( &ChainSilhouetteIterator_Type );
Py_INCREF(&ChainSilhouetteIterator_Type);
PyModule_AddObject(module, "ChainSilhouetteIterator", (PyObject *)&ChainSilhouetteIterator_Type);
return 0;
@@ -86,97 +84,96 @@ int Iterator_Init( PyObject *module )
//------------------------INSTANCE METHODS ----------------------------------
static char Iterator___doc__[] =
"Base class to define iterators.\n";
PyDoc_STRVAR(Iterator_doc,
"Base class to define iterators.");
static void Iterator___dealloc__(BPy_Iterator* self)
static void Iterator_dealloc(BPy_Iterator* self)
{
if (self->it)
delete self->it;
Py_TYPE(self)->tp_free((PyObject*)self);
Py_TYPE(self)->tp_free((PyObject*)self);
}
static PyObject * Iterator___repr__(BPy_Iterator* self)
static PyObject * Iterator_repr(BPy_Iterator* self)
{
return PyUnicode_FromFormat("type: %s - address: %p", self->it->getExactTypeName().c_str(), self->it );
return PyUnicode_FromFormat("type: %s - address: %p", self->it->getExactTypeName().c_str(), self->it);
}
static char Iterator_getExactTypeName___doc__[] =
".. method:: getExactTypeName()\n"
"\n"
" Returns the name of the iterator.\n"
"\n"
" :return: The name of the iterator.\n"
" :rtype: str\n";
static PyObject * Iterator_getExactTypeName(BPy_Iterator* self) {
return PyUnicode_FromString( self->it->getExactTypeName().c_str() );
}
static char Iterator_increment___doc__[] =
PyDoc_STRVAR(Iterator_increment_doc,
".. method:: increment()\n"
"\n"
" Makes the iterator point the next element.\n";
" Makes the iterator point the next element.");
static PyObject * Iterator_increment(BPy_Iterator* self) {
static PyObject * Iterator_increment(BPy_Iterator* self)
{
if (self->it->isEnd()) {
PyErr_SetString(PyExc_RuntimeError , "cannot increment any more");
return NULL;
}
self->it->increment();
Py_RETURN_NONE;
}
static char Iterator_decrement___doc__[] =
PyDoc_STRVAR(Iterator_decrement_doc,
".. method:: decrement()\n"
"\n"
" Makes the iterator point the previous element.\n";
" Makes the iterator point the previous element.");
static PyObject * Iterator_decrement(BPy_Iterator* self) {
static PyObject * Iterator_decrement(BPy_Iterator* self)
{
if (self->it->isBegin()) {
PyErr_SetString(PyExc_RuntimeError , "cannot decrement any more");
return NULL;
}
self->it->decrement();
Py_RETURN_NONE;
}
static char Iterator_isBegin___doc__[] =
".. method:: isBegin()\n"
"\n"
" Returns true if the interator points the first element.\n"
"\n"
" :return: True if the interator points the first element.\n"
" :rtype: bool\n";
static PyObject * Iterator_isBegin(BPy_Iterator* self) {
return PyBool_from_bool( self->it->isBegin() );
}
static char Iterator_isEnd___doc__[] =
".. method:: isEnd()\n"
"\n"
" Returns true if the interator points the last element.\n"
"\n"
" :return: True if the interator points the last element.\n"
" :rtype: bool\n";
static PyObject * Iterator_isEnd(BPy_Iterator* self) {
return PyBool_from_bool( self->it->isEnd() );
}
/*----------------------Iterator instance definitions ----------------------------*/
static PyMethodDef BPy_Iterator_methods[] = {
{"getExactTypeName", ( PyCFunction ) Iterator_getExactTypeName, METH_NOARGS, Iterator_getExactTypeName___doc__},
{"increment", ( PyCFunction ) Iterator_increment, METH_NOARGS, Iterator_increment___doc__},
{"decrement", ( PyCFunction ) Iterator_decrement, METH_NOARGS, Iterator_decrement___doc__},
{"isBegin", ( PyCFunction ) Iterator_isBegin, METH_NOARGS, Iterator_isBegin___doc__},
{"isEnd", ( PyCFunction ) Iterator_isEnd, METH_NOARGS, Iterator_isEnd___doc__},
{"increment", (PyCFunction) Iterator_increment, METH_NOARGS, Iterator_increment_doc},
{"decrement", (PyCFunction) Iterator_decrement, METH_NOARGS, Iterator_decrement_doc},
{NULL, NULL, 0, NULL}
};
/*----------------------Iterator get/setters ----------------------------*/
PyDoc_STRVAR(Iterator_exact_type_name_doc,
"The string of the name of this iterator.\n"
"\n"
":type: str");
static PyObject *Iterator_exact_type_name_get(BPy_Iterator *self, void *UNUSED(closure))
{
return PyUnicode_FromString(self->it->getExactTypeName().c_str());
}
PyDoc_STRVAR(Iterator_is_begin_doc,
"True if the interator points the first element.\n"
"\n"
":type: bool");
static PyObject *Iterator_is_begin_get(BPy_Iterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->it->isBegin());
}
PyDoc_STRVAR(Iterator_is_end_doc,
"True if the interator points the last element.\n"
"\n"
":type: bool");
static PyObject *Iterator_is_end_get(BPy_Iterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->it->isEnd());
}
static PyGetSetDef BPy_Iterator_getseters[] = {
{(char *)"exact_type_name", (getter)Iterator_exact_type_name_get, (setter)NULL, (char *)Iterator_exact_type_name_doc, NULL},
{(char *)"is_begin", (getter)Iterator_is_begin_get, (setter)NULL, (char *)Iterator_is_begin_doc, NULL},
{(char *)"is_end", (getter)Iterator_is_end_get, (setter)NULL, (char *)Iterator_is_end_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_Iterator type definition ------------------------------*/
PyTypeObject Iterator_Type = {
@@ -184,12 +181,12 @@ PyTypeObject Iterator_Type = {
"Iterator", /* tp_name */
sizeof(BPy_Iterator), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)Iterator___dealloc__, /* tp_dealloc */
(destructor)Iterator_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
(reprfunc)Iterator___repr__, /* tp_repr */
(reprfunc)Iterator_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
@@ -200,7 +197,7 @@ PyTypeObject Iterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
Iterator___doc__, /* tp_doc */
Iterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -209,7 +206,7 @@ PyTypeObject Iterator_Type = {
0, /* tp_iternext */
BPy_Iterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_Iterator_getseters, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
@@ -225,5 +222,3 @@ PyTypeObject Iterator_Type = {
#ifdef __cplusplus
}
#endif

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

@@ -11,7 +11,7 @@ extern "C" {
//------------------------INSTANCE METHODS ----------------------------------
static char AdjacencyIterator___doc__[] =
PyDoc_STRVAR(AdjacencyIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`AdjacencyIterator`\n"
"\n"
"Class for representing adjacency iterators used in the chaining\n"
@@ -37,27 +37,27 @@ static char AdjacencyIterator___doc__[] =
" Copy constructor.\n"
"\n"
" :arg it: An AdjacencyIterator object.\n"
" :type it: :class:`AdjacencyIterator`\n";
" :type it: :class:`AdjacencyIterator`");
static int AdjacencyIterator___init__(BPy_AdjacencyIterator *self, PyObject *args )
{
static int AdjacencyIterator_init(BPy_AdjacencyIterator *self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0;
if (! PyArg_ParseTuple(args, "|OOO", &obj1, &obj2, &obj3) )
return -1;
if (!PyArg_ParseTuple(args, "|OOO", &obj1, &obj2, &obj3))
return -1;
if( !obj1 && !obj2 && !obj3 ){
if (!obj1) {
self->a_it = new AdjacencyIterator();
} else if (BPy_AdjacencyIterator_Check(obj1) && !obj2) {
self->a_it = new AdjacencyIterator(*(((BPy_AdjacencyIterator *)obj1)->a_it));
} else if (BPy_ViewVertex_Check(obj1) && (!obj2 || PyBool_Check(obj2)) && (!obj3 || PyBool_Check(obj3))) {
bool restrictToSelection = (obj2) ? bool_from_PyBool(obj2) : true;
bool restrictToUnvisited = (obj3) ? bool_from_PyBool(obj3) : true;
} else if( BPy_AdjacencyIterator_Check(obj1) ) {
self->a_it = new AdjacencyIterator(*( ((BPy_AdjacencyIterator *) obj1)->a_it ));
} else if( BPy_ViewVertex_Check(obj1) ) {
bool restrictToSelection = ( obj2 ) ? bool_from_PyBool(obj2) : true;
bool restrictToUnvisited = ( obj3 ) ? bool_from_PyBool(obj3) : true;
self->a_it = new AdjacencyIterator( ((BPy_ViewVertex *) obj1)->vv, restrictToSelection, restrictToUnvisited );
self->a_it = new AdjacencyIterator(((BPy_ViewVertex *)obj1)->vv, restrictToSelection, restrictToUnvisited);
} else {
PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
return -1;
@@ -66,55 +66,54 @@ static int AdjacencyIterator___init__(BPy_AdjacencyIterator *self, PyObject *arg
self->py_it.it = self->a_it;
return 0;
}
static PyObject * AdjacencyIterator_iternext(BPy_AdjacencyIterator *self) {
static PyObject * AdjacencyIterator_iternext(BPy_AdjacencyIterator *self)
{
if (self->a_it->isEnd()) {
PyErr_SetNone(PyExc_StopIteration);
return NULL;
}
ViewEdge *ve = self->a_it->operator*();
self->a_it->increment();
return BPy_ViewEdge_from_ViewEdge( *ve );
return BPy_ViewEdge_from_ViewEdge(*ve);
}
static char AdjacencyIterator_isIncoming___doc__[] =
".. method:: isIncoming()\n"
"\n"
" Returns true if the current ViewEdge is coming towards the\n"
" iteration vertex. False otherwise.\n"
"\n"
" :return: True if the current ViewEdge is coming towards the\n"
" iteration vertex\n"
" :rtype: bool\n";
static PyMethodDef BPy_AdjacencyIterator_methods[] = {
{NULL, NULL, 0, NULL}
};
static PyObject * AdjacencyIterator_isIncoming(BPy_AdjacencyIterator *self) {
return PyBool_from_bool(self->a_it->isIncoming());
}
/*----------------------AdjacencyIterator get/setters ----------------------------*/
static char AdjacencyIterator_getObject___doc__[] =
".. method:: getObject()\n"
PyDoc_STRVAR(AdjacencyIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
" Returns the pointed ViewEdge.\n"
"\n"
" :return: The pointed ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
":type: :class:`ViewEdge`");
static PyObject * AdjacencyIterator_getObject(BPy_AdjacencyIterator *self) {
static PyObject *AdjacencyIterator_object_get(BPy_AdjacencyIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->a_it->operator*();
if( ve )
return BPy_ViewEdge_from_ViewEdge( *ve );
if (ve)
return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE;
}
/*----------------------AdjacencyIterator instance definitions ----------------------------*/
static PyMethodDef BPy_AdjacencyIterator_methods[] = {
{"isIncoming", ( PyCFunction ) AdjacencyIterator_isIncoming, METH_NOARGS, AdjacencyIterator_isIncoming___doc__},
{"getObject", ( PyCFunction ) AdjacencyIterator_getObject, METH_NOARGS, AdjacencyIterator_getObject___doc__},
{NULL, NULL, 0, NULL}
PyDoc_STRVAR(AdjacencyIterator_is_incoming_doc,
"True if the current ViewEdge is coming towards the iteration vertex, and\n"
"False otherwise.\n"
"\n"
":type: bool");
static PyObject *AdjacencyIterator_is_incoming_get(BPy_AdjacencyIterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->a_it->isIncoming());
}
static PyGetSetDef BPy_AdjacencyIterator_getseters[] = {
{(char *)"is_incoming", (getter)AdjacencyIterator_is_incoming_get, (setter)NULL, (char *)AdjacencyIterator_is_incoming_doc, NULL},
{(char *)"object", (getter)AdjacencyIterator_object_get, (setter)NULL, (char *)AdjacencyIterator_object_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_AdjacencyIterator type definition ------------------------------*/
@@ -140,7 +139,7 @@ PyTypeObject AdjacencyIterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
AdjacencyIterator___doc__, /* tp_doc */
AdjacencyIterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -149,13 +148,13 @@ PyTypeObject AdjacencyIterator_Type = {
(iternextfunc)AdjacencyIterator_iternext, /* tp_iternext */
BPy_AdjacencyIterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_AdjacencyIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)AdjacencyIterator___init__, /* tp_init */
(initproc)AdjacencyIterator_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};

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

@@ -13,7 +13,7 @@ extern "C" {
//------------------------INSTANCE METHODS ----------------------------------
static char ChainingIterator___doc__[] =
PyDoc_STRVAR(ChainingIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator` > :class:`ChainingIterator`\n"
"\n"
"Base class for chaining iterators. This class is designed to be\n"
@@ -47,52 +47,53 @@ static char ChainingIterator___doc__[] =
" Copy constructor.\n"
"\n"
" :arg brother: \n"
" :type brother: ChainingIterator\n";
" :type brother: ChainingIterator");
static int ChainingIterator___init__(BPy_ChainingIterator *self, PyObject *args )
{
static int ChainingIterator___init__(BPy_ChainingIterator *self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0, *obj4 = 0;
if (!( PyArg_ParseTuple(args, "|OOOO", &obj1, &obj2, &obj3, &obj4) ))
return -1;
if (!PyArg_ParseTuple(args, "|OOOO", &obj1, &obj2, &obj3, &obj4))
return -1;
if (obj1 && BPy_ChainingIterator_Check(obj1)) {
self->c_it = new ChainingIterator(*(((BPy_ChainingIterator *)obj1)->c_it));
if( obj1 && BPy_ChainingIterator_Check(obj1) ) {
self->c_it = new ChainingIterator(*( ((BPy_ChainingIterator *) obj1)->c_it ));
} else {
bool restrictToSelection = ( obj1 ) ? bool_from_PyBool(obj1) : true;
bool restrictToUnvisited = ( obj2 ) ? bool_from_PyBool(obj2) : true;
bool restrictToSelection = (obj1) ? bool_from_PyBool(obj1) : true;
bool restrictToUnvisited = (obj2) ? bool_from_PyBool(obj2) : true;
ViewEdge *begin;
if ( !obj3 || obj3 == Py_None )
if (!obj3 || obj3 == Py_None)
begin = NULL;
else if ( BPy_ViewEdge_Check(obj3) )
begin = ((BPy_ViewEdge *) obj3)->ve;
else if (BPy_ViewEdge_Check(obj3))
begin = ((BPy_ViewEdge *)obj3)->ve;
else {
PyErr_SetString(PyExc_TypeError, "3rd argument must be either a ViewEdge object or None");
return -1;
}
bool orientation = ( obj4 ) ? bool_from_PyBool(obj4) : true;
self->c_it = new ChainingIterator( restrictToSelection, restrictToUnvisited, begin, orientation);
bool orientation = (obj4) ? bool_from_PyBool(obj4) : true;
self->c_it = new ChainingIterator(restrictToSelection, restrictToUnvisited, begin, orientation);
}
self->py_ve_it.ve_it = self->c_it;
self->py_ve_it.py_it.it = self->c_it;
self->c_it->py_c_it = (PyObject *) self;
self->c_it->py_c_it = (PyObject *)self;
return 0;
}
static char ChainingIterator_init___doc__[] =
PyDoc_STRVAR(ChainingIterator_init_doc,
".. method:: init()\n"
"\n"
" Initializes the iterator context. This method is called each\n"
" time a new chain is started. It can be used to reset some\n"
" history information that you might want to keep.\n";
" history information that you might want to keep.");
static PyObject *ChainingIterator_init( BPy_ChainingIterator *self ) {
if( typeid(*(self->c_it)) == typeid(ChainingIterator) ) {
static PyObject *ChainingIterator_init(BPy_ChainingIterator *self)
{
if (typeid(*(self->c_it)) == typeid(ChainingIterator)) {
PyErr_SetString(PyExc_TypeError, "init() method not properly overridden");
return NULL;
}
@@ -101,7 +102,7 @@ static PyObject *ChainingIterator_init( BPy_ChainingIterator *self ) {
Py_RETURN_NONE;
}
static char ChainingIterator_traverse___doc__[] =
PyDoc_STRVAR(ChainingIterator_traverse_doc,
".. method:: traverse(it)\n"
"\n"
" This method iterates over the potential next ViewEdges and returns\n"
@@ -113,79 +114,79 @@ static char ChainingIterator_traverse___doc__[] =
" restriction rules by only iterating over the valid ViewEdges.\n"
" :type it: :class:`AdjacencyIterator`\n"
" :return: Returns the next ViewEdge to follow, or None if chaining ends.\n"
" :rtype: :class:`ViewEdge` or None\n";
" :rtype: :class:`ViewEdge` or None");
static PyObject *ChainingIterator_traverse( BPy_ChainingIterator *self, PyObject *args ) {
static PyObject *ChainingIterator_traverse(BPy_ChainingIterator *self, PyObject *args)
{
PyObject *py_a_it;
if(!( PyArg_ParseTuple(args, "O!", &AdjacencyIterator_Type, &py_a_it) ))
if(!(PyArg_ParseTuple(args, "O!", &AdjacencyIterator_Type, &py_a_it)))
return NULL;
if( typeid(*(self->c_it)) == typeid(ChainingIterator) ) {
if (typeid(*(self->c_it)) == typeid(ChainingIterator)) {
PyErr_SetString(PyExc_TypeError, "traverse() method not properly overridden");
return NULL;
}
if( ((BPy_AdjacencyIterator *) py_a_it)->a_it )
self->c_it->traverse(*( ((BPy_AdjacencyIterator *) py_a_it)->a_it ));
Py_RETURN_NONE;
}
static char ChainingIterator_getVertex___doc__[] =
".. method:: getVertex()\n"
"\n"
" Returns the vertex which is the next crossing.\n"
"\n"
" :return: The vertex which is the next crossing.\n"
" :rtype: :class:`ViewVertex`\n";
static PyObject *ChainingIterator_getVertex( BPy_ChainingIterator *self ) {
ViewVertex *v = self->c_it->getVertex();
if( v )
return Any_BPy_ViewVertex_from_ViewVertex( *v );
Py_RETURN_NONE;
}
static char ChainingIterator_isIncrementing___doc__[] =
".. method:: isIncrementing()\n"
"\n"
" Returns true if the current iteration is an incrementation.\n"
"\n"
" :return: True if the current iteration is an incrementation.\n"
" :rtype: bool\n";
static PyObject *ChainingIterator_isIncrementing( BPy_ChainingIterator *self ) {
return PyBool_from_bool( self->c_it->isIncrementing() );
}
static char ChainingIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed ViewEdge.\n"
"\n"
" :return: The pointed ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
static PyObject * ChainingIterator_getObject( BPy_ChainingIterator *self) {
ViewEdge *ve = self->c_it->operator*();
if( ve )
return BPy_ViewEdge_from_ViewEdge( *ve );
if (((BPy_AdjacencyIterator *)py_a_it)->a_it)
self->c_it->traverse(*(((BPy_AdjacencyIterator *)py_a_it)->a_it));
Py_RETURN_NONE;
}
/*----------------------ChainingIterator instance definitions ----------------------------*/
static PyMethodDef BPy_ChainingIterator_methods[] = {
{"init", ( PyCFunction ) ChainingIterator_init, METH_NOARGS, ChainingIterator_init___doc__},
{"traverse", ( PyCFunction ) ChainingIterator_traverse, METH_VARARGS, ChainingIterator_traverse___doc__},
{"getVertex", ( PyCFunction ) ChainingIterator_getVertex, METH_NOARGS, ChainingIterator_getVertex___doc__},
{"isIncrementing", ( PyCFunction ) ChainingIterator_isIncrementing, METH_NOARGS, ChainingIterator_isIncrementing___doc__},
{"getObject", ( PyCFunction ) ChainingIterator_getObject, METH_NOARGS, ChainingIterator_getObject___doc__},
{"init", (PyCFunction) ChainingIterator_init, METH_NOARGS, ChainingIterator_init_doc},
{"traverse", (PyCFunction) ChainingIterator_traverse, METH_VARARGS, ChainingIterator_traverse_doc},
{NULL, NULL, 0, NULL}
};
/*----------------------ChainingIterator get/setters ----------------------------*/
PyDoc_STRVAR(ChainingIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ChainingIterator_object_get(BPy_ChainingIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->c_it->operator*();
if (ve)
return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE;
}
PyDoc_STRVAR(ChainingIterator_next_vertex_doc,
"The ViewVertex that is the next crossing.\n"
"\n"
":type: :class:`ViewVertex`");
static PyObject *ChainingIterator_next_vertex_get(BPy_ChainingIterator *self, void *UNUSED(closure))
{
ViewVertex *v = self->c_it->getVertex();
if (v)
return Any_BPy_ViewVertex_from_ViewVertex(*v);
Py_RETURN_NONE;
}
PyDoc_STRVAR(ChainingIterator_is_incrementing_doc,
"True if the current iteration is an incrementation.\n"
"\n"
":type: bool");
static PyObject *ChainingIterator_is_incrementing_get(BPy_ChainingIterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->c_it->isIncrementing());
}
static PyGetSetDef BPy_ChainingIterator_getseters[] = {
{(char *)"object", (getter)ChainingIterator_object_get, (setter)NULL, (char *)ChainingIterator_object_doc, NULL},
{(char *)"next_vertex", (getter)ChainingIterator_next_vertex_get, (setter)NULL, (char *)ChainingIterator_next_vertex_doc, NULL},
{(char *)"is_incrementing", (getter)ChainingIterator_is_incrementing_get, (setter)NULL, (char *)ChainingIterator_is_incrementing_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_ChainingIterator type definition ------------------------------*/
PyTypeObject ChainingIterator_Type = {
@@ -209,7 +210,7 @@ PyTypeObject ChainingIterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
ChainingIterator___doc__, /* tp_doc */
ChainingIterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -218,7 +219,7 @@ PyTypeObject ChainingIterator_Type = {
0, /* tp_iternext */
BPy_ChainingIterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_ChainingIterator_getseters, /* tp_getset */
&ViewEdgeIterator_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */

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

@@ -11,7 +11,7 @@ extern "C" {
//------------------------INSTANCE METHODS ----------------------------------
static char CurvePointIterator___doc__[] =
PyDoc_STRVAR(CurvePointIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`CurvePointIterator`\n"
"\n"
"Class representing an iterator on a curve. Allows an iterating\n"
@@ -32,24 +32,24 @@ static char CurvePointIterator___doc__[] =
" Copy constructor.\n"
"\n"
" :arg brother: A CurvePointIterator object.\n"
" :type brother: :class:`CurvePointIterator`\n";
" :type brother: :class:`CurvePointIterator`");
static int CurvePointIterator___init__(BPy_CurvePointIterator *self, PyObject *args )
{
static int CurvePointIterator_init(BPy_CurvePointIterator *self, PyObject *args)
{
PyObject *obj = 0;
if (! PyArg_ParseTuple(args, "|O", &obj) )
return -1;
if (!PyArg_ParseTuple(args, "|O", &obj))
return -1;
if( !obj ){
if (!obj) {
self->cp_it = new CurveInternal::CurvePointIterator();
} else if( BPy_CurvePointIterator_Check(obj) ) {
self->cp_it = new CurveInternal::CurvePointIterator(*( ((BPy_CurvePointIterator *) obj)->cp_it ));
} else if( PyFloat_Check(obj) ) {
self->cp_it = new CurveInternal::CurvePointIterator( PyFloat_AsDouble(obj) );
} else if (BPy_CurvePointIterator_Check(obj)) {
self->cp_it = new CurveInternal::CurvePointIterator(*(((BPy_CurvePointIterator *)obj)->cp_it));
} else if (PyFloat_Check(obj)) {
self->cp_it = new CurveInternal::CurvePointIterator(PyFloat_AsDouble(obj));
} else {
PyErr_SetString(PyExc_TypeError, "invalid argument");
return -1;
@@ -60,32 +60,8 @@ static int CurvePointIterator___init__(BPy_CurvePointIterator *self, PyObject *a
return 0;
}
static char CurvePointIterator_t___doc__[] =
".. method:: t()\n"
"\n"
" Returns the curvilinear abscissa.\n"
"\n"
" :return: The curvilinear abscissa.\n"
" :rtype: float\n";
static PyObject * CurvePointIterator_t( BPy_CurvePointIterator *self ) {
return PyFloat_FromDouble( self->cp_it->t() );
}
static char CurvePointIterator_u___doc__[] =
".. method:: u()\n"
"\n"
" Returns the point parameter in the curve (0<=u<=1).\n"
"\n"
" :return: The point parameter.\n"
" :rtype: float\n";
static PyObject * CurvePointIterator_u( BPy_CurvePointIterator *self ) {
return PyFloat_FromDouble( self->cp_it->u() );
}
static char CurvePointIterator_castToInterface0DIterator___doc__[] =
".. method:: castToInterface0DIterator()\n"
PyDoc_STRVAR(CurvePointIterator_cast_to_interface0diterator_doc,
".. method:: cast_to_interface0diterator()\n"
"\n"
" Returns an Interface0DIterator converted from this\n"
" CurvePointIterator. Useful for any call to a function of the\n"
@@ -93,34 +69,58 @@ static char CurvePointIterator_castToInterface0DIterator___doc__[] =
"\n"
" :return: An Interface0DIterator object converted from the\n"
" iterator.\n"
" :rtype: :class:`Interface0DIterator`\n";
" :rtype: :class:`Interface0DIterator`");
static PyObject * CurvePointIterator_castToInterface0DIterator( BPy_CurvePointIterator *self ) {
Interface0DIterator it( self->cp_it->castToInterface0DIterator() );
return BPy_Interface0DIterator_from_Interface0DIterator( it, 0 );
static PyObject * CurvePointIterator_cast_to_interface0diterator(BPy_CurvePointIterator *self)
{
Interface0DIterator it(self->cp_it->castToInterface0DIterator());
return BPy_Interface0DIterator_from_Interface0DIterator(it, 0);
}
static char CurvePointIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns a CurvePoint pointed by the iterator.\n"
"\n"
" :return: \n"
" :rtype: :class:`CurvePoint`\n";
static PyObject * CurvePointIterator_getObject(BPy_CurvePointIterator *self) {
return BPy_CurvePoint_from_CurvePoint( self->cp_it->operator*() );
}
/*----------------------CurvePointIterator instance definitions ----------------------------*/
static PyMethodDef BPy_CurvePointIterator_methods[] = {
{"t", ( PyCFunction ) CurvePointIterator_t, METH_NOARGS, CurvePointIterator_t___doc__},
{"u", ( PyCFunction ) CurvePointIterator_u, METH_NOARGS, CurvePointIterator_u___doc__},
{"castToInterface0DIterator", ( PyCFunction ) CurvePointIterator_castToInterface0DIterator, METH_NOARGS, CurvePointIterator_castToInterface0DIterator___doc__},
{"getObject", ( PyCFunction ) CurvePointIterator_getObject, METH_NOARGS, CurvePointIterator_getObject___doc__},
{"cast_to_interface0diterator", (PyCFunction) CurvePointIterator_cast_to_interface0diterator, METH_NOARGS, CurvePointIterator_cast_to_interface0diterator_doc},
{NULL, NULL, 0, NULL}
};
/*----------------------CurvePointIterator get/setters ----------------------------*/
PyDoc_STRVAR(CurvePointIterator_object_doc,
"The CurvePoint object currently pointed by this iterator.\n"
"\n"
":type: :class:`CurvePoint`");
static PyObject *CurvePointIterator_object_get(BPy_CurvePointIterator *self, void *UNUSED(closure))
{
return BPy_CurvePoint_from_CurvePoint(self->cp_it->operator*());
}
PyDoc_STRVAR(CurvePointIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *CurvePointIterator_t_get(BPy_CurvePointIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->cp_it->t());
}
PyDoc_STRVAR(CurvePointIterator_u_doc,
"The point parameter at the current point in the stroke (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *CurvePointIterator_u_get(BPy_CurvePointIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->cp_it->u());
}
static PyGetSetDef BPy_CurvePointIterator_getseters[] = {
{(char *)"object", (getter)CurvePointIterator_object_get, (setter)NULL, (char *)CurvePointIterator_object_doc, NULL},
{(char *)"t", (getter)CurvePointIterator_t_get, (setter)NULL, (char *)CurvePointIterator_t_doc, NULL},
{(char *)"u", (getter)CurvePointIterator_u_get, (setter)NULL, (char *)CurvePointIterator_u_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_CurvePointIterator type definition ------------------------------*/
PyTypeObject CurvePointIterator_Type = {
@@ -144,7 +144,7 @@ PyTypeObject CurvePointIterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
CurvePointIterator___doc__, /* tp_doc */
CurvePointIterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -153,13 +153,13 @@ PyTypeObject CurvePointIterator_Type = {
0, /* tp_iternext */
BPy_CurvePointIterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_CurvePointIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)CurvePointIterator___init__, /* tp_init */
(initproc)CurvePointIterator_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};

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

@@ -10,7 +10,7 @@ extern "C" {
//------------------------INSTANCE METHODS ----------------------------------
static char Interface0DIterator___doc__[] =
PyDoc_STRVAR(Interface0DIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`Interface0DIterator`\n"
"\n"
"Class defining an iterator over Interface0D elements. An instance of\n"
@@ -21,24 +21,26 @@ static char Interface0DIterator___doc__[] =
" Copy constructor.\n"
"\n"
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`Interface0DIterator`\n";
" :type it: :class:`Interface0DIterator`");
static int Interface0DIterator___init__(BPy_Interface0DIterator *self, PyObject *args )
{
static int Interface0DIterator_init(BPy_Interface0DIterator *self, PyObject *args)
{
PyObject *obj = 0;
if (!( PyArg_ParseTuple(args, "O!", &Interface0DIterator_Type, &obj) ))
return -1;
if (!PyArg_ParseTuple(args, "O!", &Interface0DIterator_Type, &obj))
return -1;
self->if0D_it = new Interface0DIterator(*( ((BPy_Interface0DIterator *) obj)->if0D_it ));
self->if0D_it = new Interface0DIterator(*(((BPy_Interface0DIterator *)obj)->if0D_it));
self->py_it.it = self->if0D_it;
self->reversed = 0;
return 0;
}
static PyObject * Interface0DIterator_iternext( BPy_Interface0DIterator *self ) {
static PyObject * Interface0DIterator_iternext(BPy_Interface0DIterator *self)
{
Interface0D *if0D;
if (self->reversed) {
if (self->if0D_it->isBegin()) {
PyErr_SetNone(PyExc_StopIteration);
@@ -54,53 +56,52 @@ static PyObject * Interface0DIterator_iternext( BPy_Interface0DIterator *self )
if0D = self->if0D_it->operator->();
self->if0D_it->increment();
}
return Any_BPy_Interface0D_from_Interface0D( *if0D );
return Any_BPy_Interface0D_from_Interface0D(*if0D);
}
static char Interface0DIterator_t___doc__[] =
".. method:: t()\n"
"\n"
" Returns the curvilinear abscissa.\n"
"\n"
" :return: The curvilinear abscissa.\n"
" :rtype: float\n";
static PyObject * Interface0DIterator_t( BPy_Interface0DIterator *self ) {
return PyFloat_FromDouble( self->if0D_it->t() );
}
static char Interface0DIterator_u___doc__[] =
".. method:: u()\n"
"\n"
" Returns the point parameter in the curve 0<=u<=1.\n"
"\n"
" :return: The point parameter.\n"
" :rtype: float\n";
static PyObject * Interface0DIterator_u( BPy_Interface0DIterator *self ) {
return PyFloat_FromDouble( self->if0D_it->u() );
}
static char Interface0DIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed Interface0D.\n"
"\n"
" :return: The pointed Interface0D.\n"
" :rtype: :class:`Interface0D`\n";
static PyObject * Interface0DIterator_getObject(BPy_Interface0DIterator *self) {
return Any_BPy_Interface0D_from_Interface0D( self->if0D_it->operator*() );
}
/*----------------------Interface0DIterator instance definitions ----------------------------*/
static PyMethodDef BPy_Interface0DIterator_methods[] = {
{"t", ( PyCFunction ) Interface0DIterator_t, METH_NOARGS, Interface0DIterator_t___doc__},
{"u", ( PyCFunction ) Interface0DIterator_u, METH_NOARGS, Interface0DIterator_u___doc__},
{"getObject", ( PyCFunction ) Interface0DIterator_getObject, METH_NOARGS, Interface0DIterator_getObject___doc__},
{NULL, NULL, 0, NULL}
};
/*----------------------Interface0DIterator get/setters ----------------------------*/
PyDoc_STRVAR(Interface0DIterator_object_doc,
"The Interface0D object currently pointed by this iterator.\n"
"\n"
":type: :class:`Interface0D`");
static PyObject *Interface0DIterator_object_get(BPy_Interface0DIterator *self, void *UNUSED(closure))
{
return Any_BPy_Interface0D_from_Interface0D(self->if0D_it->operator*());
}
PyDoc_STRVAR(Interface0DIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *Interface0DIterator_t_get(BPy_Interface0DIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->if0D_it->t());
}
PyDoc_STRVAR(Interface0DIterator_u_doc,
"The point parameter at the current point in the 1D element (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *Interface0DIterator_u_get(BPy_Interface0DIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->if0D_it->u());
}
static PyGetSetDef BPy_Interface0DIterator_getseters[] = {
{(char *)"object", (getter)Interface0DIterator_object_get, (setter)NULL, (char *)Interface0DIterator_object_doc, NULL},
{(char *)"t", (getter)Interface0DIterator_t_get, (setter)NULL, (char *)Interface0DIterator_t_doc, NULL},
{(char *)"u", (getter)Interface0DIterator_u_get, (setter)NULL, (char *)Interface0DIterator_u_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_Interface0DIterator type definition ------------------------------*/
PyTypeObject Interface0DIterator_Type = {
@@ -124,7 +125,7 @@ PyTypeObject Interface0DIterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
Interface0DIterator___doc__, /* tp_doc */
Interface0DIterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -133,13 +134,13 @@ PyTypeObject Interface0DIterator_Type = {
(iternextfunc)Interface0DIterator_iternext, /* tp_iternext */
BPy_Interface0DIterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_Interface0DIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)Interface0DIterator___init__, /* tp_init */
(initproc)Interface0DIterator_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};

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

@@ -12,7 +12,7 @@ extern "C" {
//------------------------INSTANCE METHODS ----------------------------------
static char SVertexIterator___doc__[] =
PyDoc_STRVAR(SVertexIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`SVertexIterator`\n"
"\n"
"Class representing an iterator over :class:`SVertex` of a\n"
@@ -44,34 +44,34 @@ static char SVertexIterator___doc__[] =
" :arg next: The next FEdge going out from v.\n"
" :type next: :class:`FEdge`\n"
" :arg t: The curvilinear abscissa at v.\n"
" :type t: float\n";
" :type t: float");
static int SVertexIterator___init__(BPy_SVertexIterator *self, PyObject *args )
{
static int SVertexIterator_init(BPy_SVertexIterator *self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0, *obj4 = 0;
float f = 0;
if (! PyArg_ParseTuple(args, "|OOOOf", &obj1, &obj2, &obj3, &obj4, f) )
return -1;
if (!PyArg_ParseTuple(args, "|OOOOf", &obj1, &obj2, &obj3, &obj4, f))
return -1;
if( !obj1 ){
if (!obj1) {
self->sv_it = new ViewEdgeInternal::SVertexIterator();
} else if( BPy_SVertexIterator_Check(obj1) ) {
self->sv_it = new ViewEdgeInternal::SVertexIterator(*( ((BPy_SVertexIterator *) obj1)->sv_it ));
} else if( obj1 && BPy_SVertex_Check(obj1) &&
obj2 && BPy_SVertex_Check(obj2) &&
obj3 && BPy_FEdge_Check(obj3) &&
obj4 && BPy_FEdge_Check(obj4) ) {
} else if (BPy_SVertexIterator_Check(obj1)) {
self->sv_it = new ViewEdgeInternal::SVertexIterator(*(((BPy_SVertexIterator *)obj1)->sv_it));
} else if (obj1 && BPy_SVertex_Check(obj1) &&
obj2 && BPy_SVertex_Check(obj2) &&
obj3 && BPy_FEdge_Check(obj3) &&
obj4 && BPy_FEdge_Check(obj4)) {
self->sv_it = new ViewEdgeInternal::SVertexIterator(
((BPy_SVertex *) obj1)->sv,
((BPy_SVertex *) obj2)->sv,
((BPy_FEdge *) obj3)->fe,
((BPy_FEdge *) obj4)->fe,
f );
((BPy_SVertex *)obj1)->sv,
((BPy_SVertex *)obj2)->sv,
((BPy_FEdge *)obj3)->fe,
((BPy_FEdge *)obj4)->fe,
f);
} else {
PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
return -1;
@@ -82,55 +82,54 @@ static int SVertexIterator___init__(BPy_SVertexIterator *self, PyObject *args )
return 0;
}
static char SVertexIterator_t___doc__[] =
".. method:: t()\n"
"\n"
" Returns the curvilinear abscissa.\n"
"\n"
" :return: The curvilinear abscissa.\n"
" :rtype: float\n";
static PyObject * SVertexIterator_t( BPy_SVertexIterator *self ) {
return PyFloat_FromDouble( self->sv_it->t() );
}
static char SVertexIterator_u___doc__[] =
".. method:: u()\n"
"\n"
" Returns the point parameter (0<=u<=1).\n"
"\n"
" :return: The point parameter.\n"
" :rtype: float\n";
static PyObject * SVertexIterator_u( BPy_SVertexIterator *self ) {
return PyFloat_FromDouble( self->sv_it->u() );
}
static char SVertexIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed SVertex.\n"
"\n"
" :return: the pointed SVertex.\n"
" :rtype: :class:`SVertex`\n";
static PyObject * SVertexIterator_getObject( BPy_SVertexIterator *self) {
SVertex *sv = self->sv_it->operator->();
if( sv )
return BPy_SVertex_from_SVertex( *sv );
Py_RETURN_NONE;
}
/*----------------------SVertexIterator instance definitions ----------------------------*/
static PyMethodDef BPy_SVertexIterator_methods[] = {
{"t", ( PyCFunction ) SVertexIterator_t, METH_NOARGS, SVertexIterator_t___doc__},
{"u", ( PyCFunction ) SVertexIterator_u, METH_NOARGS, SVertexIterator_u___doc__},
{"getObject", ( PyCFunction ) SVertexIterator_getObject, METH_NOARGS, SVertexIterator_getObject___doc__},
{NULL, NULL, 0, NULL}
};
/*----------------------SVertexIterator get/setters ----------------------------*/
PyDoc_STRVAR(SVertexIterator_object_doc,
"The SVertex object currently pointed by this iterator.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *SVertexIterator_object_get(BPy_SVertexIterator *self, void *UNUSED(closure))
{
SVertex *sv = self->sv_it->operator->();
if (sv)
return BPy_SVertex_from_SVertex(*sv);
Py_RETURN_NONE;
}
PyDoc_STRVAR(SVertexIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *SVertexIterator_t_get(BPy_SVertexIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->sv_it->t());
}
PyDoc_STRVAR(SVertexIterator_u_doc,
"The point parameter at the current point in the 1D element (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *SVertexIterator_u_get(BPy_SVertexIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->sv_it->u());
}
static PyGetSetDef BPy_SVertexIterator_getseters[] = {
{(char *)"object", (getter)SVertexIterator_object_get, (setter)NULL, (char *)SVertexIterator_object_doc, NULL},
{(char *)"t", (getter)SVertexIterator_t_get, (setter)NULL, (char *)SVertexIterator_t_doc, NULL},
{(char *)"u", (getter)SVertexIterator_u_get, (setter)NULL, (char *)SVertexIterator_u_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_SVertexIterator type definition ------------------------------*/
PyTypeObject SVertexIterator_Type = {
@@ -154,7 +153,7 @@ PyTypeObject SVertexIterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
SVertexIterator___doc__, /* tp_doc */
SVertexIterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -163,13 +162,13 @@ PyTypeObject SVertexIterator_Type = {
0, /* tp_iternext */
BPy_SVertexIterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_SVertexIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)SVertexIterator___init__, /* tp_init */
(initproc)SVertexIterator_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};

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

@@ -11,7 +11,7 @@ extern "C" {
//------------------------INSTANCE METHODS ----------------------------------
static char StrokeVertexIterator___doc__[] =
PyDoc_STRVAR(StrokeVertexIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`StrokeVertexIterator`\n"
"\n"
"Class defining an iterator designed to iterate over the\n"
@@ -35,21 +35,21 @@ static char StrokeVertexIterator___doc__[] =
" Copy constructor.\n"
"\n"
" :arg it: A StrokeVertexIterator object.\n"
" :type it: :class:`StrokeVertexIterator`\n";
" :type it: :class:`StrokeVertexIterator`");
static int StrokeVertexIterator___init__(BPy_StrokeVertexIterator *self, PyObject *args )
{
static int StrokeVertexIterator_init(BPy_StrokeVertexIterator *self, PyObject *args)
{
PyObject *obj = 0;
if (! PyArg_ParseTuple(args, "|O", &obj) )
return -1;
if (!PyArg_ParseTuple(args, "|O", &obj))
return -1;
if( !obj ){
if (!obj) {
self->sv_it = new StrokeInternal::StrokeVertexIterator();
} else if( BPy_StrokeVertexIterator_Check(obj) ) {
self->sv_it = new StrokeInternal::StrokeVertexIterator(*( ((BPy_StrokeVertexIterator *) obj)->sv_it ));
} else if (BPy_StrokeVertexIterator_Check(obj)) {
self->sv_it = new StrokeInternal::StrokeVertexIterator(*(((BPy_StrokeVertexIterator *)obj)->sv_it));
} else {
PyErr_SetString(PyExc_TypeError, "invalid argument");
return -1;
@@ -61,8 +61,10 @@ static int StrokeVertexIterator___init__(BPy_StrokeVertexIterator *self, PyObjec
return 0;
}
static PyObject * StrokeVertexIterator_iternext( BPy_StrokeVertexIterator *self ) {
static PyObject * StrokeVertexIterator_iternext(BPy_StrokeVertexIterator *self)
{
StrokeVertex *sv;
if (self->reversed) {
if (self->sv_it->isBegin()) {
PyErr_SetNone(PyExc_StopIteration);
@@ -78,73 +80,74 @@ static PyObject * StrokeVertexIterator_iternext( BPy_StrokeVertexIterator *self
sv = self->sv_it->operator->();
self->sv_it->increment();
}
return BPy_StrokeVertex_from_StrokeVertex( *sv );
return BPy_StrokeVertex_from_StrokeVertex(*sv);
}
static char StrokeVertexIterator_t___doc__[] =
".. method:: t()\n"
"\n"
" Returns the curvilinear abscissa of the current point.\n"
"\n"
" :return: The curvilinear abscissa of the current point.\n"
" :rtype: float\n";
static PyObject * StrokeVertexIterator_t( BPy_StrokeVertexIterator *self ) {
return PyFloat_FromDouble( self->sv_it->t() );
}
static char StrokeVertexIterator_u___doc__[] =
".. method:: u()\n"
"\n"
" Returns the point parameter in the stroke (0<=u<=1).\n"
"\n"
" :return: The point parameter in the stroke\n"
" :rtype: float\n";
static PyObject * StrokeVertexIterator_u( BPy_StrokeVertexIterator *self ) {
return PyFloat_FromDouble( self->sv_it->u() );
}
static char StrokeVertexIterator_castToInterface0DIterator___doc__[] =
".. method:: castToInterface0DIterator()\n"
PyDoc_STRVAR(StrokeVertexIterator_cast_to_interface0diterator_doc,
".. method:: cast_to_interface0diterator()\n"
"\n"
" Returns an Interface0DIterator converted from this\n"
" StrokeVertexIterator. Useful for any call to a function of the\n"
" UnaryFunction0D type.\n"
"\n"
" :return: An Interface0DIterator converted from the StrokeVertexIterator.\n"
" :rtype: :class:`Interface0DIterator`\n";
" :rtype: :class:`Interface0DIterator`");
static PyObject * StrokeVertexIterator_castToInterface0DIterator( BPy_StrokeVertexIterator *self ) {
Interface0DIterator it( self->sv_it->castToInterface0DIterator() );
return BPy_Interface0DIterator_from_Interface0DIterator( it, 0 );
static PyObject * StrokeVertexIterator_cast_to_interface0diterator(BPy_StrokeVertexIterator *self)
{
Interface0DIterator it(self->sv_it->castToInterface0DIterator());
return BPy_Interface0DIterator_from_Interface0DIterator(it, 0);
}
static char StrokeVertexIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed StrokeVertex.\n"
"\n"
" :return: The pointed StrokeVertex.\n"
" :rtype: :class:`StrokeVertex`\n";
static PyMethodDef BPy_StrokeVertexIterator_methods[] = {
{"cast_to_interface0diterator", (PyCFunction) StrokeVertexIterator_cast_to_interface0diterator, METH_NOARGS, StrokeVertexIterator_cast_to_interface0diterator_doc},
{NULL, NULL, 0, NULL}
};
static PyObject * StrokeVertexIterator_getObject( BPy_StrokeVertexIterator *self) {
/*----------------------StrokeVertexIterator get/setters ----------------------------*/
PyDoc_STRVAR(StrokeVertexIterator_object_doc,
"The StrokeVertex object currently pointed by this iterator.\n"
"\n"
":type: :class:`StrokeVertex`");
static PyObject *StrokeVertexIterator_object_get(BPy_StrokeVertexIterator *self, void *UNUSED(closure))
{
if (!self->reversed && self->sv_it->isEnd())
Py_RETURN_NONE;
StrokeVertex *sv = self->sv_it->operator->();
if( sv )
return BPy_StrokeVertex_from_StrokeVertex( *sv );
if (sv)
return BPy_StrokeVertex_from_StrokeVertex(*sv);
Py_RETURN_NONE;
}
/*----------------------StrokeVertexIterator instance definitions ----------------------------*/
static PyMethodDef BPy_StrokeVertexIterator_methods[] = {
{"t", ( PyCFunction ) StrokeVertexIterator_t, METH_NOARGS, StrokeVertexIterator_t___doc__},
{"u", ( PyCFunction ) StrokeVertexIterator_u, METH_NOARGS, StrokeVertexIterator_u___doc__},
{"castToInterface0DIterator", ( PyCFunction ) StrokeVertexIterator_castToInterface0DIterator, METH_NOARGS, StrokeVertexIterator_castToInterface0DIterator___doc__},
{"getObject", ( PyCFunction ) StrokeVertexIterator_getObject, METH_NOARGS, StrokeVertexIterator_getObject___doc__},
{NULL, NULL, 0, NULL}
PyDoc_STRVAR(StrokeVertexIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *StrokeVertexIterator_t_get(BPy_StrokeVertexIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->sv_it->t());
}
PyDoc_STRVAR(StrokeVertexIterator_u_doc,
"The point parameter at the current point in the stroke (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *StrokeVertexIterator_u_get(BPy_StrokeVertexIterator *self, void *UNUSED(closure))
{
return PyFloat_FromDouble(self->sv_it->u());
}
static PyGetSetDef BPy_StrokeVertexIterator_getseters[] = {
{(char *)"object", (getter)StrokeVertexIterator_object_get, (setter)NULL, (char *)StrokeVertexIterator_object_doc, NULL},
{(char *)"t", (getter)StrokeVertexIterator_t_get, (setter)NULL, (char *)StrokeVertexIterator_t_doc, NULL},
{(char *)"u", (getter)StrokeVertexIterator_u_get, (setter)NULL, (char *)StrokeVertexIterator_u_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_StrokeVertexIterator type definition ------------------------------*/
@@ -170,7 +173,7 @@ PyTypeObject StrokeVertexIterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
StrokeVertexIterator___doc__, /* tp_doc */
StrokeVertexIterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -179,13 +182,13 @@ PyTypeObject StrokeVertexIterator_Type = {
(iternextfunc)StrokeVertexIterator_iternext, /* tp_iternext */
BPy_StrokeVertexIterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_StrokeVertexIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)StrokeVertexIterator___init__, /* tp_init */
(initproc)StrokeVertexIterator_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};

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

@@ -12,7 +12,7 @@ extern "C" {
//------------------------INSTANCE METHODS ----------------------------------
static char ViewEdgeIterator___doc__[] =
PyDoc_STRVAR(ViewEdgeIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator`\n"
"\n"
"Base class for iterators over ViewEdges of the :class:`ViewMap` Graph.\n"
@@ -38,182 +38,148 @@ static char ViewEdgeIterator___doc__[] =
" Copy constructor.\n"
"\n"
" :arg it: A ViewEdgeIterator object.\n"
" :type it: :class:`ViewEdgeIterator`\n";
" :type it: :class:`ViewEdgeIterator`");
static int ViewEdgeIterator___init__(BPy_ViewEdgeIterator *self, PyObject *args )
{
static int ViewEdgeIterator_init(BPy_ViewEdgeIterator *self, PyObject *args)
{
PyObject *obj1 = 0, *obj2 = 0;
if (!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) ))
return -1;
if (!PyArg_ParseTuple(args, "O|O", &obj1, &obj2))
return -1;
if (BPy_ViewEdgeIterator_Check(obj1)) {
self->ve_it = new ViewEdgeInternal::ViewEdgeIterator(*(((BPy_ViewEdgeIterator *)obj1)->ve_it));
if( obj1 && BPy_ViewEdgeIterator_Check(obj1) ) {
self->ve_it = new ViewEdgeInternal::ViewEdgeIterator(*( ((BPy_ViewEdgeIterator *) obj1)->ve_it ));
} else {
ViewEdge *begin;
if ( !obj1 || obj1 == Py_None )
if (obj1 == Py_None)
begin = NULL;
else if ( BPy_ViewEdge_Check(obj1) )
begin = ((BPy_ViewEdge *) obj1)->ve;
else if (BPy_ViewEdge_Check(obj1))
begin = ((BPy_ViewEdge *)obj1)->ve;
else {
PyErr_SetString(PyExc_TypeError, "1st argument must be either a ViewEdge object or None");
return -1;
}
bool orientation = ( obj2 ) ? bool_from_PyBool(obj2) : true;
self->ve_it = new ViewEdgeInternal::ViewEdgeIterator( begin, orientation);
bool orientation = (obj2) ? bool_from_PyBool(obj2) : true;
self->ve_it = new ViewEdgeInternal::ViewEdgeIterator(begin, orientation);
}
self->py_it.it = self->ve_it;
return 0;
}
static char ViewEdgeIterator_getCurrentEdge___doc__[] =
".. method:: getCurrentEdge()\n"
PyDoc_STRVAR(ViewEdgeIterator_change_orientation_doc,
".. method:: change_orientation()\n"
"\n"
" Returns the current pointed ViewEdge.\n"
"\n"
" :return: The current pointed ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
" Changes the current orientation.");
static PyObject *ViewEdgeIterator_getCurrentEdge( BPy_ViewEdgeIterator *self ) {
ViewEdge *ve = self->ve_it->getCurrentEdge();
if( ve )
return BPy_ViewEdge_from_ViewEdge( *ve );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_setCurrentEdge___doc__[] =
".. method:: setCurrentEdge(edge)\n"
"\n"
" Sets the current pointed ViewEdge.\n"
"\n"
" :arg edge: The current pointed ViewEdge.\n"
" :type edge: :class:`ViewEdge`\n";
static PyObject *ViewEdgeIterator_setCurrentEdge( BPy_ViewEdgeIterator *self, PyObject *args ) {
PyObject *py_ve;
if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
return NULL;
self->ve_it->setCurrentEdge( ((BPy_ViewEdge *) py_ve)->ve );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_getBegin___doc__[] =
".. method:: getBegin()\n"
"\n"
" Returns the first ViewEdge used for the iteration.\n"
"\n"
" :return: The first ViewEdge used for the iteration.\n"
" :rtype: :class:`ViewEdge`\n";
static PyObject *ViewEdgeIterator_getBegin( BPy_ViewEdgeIterator *self ) {
ViewEdge *ve = self->ve_it->getBegin();
if( ve )
return BPy_ViewEdge_from_ViewEdge( *ve );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_setBegin___doc__[] =
".. method:: setBegin(begin)\n"
"\n"
" Sets the first ViewEdge used for the iteration.\n"
"\n"
" :arg begin: The first ViewEdge used for the iteration.\n"
" :type begin: :class:`ViewEdge`\n";
static PyObject *ViewEdgeIterator_setBegin( BPy_ViewEdgeIterator *self, PyObject *args ) {
PyObject *py_ve;
if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
return NULL;
self->ve_it->setBegin( ((BPy_ViewEdge *) py_ve)->ve );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_getOrientation___doc__[] =
".. method:: getOrientation()\n"
"\n"
" Returns the orientation of the pointed ViewEdge in the iteration.\n"
"\n"
" :return: The orientation of the pointed ViewEdge in the iteration.\n"
" :rtype: bool\n";
static PyObject *ViewEdgeIterator_getOrientation( BPy_ViewEdgeIterator *self ) {
return PyBool_from_bool( self->ve_it->getOrientation() );
}
static char ViewEdgeIterator_setOrientation___doc__[] =
".. method:: setOrientation(orientation)\n"
"\n"
" Sets the orientation of the pointed ViewEdge in the iteration.\n"
"\n"
" :arg orientation: If true, we'll look for the next ViewEdge among\n"
" the ViewEdges that surround the ending ViewVertex of begin. If\n"
" false, we'll search over the ViewEdges surrounding the ending\n"
" ViewVertex of begin.\n"
" :type orientation: bool\n";
static PyObject *ViewEdgeIterator_setOrientation( BPy_ViewEdgeIterator *self, PyObject *args ) {
PyObject *py_b;
if(!( PyArg_ParseTuple(args, "O", &py_b) ))
return NULL;
self->ve_it->setOrientation( bool_from_PyBool(py_b) );
Py_RETURN_NONE;
}
static char ViewEdgeIterator_changeOrientation___doc__[] =
".. method:: changeOrientation()\n"
"\n"
" Changes the current orientation.\n";
static PyObject *ViewEdgeIterator_changeOrientation( BPy_ViewEdgeIterator *self ) {
static PyObject *ViewEdgeIterator_change_orientation(BPy_ViewEdgeIterator *self)
{
self->ve_it->changeOrientation();
Py_RETURN_NONE;
}
static char ViewEdgeIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed ViewEdge.\n"
"\n"
" :return: The pointed ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
static PyMethodDef BPy_ViewEdgeIterator_methods[] = {
{"change_orientation", (PyCFunction) ViewEdgeIterator_change_orientation, METH_NOARGS, ViewEdgeIterator_change_orientation_doc},
{NULL, NULL, 0, NULL}
};
static PyObject * ViewEdgeIterator_getObject( BPy_ViewEdgeIterator *self) {
/*----------------------ViewEdgeIterator get/setters ----------------------------*/
PyDoc_STRVAR(ViewEdgeIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ViewEdgeIterator_object_get(BPy_ViewEdgeIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->ve_it->operator*();
if( ve )
return BPy_ViewEdge_from_ViewEdge( *ve );
if (ve)
return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE;
}
/*----------------------ViewEdgeIterator instance definitions ----------------------------*/
static PyMethodDef BPy_ViewEdgeIterator_methods[] = {
{"getCurrentEdge", ( PyCFunction ) ViewEdgeIterator_getCurrentEdge, METH_NOARGS, ViewEdgeIterator_getCurrentEdge___doc__},
{"setCurrentEdge", ( PyCFunction ) ViewEdgeIterator_setCurrentEdge, METH_VARARGS, ViewEdgeIterator_setCurrentEdge___doc__},
{"getBegin", ( PyCFunction ) ViewEdgeIterator_getBegin, METH_NOARGS, ViewEdgeIterator_getBegin___doc__},
{"setBegin", ( PyCFunction ) ViewEdgeIterator_setBegin, METH_VARARGS, ViewEdgeIterator_setBegin___doc__},
{"getOrientation", ( PyCFunction ) ViewEdgeIterator_getOrientation, METH_NOARGS, ViewEdgeIterator_getOrientation___doc__},
{"setOrientation", ( PyCFunction ) ViewEdgeIterator_setOrientation, METH_VARARGS, ViewEdgeIterator_setOrientation___doc__},
{"changeOrientation", ( PyCFunction ) ViewEdgeIterator_changeOrientation, METH_NOARGS, ViewEdgeIterator_changeOrientation___doc__},
{"getObject", ( PyCFunction ) ViewEdgeIterator_getObject, METH_NOARGS, ViewEdgeIterator_getObject___doc__},
{NULL, NULL, 0, NULL}
PyDoc_STRVAR(ViewEdgeIterator_current_edge_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ViewEdgeIterator_current_edge_get(BPy_ViewEdgeIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->ve_it->getCurrentEdge();
if (ve)
return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE;}
static int ViewEdgeIterator_current_edge_set(BPy_ViewEdgeIterator *self, PyObject *value, void *UNUSED(closure))
{
if (!BPy_ViewEdge_Check(value)) {
PyErr_SetString(PyExc_TypeError, "value must be a ViewEdge");
return -1;
}
self->ve_it->setCurrentEdge(((BPy_ViewEdge *)value)->ve);
return 0;
}
PyDoc_STRVAR(ViewEdgeIterator_orientation_doc,
"The orientation of the pointed ViewEdge in the iteration.\n"
"If true, the iterator looks for the next ViewEdge among those ViewEdges\n"
"that surround the ending ViewVertex of the \"begin\" ViewEdge. If false,\n"
"the iterator searches over the ViewEdges surrounding the ending ViewVertex\n"
"of the \"begin\" ViewEdge.\n"
"\n"
":type: bool");
static PyObject *ViewEdgeIterator_orientation_get(BPy_ViewEdgeIterator *self, void *UNUSED(closure))
{
return PyBool_from_bool(self->ve_it->getOrientation());
}
static int ViewEdgeIterator_orientation_set(BPy_ViewEdgeIterator *self, PyObject *value, void *UNUSED(closure))
{
if (!PyBool_Check(value)) {
PyErr_SetString(PyExc_TypeError, "value must be a boolean");
return -1;
}
self->ve_it->setOrientation(bool_from_PyBool(value));
return 0;
}
PyDoc_STRVAR(ViewEdgeIterator_begin_doc,
"The first ViewEdge used for the iteration.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ViewEdgeIterator_begin_get(BPy_ViewEdgeIterator *self, void *UNUSED(closure))
{
ViewEdge *ve = self->ve_it->getBegin();
if (ve)
return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE;
}
static int ViewEdgeIterator_begin_set(BPy_ViewEdgeIterator *self, PyObject *value, void *UNUSED(closure))
{
if(!BPy_ViewEdge_Check(value)) {
PyErr_SetString(PyExc_TypeError, "value must be a ViewEdge");
return -1;
}
self->ve_it->setBegin(((BPy_ViewEdge *)value)->ve);
return 0;
}
static PyGetSetDef BPy_ViewEdgeIterator_getseters[] = {
{(char *)"object", (getter)ViewEdgeIterator_object_get, (setter)NULL, (char *)ViewEdgeIterator_object_doc, NULL},
{(char *)"current_edge", (getter)ViewEdgeIterator_current_edge_get, (setter)ViewEdgeIterator_current_edge_set, (char *)ViewEdgeIterator_current_edge_doc, NULL},
{(char *)"orientation", (getter)ViewEdgeIterator_orientation_get, (setter)ViewEdgeIterator_orientation_set, (char *)ViewEdgeIterator_orientation_doc, NULL},
{(char *)"begin", (getter)ViewEdgeIterator_begin_get, (setter)ViewEdgeIterator_begin_set, (char *)ViewEdgeIterator_begin_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_ViewEdgeIterator type definition ------------------------------*/
@@ -239,7 +205,7 @@ PyTypeObject ViewEdgeIterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
ViewEdgeIterator___doc__, /* tp_doc */
ViewEdgeIterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -248,13 +214,13 @@ PyTypeObject ViewEdgeIterator_Type = {
0, /* tp_iternext */
BPy_ViewEdgeIterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_ViewEdgeIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)ViewEdgeIterator___init__, /* tp_init */
(initproc)ViewEdgeIterator_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};

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

@@ -10,7 +10,7 @@ extern "C" {
//------------------------INSTANCE METHODS ----------------------------------
static char orientedViewEdgeIterator___doc__[] =
PyDoc_STRVAR(orientedViewEdgeIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`orientedViewEdgeIterator`\n"
"\n"
"Class representing an iterator over oriented ViewEdges around a\n"
@@ -27,32 +27,34 @@ static char orientedViewEdgeIterator___doc__[] =
" Copy constructor.\n"
"\n"
" :arg iBrother: An orientedViewEdgeIterator object.\n"
" :type iBrother: :class:`orientedViewEdgeIterator`\n";
" :type iBrother: :class:`orientedViewEdgeIterator`");
static int orientedViewEdgeIterator___init__(BPy_orientedViewEdgeIterator *self, PyObject *args )
{
static int orientedViewEdgeIterator_init(BPy_orientedViewEdgeIterator *self, PyObject *args)
{
PyObject *obj = 0;
if (!( PyArg_ParseTuple(args, "|O", &obj) ))
return -1;
if (!PyArg_ParseTuple(args, "|O", &obj))
return -1;
if( !obj )
if (!obj)
self->ove_it = new ViewVertexInternal::orientedViewEdgeIterator();
else if( BPy_orientedViewEdgeIterator_Check(obj) )
self->ove_it = new ViewVertexInternal::orientedViewEdgeIterator(*( ((BPy_orientedViewEdgeIterator *) obj)->ove_it ));
else if (BPy_orientedViewEdgeIterator_Check(obj))
self->ove_it = new ViewVertexInternal::orientedViewEdgeIterator(*(((BPy_orientedViewEdgeIterator *)obj)->ove_it));
else {
PyErr_SetString(PyExc_TypeError, "invalid argument");
return -1;
}
self->py_it.it = self->ove_it;
self->reversed = 0;
return 0;
}
static PyObject * orientedViewEdgeIterator_iternext( BPy_orientedViewEdgeIterator *self ) {
static PyObject * orientedViewEdgeIterator_iternext(BPy_orientedViewEdgeIterator *self)
{
ViewVertex::directedViewEdge *dve;
if (self->reversed) {
if (self->ove_it->isBegin()) {
PyErr_SetNone(PyExc_StopIteration);
@@ -68,28 +70,33 @@ static PyObject * orientedViewEdgeIterator_iternext( BPy_orientedViewEdgeIterato
dve = self->ove_it->operator->();
self->ove_it->increment();
}
return BPy_directedViewEdge_from_directedViewEdge( *dve );
return BPy_directedViewEdge_from_directedViewEdge(*dve);
}
static char orientedViewEdgeIterator_getObject___doc__[] =
".. method:: getObject()\n"
"\n"
" Returns the pointed oriented ViewEdge.\n"
"\n"
" :return: A tuple of the pointed ViewEdge and a boolean value. If\n"
" the boolean value is true, the ViewEdge is incoming.\n"
" :rtype: (:class:`directedViewEdge`, bool)\n";
static PyObject * orientedViewEdgeIterator_getObject( BPy_orientedViewEdgeIterator *self) {
return BPy_directedViewEdge_from_directedViewEdge( self->ove_it->operator*() );
}
/*----------------------orientedViewEdgeIterator instance definitions ----------------------------*/
static PyMethodDef BPy_orientedViewEdgeIterator_methods[] = {
{"getObject", ( PyCFunction ) orientedViewEdgeIterator_getObject, METH_NOARGS, orientedViewEdgeIterator_getObject___doc__},
{NULL, NULL, 0, NULL}
};
/*----------------------orientedViewEdgeIterator get/setters ----------------------------*/
PyDoc_STRVAR(orientedViewEdgeIterator_object_doc,
"The oriented ViewEdge (i.e., a tuple of the pointed ViewEdge and a boolean\n"
"value) currently pointed by this iterator. If the boolean value is true,\n"
"the ViewEdge is incoming.\n"
"\n"
":type: (:class:`directedViewEdge`, bool)");
static PyObject *orientedViewEdgeIterator_object_get(BPy_orientedViewEdgeIterator *self, void *UNUSED(closure))
{
return BPy_directedViewEdge_from_directedViewEdge(self->ove_it->operator*());
}
static PyGetSetDef BPy_orientedViewEdgeIterator_getseters[] = {
{(char *)"object", (getter)orientedViewEdgeIterator_object_get, (setter)NULL, (char *)orientedViewEdgeIterator_object_doc, NULL},
{NULL, NULL, NULL, NULL, NULL} /* Sentinel */
};
/*-----------------------BPy_orientedViewEdgeIterator type definition ------------------------------*/
PyTypeObject orientedViewEdgeIterator_Type = {
@@ -113,7 +120,7 @@ PyTypeObject orientedViewEdgeIterator_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
orientedViewEdgeIterator___doc__, /* tp_doc */
orientedViewEdgeIterator_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -122,13 +129,13 @@ PyTypeObject orientedViewEdgeIterator_Type = {
(iternextfunc)orientedViewEdgeIterator_iternext, /* tp_iternext */
BPy_orientedViewEdgeIterator_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
BPy_orientedViewEdgeIterator_getseters, /* tp_getset */
&Iterator_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)orientedViewEdgeIterator___init__, /* tp_init */
(initproc)orientedViewEdgeIterator_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};