Freestyle Python API improvements - part 3.

Major API updates were made to address code review comments.
This revision mostly focuses on Python wrappers of C++ 0D and 1D elements (i.e.,
Interface0D and Interface1D, as well as their subclasses).

* Most getter/setter methods were reimplemented as attributes using PyGetSetDef.
Vector attributes are now implemented based on mathutils callbacks.  Boolean
attributes now only accept boolean values.

* The __getitem__ method was removed and the Sequence protocol was used instead.

* 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).  Some naming inconsistency within the Freestyle Python
API was also addressed.

* The Freestyle API had a number of method names including prefix/suffix "A" and
"B", and their meanings were inconsistent (i.e., referring to different things
depending on the classes).  The names with these two letters were replaced with
more straightforward names.  Also some attribute names were changed so as to indicate
the type of the value (e.g., FEdge.next_fedge instead of FEdge.next_edge) in line
with other names explicitly indicating what the value is (e.g., SVertex.viewvertex).

* In addition, some code clean-up was done in both C++ and Python.

Notes:

In summary, the following irregular naming changes were made through this revision
(those resulting from regular changes of naming conventions are not listed):

- CurvePoint: {A,B} --> {first,second}_svertex
- FEdge: vertex{A,B} --> {first,second}_svertex
- FEdge: {next,previous}Edge --> {next,previous}_fedge
- FEdgeSharp: normal{A,B} --> normal_{right,left}
- FEdgeSharp: {a,b}FaceMark --> face_mark_{right,left}
- FEdgeSharp: {a,b}Material --> material_{right,left}
- FEdgeSharp: {a,b}MaterialIndex --> material_index_{right,left}
- FrsCurve: empty --> is_empty
- FrsCurve: nSegments --> segments_size
- TVertex: mate() --> get_mate()
- ViewEdge: fedge{A,B} --> {first,last}_fedge
- ViewEdge: setaShape, aShape --> occlude
- ViewEdge: {A,B} --> {first,last}_viewvertex
- ViewMap: getScene3dBBox --> scene_bbox

20 files changed, 2270 insertions, 2583 deletions

diff --git a/source/blender/freestyle/intern/python/BPy_Id.cpp b/source/blender/freestyle/intern/python/BPy_Id.cpp
index 8f8336f6c17..54942abb58d 100644
--- a/source/blender/freestyle/intern/python/BPy_Id.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Id.cpp
@@ -76,68 +76,6 @@ static PyObject * Id___repr__(BPy_Id* self)
     return PyUnicode_FromFormat("[ first: %i, second: %i ](BPy_Id)", self->id->getFirst(), self->id->getSecond() );
 }
 
-static char Id_getFirst___doc__[] =
-".. method:: getFirst()\n"
-"\n"
-"   Returns the first Id number.\n"
-"\n"
-"   :return: The first Id number.\n"
-"   :rtype: int\n";
-
-static PyObject *Id_getFirst( BPy_Id *self ) {
-	return PyLong_FromLong( self->id->getFirst() );
-}
-
-static char Id_getSecond___doc__[] =
-".. method:: getSecond()\n"
-"\n"
-"   Returns the second Id number.\n"
-"\n"
-"   :return: The second Id number.\n"
-"   :rtype: int\n";
-
-static PyObject *Id_getSecond( BPy_Id *self) {
-	return PyLong_FromLong( self->id->getSecond() );
-}
-
-static char Id_setFirst___doc__[] =
-".. method:: setFirst(iFirst)\n"
-"\n"
-"   Sets the first number constituting the Id.\n"
-"\n"
-"   :arg iFirst: The first number constituting the Id.\n"
-"   :type iFirst: int\n";
-
-static PyObject *Id_setFirst( BPy_Id *self , PyObject *args) {
-	unsigned int i;
-
-	if( !PyArg_ParseTuple(args, "i", &i) )
-		return NULL;
-
-	self->id->setFirst( i );
-
-	Py_RETURN_NONE;
-}
-
-static char Id_setSecond___doc__[] =
-".. method:: setSecond(iSecond)\n"
-"\n"
-"   Sets the second number constituting the Id.\n"
-"\n"
-"   :arg iSecond: The second number constituting the Id.\n"
-"   :type iSecond: int\n";
-
-static PyObject *Id_setSecond( BPy_Id *self , PyObject *args) {
-	unsigned int i;
-
-	if( !PyArg_ParseTuple(args, "i", &i) )
-		return NULL;
-
-	self->id->setSecond( i );
-
-	Py_RETURN_NONE;
-}
-
 static PyObject * Id_RichCompare(BPy_Id *o1, BPy_Id *o2, int opid) {
 	switch(opid){
 		case Py_LT:
@@ -165,13 +103,61 @@ static PyObject * Id_RichCompare(BPy_Id *o1, BPy_Id *o2, int opid) {
 
 /*----------------------Id instance definitions ----------------------------*/
 static PyMethodDef BPy_Id_methods[] = {
-	{"getFirst", ( PyCFunction ) Id_getFirst, METH_NOARGS, Id_getFirst___doc__},
-	{"getSecond", ( PyCFunction ) Id_getSecond, METH_NOARGS, Id_getSecond___doc__},
-	{"setFirst", ( PyCFunction ) Id_setFirst, METH_VARARGS, Id_setFirst___doc__},
-	{"setSecond", ( PyCFunction ) Id_setSecond, METH_VARARGS, Id_setSecond___doc__},
 	{NULL, NULL, 0, NULL}
 };
 
+/*----------------------Id get/setters ----------------------------*/
+
+PyDoc_STRVAR(Id_first_doc,
+"The first number constituting the Id.\n"
+"\n"
+":type: int"
+);
+
+static PyObject *Id_first_get(BPy_Id *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->id->getFirst());
+}
+
+static int Id_first_set(BPy_Id *self, PyObject *value, void *UNUSED(closure))
+{
+	int scalar;
+	if ((scalar = PyLong_AsLong(value)) == -1 && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_TypeError, "value must be an integer");
+		return -1;
+	}
+	self->id->setFirst(scalar);
+	return 0;
+}
+
+PyDoc_STRVAR(Id_second_doc,
+"The second number constituting the Id.\n"
+"\n"
+":type: int"
+);
+
+static PyObject *Id_second_get(BPy_Id *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->id->getSecond());
+}
+
+static int Id_second_set(BPy_Id *self, PyObject *value, void *UNUSED(closure))
+{
+	int scalar;
+	if ((scalar = PyLong_AsLong(value)) == -1 && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_TypeError, "value must be an integer");
+		return -1;
+	}
+	self->id->setSecond(scalar);
+	return 0;
+}
+
+static PyGetSetDef BPy_Id_getseters[] = {
+	{(char *)"first", (getter)Id_first_get, (setter)Id_first_set, (char *)Id_first_doc, NULL},
+	{(char *)"second", (getter)Id_second_get, (setter)Id_second_set, (char *)Id_second_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
+};
+
 /*-----------------------BPy_Id type definition ------------------------------*/
 
 PyTypeObject Id_Type = {
@@ -204,7 +190,7 @@ PyTypeObject Id_Type = {
 	0,                              /* tp_iternext */
 	BPy_Id_methods,                 /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_Id_getseters,               /* tp_getset */
 	0,                              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
diff --git a/source/blender/freestyle/intern/python/BPy_Interface0D.cpp b/source/blender/freestyle/intern/python/BPy_Interface0D.cpp
index be8b87cd1bc..3aedea2e034 100644
--- a/source/blender/freestyle/intern/python/BPy_Interface0D.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Interface0D.cpp
@@ -17,284 +17,225 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //-------------------MODULE INITIALIZATION--------------------------------
-int Interface0D_Init( PyObject *module )
+int Interface0D_Init(PyObject *module)
 {
-	if( module == NULL )
+	if (module == NULL)
 		return -1;
 
-	if( PyType_Ready( &Interface0D_Type ) < 0 )
+	if (PyType_Ready(&Interface0D_Type) < 0)
 		return -1;
-	Py_INCREF( &Interface0D_Type );
+	Py_INCREF(&Interface0D_Type);
 	PyModule_AddObject(module, "Interface0D", (PyObject *)&Interface0D_Type);
 	
-	if( PyType_Ready( &CurvePoint_Type ) < 0 )
+	if (PyType_Ready(&CurvePoint_Type) < 0)
 		return -1;
-	Py_INCREF( &CurvePoint_Type );
+	Py_INCREF(&CurvePoint_Type);
 	PyModule_AddObject(module, "CurvePoint", (PyObject *)&CurvePoint_Type);
 	
-	if( PyType_Ready( &SVertex_Type ) < 0 )
+	if (PyType_Ready(&SVertex_Type) < 0)
 		return -1;
-	Py_INCREF( &SVertex_Type );
+	Py_INCREF(&SVertex_Type);
 	PyModule_AddObject(module, "SVertex", (PyObject *)&SVertex_Type);	
 	
-	if( PyType_Ready( &ViewVertex_Type ) < 0 )
+	if (PyType_Ready(&ViewVertex_Type) < 0)
 		return -1;
-	Py_INCREF( &ViewVertex_Type );
+	Py_INCREF(&ViewVertex_Type);
 	PyModule_AddObject(module, "ViewVertex", (PyObject *)&ViewVertex_Type);
 	
-	if( PyType_Ready( &StrokeVertex_Type ) < 0 )
+	if (PyType_Ready(&StrokeVertex_Type) < 0)
 		return -1;
-	Py_INCREF( &StrokeVertex_Type );
+	Py_INCREF(&StrokeVertex_Type);
 	PyModule_AddObject(module, "StrokeVertex", (PyObject *)&StrokeVertex_Type);
 	
-	if( PyType_Ready( &NonTVertex_Type ) < 0 )
+	if (PyType_Ready(&NonTVertex_Type) < 0)
 		return -1;
-	Py_INCREF( &NonTVertex_Type );
+	Py_INCREF(&NonTVertex_Type);
 	PyModule_AddObject(module, "NonTVertex", (PyObject *)&NonTVertex_Type);
 	
-	if( PyType_Ready( &TVertex_Type ) < 0 )
+	if (PyType_Ready(&TVertex_Type) < 0)
 		return -1;
-	Py_INCREF( &TVertex_Type );
+	Py_INCREF(&TVertex_Type);
 	PyModule_AddObject(module, "TVertex", (PyObject *)&TVertex_Type);
 
+	SVertex_mathutils_register_callback();
 	StrokeVertex_mathutils_register_callback();
 
 	return 0;
 }
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------Interface1D methods ----------------------------*/
 
-static char Interface0D___doc__[] =
+PyDoc_STRVAR(Interface0D_doc,
 "Base class for any 0D element.\n"
 "\n"
 ".. method:: __init__()\n"
 "\n"
-"   Default constructor.\n";
+"   Default constructor.");
 
-static int Interface0D___init__(BPy_Interface0D *self, PyObject *args, PyObject *kwds)
+static int Interface0D_init(BPy_Interface0D *self, PyObject *args, PyObject *kwds)
 {
-    if ( !PyArg_ParseTuple(args, "") )
-        return -1;
+	if (!PyArg_ParseTuple(args, ""))
+		return -1;
 	self->if0D = new Interface0D();
 	self->borrowed = 0;
 	return 0;
 }
 
-static void Interface0D___dealloc__(BPy_Interface0D* self)
+static void Interface0D_dealloc(BPy_Interface0D* self)
 {
-	if( self->if0D && !self->borrowed )
+	if (self->if0D && !self->borrowed)
 		delete self->if0D;
-    Py_TYPE(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-static PyObject * Interface0D___repr__(BPy_Interface0D* self)
+static PyObject * Interface0D_repr(BPy_Interface0D* self)
 {
-    return PyUnicode_FromFormat("type: %s - address: %p", self->if0D->getExactTypeName().c_str(), self->if0D );
+	return PyUnicode_FromFormat("type: %s - address: %p", self->if0D->getExactTypeName().c_str(), self->if0D);
 }
 
-static char Interface0D_getExactTypeName___doc__[] =
-".. method:: getExactTypeName()\n"
+PyDoc_STRVAR(Interface0D_get_fedge_doc,
+".. method:: get_fedge(inter)\n"
 "\n"
-"   Returns the name of the 0D element.\n"
+"   Returns the FEdge that lies between this 0D element and the 0D\n"
+"   element given as the argument.\n"
 "\n"
-"   :return: Name of the interface.\n"
-"   :rtype: str\n";
-
-static PyObject *Interface0D_getExactTypeName( BPy_Interface0D *self ) {
-	return PyUnicode_FromString( self->if0D->getExactTypeName().c_str() );	
-}
+"   :arg inter: A 0D element.\n"
+"   :type inter: :class:`Interface0D`\n"
+"   :return: The FEdge lying between the two 0D elements.\n"
+"   :rtype: :class:`FEdge`");
 
-static char Interface0D_getX___doc__[] =
-".. method:: getX()\n"
-"\n"
-"   Returns the X coordinate of the 3D point of the 0D element.\n"
-"\n"
-"   :return: The X coordinate of the 3D point.\n"
-"   :rtype: float\n";
+static PyObject *Interface0D_get_fedge(BPy_Interface0D *self, PyObject *args)
+{
+	PyObject *py_if0D;
 
-static PyObject *Interface0D_getX( BPy_Interface0D *self ) {
-	double x = self->if0D->getX();
-	if (PyErr_Occurred())
+	if (!PyArg_ParseTuple(args, "O!", &Interface0D_Type, &py_if0D))
 		return NULL;
-	return PyFloat_FromDouble( x );
-}
-
-static char Interface0D_getY___doc__[] =
-".. method:: getY()\n"
-"\n"
-"   Returns the Y coordinate of the 3D point of the 0D element.\n"
-"\n"
-"   :return: The Y coordinate of the 3D point.\n"
-"   :rtype: float\n";
-
-static PyObject *Interface0D_getY( BPy_Interface0D *self ) {
-	double y = self->if0D->getY();
+	FEdge *fe = self->if0D->getFEdge(*(((BPy_Interface0D *)py_if0D)->if0D));
 	if (PyErr_Occurred())
 		return NULL;
-	return PyFloat_FromDouble( y );
+	if (fe)
+		return Any_BPy_FEdge_from_FEdge(*fe);
+	Py_RETURN_NONE;
 }
 
-static char Interface0D_getZ___doc__[] =
-".. method:: getZ()\n"
-"\n"
-"   Returns the Z coordinate of the 3D point of the 0D element.\n"
-"\n"
-"   :return: The Z coordinate of the 3D point.\n"
-"   :rtype: float\n";
+static PyMethodDef BPy_Interface0D_methods[] = {
+	{"get_fedge", (PyCFunction)Interface0D_get_fedge, METH_VARARGS, Interface0D_get_fedge_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-static PyObject *Interface0D_getZ( BPy_Interface0D *self ) {
-	double z = self->if0D->getZ();
-	if (PyErr_Occurred())
-		return NULL;
-	return PyFloat_FromDouble( z );
-}
+/*----------------------Interface1D get/setters ----------------------------*/
 
-static char Interface0D_getPoint3D___doc__[] =
-".. method:: getPoint3D()\n"
+PyDoc_STRVAR(Interface0D_exact_type_name_doc,
+"The string of the the name of this 0D element.\n"
 "\n"
-"   Returns the location of the 0D element in the 3D space.\n"
-"\n"
-"   :return: The 3D point of the 0D element.\n"
-"   :rtype: :class:`mathutils.Vector`\n";
+":type: str");
 
-static PyObject *Interface0D_getPoint3D( BPy_Interface0D *self ) {
-	Vec3f v( self->if0D->getPoint3D() );
-	if (PyErr_Occurred())
-		return NULL;
-	return Vector_from_Vec3f( v );
+static PyObject *Interface0D_exact_type_name_get(BPy_Interface0D *self, void *UNUSED(closure))
+{
+	return PyUnicode_FromString(self->if0D->getExactTypeName().c_str());
 }
 
-static char Interface0D_getProjectedX___doc__[] =
-".. method:: getProjectedX()\n"
-"\n"
-"   Returns the X coordinate of the 2D point of the 0D element.\n"
+PyDoc_STRVAR(Interface0D_point_3d_doc,
+"The 3D point of this 0D element.\n"
 "\n"
-"   :return: The X coordinate of the 2D point.\n"
-"   :rtype: float\n";
+":type: mathutils.Vector");
 
-static PyObject *Interface0D_getProjectedX( BPy_Interface0D *self ) {
-	double x = self->if0D->getProjectedX();
+static PyObject *Interface0D_point_3d_get(BPy_Interface0D *self, void *UNUSED(closure))
+{
+	Vec3f p(self->if0D->getPoint3D());
 	if (PyErr_Occurred())
 		return NULL;
-	return PyFloat_FromDouble( x );
+	return Vector_from_Vec3f(p);
 }
 
-static char Interface0D_getProjectedY___doc__[] =
-".. method:: getProjectedY()\n"
-"\n"
-"   Returns the Y coordinate of the 2D point of the 0D element.\n"
+PyDoc_STRVAR(Interface0D_projected_x_doc,
+"The X coordinate of the projected 3D point of this 0D element.\n"
 "\n"
-"   :return: The Y coordinate of the 2D point.\n"
-"   :rtype: float\n";
+":type: float");
 
-static PyObject *Interface0D_getProjectedY( BPy_Interface0D *self ) {
-	double y = self->if0D->getProjectedY();
+static PyObject *Interface0D_projected_x_get(BPy_Interface0D *self, void *UNUSED(closure))
+{
+	real x = self->if0D->getProjectedX();
 	if (PyErr_Occurred())
 		return NULL;
-	return PyFloat_FromDouble( y );
+	return PyFloat_FromDouble(x);
 }
 
-static char Interface0D_getProjectedZ___doc__[] =
-".. method:: getProjectedZ()\n"
-"\n"
-"   Returns the Z coordinate of the 2D point of the 0D element.\n"
+PyDoc_STRVAR(Interface0D_projected_y_doc,
+"The Y coordinate of the projected 3D point of this 0D element.\n"
 "\n"
-"   :return: The Z coordinate of the 2D point.\n"
-"   :rtype: float\n";
+":type: float");
 
-static PyObject *Interface0D_getProjectedZ( BPy_Interface0D *self ) {
-	double z = self->if0D->getProjectedZ();
+static PyObject *Interface0D_projected_y_get(BPy_Interface0D *self, void *UNUSED(closure))
+{
+	real y = self->if0D->getProjectedY();
 	if (PyErr_Occurred())
 		return NULL;
-	return PyFloat_FromDouble( z );
+	return PyFloat_FromDouble(y);
 }
 
-static char Interface0D_getPoint2D___doc__[] =
-".. method:: getPoint2D()\n"
-"\n"
-"   Returns the location of the 0D element in the 2D space.\n"
+PyDoc_STRVAR(Interface0D_projected_z_doc,
+"The Z coordinate of the projected 3D point of this 0D element.\n"
 "\n"
-"   :return: The 2D point of the 0D element.\n"
-"   :rtype: :class:`mathutils.Vector`\n";
+":type: float");
 
-static PyObject *Interface0D_getPoint2D( BPy_Interface0D *self ) {
-	Vec2f v( self->if0D->getPoint2D() );
+static PyObject *Interface0D_projected_z_get(BPy_Interface0D *self, void *UNUSED(closure))
+{
+	real z = self->if0D->getProjectedZ();
 	if (PyErr_Occurred())
 		return NULL;
-	return Vector_from_Vec2f( v );
+	return PyFloat_FromDouble(z);
 }
 
-static char Interface0D_getFEdge___doc__[] =
-".. method:: getFEdge(inter)\n"
-"\n"
-"   Returns the FEdge that lies between this 0D element and the 0D\n"
-"   element given as the argument.\n"
+PyDoc_STRVAR(Interface0D_point_2d_doc,
+"The 2D point of this 0D element.\n"
 "\n"
-"   :arg inter: A 0D element.\n"
-"   :type inter: :class:`Interface0D`\n"
-"   :return: The FEdge lying between the two 0D elements.\n"
-"   :rtype: :class:`FEdge`\n";
+":type: mathutils.Vector");
 
-static PyObject *Interface0D_getFEdge( BPy_Interface0D *self, PyObject *args ) {
-	PyObject *py_if0D;
-
-	if(!( PyArg_ParseTuple(args, "O!", &Interface0D_Type, &py_if0D) ))
-		return NULL;
-
-	FEdge *fe = self->if0D->getFEdge(*( ((BPy_Interface0D *) py_if0D)->if0D ));
+static PyObject *Interface0D_point_2d_get(BPy_Interface0D *self, void *UNUSED(closure))
+{
+	Vec2f p(self->if0D->getPoint2D());
 	if (PyErr_Occurred())
 		return NULL;
-	if( fe )
-		return Any_BPy_FEdge_from_FEdge( *fe );
-	
-	Py_RETURN_NONE;
+	return Vector_from_Vec2f(p);
 }
 
-static char Interface0D_getId___doc__[] =
-".. method:: getId()\n"
+PyDoc_STRVAR(Interface0D_id_doc,
+"The Id of this 0D element.\n"
 "\n"
-"   Returns the identifier of the 0D element.\n"
-"\n"
-"   :return: The identifier of the 0D element.\n"
-"   :rtype: :class:`Id`\n";
+":type: :class:`Id`");
 
-static PyObject *Interface0D_getId( BPy_Interface0D *self ) {
-	Id id( self->if0D->getId() );
+static PyObject *Interface0D_id_get(BPy_Interface0D *self, void *UNUSED(closure))
+{
+	Id id(self->if0D->getId());
 	if (PyErr_Occurred())
 		return NULL;
-	return BPy_Id_from_Id( id );
+	return BPy_Id_from_Id(id); // return a copy
 }
 
-static char Interface0D_getNature___doc__[] =
-".. method:: getNature()\n"
+PyDoc_STRVAR(Interface0D_nature_doc,
+"The nature of this 0D element.\n"
 "\n"
-"   Returns the nature of the 0D element.\n"
-"\n"
-"   :return: The nature of the 0D element.\n"
-"   :rtype: :class:`Nature`\n";
+":type: :class:`Nature`");
 
-static PyObject *Interface0D_getNature( BPy_Interface0D *self ) {
+static PyObject *Interface0D_nature_get(BPy_Interface0D *self, void *UNUSED(closure))
+{
 	Nature::VertexNature nature = self->if0D->getNature();
 	if (PyErr_Occurred())
 		return NULL;
-	return BPy_Nature_from_Nature( nature );
+	return BPy_Nature_from_Nature(nature);
 }
 
-/*----------------------Interface0D instance definitions ----------------------------*/
-static PyMethodDef BPy_Interface0D_methods[] = {
-	{"getExactTypeName", ( PyCFunction ) Interface0D_getExactTypeName, METH_NOARGS, Interface0D_getExactTypeName___doc__},
-	{"getX", ( PyCFunction ) Interface0D_getX, METH_NOARGS, Interface0D_getX___doc__},
-	{"getY", ( PyCFunction ) Interface0D_getY, METH_NOARGS, Interface0D_getY___doc__},
-	{"getZ", ( PyCFunction ) Interface0D_getZ, METH_NOARGS, Interface0D_getZ___doc__},
-	{"getPoint3D", ( PyCFunction ) Interface0D_getPoint3D, METH_NOARGS, Interface0D_getPoint3D___doc__},
-	{"getProjectedX", ( PyCFunction ) Interface0D_getProjectedX, METH_NOARGS, Interface0D_getProjectedX___doc__},
-	{"getProjectedY", ( PyCFunction ) Interface0D_getProjectedY, METH_NOARGS, Interface0D_getProjectedY___doc__},
-	{"getProjectedZ", ( PyCFunction ) Interface0D_getProjectedZ, METH_NOARGS, Interface0D_getProjectedZ___doc__},
-	{"getPoint2D", ( PyCFunction ) Interface0D_getPoint2D, METH_NOARGS, Interface0D_getPoint2D___doc__},
-	{"getFEdge", ( PyCFunction ) Interface0D_getFEdge, METH_VARARGS, Interface0D_getFEdge___doc__},
-	{"getId", ( PyCFunction ) Interface0D_getId, METH_NOARGS, Interface0D_getId___doc__},
-	{"getNature", ( PyCFunction ) Interface0D_getNature, METH_NOARGS, Interface0D_getNature___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_Interface0D_getseters[] = {
+	{(char *)"exact_type_name", (getter)Interface0D_exact_type_name_get, (setter)NULL, (char *)Interface0D_exact_type_name_doc, NULL},
+	{(char *)"point_3d", (getter)Interface0D_point_3d_get, (setter)NULL, (char *)Interface0D_point_3d_doc, NULL},
+	{(char *)"projected_x", (getter)Interface0D_projected_x_get, (setter)NULL, (char *)Interface0D_projected_x_doc, NULL},
+	{(char *)"projected_y", (getter)Interface0D_projected_y_get, (setter)NULL, (char *)Interface0D_projected_y_doc, NULL},
+	{(char *)"projected_z", (getter)Interface0D_projected_z_get, (setter)NULL, (char *)Interface0D_projected_z_doc, NULL},
+	{(char *)"point_2d", (getter)Interface0D_point_2d_get, (setter)NULL, (char *)Interface0D_point_2d_doc, NULL},
+	{(char *)"id", (getter)Interface0D_id_get, (setter)NULL, (char *)Interface0D_id_doc, NULL},
+	{(char *)"nature", (getter)Interface0D_nature_get, (setter)NULL, (char *)Interface0D_nature_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_Interface0D type definition ------------------------------*/
@@ -304,12 +245,12 @@ PyTypeObject Interface0D_Type = {
 	"Interface0D",                  /* tp_name */
 	sizeof(BPy_Interface0D),        /* tp_basicsize */
 	0,                              /* tp_itemsize */
-	(destructor)Interface0D___dealloc__, /* tp_dealloc */
+	(destructor)Interface0D_dealloc, /* tp_dealloc */
 	0,                              /* tp_print */
 	0,                              /* tp_getattr */
 	0,                              /* tp_setattr */
 	0,                              /* tp_reserved */
-	(reprfunc)Interface0D___repr__, /* tp_repr */
+	(reprfunc)Interface0D_repr,     /* tp_repr */
 	0,                              /* tp_as_number */
 	0,                              /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
@@ -320,7 +261,7 @@ PyTypeObject Interface0D_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	Interface0D___doc__,            /* tp_doc */
+	Interface0D_doc,                /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -329,23 +270,15 @@ PyTypeObject Interface0D_Type = {
 	0,                              /* tp_iternext */
 	BPy_Interface0D_methods,        /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_Interface0D_getseters,      /* tp_getset */
 	0,                              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)Interface0D___init__, /* tp_init */
+	(initproc)Interface0D_init,     /* tp_init */
 	0,                              /* tp_alloc */
 	PyType_GenericNew,              /* tp_new */
-	0,				/* tp_free */
-	0,				/* tp_is_gc */
-	0,				/* tp_bases */
-	0,				/* tp_mro */
-	0,				/* tp_cache */
-	0,				/* tp_subclasses */
-	0,				/* tp_weaklist */
-	0				/* tp_del */
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -353,4 +286,3 @@ PyTypeObject Interface0D_Type = {
 #ifdef __cplusplus
 }
 #endif
-
diff --git a/source/blender/freestyle/intern/python/BPy_Interface1D.cpp b/source/blender/freestyle/intern/python/BPy_Interface1D.cpp
index 7b4bdddf70c..f6046b4cad3 100644
--- a/source/blender/freestyle/intern/python/BPy_Interface1D.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Interface1D.cpp
@@ -18,211 +18,126 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //-------------------MODULE INITIALIZATION--------------------------------
-int Interface1D_Init( PyObject *module )
+int Interface1D_Init(PyObject *module)
 {
-	if( module == NULL )
+	if (module == NULL)
 		return -1;
 
-	if( PyType_Ready( &Interface1D_Type ) < 0 )
+	if (PyType_Ready(&Interface1D_Type) < 0)
 		return -1;
-	Py_INCREF( &Interface1D_Type );
+	Py_INCREF(&Interface1D_Type);
 	PyModule_AddObject(module, "Interface1D", (PyObject *)&Interface1D_Type);
-	
-	if( PyType_Ready( &FrsCurve_Type ) < 0 )
+
+	if (PyType_Ready(&FrsCurve_Type) < 0)
 		return -1;
-	Py_INCREF( &FrsCurve_Type );
+	Py_INCREF(&FrsCurve_Type);
 	PyModule_AddObject(module, "Curve", (PyObject *)&FrsCurve_Type);
 
-	if( PyType_Ready( &Chain_Type ) < 0 )
+	if (PyType_Ready(&Chain_Type) < 0)
 		return -1;
-	Py_INCREF( &Chain_Type );
+	Py_INCREF(&Chain_Type);
 	PyModule_AddObject(module, "Chain", (PyObject *)&Chain_Type);
-	
-	if( PyType_Ready( &FEdge_Type ) < 0 )
+
+	if (PyType_Ready(&FEdge_Type) < 0)
 		return -1;
-	Py_INCREF( &FEdge_Type );
+	Py_INCREF(&FEdge_Type);
 	PyModule_AddObject(module, "FEdge", (PyObject *)&FEdge_Type);
 
-	if( PyType_Ready( &FEdgeSharp_Type ) < 0 )
+	if (PyType_Ready(&FEdgeSharp_Type) < 0)
 		return -1;
-	Py_INCREF( &FEdgeSharp_Type );
+	Py_INCREF(&FEdgeSharp_Type);
 	PyModule_AddObject(module, "FEdgeSharp", (PyObject *)&FEdgeSharp_Type);
-	
-	if( PyType_Ready( &FEdgeSmooth_Type ) < 0 )
+
+	if (PyType_Ready(&FEdgeSmooth_Type) < 0)
 		return -1;
-	Py_INCREF( &FEdgeSmooth_Type );
+	Py_INCREF(&FEdgeSmooth_Type);
 	PyModule_AddObject(module, "FEdgeSmooth", (PyObject *)&FEdgeSmooth_Type);
 
-	if( PyType_Ready( &Stroke_Type ) < 0 )
+	if (PyType_Ready(&Stroke_Type) < 0)
 		return -1;
-	Py_INCREF( &Stroke_Type );
+	Py_INCREF(&Stroke_Type);
 	PyModule_AddObject(module, "Stroke", (PyObject *)&Stroke_Type);
 
-	PyDict_SetItemString( Stroke_Type.tp_dict, "DRY_MEDIUM", BPy_MediumType_DRY_MEDIUM );
-	PyDict_SetItemString( Stroke_Type.tp_dict, "HUMID_MEDIUM", BPy_MediumType_HUMID_MEDIUM );
-	PyDict_SetItemString( Stroke_Type.tp_dict, "OPAQUE_MEDIUM", BPy_MediumType_OPAQUE_MEDIUM );
+	PyDict_SetItemString(Stroke_Type.tp_dict, "DRY_MEDIUM", BPy_MediumType_DRY_MEDIUM);
+	PyDict_SetItemString(Stroke_Type.tp_dict, "HUMID_MEDIUM", BPy_MediumType_HUMID_MEDIUM);
+	PyDict_SetItemString(Stroke_Type.tp_dict, "OPAQUE_MEDIUM", BPy_MediumType_OPAQUE_MEDIUM);
 
-	if( PyType_Ready( &ViewEdge_Type ) < 0 )
+	if (PyType_Ready(&ViewEdge_Type) < 0)
 		return -1;
-	Py_INCREF( &ViewEdge_Type );
+	Py_INCREF(&ViewEdge_Type);
 	PyModule_AddObject(module, "ViewEdge", (PyObject *)&ViewEdge_Type);
 
+	FEdgeSharp_mathutils_register_callback();
+	FEdgeSmooth_mathutils_register_callback();
+
 	return 0;
 }
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------Interface1D methods ----------------------------*/
 
-static char Interface1D___doc__[] =
+PyDoc_STRVAR(Interface1D_doc,
 "Base class for any 1D element.\n"
 "\n"
 ".. method:: __init__()\n"
 "\n"
-"   Default constructor.\n";
+"   Default constructor.");
 
-static int Interface1D___init__(BPy_Interface1D *self, PyObject *args, PyObject *kwds)
+static int Interface1D_init(BPy_Interface1D *self, PyObject *args, PyObject *kwds)
 {
-    if ( !PyArg_ParseTuple(args, "") )
-        return -1;
+	if (!PyArg_ParseTuple(args, ""))
+		return -1;
 	self->if1D = new Interface1D();
 	self->borrowed = 0;
 	return 0;
 }
 
-static void Interface1D___dealloc__(BPy_Interface1D* self)
+static void Interface1D_dealloc(BPy_Interface1D* self)
 {
-	if( self->if1D && !self->borrowed )
+	if (self->if1D && !self->borrowed)
 		delete self->if1D;
-    Py_TYPE(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-static PyObject * Interface1D___repr__(BPy_Interface1D* self)
+static PyObject * Interface1D_repr(BPy_Interface1D* self)
 {
-    return PyUnicode_FromFormat("type: %s - address: %p", self->if1D->getExactTypeName().c_str(), self->if1D );
-}
-
-static char Interface1D_getExactTypeName___doc__[] =
-".. method:: getExactTypeName()\n"
-"\n"
-"   Returns the string of the name of the 1D element.\n"
-"\n"
-"   :return: The name of the 1D element.\n"
-"   :rtype: str\n";
-
-static PyObject *Interface1D_getExactTypeName( BPy_Interface1D *self ) {
-	return PyUnicode_FromString( self->if1D->getExactTypeName().c_str() );	
-}
-
-#if 0
-static PyObject *Interface1D_getVertices( BPy_Interface1D *self ) {
-	return PyList_New(0);
-}
-
-static PyObject *Interface1D_getPoints( BPy_Interface1D *self ) {
-	return PyList_New(0);
-}
-#endif
-
-static char Interface1D_getLength2D___doc__[] =
-".. method:: getLength2D()\n"
-"\n"
-"   Returns the 2D length of the 1D element.\n"
-"\n"
-"   :return: The 2D length of the 1D element.\n"
-"   :rtype: float\n";
-
-static PyObject *Interface1D_getLength2D( BPy_Interface1D *self ) {
-	return PyFloat_FromDouble( (double) self->if1D->getLength2D() );
-}
-
-static char Interface1D_getId___doc__[] =
-".. method:: getId()\n"
-"\n"
-"   Returns the Id of the 1D element .\n"
-"\n"
-"   :return: The Id of the 1D element .\n"
-"   :rtype: :class:`Id`\n";
-
-static PyObject *Interface1D_getId( BPy_Interface1D *self ) {
-	Id id( self->if1D->getId() );
-	return BPy_Id_from_Id( id );
-}
-
-static char Interface1D_getNature___doc__[] =
-".. method:: getNature()\n"
-"\n"
-"   Returns the nature of the 1D element.\n"
-"\n"
-"   :return: The nature of the 1D element.\n"
-"   :rtype: :class:`Nature`\n";
-
-static PyObject *Interface1D_getNature( BPy_Interface1D *self ) {
-	return BPy_Nature_from_Nature( self->if1D->getNature() );
-}
-
-static char Interface1D_getTimeStamp___doc__[] =
-".. method:: getTimeStamp()\n"
-"\n"
-"   Returns the time stamp of the 1D element. Mainly used for selection.\n"
-"\n"
-"   :return: The time stamp of the 1D element.\n"
-"   :rtype: int\n";
-
-static PyObject *Interface1D_getTimeStamp( BPy_Interface1D *self ) {
-	return PyLong_FromLong( self->if1D->getTimeStamp() );
+	return PyUnicode_FromFormat("type: %s - address: %p", self->if1D->getExactTypeName().c_str(), self->if1D);
 }
 
-static char Interface1D_setTimeStamp___doc__[] =
-".. method:: setTimeStamp(iTimeStamp)\n"
-"\n"
-"   Sets the time stamp for the 1D element.\n"
-"\n"
-"   :arg iTimeStamp: A time stamp.\n"
-"   :type iTimeStamp: int\n";
-
-static PyObject *Interface1D_setTimeStamp( BPy_Interface1D *self, PyObject *args) {
-	int timestamp = 0 ;
-
-	if( !PyArg_ParseTuple(args, "i", &timestamp) )
-		return NULL;
-	
-	self->if1D->setTimeStamp( timestamp );
-
-	Py_RETURN_NONE;
-}
-
-static char Interface1D_verticesBegin___doc__[] =
-".. method:: verticesBegin()\n"
+PyDoc_STRVAR(Interface1D_vertices_begin_doc,
+".. method:: vertices_begin()\n"
 "\n"
 "   Returns an iterator over the Interface1D vertices, pointing to the\n"
 "   first vertex.\n"
 "\n"
 "   :return: An Interface0DIterator pointing to the first vertex.\n"
-"   :rtype: :class:`Interface0DIterator`\n";
+"   :rtype: :class:`Interface0DIterator`");
 
-static PyObject * Interface1D_verticesBegin( BPy_Interface1D *self ) {
-	Interface0DIterator if0D_it( self->if1D->verticesBegin() );
-	return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it, 0 );
+static PyObject * Interface1D_vertices_begin(BPy_Interface1D *self)
+{
+	Interface0DIterator if0D_it(self->if1D->verticesBegin());
+	return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 0);
 }
 
-static char Interface1D_verticesEnd___doc__[] =
-".. method:: verticesEnd()\n"
+PyDoc_STRVAR(Interface1D_vertices_end_doc,
+".. method:: vertices_end()\n"
 "\n"
 "   Returns an iterator over the Interface1D vertices, pointing after\n"
 "   the last vertex.\n"
 "\n"
 "   :return: An Interface0DIterator pointing after the last vertex.\n"
-"   :rtype: :class:`Interface0DIterator`\n";
+"   :rtype: :class:`Interface0DIterator`");
 
-static PyObject * Interface1D_verticesEnd( BPy_Interface1D *self ) {
-	Interface0DIterator if0D_it( self->if1D->verticesEnd() );
-	return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it, 1 );
+static PyObject * Interface1D_vertices_end(BPy_Interface1D *self)
+{
+	Interface0DIterator if0D_it(self->if1D->verticesEnd());
+	return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 1);
 }
 
-static char Interface1D_pointsBegin___doc__[] =
-".. method:: pointsBegin(t=0.0)\n"
+PyDoc_STRVAR(Interface1D_points_begin_doc,
+".. method:: points_begin(t=0.0)\n"
 "\n"
 "   Returns an iterator over the Interface1D points, pointing to the\n"
-"   first point. The difference with verticesBegin() is that here we can\n"
+"   first point. The difference with vertices_begin() is that here we can\n"
 "   iterate over points of the 1D element at a any given sampling.\n"
 "   Indeed, for each iteration, a virtual point is created.\n"
 "\n"
@@ -230,23 +145,23 @@ static char Interface1D_pointsBegin___doc__[] =
 "      this 1D element.\n"
 "   :type t: float\n"
 "   :return: An Interface0DIterator pointing to the first point.\n"
-"   :rtype: :class:`Interface0DIterator`\n";
+"   :rtype: :class:`Interface0DIterator`");
 
-static PyObject * Interface1D_pointsBegin( BPy_Interface1D *self, PyObject *args ) {
+static PyObject * Interface1D_points_begin(BPy_Interface1D *self, PyObject *args)
+{
 	float f = 0;
 
-	if(!( PyArg_ParseTuple(args, "|f", &f)  ))
+	if(!(PyArg_ParseTuple(args, "|f", &f)))
 		return NULL;
-	
-	Interface0DIterator if0D_it( self->if1D->pointsBegin(f) );
-	return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it, 0 );
+	Interface0DIterator if0D_it(self->if1D->pointsBegin(f));
+	return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 0);
 }
 
-static char Interface1D_pointsEnd___doc__[] =
-".. method:: pointsEnd(t=0.0)\n"
+PyDoc_STRVAR(Interface1D_points_end_doc,
+".. method:: points_end(t=0.0)\n"
 "\n"
 "   Returns an iterator over the Interface1D points, pointing after the\n"
-"   last point. The difference with verticesEnd() is that here we can\n"
+"   last point. The difference with vertices_end() is that here we can\n"
 "   iterate over points of the 1D element at a given sampling.  Indeed,\n"
 "   for each iteration, a virtual point is created.\n"
 "\n"
@@ -254,37 +169,108 @@ static char Interface1D_pointsEnd___doc__[] =
 "      this 1D element.\n"
 "   :type t: float\n"
 "   :return: An Interface0DIterator pointing after the last point.\n"
-"   :rtype: :class:`Interface0DIterator`\n";
+"   :rtype: :class:`Interface0DIterator`");
 
-static PyObject * Interface1D_pointsEnd( BPy_Interface1D *self, PyObject *args ) {
+static PyObject * Interface1D_points_end(BPy_Interface1D *self, PyObject *args)
+{
 	float f = 0;
 
-	if(!( PyArg_ParseTuple(args, "|f", &f)  ))
+	if (!PyArg_ParseTuple(args, "|f", &f))
 		return NULL;
-	
-	Interface0DIterator if0D_it( self->if1D->pointsEnd(f) );
-	return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it, 1 );
+	Interface0DIterator if0D_it(self->if1D->pointsEnd(f));
+	return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 1);
 }
 
-/*----------------------Interface1D instance definitions ----------------------------*/
 static PyMethodDef BPy_Interface1D_methods[] = {
-	{"getExactTypeName", ( PyCFunction ) Interface1D_getExactTypeName, METH_NOARGS, Interface1D_getExactTypeName___doc__},
-#if 0
-	{"getVertices", ( PyCFunction ) Interface1D_getVertices, METH_NOARGS, "Returns the vertices"},
-	{"getPoints", ( PyCFunction ) Interface1D_getPoints, METH_NOARGS, "Returns the points. The difference with getVertices() is that here we can iterate over points of the 1D element at any given sampling. At each call, a virtual point is created."},
-#endif
-	{"getLength2D", ( PyCFunction ) Interface1D_getLength2D, METH_NOARGS, Interface1D_getLength2D___doc__},
-	{"getId", ( PyCFunction ) Interface1D_getId, METH_NOARGS, Interface1D_getId___doc__},
-	{"getNature", ( PyCFunction ) Interface1D_getNature, METH_NOARGS, Interface1D_getNature___doc__},
-	{"getTimeStamp", ( PyCFunction ) Interface1D_getTimeStamp, METH_NOARGS, Interface1D_getTimeStamp___doc__},
-	{"setTimeStamp", ( PyCFunction ) Interface1D_setTimeStamp, METH_VARARGS, Interface1D_setTimeStamp___doc__},
-	{"verticesBegin", ( PyCFunction ) Interface1D_verticesBegin, METH_NOARGS, Interface1D_verticesBegin___doc__},
-	{"verticesEnd", ( PyCFunction ) Interface1D_verticesEnd, METH_NOARGS, Interface1D_verticesEnd___doc__},
-	{"pointsBegin", ( PyCFunction ) Interface1D_pointsBegin, METH_VARARGS, Interface1D_pointsBegin___doc__},
-	{"pointsEnd", ( PyCFunction ) Interface1D_pointsEnd, METH_VARARGS, Interface1D_pointsEnd___doc__},
+	{"vertices_begin", (PyCFunction)Interface1D_vertices_begin, METH_NOARGS, Interface1D_vertices_begin_doc},
+	{"vertices_end", (PyCFunction)Interface1D_vertices_end, METH_NOARGS, Interface1D_vertices_end_doc},
+	{"points_begin", (PyCFunction)Interface1D_points_begin, METH_VARARGS, Interface1D_points_begin_doc},
+	{"points_end", (PyCFunction)Interface1D_points_end, METH_VARARGS, Interface1D_points_end_doc},
 	{NULL, NULL, 0, NULL}
 };
 
+/*----------------------Interface1D get/setters ----------------------------*/
+
+PyDoc_STRVAR(Interface1D_exact_type_name_doc,
+"The string of the name of the 1D element.\n"
+"\n"
+":type: str");
+
+static PyObject *Interface1D_exact_type_name_get(BPy_Interface1D *self, void *UNUSED(closure))
+{
+	return PyUnicode_FromString(self->if1D->getExactTypeName().c_str());
+}
+
+PyDoc_STRVAR(Interface1D_id_doc,
+"The Id of this Interface1D.\n"
+"\n"
+":type: :class:`Id`");
+
+static PyObject *Interface1D_id_get(BPy_Interface1D *self, void *UNUSED(closure))
+{
+	Id id(self->if1D->getId());
+	if (PyErr_Occurred())
+		return NULL;
+	return BPy_Id_from_Id(id); // return a copy
+}
+
+PyDoc_STRVAR(Interface1D_nature_doc,
+"The nature of this Interface1D.\n"
+"\n"
+":type: :class:`Nature`");
+
+static PyObject *Interface1D_nature_get(BPy_Interface1D *self, void *UNUSED(closure))
+{
+	Nature::VertexNature nature = self->if1D->getNature();
+	if (PyErr_Occurred())
+		return NULL;
+	return BPy_Nature_from_Nature(nature);
+}
+
+PyDoc_STRVAR(Interface1D_length_2d_doc,
+"The 2D length of this Interface1D.\n"
+"\n"
+":type: float");
+
+static PyObject *Interface1D_length_2d_get(BPy_Interface1D *self, void *UNUSED(closure))
+{
+	real length = self->if1D->getLength2D();
+	if (PyErr_Occurred())
+		return NULL;
+	return PyFloat_FromDouble((double)length);
+}
+
+PyDoc_STRVAR(Interface1D_time_stamp_doc,
+"The time stamp of the 1D element, mainly used for selection.\n"
+"\n"
+":type: int");
+
+static PyObject *Interface1D_time_stamp_get(BPy_Interface1D *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->if1D->getTimeStamp());
+}
+
+static int Interface1D_time_stamp_set(BPy_Interface1D *self, PyObject *value, void *UNUSED(closure))
+{
+	int timestamp;
+
+	if ((timestamp = PyLong_AsLong(value)) == -1 && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_TypeError, "value must be a number");
+		return -1;
+	}
+	self->if1D->setTimeStamp(timestamp);
+	return 0;
+}
+
+static PyGetSetDef BPy_Interface1D_getseters[] = {
+	{(char *)"exact_type_name", (getter)Interface1D_exact_type_name_get, (setter)NULL, (char *)Interface1D_exact_type_name_doc, NULL},
+	{(char *)"id", (getter)Interface1D_id_get, (setter)NULL, (char *)Interface1D_id_doc, NULL},
+	{(char *)"nature", (getter)Interface1D_nature_get, (setter)NULL, (char *)Interface1D_nature_doc, NULL},
+	{(char *)"length_2d", (getter)Interface1D_length_2d_get, (setter)NULL, (char *)Interface1D_length_2d_doc, NULL},
+	{(char *)"time_stamp", (getter)Interface1D_time_stamp_get, (setter)Interface1D_time_stamp_set, (char *)Interface1D_time_stamp_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
+};
+
 /*-----------------------BPy_Interface1D type definition ------------------------------*/
 
 PyTypeObject Interface1D_Type = {
@@ -292,12 +278,12 @@ PyTypeObject Interface1D_Type = {
 	"Interface1D",                  /* tp_name */
 	sizeof(BPy_Interface1D),        /* tp_basicsize */
 	0,                              /* tp_itemsize */
-	(destructor)Interface1D___dealloc__, /* tp_dealloc */
+	(destructor)Interface1D_dealloc, /* tp_dealloc */
 	0,                              /* tp_print */
 	0,                              /* tp_getattr */
 	0,                              /* tp_setattr */
 	0,                              /* tp_reserved */
-	(reprfunc)Interface1D___repr__, /* tp_repr */
+	(reprfunc)Interface1D_repr,     /* tp_repr */
 	0,                              /* tp_as_number */
 	0,                              /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
@@ -308,7 +294,7 @@ PyTypeObject Interface1D_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	Interface1D___doc__,            /* tp_doc */
+	Interface1D_doc,                /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -317,13 +303,13 @@ PyTypeObject Interface1D_Type = {
 	0,                              /* tp_iternext */
 	BPy_Interface1D_methods,        /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_Interface1D_getseters,      /* tp_getset */
 	0,                              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)Interface1D___init__, /* tp_init */
+	(initproc)Interface1D_init,     /* tp_init */
 	0,                              /* tp_alloc */
 	PyType_GenericNew,              /* tp_new */
 };
@@ -333,5 +319,3 @@ PyTypeObject Interface1D_Type = {
 #ifdef __cplusplus
 }
 #endif
-
-
diff --git a/source/blender/freestyle/intern/python/BPy_SShape.cpp b/source/blender/freestyle/intern/python/BPy_SShape.cpp
index 65951182f10..763e88e2ce1 100644
--- a/source/blender/freestyle/intern/python/BPy_SShape.cpp
+++ b/source/blender/freestyle/intern/python/BPy_SShape.cpp
@@ -13,22 +13,22 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //-------------------MODULE INITIALIZATION--------------------------------
-int SShape_Init( PyObject *module )
+int SShape_Init(PyObject *module)
 {
-	if( module == NULL )
+	if (module == NULL)
 		return -1;
 
-	if( PyType_Ready( &SShape_Type ) < 0 )
+	if (PyType_Ready(&SShape_Type) < 0)
 		return -1;
-
 	Py_INCREF( &SShape_Type );
 	PyModule_AddObject(module, "SShape", (PyObject *)&SShape_Type);
+
 	return 0;
 }
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------SShape methods ----------------------------*/
 
-static char SShape___doc__[] =
+PyDoc_STRVAR(SShape_doc,
 "Class to define a feature shape.  It is the gathering of feature\n"
 "elements from an identified input shape.\n"
 "\n"
@@ -41,243 +41,206 @@ static char SShape___doc__[] =
 "   Copy constructor.\n"
 "\n"
 "   :arg iBrother: An SShape object.\n"
-"   :type iBrother: :class:`SShape`\n";
+"   :type iBrother: :class:`SShape`");
 
-static int SShape___init__(BPy_SShape *self, PyObject *args, PyObject *kwds)
+static int SShape_init(BPy_SShape *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *obj = NULL;
 
-    if (! PyArg_ParseTuple(args, "|O!", &SShape_Type, &obj) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|O!", &SShape_Type, &obj))
+		return -1;
 
-	if( !obj ) {
+	if (!obj) {
 		self->ss = new SShape();
-	
 	} else {
-		self->ss = new SShape(*( ((BPy_SShape *) obj)->ss ));
+		self->ss = new SShape(*(((BPy_SShape *)obj)->ss));
 	}
 	self->borrowed = 0;
 
-    return 0;
+	return 0;
 }
 
-static void SShape___dealloc__(BPy_SShape *self)
+static void SShape_dealloc(BPy_SShape *self)
 {
-	if( self->ss && !self->borrowed )
+	if (self->ss && !self->borrowed)
 		delete self->ss;
-    Py_TYPE(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-static PyObject * SShape___repr__(BPy_SShape *self)
+static PyObject * SShape_repr(BPy_SShape *self)
 {
-    return PyUnicode_FromFormat("SShape - address: %p", self->ss );
+	return PyUnicode_FromFormat("SShape - address: %p", self->ss);
 }
 
-static char SShape_AddEdge___doc__[] =
-".. method:: AddEdge(iEdge)\n"
+static char SShape_add_edge_doc[] =
+".. method:: add_edge(iEdge)\n"
 "\n"
 "   Adds an FEdge to the list of FEdges.\n"
 "\n"
 "   :arg iEdge: An FEdge object.\n"
 "   :type iEdge: :class:`FEdge`\n";
 
-static PyObject * SShape_AddEdge( BPy_SShape *self , PyObject *args) {
+static PyObject * SShape_add_edge(BPy_SShape *self , PyObject *args)
+{
 	PyObject *py_fe = 0;
 
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
+	if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe))
 		return NULL;
-	
-	self->ss->AddEdge( ((BPy_FEdge *) py_fe)->fe );
-
+	self->ss->AddEdge(((BPy_FEdge *)py_fe)->fe);
 	Py_RETURN_NONE;
 }
 
-static char SShape_AddNewVertex___doc__[] =
-".. method:: AddNewVertex(iv)\n"
+PyDoc_STRVAR(SShape_add_vertex_doc,
+".. method:: add_vertex(iv)\n"
 "\n"
 "   Adds an SVertex to the list of SVertex of this Shape.  The SShape\n"
 "   attribute of the SVertex is also set to this SShape.\n"
 "\n"
 "   :arg iv: An SVertex object.\n"
-"   :type iv: :class:`SVertex`\n";
+"   :type iv: :class:`SVertex`");
 
-static PyObject * SShape_AddNewVertex( BPy_SShape *self , PyObject *args) {
+static PyObject * SShape_add_vertex(BPy_SShape *self , PyObject *args)
+{
 	PyObject *py_sv = 0;
 
-	if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
+	if (!PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv))
 		return NULL;
-	
-	self->ss->AddNewVertex( ((BPy_SVertex *) py_sv)->sv );
-
+	self->ss->AddNewVertex(((BPy_SVertex *)py_sv)->sv);
 	Py_RETURN_NONE;
 }
 
-static char SShape_setBBox___doc__[] =
-".. method:: setBBox(iBBox)\n"
-"\n"
-"   Sets the bounding box of the SShape.\n"
+PyDoc_STRVAR(SShape_compute_bbox_doc,
+".. method:: compute_bbox()\n"
 "\n"
-"   :arg iBBox: The bounding box of the SShape.\n"
-"   :type iBBox: :class:`BBox`\n";
-
-static PyObject * SShape_setBBox( BPy_SShape *self , PyObject *args) {
-	PyObject *py_bb = 0;
-
-	if(!( PyArg_ParseTuple(args, "O!", &BBox_Type, &py_bb) ))
-		return NULL;
-	
-	self->ss->setBBox(*( ((BPy_BBox*) py_bb)->bb ));
+"   Compute the bbox of the SShape.");
 
+static PyObject * SShape_compute_bbox(BPy_SShape *self)
+{
+	self->ss->ComputeBBox();
 	Py_RETURN_NONE;
 }
 
-static char SShape_ComputeBBox___doc__[] =
-".. method:: ComputeBBox()\n"
+// const Material & 	material (unsigned i) const
+// const vector< Material > & 	materials () const
+// void 	SetMaterials (const vector< Material > &iMaterials)
+
+static PyMethodDef BPy_SShape_methods[] = {
+	{"add_edge", (PyCFunction)SShape_add_edge, METH_VARARGS, SShape_add_edge_doc},
+	{"add_vertex", (PyCFunction)SShape_add_vertex, METH_VARARGS, SShape_add_vertex_doc},
+	{"compute_bbox", (PyCFunction)SShape_compute_bbox, METH_NOARGS, SShape_compute_bbox_doc},
+	{NULL, NULL, 0, NULL}
+};
+
+/*----------------------SShape get/setters ----------------------------*/
+
+PyDoc_STRVAR(SShape_id_doc,
+"The Id of this SShape.\n"
 "\n"
-"   Compute the bbox of the SShape.\n";
+":type: :class:`Id`");
 
-static PyObject * SShape_ComputeBBox( BPy_SShape *self ) {
-	self->ss->ComputeBBox();
+static PyObject *SShape_id_get(BPy_SShape *self, void *UNUSED(closure))
+{
+	Id id(self->ss->getId());
+	return BPy_Id_from_Id(id); // return a copy
+}
 
-	Py_RETURN_NONE;
+static int SShape_id_set(BPy_SShape *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Id_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an Id");
+		return -1;
+	}
+	self->ss->setId(*(((BPy_Id *)value)->id));
+	return 0;
 }
 
-static char SShape_bbox___doc__[] =
-".. method:: bbox()\n"
+PyDoc_STRVAR(SShape_name_doc,
+"The name of the SShape.\n"
 "\n"
-"   Returns the bounding box of the SShape.\n"
-"\n"
-"   :return: the bounding box of the SShape.\n"
-"   :rtype: :class:`BBox`\n";
+":type: str");
 
-static PyObject * SShape_bbox( BPy_SShape *self ) {
-	BBox<Vec3r> bb( self->ss->bbox() );
-	return BPy_BBox_from_BBox( bb );
+static PyObject *SShape_name_get(BPy_SShape *self, void *UNUSED(closure))
+{
+	return PyUnicode_FromString(self->ss->getName().c_str());
 }
 
-static char SShape_getVertexList___doc__[] =
-".. method:: getVertexList()\n"
+static int SShape_name_set(BPy_SShape *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!PyUnicode_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a string");
+		return -1;
+	}
+	const string name = _PyUnicode_AsString(value);
+	self->ss->setName(name);
+	return 0;
+}
+
+PyDoc_STRVAR(SShape_bbox_doc,
+"The bounding box of the SShape.\n"
 "\n"
-"   Returns the list of vertices of the SShape.\n"
+":type: :class:`BBox`");
+
+static PyObject *SShape_bbox_get(BPy_SShape *self, void *UNUSED(closure))
+{
+	BBox<Vec3r> bb(self->ss->bbox());
+	return BPy_BBox_from_BBox(bb); // return a copy
+}
+
+static int SShape_bbox_set(BPy_SShape *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_BBox_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a BBox");
+		return -1;
+	}
+	self->ss->setBBox(*(((BPy_BBox*)value)->bb));
+	return 0;
+}
+
+PyDoc_STRVAR(SShape_vertices_doc,
+"The list of vertices constituting this SShape.\n"
 "\n"
-"   :return: The list of vertices objects.\n"
-"   :rtype: List of :class:`SVertex` objects\n";
+":type: List of :class:`SVertex` objects");
 
-static PyObject * SShape_getVertexList( BPy_SShape *self ) {
+static PyObject *SShape_vertices_get(BPy_SShape *self, void *UNUSED(closure))
+{
 	PyObject *py_vertices = PyList_New(0);
 
 	vector< SVertex * > vertices = self->ss->getVertexList();
 	vector< SVertex * >::iterator it;
 	
-	for( it = vertices.begin(); it != vertices.end(); it++ ) {
-		PyList_Append( py_vertices, BPy_SVertex_from_SVertex(*( *it )) );
+	for (it = vertices.begin(); it != vertices.end(); it++) {
+		PyList_Append(py_vertices, BPy_SVertex_from_SVertex(*(*it)));
 	}
 	
 	return py_vertices;
 }
 
-static char SShape_getEdgeList___doc__[] =
-".. method:: getEdgeList()\n"
-"\n"
-"   Returns the list of edges of the SShape.\n"
+PyDoc_STRVAR(SShape_edges_doc,
+"The list of edges constituting this SShape.\n"
 "\n"
-"   :return: The list of edges of the SShape.\n"
-"   :rtype: List of :class:`FEdge` objects\n";
+":type: List of :class:`FEdge` objects");
 
-static PyObject * SShape_getEdgeList( BPy_SShape *self ) {
+static PyObject *SShape_edges_get(BPy_SShape *self, void *UNUSED(closure))
+{
 	PyObject *py_edges = PyList_New(0);
 
 	vector< FEdge * > edges = self->ss->getEdgeList();
 	vector< FEdge * >::iterator it;
 	
-	for( it = edges.begin(); it != edges.end(); it++ ) {
-		PyList_Append( py_edges, Any_BPy_FEdge_from_FEdge(*( *it )) );
+	for (it = edges.begin(); it != edges.end(); it++) {
+		PyList_Append(py_edges, Any_BPy_FEdge_from_FEdge(*(*it)));
 	}
 	
 	return py_edges;
 }
 
-static char SShape_getId___doc__[] =
-".. method:: getId()\n"
-"\n"
-"   Returns the Id of the SShape.\n"
-"\n"
-"   :return: The Id of the SShape.\n"
-"   :rtype: :class:`Id`\n";
-
-static PyObject * SShape_getId( BPy_SShape *self ) {
-	Id id( self->ss->getId() );
-	return BPy_Id_from_Id( id );
-}
-
-static char SShape_setId___doc__[] =
-".. method:: setId(id)\n"
-"\n"
-"   Sets the Id of the SShape.\n"
-"\n"
-"   :arg id: The Id of the SShape.\n"
-"   :type id: :class:`Id`\n";
-
-static PyObject * SShape_setId( BPy_SShape *self , PyObject *args) {
-	PyObject *py_id;
-
-	if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ))
-		return NULL;
-
-	self->ss->setId(*( ((BPy_Id *) py_id)->id ));
-
-	Py_RETURN_NONE;
-}
-
-static char SShape_getName___doc__[] =
-".. method:: getName()\n"
-"\n"
-"   Returns the name of the SShape.\n"
-"\n"
-"   :return: The name string.\n"
-"   :rtype: str\n";
-
-static PyObject * SShape_getName( BPy_SShape *self ) {
-	return PyUnicode_FromString( self->ss->getName().c_str() );
-}
-
-static char SShape_setName___doc__[] =
-".. method:: setName(name)\n"
-"\n"
-"   Sets the name of the SShape.\n"
-"\n"
-"   :arg name: A name string.\n"
-"   :type name: str\n";
-
-static PyObject * SShape_setName( BPy_SShape *self , PyObject *args) {
-	char *s;
-
-	if(!( PyArg_ParseTuple(args, "s", &s) ))
-		return NULL;
-
-	self->ss->setName(s);
-
-	Py_RETURN_NONE;
-}
-
-// const Material & 	material (unsigned i) const
-// const vector< Material > & 	materials () const
-// void 	SetMaterials (const vector< Material > &iMaterials)
-
-/*----------------------SShape instance definitions ----------------------------*/
-static PyMethodDef BPy_SShape_methods[] = {
-	{"AddEdge", ( PyCFunction ) SShape_AddEdge, METH_VARARGS, SShape_AddEdge___doc__},
-	{"AddNewVertex", ( PyCFunction ) SShape_AddNewVertex, METH_VARARGS, SShape_AddNewVertex___doc__},
-	{"setBBox", ( PyCFunction ) SShape_setBBox, METH_VARARGS, SShape_setBBox___doc__},
-	{"ComputeBBox", ( PyCFunction ) SShape_ComputeBBox, METH_NOARGS, SShape_ComputeBBox___doc__},
-	{"bbox", ( PyCFunction ) SShape_bbox, METH_NOARGS, SShape_bbox___doc__},
-	{"getVertexList", ( PyCFunction ) SShape_getVertexList, METH_NOARGS, SShape_getVertexList___doc__},
-	{"getEdgeList", ( PyCFunction ) SShape_getEdgeList, METH_NOARGS, SShape_getEdgeList___doc__},
-	{"getId", ( PyCFunction ) SShape_getId, METH_NOARGS, SShape_getId___doc__},
-	{"setId", ( PyCFunction ) SShape_setId, METH_VARARGS, SShape_setId___doc__},
-	{"getName", ( PyCFunction ) SShape_getName, METH_NOARGS, SShape_getName___doc__},
-	{"setName", ( PyCFunction ) SShape_setName, METH_VARARGS, SShape_setName___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_SShape_getseters[] = {
+	{(char *)"id", (getter)SShape_id_get, (setter)SShape_id_set, (char *)SShape_id_doc, NULL},
+	{(char *)"name", (getter)SShape_name_get, (setter)SShape_name_set, (char *)SShape_name_doc, NULL},
+	{(char *)"bbox", (getter)SShape_bbox_get, (setter)SShape_bbox_set, (char *)SShape_bbox_doc, NULL},
+	{(char *)"edges", (getter)SShape_edges_get, (setter)NULL, (char *)SShape_edges_doc, NULL},
+	{(char *)"vertices", (getter)SShape_vertices_get, (setter)NULL, (char *)SShape_vertices_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_SShape type definition ------------------------------*/
@@ -287,12 +250,12 @@ PyTypeObject SShape_Type = {
 	"SShape",                       /* tp_name */
 	sizeof(BPy_SShape),             /* tp_basicsize */
 	0,                              /* tp_itemsize */
-	(destructor)SShape___dealloc__, /* tp_dealloc */
+	(destructor)SShape_dealloc,     /* tp_dealloc */
 	0,                              /* tp_print */
 	0,                              /* tp_getattr */
 	0,                              /* tp_setattr */
 	0,                              /* tp_reserved */
-	(reprfunc)SShape___repr__,      /* tp_repr */
+	(reprfunc)SShape_repr,          /* tp_repr */
 	0,                              /* tp_as_number */
 	0,                              /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
@@ -303,7 +266,7 @@ PyTypeObject SShape_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	SShape___doc__,                 /* tp_doc */
+	SShape_doc,                     /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -312,13 +275,13 @@ PyTypeObject SShape_Type = {
 	0,                              /* tp_iternext */
 	BPy_SShape_methods,             /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_SShape_getseters,           /* tp_getset */
 	0,                              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)SShape___init__,      /* tp_init */
+	(initproc)SShape_init,          /* tp_init */
 	0,                              /* tp_alloc */
 	PyType_GenericNew,              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/BPy_ViewMap.cpp b/source/blender/freestyle/intern/python/BPy_ViewMap.cpp
index c9667103e5a..985e6408e1b 100644
--- a/source/blender/freestyle/intern/python/BPy_ViewMap.cpp
+++ b/source/blender/freestyle/intern/python/BPy_ViewMap.cpp
@@ -12,48 +12,48 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //-------------------MODULE INITIALIZATION--------------------------------
-int ViewMap_Init( PyObject *module )
+int ViewMap_Init(PyObject *module)
 {
-	if( module == NULL )
+	if (module == NULL)
 		return -1;
 
-	if( PyType_Ready( &ViewMap_Type ) < 0 )
+	if (PyType_Ready( &ViewMap_Type ) < 0)
 		return -1;
-
-	Py_INCREF( &ViewMap_Type );
+	Py_INCREF(&ViewMap_Type);
 	PyModule_AddObject(module, "ViewMap", (PyObject *)&ViewMap_Type);
+
 	return 0;
 }
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------ViewMap methods----------------------------*/
 
-static char ViewMap___doc__[] =
+PyDoc_STRVAR(ViewMap_doc,
 "Class defining the ViewMap.\n"
 "\n"
 ".. method:: __init__()\n"
 "\n"
-"   Default constructor.\n";
+"   Default constructor.");
 
-static int ViewMap___init__(BPy_ViewMap *self, PyObject *args, PyObject *kwds)
+static int ViewMap_init(BPy_ViewMap *self, PyObject *args, PyObject *kwds)
 {
 	self->vm = new ViewMap();
-    return 0;
+	return 0;
 }
 
-static void ViewMap___dealloc__(BPy_ViewMap *self)
+static void ViewMap_dealloc(BPy_ViewMap *self)
 {
-	if( self->vm )
+	if (self->vm)
 		delete self->vm;
-    Py_TYPE(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-static PyObject * ViewMap___repr__(BPy_ViewMap *self)
+static PyObject * ViewMap_repr(BPy_ViewMap *self)
 {
-    return PyUnicode_FromFormat("ViewMap - address: %p", self->vm );
+	return PyUnicode_FromFormat("ViewMap - address: %p", self->vm);
 }
 
-static char ViewMap_getClosestViewEdge___doc__[] =
-".. method:: getClosestViewEdge(x, y)\n"
+PyDoc_STRVAR(ViewMap_get_closest_viewedge_doc,
+".. method:: get_closest_viewedge(x, y)\n"
 "\n"
 "   Gets the ViewEdge nearest to the 2D point specified as arguments.\n"
 "\n"
@@ -62,23 +62,22 @@ static char ViewMap_getClosestViewEdge___doc__[] =
 "   :arg y: Y coordinate of a 2D point.\n"
 "   :type y: float\n"
 "   :return: The ViewEdge nearest to the specified 2D point.\n"
-"   :rtype: :class:`ViewEdge`\n";
+"   :rtype: :class:`ViewEdge`");
 
-static PyObject * ViewMap_getClosestViewEdge( BPy_ViewMap *self , PyObject *args) {
+static PyObject * ViewMap_get_closest_viewedge(BPy_ViewMap *self , PyObject *args)
+{
 	double x, y;
 
-	if(!( PyArg_ParseTuple(args, "dd", &x, &y) ))
+	if (!PyArg_ParseTuple(args, "dd", &x, &y))
 		return NULL;
-
-	ViewEdge *ve = const_cast<ViewEdge *>( self->vm->getClosestViewEdge(x,y) );
-	if( ve )
+	ViewEdge *ve = const_cast<ViewEdge *>(self->vm->getClosestViewEdge(x,y));
+	if (ve)
 		return BPy_ViewEdge_from_ViewEdge(*ve);
-
 	Py_RETURN_NONE;
 }
 
-static char ViewMap_getClosestFEdge___doc__[] =
-".. method:: getClosestFEdge(x, y)\n"
+PyDoc_STRVAR(ViewMap_get_closest_fedge_doc,
+".. method:: get_closest_fedge(x, y)\n"
 "\n"
 "   Gets the FEdge nearest to the 2D point specified as arguments.\n"
 "\n"
@@ -87,62 +86,53 @@ static char ViewMap_getClosestFEdge___doc__[] =
 "   :arg y: Y coordinate of a 2D point.\n"
 "   :type y: float\n"
 "   :return: The FEdge nearest to the specified 2D point.\n"
-"   :rtype: :class:`FEdge`\n";
+"   :rtype: :class:`FEdge`");
 
-static PyObject * ViewMap_getClosestFEdge( BPy_ViewMap *self , PyObject *args) {
+static PyObject * ViewMap_get_closest_fedge(BPy_ViewMap *self , PyObject *args)
+{
 	double x, y;
 
-	if(!( PyArg_ParseTuple(args, "dd", &x, &y) ))
+	if (!PyArg_ParseTuple(args, "dd", &x, &y))
 		return NULL;
-
-	FEdge *fe = const_cast<FEdge *>( self->vm->getClosestFEdge(x,y) );
-	if( fe )
+	FEdge *fe = const_cast<FEdge *>(self->vm->getClosestFEdge(x,y));
+	if (fe)
 		return Any_BPy_FEdge_from_FEdge(*fe);
-
 	Py_RETURN_NONE;
 }
 
-static char ViewMap_getScene3dBBox___doc__[] =
-".. method:: getScene3dBBox()\n"
-"\n"
-"   Returns the scene 3D bounding box.\n"
-"\n"
-"   :return: The scene 3D bounding box.\n"
-"   :rtype: :class:`BBox`\n";
-
-static PyObject * ViewMap_getScene3dBBox( BPy_ViewMap *self , PyObject *args) {
-	BBox<Vec3r> bb( self->vm->getScene3dBBox() );
-	return BPy_BBox_from_BBox( bb );
-}
-
-static char ViewMap_setScene3dBBox___doc__[] =
-".. method:: setScene3dBBox(bbox)\n"
-"\n"
-"   Sets the scene 3D bounding box.\n"
-"\n"
-"   :arg bbox: The scene 3D bounding box.\n"
-"   :type bbox: :class:`BBox`\n";
+// static ViewMap *getInstance ();
 
-static PyObject * ViewMap_setScene3dBBox( BPy_ViewMap *self , PyObject *args) {
-	PyObject *py_bb = 0;
+static PyMethodDef BPy_ViewMap_methods[] = {
+	{"get_closest_viewedge", (PyCFunction)ViewMap_get_closest_viewedge, METH_VARARGS, ViewMap_get_closest_viewedge_doc},
+	{"get_closest_fedge", (PyCFunction)ViewMap_get_closest_fedge, METH_VARARGS, ViewMap_get_closest_fedge_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-	if(!( PyArg_ParseTuple(args, "O!", &BBox_Type, &py_bb) ))
-		return NULL;
+/*----------------------ViewMap get/setters ----------------------------*/
 
-	self->vm->setScene3dBBox(*( ((BPy_BBox *) py_bb)->bb ));
+PyDoc_STRVAR(ViewMap_scene_bbox_doc,
+"The 3D bounding box of the scene.\n"
+"\n"
+":type: :class:`BBox`");
 
-	Py_RETURN_NONE;
+static PyObject *ViewMap_scene_bbox_get(BPy_ViewMap *self, void *UNUSED(closure))
+{
+	return BPy_BBox_from_BBox(self->vm->getScene3dBBox());
 }
 
-// static ViewMap *getInstance ();
+static int ViewMap_scene_bbox_set(BPy_ViewMap *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_BBox_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a BBox");
+		return -1;
+	}
+	self->vm->setScene3dBBox(*(((BPy_BBox *)value)->bb));
+	return 0;
+}
 
-/*---------------------- BPy_ViewShape instance definitions ----------------------------*/
-static PyMethodDef BPy_ViewMap_methods[] = {
-	{"getClosestViewEdge", ( PyCFunction ) ViewMap_getClosestViewEdge, METH_VARARGS, ViewMap_getClosestViewEdge___doc__},
-	{"getClosestFEdge", ( PyCFunction ) ViewMap_getClosestFEdge, METH_VARARGS, ViewMap_getClosestFEdge___doc__},
-	{"getScene3dBBox", ( PyCFunction ) ViewMap_getScene3dBBox, METH_NOARGS, ViewMap_getScene3dBBox___doc__},
-	{"setScene3dBBox", ( PyCFunction ) ViewMap_setScene3dBBox, METH_VARARGS, ViewMap_setScene3dBBox___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_ViewMap_getseters[] = {
+	{(char *)"scene_bbox", (getter)ViewMap_scene_bbox_get, (setter)ViewMap_scene_bbox_set, (char *)ViewMap_scene_bbox_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_ViewMap type definition ------------------------------*/
@@ -152,12 +142,12 @@ PyTypeObject ViewMap_Type = {
 	"ViewMap",                      /* tp_name */
 	sizeof(BPy_ViewMap),            /* tp_basicsize */
 	0,                              /* tp_itemsize */
-	(destructor)ViewMap___dealloc__, /* tp_dealloc */
+	(destructor)ViewMap_dealloc,    /* tp_dealloc */
 	0,                              /* tp_print */
 	0,                              /* tp_getattr */
 	0,                              /* tp_setattr */
 	0,                              /* tp_reserved */
-	(reprfunc)ViewMap___repr__,     /* tp_repr */
+	(reprfunc)ViewMap_repr,         /* tp_repr */
 	0,                              /* tp_as_number */
 	0,                              /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
@@ -168,7 +158,7 @@ PyTypeObject ViewMap_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	ViewMap___doc__,                /* tp_doc */
+	ViewMap_doc,                    /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -177,13 +167,13 @@ PyTypeObject ViewMap_Type = {
 	0,                              /* tp_iternext */
 	BPy_ViewMap_methods,            /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_ViewMap_getseters,          /* tp_getset */
 	0,                              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)ViewMap___init__,     /* tp_init */
+	(initproc)ViewMap_init,         /* tp_init */
 	0,                              /* tp_alloc */
 	PyType_GenericNew,              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/BPy_ViewShape.cpp b/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
index eebfa88773c..95e17251194 100644
--- a/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
+++ b/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
@@ -12,22 +12,23 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //-------------------MODULE INITIALIZATION--------------------------------
-int ViewShape_Init( PyObject *module )
+
+int ViewShape_Init(PyObject *module)
 {
-	if( module == NULL )
+	if (module == NULL)
 		return -1;
 
-	if( PyType_Ready( &ViewShape_Type ) < 0 )
+	if (PyType_Ready(&ViewShape_Type) < 0)
 		return -1;
-
-	Py_INCREF( &ViewShape_Type );
+	Py_INCREF(&ViewShape_Type);
 	PyModule_AddObject(module, "ViewShape", (PyObject *)&ViewShape_Type);
+
 	return 0;
 }
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------ViewShape methods ----------------------------*/
 
-static char ViewShape___doc__[] =
+PyDoc_STRVAR(ViewShape_doc,
 "Class gathering the elements of the ViewMap (i.e., :class:`ViewVertex`\n"
 "and :class:`ViewEdge`) that are issued from the same input shape.\n"
 "\n"
@@ -47,23 +48,23 @@ static char ViewShape___doc__[] =
 "   Builds a ViewShape from an SShape.\n"
 "\n"
 "   :arg iSShape: An SShape object.\n"
-"   :type iSShape: :class:`SShape`\n";
+"   :type iSShape: :class:`SShape`");
 
-static int ViewShape___init__(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
+static int ViewShape_init(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *obj;
 
-    if (! PyArg_ParseTuple(args, "|O", &obj) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|O", &obj))
+		return -1;
 
-	if( !obj ) {
+	if (!obj) {
 		self->vs = new ViewShape();
-	
-	} else if( BPy_SShape_Check(obj) ) {
-		self->vs = new ViewShape( ((BPy_SShape *) obj)->ss );
-	
-	} else if( BPy_ViewShape_Check(obj) ) {
-		self->vs = new ViewShape(*( ((BPy_ViewShape *) obj)->vs ));
+
+	} else if (BPy_SShape_Check(obj)) {
+		self->vs = new ViewShape(((BPy_SShape *)obj)->ss);
+
+	} else if (BPy_ViewShape_Check(obj)) {
+		self->vs = new ViewShape(*(((BPy_ViewShape *)obj)->vs));
 
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
@@ -71,236 +72,196 @@ static int ViewShape___init__(BPy_ViewShape *self, PyObject *args, PyObject *kwd
 	}
 	self->borrowed = 0;
 	
-    return 0;
+	return 0;
 }
 
-static void ViewShape___dealloc__(BPy_ViewShape *self)
+static void ViewShape_dealloc(BPy_ViewShape *self)
 {
-	if( self->vs && !self->borrowed )
+	if (self->vs && !self->borrowed)
 		delete self->vs;
-    Py_TYPE(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-static PyObject * ViewShape___repr__(BPy_ViewShape *self)
+static PyObject * ViewShape_repr(BPy_ViewShape *self)
 {
-    return PyUnicode_FromFormat("ViewShape - address: %p", self->vs );
+	return PyUnicode_FromFormat("ViewShape - address: %p", self->vs );
 }
 
-static char ViewShape_sshape___doc__[] =
-".. method:: sshape()\n"
+PyDoc_STRVAR(ViewShape_add_edge_doc,
+".. method:: add_edge(iEdge)\n"
 "\n"
-"   Returns the SShape on top of which this ViewShape is built.\n"
+"   Adds a ViewEdge to the list of ViewEdge objects.\n"
 "\n"
-"   :return: The SShape on top of which this ViewShape is built.\n"
-"   :rtype: :class:`SShape`\n";
+"   :arg iEdge: A ViewEdge object.\n"
+"   :type iEdge: :class:`ViewEdge`\n");
 
-static PyObject * ViewShape_sshape( BPy_ViewShape *self ) {
-	return BPy_SShape_from_SShape( *(self->vs->sshape()) );
+static PyObject * ViewShape_add_edge(BPy_ViewShape *self , PyObject *args)
+{
+	PyObject *py_ve = 0;
+
+	if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
+		return NULL;
+	self->vs->AddEdge(((BPy_ViewEdge *)py_ve)->ve);
+	Py_RETURN_NONE;
 }
 
-static char ViewShape_vertices___doc__[] =
-".. method:: vertices()\n"
+PyDoc_STRVAR(ViewShape_add_vertex_doc,
+".. method:: add_vertex(iVertex)\n"
 "\n"
-"   Returns the list of ViewVertex objects contained in this ViewShape.\n"
+"   Adds a ViewVertex to the list of the ViewVertex objects.\n"
 "\n"
-"   :return: The list of ViewVertex objects.\n"
-"   :rtype: List of :class:`ViewVertex` objects\n";
+"   :arg iVertex: A ViewVertex object.\n"
+"   :type iVertex: :class:`ViewVertex`");
 
-static PyObject * ViewShape_vertices( BPy_ViewShape *self ) {
-	PyObject *py_vertices = PyList_New(0);
+static PyObject * ViewShape_add_vertex(BPy_ViewShape *self , PyObject *args)
+{
+	PyObject *py_vv = 0;
 
-	vector< ViewVertex * > vertices = self->vs->vertices();
-	vector< ViewVertex * >::iterator it;
-	
-	for( it = vertices.begin(); it != vertices.end(); it++ ) {
-		PyList_Append( py_vertices, Any_BPy_ViewVertex_from_ViewVertex(*( *it )) );
-	}
-	
-	return py_vertices;
+	if (!PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv))
+		return NULL;
+	self->vs->AddVertex(((BPy_ViewVertex *)py_vv)->vv);
+	Py_RETURN_NONE;
 }
 
-static char ViewShape_edges___doc__[] =
-".. method:: edges()\n"
-"\n"
-"   Returns the list of ViewEdge objects contained in this ViewShape.\n"
-"\n"
-"   :return: The list of ViewEdge objects.\n"
-"   :rtype: List of :class:`ViewEdge` objects\n";
+// virtual ViewShape *duplicate()
 
-static PyObject * ViewShape_edges( BPy_ViewShape *self ) {
-	PyObject *py_edges = PyList_New(0);
+static PyMethodDef BPy_ViewShape_methods[] = {
+	{"add_edge", (PyCFunction)ViewShape_add_edge, METH_VARARGS, ViewShape_add_edge_doc},
+	{"add_vertex", (PyCFunction)ViewShape_add_vertex, METH_VARARGS, ViewShape_add_vertex_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-	vector< ViewEdge * > edges = self->vs->edges();
-	vector< ViewEdge * >::iterator it;
-	
-	for( it = edges.begin(); it != edges.end(); it++ ) {
-		PyList_Append( py_edges, BPy_ViewEdge_from_ViewEdge(*( *it )) );
-	}
-	
-	return py_edges;
-}
+/*----------------------ViewShape get/setters ----------------------------*/
 
-static char ViewShape_getId___doc__[] =
-".. method:: getId()\n"
+PyDoc_STRVAR(ViewShape_sshape_doc,
+"The SShape on top of which this ViewShape is built.\n"
 "\n"
-"   Returns the ViewShape id.\n"
-"\n"
-"   :return: An Id object.\n"
-"   :rtype: :class:`Id`\n";
+":type: :class:`SShape`");
 
-static PyObject * ViewShape_getId( BPy_ViewShape *self ) {
-	Id id( self->vs->getId() );
-	return BPy_Id_from_Id( id );
+static PyObject *ViewShape_sshape_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	return BPy_SShape_from_SShape(*(self->vs->sshape()));
 }
 
-static char ViewShape_getName___doc__[] =
-".. method:: getName()\n"
-"\n"
-"   Returns the name of the ViewShape.\n"
-"\n"
-"   :return: The name string.\n"
-"   :rtype: str\n";
-
-static PyObject * ViewShape_getName( BPy_ViewShape *self ) {
-	return PyUnicode_FromString( self->vs->getName().c_str() );
+static int ViewShape_sshape_set(BPy_ViewShape *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SShape_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SShape");
+		return -1;
+	}
+	self->vs->setSShape(((BPy_SShape *)value)->ss);
+	return 0;
 }
 
-static char ViewShape_setSShape___doc__[] =
-".. method:: setSShape(iSShape)\n"
-"\n"
-"   Sets the SShape on top of which the ViewShape is built.\n"
+PyDoc_STRVAR(ViewShape_vertices_doc,
+"The list of ViewVertex objects contained in this ViewShape.\n"
 "\n"
-"   :arg iSShape: An SShape object.\n"
-"   :type iSShape: :class:`SShape`\n";
-
-static PyObject * ViewShape_setSShape( BPy_ViewShape *self , PyObject *args) {
-	PyObject *py_ss = 0;
+":type: List of :class:`ViewVertex` objects");
 
-	if(!( PyArg_ParseTuple(args, "O!", &SShape_Type, &py_ss) ))
-		return NULL;
-	
-	self->vs->setSShape( ((BPy_SShape *) py_ss)->ss );
+static PyObject *ViewShape_vertices_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	PyObject *py_vertices = PyList_New(0);
 
-	Py_RETURN_NONE;
+	vector< ViewVertex * > vertices = self->vs->vertices();
+	vector< ViewVertex * >::iterator it;
+	for (it = vertices.begin(); it != vertices.end(); it++) {
+		PyList_Append( py_vertices, Any_BPy_ViewVertex_from_ViewVertex(*(*it)));
+	}
+	return py_vertices;
 }
 
-static char ViewShape_setVertices___doc__[] =
-".. method:: setVertices(iVertices)\n"
-"\n"
-"   Sets the list of ViewVertex objects contained in this ViewShape.\n"
-"\n"
-"   :arg iVertices: The list of ViewVertex objects.\n"
-"   :type iVertices: List of :class:`ViewVertex` objects\n";
-
-static PyObject * ViewShape_setVertices( BPy_ViewShape *self , PyObject *args) {
+static int ViewShape_vertices_set(BPy_ViewShape *self, PyObject *value, void *UNUSED(closure))
+{
 	PyObject *list = 0;
-	PyObject *tmp;
-	
-	if(!( PyArg_ParseTuple(args, "O!", &PyList_Type, &list) ))
-		return NULL;
-	
+	PyObject *item;
 	vector< ViewVertex *> v;
 	
-	for( int i=0; i < PyList_Size(list); i++ ) {
-		tmp = PyList_GetItem(list, i);
-		if( BPy_ViewVertex_Check(tmp) )
-			v.push_back( ((BPy_ViewVertex *) tmp)->vv );
-		else {
-			PyErr_SetString(PyExc_TypeError, "argument must be list of ViewVertex objects");
-			return NULL;
+	if (!PyList_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a list of ViewVertex objects");
+		return -1;
+	}
+	for (int i = 0; i < PyList_Size(list); i++) {
+		item = PyList_GetItem(list, i);
+		if (BPy_ViewVertex_Check(item)) {
+			v.push_back(((BPy_ViewVertex *)item)->vv);
+		} else {
+			PyErr_SetString(PyExc_TypeError, "value must be a list of ViewVertex objects");
+			return -1;
 		}
 	}
-		
-	self->vs->setVertices( v );
-
-	Py_RETURN_NONE;
+	self->vs->setVertices(v);
+	return 0;
 }
 
-static char ViewShape_setEdges___doc__[] =
-".. method:: setEdges(iEdges)\n"
-"\n"
-"   Sets the list of ViewEdge objects contained in this ViewShape.\n"
+PyDoc_STRVAR(ViewShape_edges_doc,
+"The list of ViewEdge objects contained in this ViewShape.\n"
 "\n"
-"   :arg iEdges: The list of ViewEdge objects.\n"
-"   :type iEdges: List of :class:`ViewEdge` objects.\n";
+":type: List of :class:`ViewEdge` objects");
 
-static PyObject * ViewShape_setEdges( BPy_ViewShape *self , PyObject *args) {
-	PyObject *list = 0;
-	PyObject *tmp;
+static PyObject *ViewShape_edges_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	PyObject *py_edges = PyList_New(0);
 
-	if(!( PyArg_ParseTuple(args, "O!", &PyList_Type, &list) ))
-		return NULL;
+	vector< ViewEdge * > edges = self->vs->edges();
+	vector< ViewEdge * >::iterator it;
 
+	for (it = edges.begin(); it != edges.end(); it++) {
+		PyList_Append(py_edges, BPy_ViewEdge_from_ViewEdge(*(*it)));
+	}
+	return py_edges;
+}
+
+static int ViewShape_edges_set(BPy_ViewShape *self, PyObject *value, void *UNUSED(closure))
+{
+	PyObject *list = 0;
+	PyObject *item;
 	vector<ViewEdge *> v;
 
-	for( int i=0; i < PyList_Size(list); i++ ) {
-		tmp = PyList_GetItem(list, i);
-		if( BPy_ViewEdge_Check(tmp) )
-			v.push_back( ((BPy_ViewEdge *) tmp)->ve );
-		else {
+	if (!PyList_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a list of ViewEdge objects");
+		return -1;
+	}
+	for (int i = 0; i < PyList_Size(list); i++) {
+		item = PyList_GetItem(list, i);
+		if (BPy_ViewEdge_Check(item)) {
+			v.push_back(((BPy_ViewEdge *)item)->ve);
+		} else {
 			PyErr_SetString(PyExc_TypeError, "argument must be list of ViewEdge objects");
-			return NULL;
+			return -1;
 		}
 	}
-
-	self->vs->setEdges( v );
-
-	Py_RETURN_NONE;
+	self->vs->setEdges(v);
+	return 0;
 }
 
-static char ViewShape_AddEdge___doc__[] =
-".. method:: AddEdge(iEdge)\n"
-"\n"
-"   Adds a ViewEdge to the list of ViewEdge objects.\n"
+PyDoc_STRVAR(ViewShape_name_doc,
+"The name of the ViewShape.\n"
 "\n"
-"   :arg iEdge: A ViewEdge object.\n"
-"   :type iEdge: :class:`ViewEdge`\n";
-
-static PyObject * ViewShape_AddEdge( BPy_ViewShape *self , PyObject *args) {
-	PyObject *py_ve = 0;
+":type: str");
 
-	if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
-		return NULL;
-	
-	self->vs->AddEdge( ((BPy_ViewEdge *) py_ve)->ve );
-
-	Py_RETURN_NONE;
+static PyObject *ViewShape_name_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	return PyUnicode_FromString(self->vs->getName().c_str());
 }
 
-static char ViewShape_AddVertex___doc__[] =
-".. method:: AddVertex(iVertex)\n"
-"\n"
-"   Adds a ViewVertex to the list of the ViewVertex objects.\n"
+PyDoc_STRVAR(ViewShape_id_doc,
+"The Id of this ViewShape.\n"
 "\n"
-"   :arg iVertex: A ViewVertex object.\n"
-"   :type iVertex: :class:`ViewVertex`\n";
-
-static PyObject * ViewShape_AddVertex( BPy_ViewShape *self , PyObject *args) {
-	PyObject *py_vv = 0;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv) ))
-		return NULL;
-	
-	self->vs->AddVertex( ((BPy_ViewVertex *) py_vv)->vv );
+":type: :class:`Id`");
 
-	Py_RETURN_NONE;
+static PyObject *ViewShape_id_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	Id id(self->vs->getId());
+	return BPy_Id_from_Id(id); // return a copy
 }
 
-// virtual ViewShape * 	duplicate ()
-
-/*---------------------- BPy_ViewShape instance definitions ----------------------------*/
-static PyMethodDef BPy_ViewShape_methods[] = {
-	{"sshape", ( PyCFunction ) ViewShape_sshape, METH_NOARGS, ViewShape_sshape___doc__},
-	{"vertices", ( PyCFunction ) ViewShape_vertices, METH_NOARGS, ViewShape_vertices___doc__},
-	{"edges", ( PyCFunction ) ViewShape_edges, METH_NOARGS, ViewShape_edges___doc__},
-	{"getId", ( PyCFunction ) ViewShape_getId, METH_NOARGS, ViewShape_getId___doc__},
-	{"getName", ( PyCFunction ) ViewShape_getName, METH_NOARGS, ViewShape_getName___doc__},
-	{"setSShape", ( PyCFunction ) ViewShape_setSShape, METH_VARARGS, ViewShape_setSShape___doc__},
-	{"setVertices", ( PyCFunction ) ViewShape_setVertices, METH_VARARGS, ViewShape_setVertices___doc__},
-	{"setEdges", ( PyCFunction ) ViewShape_setEdges, METH_VARARGS, ViewShape_setEdges___doc__},
-	{"AddEdge", ( PyCFunction ) ViewShape_AddEdge, METH_VARARGS, ViewShape_AddEdge___doc__},
-	{"AddVertex", ( PyCFunction ) ViewShape_AddVertex, METH_VARARGS, ViewShape_AddVertex___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_ViewShape_getseters[] = {
+	{(char *)"sshape", (getter)ViewShape_sshape_get, (setter)ViewShape_sshape_set, (char *)ViewShape_sshape_doc, NULL},
+	{(char *)"vertices", (getter)ViewShape_vertices_get, (setter)ViewShape_vertices_set, (char *)ViewShape_vertices_doc, NULL},
+	{(char *)"edges", (getter)ViewShape_edges_get, (setter)ViewShape_edges_set, (char *)ViewShape_edges_doc, NULL},
+	{(char *)"name", (getter)ViewShape_name_get, (setter)NULL, (char *)ViewShape_name_doc, NULL},
+	{(char *)"id", (getter)ViewShape_id_get, (setter)NULL, (char *)ViewShape_id_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_ViewShape type definition ------------------------------*/
@@ -310,12 +271,12 @@ PyTypeObject ViewShape_Type = {
 	"ViewShape",                    /* tp_name */
 	sizeof(BPy_ViewShape),          /* tp_basicsize */
 	0,                              /* tp_itemsize */
-	(destructor)ViewShape___dealloc__, /* tp_dealloc */
+	(destructor)ViewShape_dealloc,  /* tp_dealloc */
 	0,                              /* tp_print */
 	0,                              /* tp_getattr */
 	0,                              /* tp_setattr */
 	0,                              /* tp_reserved */
-	(reprfunc)ViewShape___repr__,   /* tp_repr */
+	(reprfunc)ViewShape_repr,       /* tp_repr */
 	0,                              /* tp_as_number */
 	0,                              /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
@@ -326,7 +287,7 @@ PyTypeObject ViewShape_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	ViewShape___doc__,              /* tp_doc */
+	ViewShape_doc,              /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -335,13 +296,13 @@ PyTypeObject ViewShape_Type = {
 	0,                              /* tp_iternext */
 	BPy_ViewShape_methods,          /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_ViewShape_getseters,        /* tp_getset */
 	0,                              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)ViewShape___init__,   /* tp_init */
+	(initproc)ViewShape_init,       /* tp_init */
 	0,                              /* tp_alloc */
 	PyType_GenericNew,              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp
index e213edd5c79..3e2cc495785 100644
--- a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp
@@ -9,9 +9,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------CurvePoint methods----------------------------*/
 
-static char CurvePoint___doc__[] =
+PyDoc_STRVAR(CurvePoint_doc,
 "Class hierarchy: :class:`Interface0D` > :class:`CurvePoint`\n"
 "\n"
 "Class to represent a point of a curve.  A CurvePoint can be any point\n"
@@ -57,15 +57,15 @@ static char CurvePoint___doc__[] =
 "   :type iB: :class:`CurvePoint`\n"
 "   :arg t2d: The 2D interpolation parameter used to linearly\n"
 "             interpolate iA and iB.\n"
-"   :type t2d: float\n";
+"   :type t2d: float");
 
-static int CurvePoint___init__(BPy_CurvePoint *self, PyObject *args, PyObject *kwds)
+static int CurvePoint_init(BPy_CurvePoint *self, PyObject *args, PyObject *kwds)
 {
 
 	PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0;
 
-    if (! PyArg_ParseTuple(args, "|OOO!", &obj1, &obj2, &PyFloat_Type, &obj3) )
-        return -1;
+	if (! PyArg_ParseTuple(args, "|OOO!", &obj1, &obj2, &PyFloat_Type, &obj3) )
+		return -1;
 
 	if( !obj1 ){
 		self->cp = new CurvePoint();
@@ -102,131 +102,99 @@ static int CurvePoint___init__(BPy_CurvePoint *self, PyObject *args, PyObject *k
 	return 0;
 }
 
-static char CurvePoint_A___doc__[] =
-".. method:: A()\n"
-"\n"
-"   Returns the first SVertex upon which the CurvePoint is built.\n"
-"\n"
-"   :return: The first SVertex.\n"
-"   :rtype: :class:`SVertex`\n";
+///bool 	operator== (const CurvePoint &b)
 
-static PyObject * CurvePoint_A( BPy_CurvePoint *self ) {
-	SVertex *A = self->cp->A();
-	if( A )
-		return BPy_SVertex_from_SVertex( *A );
+static PyMethodDef BPy_CurvePoint_methods[] = {
+	{NULL, NULL, 0, NULL}
+};
 
-	Py_RETURN_NONE;
-}
+/*----------------------CurvePoint get/setters ----------------------------*/
 
-static char CurvePoint_B___doc__[] =
-".. method:: B()\n"
+PyDoc_STRVAR(CurvePoint_first_svertex_doc,
+"The first SVertex upon which the CurvePoint is built.\n"
 "\n"
-"   Returns the second SVertex upon which the CurvePoint is built.\n"
-"\n"
-"   :return: The second SVertex.\n"
-"   :rtype: :class:`SVertex`\n";
-
-static PyObject * CurvePoint_B( BPy_CurvePoint *self ) {
-	SVertex *B = self->cp->B();
-	if( B )
-		return BPy_SVertex_from_SVertex( *B );
+":type: int");
 
+static PyObject *CurvePoint_first_svertex_get(BPy_CurvePoint *self, void *UNUSED(closure))
+{
+	SVertex *A = self->cp->A();
+	if (A)
+		return BPy_SVertex_from_SVertex(*A);
 	Py_RETURN_NONE;
 }
 
-static char CurvePoint_t2d___doc__[] =
-".. method:: t2d()\n"
-"\n"
-"   Returns the 2D interpolation parameter.\n"
-"\n"
-"   :return: The 2D interpolation parameter.\n"
-"   :rtype: float\n";
-
-static PyObject * CurvePoint_t2d( BPy_CurvePoint *self ) {
-	return PyFloat_FromDouble( self->cp->t2d() );
+static int CurvePoint_first_svertex_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
+	}
+	self->cp->setA(((BPy_SVertex *)value)->sv);
+	return 0;
 }
 
-static char CurvePoint_setA___doc__[] =
-".. method:: setA(iA)\n"
+PyDoc_STRVAR(CurvePoint_second_svertex_doc,
+"The second SVertex upon which the CurvePoint is built.\n"
 "\n"
-"   Sets the first SVertex upon which to build the CurvePoint.\n"
-"\n"
-"   :arg iA: The first SVertex.\n"
-"   :type iA: :class:`SVertex`\n";
-
-static PyObject *CurvePoint_setA( BPy_CurvePoint *self , PyObject *args) {
-	PyObject *py_sv;
-
-	if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
-		return NULL;
-
-	self->cp->setA( ((BPy_SVertex *) py_sv)->sv );
+":type: int");
 
+static PyObject *CurvePoint_second_svertex_get(BPy_CurvePoint *self, void *UNUSED(closure))
+{
+	SVertex *B = self->cp->B();
+	if (B)
+		return BPy_SVertex_from_SVertex(*B);
 	Py_RETURN_NONE;
 }
 
-static char CurvePoint_setB___doc__[] =
-".. method:: setB(iB)\n"
-"\n"
-"   Sets the first SVertex upon which to build the CurvePoint.\n"
-"\n"
-"   :arg iB: The second SVertex.\n"
-"   :type iB: :class:`SVertex`\n";
-
-static PyObject *CurvePoint_setB( BPy_CurvePoint *self , PyObject *args) {
-	PyObject *py_sv;
-
-	if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
-		return NULL;
-
-	self->cp->setB( ((BPy_SVertex *) py_sv)->sv );
-
-	Py_RETURN_NONE;
+static int CurvePoint_second_svertex_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
+	}
+	self->cp->setB(((BPy_SVertex *)value)->sv);
+	return 0;
 }
 
-static char CurvePoint_setT2d___doc__[] =
-".. method:: setT2d(t)\n"
-"\n"
-"   Sets the 2D interpolation parameter to use.\n"
+PyDoc_STRVAR(CurvePoint_t2d_doc,
+"The 2D interpolation parameter.\n"
 "\n"
-"   :arg t: The 2D interpolation parameter.\n"
-"   :type t: float\n";
+":type: float");
 
-static PyObject *CurvePoint_setT2d( BPy_CurvePoint *self , PyObject *args) {
-	float t;
-
-	if(!( PyArg_ParseTuple(args, "f", &t) ))
-		return NULL;
-
-	self->cp->setT2d( t );
+static PyObject *CurvePoint_t2d_get(BPy_CurvePoint *self, void *UNUSED(closure))
+{
+	return PyFloat_FromDouble(self->cp->t2d());
+}
 
-	Py_RETURN_NONE;
+static int CurvePoint_t2d_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure))
+{
+	float scalar;
+	if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_TypeError, "value must be a number");
+		return -1;
+	}
+	self->cp->setT2d(scalar);
+	return 0;
 }
 
-static char CurvePoint_curvatureFredo___doc__[] =
-".. method:: curvatureFredo()\n"
-"\n"
-"   Returns the angle in radians.\n"
+PyDoc_STRVAR(CurvePoint_curvature_fredo_doc,
+"The angle (Fredo's curvature) in radians.\n"
 "\n"
-"   :return: The angle in radians.\n"
-"   :rtype: float\n";
+":type: float");
 
-static PyObject *CurvePoint_curvatureFredo( BPy_CurvePoint *self , PyObject *args) {
-	return PyFloat_FromDouble( self->cp->curvatureFredo() );
+static PyObject *CurvePoint_curvature_fredo_get(BPy_CurvePoint *self, void *UNUSED(closure))
+{
+	return PyFloat_FromDouble(self->cp->curvatureFredo());
 }
 
-///bool 	operator== (const CurvePoint &b)
+// todo - CurvePoint.directionFredo()
 
-/*----------------------CurvePoint instance definitions ----------------------------*/
-static PyMethodDef BPy_CurvePoint_methods[] = {	
-	{"A", ( PyCFunction ) CurvePoint_A, METH_NOARGS, CurvePoint_A___doc__},
-	{"B", ( PyCFunction ) CurvePoint_B, METH_NOARGS, CurvePoint_B___doc__},
-	{"t2d", ( PyCFunction ) CurvePoint_t2d, METH_NOARGS, CurvePoint_t2d___doc__},
-	{"setA", ( PyCFunction ) CurvePoint_setA, METH_VARARGS, CurvePoint_setA___doc__},
-	{"setB", ( PyCFunction ) CurvePoint_setB, METH_VARARGS, CurvePoint_setB___doc__},
-	{"setT2d", ( PyCFunction ) CurvePoint_setT2d, METH_VARARGS, CurvePoint_setT2d___doc__},
-	{"curvatureFredo", ( PyCFunction ) CurvePoint_curvatureFredo, METH_NOARGS, CurvePoint_curvatureFredo___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_CurvePoint_getseters[] = {
+	{(char *)"first_svertex", (getter)CurvePoint_first_svertex_get, (setter)CurvePoint_first_svertex_set, (char *)CurvePoint_first_svertex_doc, NULL},
+	{(char *)"second_svertex", (getter)CurvePoint_second_svertex_get, (setter)CurvePoint_second_svertex_set, (char *)CurvePoint_second_svertex_doc, NULL},
+	{(char *)"t2d", (getter)CurvePoint_t2d_get, (setter)CurvePoint_t2d_set, (char *)CurvePoint_t2d_doc, NULL},
+	{(char *)"curvature_fredo", (getter)CurvePoint_curvature_fredo_get, (setter)NULL, (char *)CurvePoint_curvature_fredo_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_CurvePoint type definition ------------------------------*/
@@ -251,7 +219,7 @@ PyTypeObject CurvePoint_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	CurvePoint___doc__,             /* tp_doc */
+	CurvePoint_doc,                 /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -260,13 +228,13 @@ PyTypeObject CurvePoint_Type = {
 	0,                              /* tp_iternext */
 	BPy_CurvePoint_methods,         /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_CurvePoint_getseters,       /* tp_getset */
 	&Interface0D_Type,              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)CurvePoint___init__,  /* tp_init */
+	(initproc)CurvePoint_init,      /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
index 14e6f143b84..0d0a772b4e5 100644
--- a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
@@ -10,7 +10,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-static char SVertex___doc__[] =
+/*----------------------SVertex methods ----------------------------*/
+
+PyDoc_STRVAR(SVertex_doc,
 "Class hierarchy: :class:`Interface0D` > :class:`SVertex`\n"
 "\n"
 "Class to define a vertex of the embedding.\n"
@@ -33,32 +35,29 @@ static char SVertex___doc__[] =
 "   :arg iPoint3D: A three-dimensional vector.\n"
 "   :type iPoint3D: :class:`mathutils.Vector`\n"
 "   :arg id: An Id object.\n"
-"   :type id: :class:`Id`\n";
-
-//------------------------INSTANCE METHODS ----------------------------------
+"   :type id: :class:`Id`");
 
-static int SVertex___init__(BPy_SVertex *self, PyObject *args, PyObject *kwds)
+static int SVertex_init(BPy_SVertex *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *py_point = 0;
 	BPy_Id *py_id = 0;
-	
 
-	if (! PyArg_ParseTuple(args, "|OO!", &py_point, &Id_Type, &py_id) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|OO!", &py_point, &Id_Type, &py_id))
+		return -1;
 	
-	if( !py_point ) {
+	if (!py_point) {
 		self->sv = new SVertex();
 
-	} else if( !py_id && BPy_SVertex_Check(py_point) ) {
+	} else if (!py_id && BPy_SVertex_Check(py_point)) {
 		self->sv = new SVertex( *(((BPy_SVertex *)py_point)->sv) );
 
-	} else if( py_point && py_id ) {
+	} else if (py_point && py_id) {
 		Vec3r *v = Vec3r_ptr_from_PyObject(py_point);
-		if( !v ) {
+		if (!v) {
 			PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
 			return -1;
 		}
-		self->sv = new SVertex( *v, *(py_id->id) );
+		self->sv = new SVertex(*v, *(py_id->id));
 		delete v;
 
 	} else {
@@ -68,192 +67,310 @@ static int SVertex___init__(BPy_SVertex *self, PyObject *args, PyObject *kwds)
 
 	self->py_if0D.if0D = self->sv;
 	self->py_if0D.borrowed = 0;
-	
+
 	return 0;
 }
 
-static char SVertex_normals___doc__[] =
-".. method:: normals()\n"
+PyDoc_STRVAR(SVertex_add_normal_doc,
+".. method:: add_normal(n)\n"
 "\n"
-"   Returns the normals for this Vertex as a list.  In a smooth surface,\n"
-"   a vertex has exactly one normal.  In a sharp surface, a vertex can\n"
-"   have any number of normals.\n"
+"   Adds a normal to the SVertex's set of normals.  If the same normal\n"
+"   is already in the set, nothing changes.\n"
 "\n"
-"   :return: A list of normals.\n"
-"   :rtype: List of :class:`mathutils.Vector` objects\n";
+"   :arg n: A three-dimensional vector.\n"
+"   :type n: :class:`mathutils.Vector`, list or tuple of 3 real numbers");
 
-static PyObject * SVertex_normals( BPy_SVertex *self ) {
-	PyObject *py_normals; 
-	set< Vec3r > normals;
-	
-	py_normals  = PyList_New(0);
-	normals = self->sv->normals();
-		
-	for( set< Vec3r >::iterator set_iterator = normals.begin(); set_iterator != normals.end(); set_iterator++ ) {
-		Vec3r v( *set_iterator );
-		PyList_Append( py_normals, Vector_from_Vec3r(v) );
+static PyObject *SVertex_add_normal( BPy_SVertex *self , PyObject *args) {
+	PyObject *py_normal;
+
+	if (!PyArg_ParseTuple(args, "O", &py_normal))
+		return NULL;
+	Vec3r *n = Vec3r_ptr_from_PyObject(py_normal);
+	if (!n) {
+		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
+		return NULL;
 	}
-	
-	return py_normals;
+	self->sv->AddNormal(*n);
+	delete n;
+
+	Py_RETURN_NONE;
 }
 
-static char SVertex_normalsSize___doc__[] =
-".. method:: normalsSize()\n"
+PyDoc_STRVAR(SVertex_add_fedge_doc,
+".. method:: add_fedge(fe)\n"
 "\n"
-"   Returns the number of different normals for this vertex.\n"
+"   Add an FEdge to the list of edges emanating from this SVertex.\n"
 "\n"
-"   :return: The number of normals.\n"
-"   :rtype: int\n";
+"   :arg fe: An FEdge.\n"
+"   :type fe: :class:`FEdge`");
+
+static PyObject *SVertex_add_fedge( BPy_SVertex *self , PyObject *args) {
+	PyObject *py_fe;
 
-static PyObject * SVertex_normalsSize( BPy_SVertex *self ) {
-	return PyLong_FromLong( self->sv->normalsSize() );
+	if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe))
+		return NULL;
+	
+	self->sv->AddFEdge(((BPy_FEdge *)py_fe)->fe);
+
+	Py_RETURN_NONE;
 }
 
-static char SVertex_viewvertex___doc__[] =
-".. method:: viewvertex()\n"
-"\n"
-"   If this SVertex is also a ViewVertex, this method returns the\n"
-"   ViewVertex.  None is returned otherwise.\n"
-"\n"
-"   :return: The ViewVertex object.\n"
-"   :rtype: :class:`ViewVertex`\n";
+// virtual bool 	operator== (const SVertex &iBrother)
 
-static PyObject * SVertex_viewvertex( BPy_SVertex *self ) {
-	ViewVertex *vv = self->sv->viewvertex();
-	if( vv )
-		return Any_BPy_ViewVertex_from_ViewVertex( *vv );
+static PyMethodDef BPy_SVertex_methods[] = {
+	{"add_normal", (PyCFunction)SVertex_add_normal, METH_VARARGS, SVertex_add_normal_doc},
+	{"add_fedge", (PyCFunction)SVertex_add_fedge, METH_VARARGS, SVertex_add_fedge_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-	Py_RETURN_NONE;
+/*----------------------mathutils callbacks ----------------------------*/
+
+/* subtype */
+#define MATHUTILS_SUBTYPE_POINT3D  1
+#define MATHUTILS_SUBTYPE_POINT2D  2
+
+static int SVertex_mathutils_check(BaseMathObject *bmo)
+{
+	if (!BPy_SVertex_Check(bmo->cb_user))
+		return -1;
+	return 0;
 }
 
-static char SVertex_setPoint3D___doc__[] =
-".. method:: setPoint3D(p)\n"
-"\n"
-"   Sets the 3D coordinates of the SVertex.\n"
-"\n"
-"   :arg p: A three-dimensional vector.\n"
-"   :type p: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
+static int SVertex_mathutils_get(BaseMathObject *bmo, int subtype)
+{
+	BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user;
+	switch (subtype) {
+	case MATHUTILS_SUBTYPE_POINT3D:
+		bmo->data[0] = self->sv->getX();
+		bmo->data[1] = self->sv->getY();
+		bmo->data[2] = self->sv->getZ();
+		break;
+	case MATHUTILS_SUBTYPE_POINT2D:
+		bmo->data[0] = self->sv->getProjectedX();
+		bmo->data[1] = self->sv->getProjectedY();
+		bmo->data[2] = self->sv->getProjectedZ();
+		break;
+	default:
+		return -1;
+	}
+	return 0;
+}
 
-static PyObject *SVertex_setPoint3D( BPy_SVertex *self , PyObject *args) {
-	PyObject *py_point;
+static int SVertex_mathutils_set(BaseMathObject *bmo, int subtype)
+{
+	BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user;
+	switch (subtype) {
+	case MATHUTILS_SUBTYPE_POINT3D:
+		{
+			Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]);
+			self->sv->setPoint3D(p);
+		}
+		break;
+	case MATHUTILS_SUBTYPE_POINT2D:
+		{
+			Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]);
+			self->sv->setPoint2D(p);
+		}
+		break;
+	default:
+		return -1;
+	}
+	return 0;
+}
 
-	if(!( PyArg_ParseTuple(args, "O", &py_point) ))
-		return NULL;
-	Vec3r *v = Vec3r_ptr_from_PyObject(py_point);
-	if( !v ) {
-		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
-		return NULL;
+static int SVertex_mathutils_get_index(BaseMathObject *bmo, int subtype, int index)
+{
+	BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user;
+	switch (subtype) {
+	case MATHUTILS_SUBTYPE_POINT3D:
+		switch (index) {
+		case 0: bmo->data[0] = self->sv->getX(); break;
+		case 1: bmo->data[1] = self->sv->getY(); break;
+		case 2: bmo->data[2] = self->sv->getZ(); break;
+		default:
+			return -1;
+		}
+		break;
+	case MATHUTILS_SUBTYPE_POINT2D:
+		switch (index) {
+		case 0: bmo->data[0] = self->sv->getProjectedX(); break;
+		case 1: bmo->data[1] = self->sv->getProjectedY(); break;
+		case 2: bmo->data[2] = self->sv->getProjectedZ(); break;
+		default:
+			return -1;
+		}
+		break;
+	default:
+		return -1;
 	}
-	self->sv->setPoint3D( *v );
-	delete v;
+	return 0;
+}
 
-	Py_RETURN_NONE;
+static int SVertex_mathutils_set_index(BaseMathObject *bmo, int subtype, int index)
+{
+	BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user;
+	switch (subtype) {
+	case MATHUTILS_SUBTYPE_POINT3D:
+		{
+			Vec3r p(self->sv->point3D());
+			p[index] = bmo->data[index];
+			self->sv->setPoint3D(p);
+		}
+		break;
+	case MATHUTILS_SUBTYPE_POINT2D:
+		{
+			Vec3r p(self->sv->point2D());
+			p[index] = bmo->data[index];
+			self->sv->setPoint2D(p);
+		}
+		break;
+	default:
+		return -1;
+	}
+	return 0;
 }
 
-static char SVertex_setPoint2D___doc__[] =
-".. method:: setPoint2D(p)\n"
-"\n"
-"   Sets the 2D projected coordinates of the SVertex.\n"
+static Mathutils_Callback SVertex_mathutils_cb = {
+	SVertex_mathutils_check,
+	SVertex_mathutils_get,
+	SVertex_mathutils_set,
+	SVertex_mathutils_get_index,
+	SVertex_mathutils_set_index
+};
+
+static unsigned char SVertex_mathutils_cb_index = -1;
+
+void SVertex_mathutils_register_callback()
+{
+	SVertex_mathutils_cb_index = Mathutils_RegisterCallback(&SVertex_mathutils_cb);
+}
+
+/*----------------------SVertex get/setters ----------------------------*/
+
+PyDoc_STRVAR(SVertex_point_3d_doc,
+"The 3D coordinates of the SVertex.\n"
 "\n"
-"   :arg p: A three-dimensional vector.\n"
-"   :type p: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
+":type: mathutils.Vector");
 
-static PyObject *SVertex_setPoint2D( BPy_SVertex *self , PyObject *args) {
-	PyObject *py_point;
+static PyObject *SVertex_point_3d_get(BPy_SVertex *self, void *UNUSED(closure))
+{
+	return Vector_CreatePyObject_cb((PyObject *)self, 3, SVertex_mathutils_cb_index, MATHUTILS_SUBTYPE_POINT3D);
+}
 
-	if(!( PyArg_ParseTuple(args, "O", &py_point) ))
-		return NULL;
-	Vec3r *v = Vec3r_ptr_from_PyObject(py_point);
-	if( !v ) {
-		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
-		return NULL;
+static int SVertex_point_3d_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	float v[3];
+	if (!float_array_from_PyObject(value, v, 3)) {
+		PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector");
+		return -1;
 	}
-	self->sv->setPoint2D( *v );
-	delete v;
-
-	Py_RETURN_NONE;
+	Vec3r p(v[0], v[1], v[2]);
+	self->sv->setPoint3D(p);
+	return 0;
 }
 
-static char SVertex_AddNormal___doc__[] =
-".. method:: AddNormal(n)\n"
-"\n"
-"   Adds a normal to the SVertex's set of normals.  If the same normal\n"
-"   is already in the set, nothing changes.\n"
+PyDoc_STRVAR(SVertex_point_2d_doc,
+"The projected 3D coordinates of the SVertex.\n"
 "\n"
-"   :arg n: A three-dimensional vector.\n"
-"   :type n: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
+":type: mathutils.Vector");
 
-static PyObject *SVertex_AddNormal( BPy_SVertex *self , PyObject *args) {
-	PyObject *py_normal;
+static PyObject *SVertex_point_2d_get(BPy_SVertex *self, void *UNUSED(closure))
+{
+	return Vector_CreatePyObject_cb((PyObject *)self, 3, SVertex_mathutils_cb_index, MATHUTILS_SUBTYPE_POINT2D);
+}
 
-	if(!( PyArg_ParseTuple(args, "O", &py_normal) ))
-		return NULL;
-	Vec3r *n = Vec3r_ptr_from_PyObject(py_normal);
-	if( !n ) {
-		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
-		return NULL;
+static int SVertex_point_2d_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	float v[3];
+	if (!float_array_from_PyObject(value, v, 3)) {
+		PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector");
+		return -1;
 	}
-	self->sv->AddNormal( *n );
-	delete n;
-
-	Py_RETURN_NONE;
+	Vec3r p(v[0], v[1], v[2]);
+	self->sv->setPoint2D(p);
+	return 0;
 }
 
-static char SVertex_setId___doc__[] =
-".. method:: setId(id)\n"
-"\n"
-"   Sets the identifier of the SVertex.\n"
+PyDoc_STRVAR(SVertex_id_doc,
+"The Id of this SVertex.\n"
 "\n"
-"   :arg id: The identifier.\n"
-"   :type id: :class:`Id`\n";
+":type: :class:`Id`");
 
-static PyObject *SVertex_setId( BPy_SVertex *self , PyObject *args) {
-	BPy_Id *py_id;
+static PyObject *SVertex_id_get(BPy_SVertex *self, void *UNUSED(closure))
+{
+	Id id(self->sv->getId());
+	return BPy_Id_from_Id(id); // return a copy
+}
 
-	if( !PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) )
-		return NULL;
+static int SVertex_id_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Id_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an Id");
+		return -1;
+	}
+	self->sv->setId(*(((BPy_Id *)value)->id));
+	return 0;
+}
 
-	self->sv->setId( *(py_id->id) );
+PyDoc_STRVAR(SVertex_normals_doc,
+"The normals for this Vertex as a list.  In a sharp surface, an SVertex\n"
+"has exactly one normal.  In a smooth surface, an SVertex can have any\n"
+"number of normals.\n"
+"\n"
+":type: list of :class:`mathutils.Vector` objects");
 
-	Py_RETURN_NONE;
+static PyObject *SVertex_normals_get(BPy_SVertex *self, void *UNUSED(closure))
+{
+	PyObject *py_normals; 
+	set< Vec3r > normals;
+	
+	py_normals = PyList_New(0);
+	normals = self->sv->normals();
+	for (set< Vec3r >::iterator set_iterator = normals.begin(); set_iterator != normals.end(); set_iterator++) {
+		Vec3r v(*set_iterator);
+		PyList_Append(py_normals, Vector_from_Vec3r(v));
+	}
+	return py_normals;
 }
 
-static char SVertex_AddFEdge___doc__[] =
-".. method:: AddFEdge(fe)\n"
-"\n"
-"   Add an FEdge to the list of edges emanating from this SVertex.\n"
+PyDoc_STRVAR(SVertex_normals_size_doc,
+"The number of different normals for this SVertex.\n"
 "\n"
-"   :arg fe: An FEdge.\n"
-"   :type fe: :class:`FEdge`\n";
+":type: int");
 
-static PyObject *SVertex_AddFEdge( BPy_SVertex *self , PyObject *args) {
-	PyObject *py_fe;
+static PyObject *SVertex_normals_size_get(BPy_SVertex *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->sv->normalsSize());
+}
 
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-	
-	self->sv->AddFEdge( ((BPy_FEdge *) py_fe)->fe );
+PyDoc_STRVAR(SVertex_viewvertex_doc,
+"If this SVertex is also a ViewVertex, this property refers to the\n"
+"ViewVertex, and None otherwise.\n"
+":type: :class:`ViewVertex`");
 
+static PyObject *SVertex_viewvertex_get(BPy_SVertex *self, void *UNUSED(closure))
+{
+	ViewVertex *vv = self->sv->viewvertex();
+	if (vv)
+		return Any_BPy_ViewVertex_from_ViewVertex(*vv);
 	Py_RETURN_NONE;
 }
 
-static char SVertex_curvatures___doc__[] =
-".. method:: curvatures()\n"
+PyDoc_STRVAR(SVertex_curvatures_doc,
+"Curvature information expressed in the form of a seven-element tuple\n"
+"(K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values\n"
+"representing the first (maximum) and second (minimum) principal\n"
+"curvatures at this SVertex, respectively; e1 and e2 are\n"
+"three-dimensional vectors representing the first and second principal\n"
+"directions, i.e. the directions of the normal plane where the\n"
+"curvature takes its maximum and minimum values, respectively; and Kr,\n"
+"er and dKr are the radial curvature, radial direction, and the\n"
+"derivative of the radial curvature at this SVertex, repectively.\n"
 "\n"
-"   Returns curvature information in the form of a seven-element tuple\n"
-"   (K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values\n"
-"   representing the first (maximum) and second (minimum) principal\n"
-"   curvatures at this SVertex, respectively; e1 and e2 are\n"
-"   three-dimensional vectors representing the first and second principal\n"
-"   directions, i.e. the directions of the normal plane where the\n"
-"   curvature takes its maximum and minimum values, respectively; and Kr,\n"
-"   er and dKr are the radial curvature, radial direction, and the\n"
-"   derivative of the radial curvature at this SVertex, repectively.\n"
-"   :return: curvature information expressed by a seven-element tuple\n"
-"   (K1, e1, K2, e2, Kr, er, dKr).\n"
-"   :rtype: tuple\n";
-
-static PyObject *SVertex_curvatures( BPy_SVertex *self , PyObject *args) {
+":type: tuple");
+
+static PyObject *SVertex_curvatures_get(BPy_SVertex *self, void *UNUSED(closure))
+{
 	const CurvatureInfo *info = self->sv->getCurvatureInfo();
 	if (!info)
 		Py_RETURN_NONE;
@@ -261,31 +378,25 @@ static PyObject *SVertex_curvatures( BPy_SVertex *self , PyObject *args) {
 	Vec3r e2(info->e2.x(), info->e2.y(), info->e2.z());
 	Vec3r er(info->er.x(), info->er.y(), info->er.z());
 	PyObject *retval = PyTuple_New(7);
-	PyTuple_SET_ITEM( retval, 0, PyFloat_FromDouble(info->K1));
-	PyTuple_SET_ITEM( retval, 2, Vector_from_Vec3r(e1));
-	PyTuple_SET_ITEM( retval, 1, PyFloat_FromDouble(info->K2));
-	PyTuple_SET_ITEM( retval, 3, Vector_from_Vec3r(e2));
-	PyTuple_SET_ITEM( retval, 4, PyFloat_FromDouble(info->Kr));
-	PyTuple_SET_ITEM( retval, 5, Vector_from_Vec3r(er));
-	PyTuple_SET_ITEM( retval, 6, PyFloat_FromDouble(info->dKr));
+	PyTuple_SET_ITEM(retval, 0, PyFloat_FromDouble(info->K1));
+	PyTuple_SET_ITEM(retval, 2, Vector_from_Vec3r(e1));
+	PyTuple_SET_ITEM(retval, 1, PyFloat_FromDouble(info->K2));
+	PyTuple_SET_ITEM(retval, 3, Vector_from_Vec3r(e2));
+	PyTuple_SET_ITEM(retval, 4, PyFloat_FromDouble(info->Kr));
+	PyTuple_SET_ITEM(retval, 5, Vector_from_Vec3r(er));
+	PyTuple_SET_ITEM(retval, 6, PyFloat_FromDouble(info->dKr));
 	return retval;
 }
 
-// virtual bool 	operator== (const SVertex &iBrother)
-// ViewVertex * 	viewvertex ()
-
-/*----------------------SVertex instance definitions ----------------------------*/
-static PyMethodDef BPy_SVertex_methods[] = {
-	{"normals", ( PyCFunction ) SVertex_normals, METH_NOARGS, SVertex_normals___doc__},
-	{"normalsSize", ( PyCFunction ) SVertex_normalsSize, METH_NOARGS, SVertex_normalsSize___doc__},
-	{"viewvertex", ( PyCFunction ) SVertex_viewvertex, METH_NOARGS, SVertex_viewvertex___doc__},
-	{"setPoint3D", ( PyCFunction ) SVertex_setPoint3D, METH_VARARGS, SVertex_setPoint3D___doc__},
-	{"setPoint2D", ( PyCFunction ) SVertex_setPoint2D, METH_VARARGS, SVertex_setPoint2D___doc__},
-	{"AddNormal", ( PyCFunction ) SVertex_AddNormal, METH_VARARGS, SVertex_AddNormal___doc__},
-	{"setId", ( PyCFunction ) SVertex_setId, METH_VARARGS, SVertex_setId___doc__},
-	{"AddFEdge", ( PyCFunction ) SVertex_AddFEdge, METH_VARARGS, SVertex_AddFEdge___doc__},
-	{"curvatures", ( PyCFunction ) SVertex_curvatures, METH_NOARGS, SVertex_curvatures___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_SVertex_getseters[] = {
+	{(char *)"point_3d", (getter)SVertex_point_3d_get, (setter)SVertex_point_3d_set, (char *)SVertex_point_3d_doc, NULL},
+	{(char *)"point_2d", (getter)SVertex_point_2d_get, (setter)SVertex_point_2d_set, (char *)SVertex_point_2d_doc, NULL},
+	{(char *)"id", (getter)SVertex_id_get, (setter)SVertex_id_set, (char *)SVertex_id_doc, NULL},
+	{(char *)"normals", (getter)SVertex_normals_get, (setter)NULL, (char *)SVertex_normals_doc, NULL},
+	{(char *)"normals_size", (getter)SVertex_normals_size_get, (setter)NULL, (char *)SVertex_normals_size_doc, NULL},
+	{(char *)"viewvertex", (getter)SVertex_viewvertex_get, (setter)NULL, (char *)SVertex_viewvertex_doc, NULL},
+	{(char *)"curvatures", (getter)SVertex_curvatures_get, (setter)NULL, (char *)SVertex_curvatures_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_SVertex type definition ------------------------------*/
@@ -310,7 +421,7 @@ PyTypeObject SVertex_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	SVertex___doc__,                /* tp_doc */
+	SVertex_doc,                    /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -319,13 +430,13 @@ PyTypeObject SVertex_Type = {
 	0,                              /* tp_iternext */
 	BPy_SVertex_methods,            /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_SVertex_getseters,          /* tp_getset */
 	&Interface0D_Type,              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)SVertex___init__,     /* tp_init */
+	(initproc)SVertex_init,         /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
@@ -335,4 +446,3 @@ PyTypeObject SVertex_Type = {
 #ifdef __cplusplus
 }
 #endif
-
diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h
index 7d310f2b7dc..61c65659a5e 100644
--- a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h
+++ b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h
@@ -23,6 +23,10 @@ typedef struct {
 	SVertex *sv;
 } BPy_SVertex;
 
+/*---------------------------Python BPy_SVertex visible prototypes-----------*/
+
+void SVertex_mathutils_register_callback();
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __cplusplus
diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp
index c1fe6875ea7..4fabfc508db 100644
--- a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp
@@ -10,9 +10,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------ViewVertex methods----------------------------*/
 
-static char ViewVertex___doc__[] =
+PyDoc_STRVAR(ViewVertex_doc,
 "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex`\n"
 "\n"
 "Class to define a view vertex.  A view vertex is a feature vertex\n"
@@ -34,43 +34,20 @@ static char ViewVertex___doc__[] =
 "   Copy constructor.\n"
 "\n"
 "   :arg iBrother: A ViewVertex object.\n"
-"   :type iBrother: :class:`ViewVertex`\n";
+"   :type iBrother: :class:`ViewVertex`");
 
-static int ViewVertex___init__( BPy_ViewVertex *self, PyObject *args, PyObject *kwds )
-{	
-    if( !PyArg_ParseTuple(args, "") )
-        return -1;
+static int ViewVertex_init(BPy_ViewVertex *self, PyObject *args, PyObject *kwds)
+{
+	if (!PyArg_ParseTuple(args, ""))
+		return -1;
 	self->vv = 0; // ViewVertex is abstract
 	self->py_if0D.if0D = self->vv;
 	self->py_if0D.borrowed = 0;
 	return 0;
 }
 
-static char ViewVertex_setNature___doc__[] =
-".. method:: setNature(iNature)\n"
-"\n"
-"   Sets the nature of the vertex.\n"
-"\n"
-"   :arg iNature: A Nature object.\n"
-"   :type iNature: :class:`Nature`\n";
-
-static PyObject * ViewVertex_setNature( BPy_ViewVertex *self, PyObject *args ) {
-	PyObject *py_n;
-
-	if( !self->vv )
-		Py_RETURN_NONE;
-		
-	if(!( PyArg_ParseTuple(args, "O!", &Nature_Type, &py_n) ))
-		return NULL;
-	
-	PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i );
-	((ViewVertex *) self->py_if0D.if0D)->setNature( PyLong_AsLong(i) );
-
-	Py_RETURN_NONE;
-}
-
-static char ViewVertex_edgesBegin___doc__[] =
-".. method:: edgesBegin()\n"
+PyDoc_STRVAR(ViewVertex_edges_begin_doc,
+".. method:: edges_begin()\n"
 "\n"
 "   Returns an iterator over the ViewEdges that goes to or comes from\n"
 "   this ViewVertex pointing to the first ViewEdge of the list. The\n"
@@ -79,40 +56,40 @@ static char ViewVertex_edgesBegin___doc__[] =
 "   (incoming/outgoing).\n"
 "\n"
 "   :return: An orientedViewEdgeIterator pointing to the first ViewEdge.\n"
-"   :rtype: :class:`orientedViewEdgeIterator`\n";
+"   :rtype: :class:`orientedViewEdgeIterator`");
 
-static PyObject * ViewVertex_edgesBegin( BPy_ViewVertex *self ) {
-	if( !self->vv )
+static PyObject * ViewVertex_edges_begin(BPy_ViewVertex *self)
+{
+	if (!self->vv)
 		Py_RETURN_NONE;
-		
-	ViewVertexInternal::orientedViewEdgeIterator ove_it( self->vv->edgesBegin() );
-	return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator( ove_it, 0 );
+	ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesBegin());
+	return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 0);
 }
 
-static char ViewVertex_edgesEnd___doc__[] =
-".. method:: edgesEnd()\n"
+PyDoc_STRVAR(ViewVertex_edges_end_doc,
+".. method:: edges_end()\n"
 "\n"
 "   Returns an orientedViewEdgeIterator over the ViewEdges around this\n"
 "   ViewVertex, pointing after the last ViewEdge.\n"
 "\n"
 "   :return: An orientedViewEdgeIterator pointing after the last ViewEdge.\n"
-"   :rtype: :class:`orientedViewEdgeIterator`\n";
+"   :rtype: :class:`orientedViewEdgeIterator`");
 
-static PyObject * ViewVertex_edgesEnd( BPy_ViewVertex *self ) {
+static PyObject * ViewVertex_edges_end(BPy_ViewVertex *self)
+{
 #if 0
-	if( !self->vv )
+	if (!self->vv)
 		Py_RETURN_NONE;
-		
-	ViewVertexInternal::orientedViewEdgeIterator ove_it( self->vv->edgesEnd() );
-	return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator( ove_it, 1 );
+	ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesEnd());
+	return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 1);
 #else
-	PyErr_SetString(PyExc_NotImplementedError, "edgesEnd method currently disabled");
+	PyErr_SetString(PyExc_NotImplementedError, "edges_end method currently disabled");
 	return NULL;
 #endif
 }
 
-static char ViewVertex_edgesIterator___doc__[] =
-".. method:: edgesIterator(iEdge)\n"
+PyDoc_STRVAR(ViewVertex_edges_iterator_doc,
+".. method:: edges_iterator(iEdge)\n"
 "\n"
 "   Returns an orientedViewEdgeIterator pointing to the ViewEdge given\n"
 "   as argument.\n"
@@ -120,31 +97,58 @@ static char ViewVertex_edgesIterator___doc__[] =
 "   :arg iEdge: A ViewEdge object.\n"
 "   :type iEdge: :class:`ViewEdge`\n"
 "   :return: An orientedViewEdgeIterator pointing to the given ViewEdge.\n"
-"   :rtype: :class:`orientedViewEdgeIterator`\n";
+"   :rtype: :class:`orientedViewEdgeIterator`");
 
-static PyObject * ViewVertex_edgesIterator( BPy_ViewVertex *self, PyObject *args ) {
+static PyObject * ViewVertex_edges_iterator(BPy_ViewVertex *self, PyObject *args)
+{
 	PyObject *py_ve;
 
-	if( !self->vv )
+	if (!self->vv)
 		Py_RETURN_NONE;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
+	if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
 		return NULL;
-	
-	ViewEdge *ve = ((BPy_ViewEdge *) py_ve)->ve;
-	ViewVertexInternal::orientedViewEdgeIterator ove_it( self->vv->edgesIterator( ve ) );
-	return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator( ove_it, 0 );
+	ViewEdge *ve = ((BPy_ViewEdge *)py_ve)->ve;
+	ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesIterator(ve));
+	return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 0);
 }
 
-/*----------------------ViewVertex instance definitions ----------------------------*/
 static PyMethodDef BPy_ViewVertex_methods[] = {
-	{"setNature", ( PyCFunction ) ViewVertex_setNature, METH_VARARGS, ViewVertex_setNature___doc__},
-	{"edgesBegin", ( PyCFunction ) ViewVertex_edgesBegin, METH_NOARGS, ViewVertex_edgesBegin___doc__},
-	{"edgesEnd", ( PyCFunction ) ViewVertex_edgesEnd, METH_NOARGS, ViewVertex_edgesEnd___doc__},
-	{"edgesIterator", ( PyCFunction ) ViewVertex_edgesIterator, METH_VARARGS, ViewVertex_edgesIterator___doc__},
+	{"edges_begin", (PyCFunction)ViewVertex_edges_begin, METH_NOARGS, ViewVertex_edges_begin_doc},
+	{"edges_end", (PyCFunction)ViewVertex_edges_end, METH_NOARGS, ViewVertex_edges_end_doc},
+	{"edges_iterator", (PyCFunction)ViewVertex_edges_iterator, METH_VARARGS, ViewVertex_edges_iterator_doc},
 	{NULL, NULL, 0, NULL}
 };
 
+/*----------------------ViewVertex get/setters ----------------------------*/
+
+PyDoc_STRVAR(ViewVertex_nature_doc,
+"The nature of this ViewVertex.\n"
+"\n"
+":type: :class:`Nature`");
+
+static PyObject *ViewVertex_nature_get(BPy_ViewVertex *self, void *UNUSED(closure))
+{
+	Nature::VertexNature nature = self->vv->getNature();
+	if (PyErr_Occurred())
+		return NULL;
+	return BPy_Nature_from_Nature(nature); // return a copy
+}
+
+static int ViewVertex_nature_set(BPy_ViewVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Nature_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a Nature");
+		return -1;
+	}
+	self->vv->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i));
+	return 0;
+}
+
+static PyGetSetDef BPy_ViewVertex_getseters[] = {
+	{(char *)"nature", (getter)ViewVertex_nature_get, (setter)ViewVertex_nature_set, (char *)ViewVertex_nature_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
+};
+
 /*-----------------------BPy_ViewVertex type definition ------------------------------*/
 PyTypeObject ViewVertex_Type = {
 	PyVarObject_HEAD_INIT(NULL, 0)
@@ -167,7 +171,7 @@ PyTypeObject ViewVertex_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	ViewVertex___doc__,             /* tp_doc */
+	ViewVertex_doc,                 /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -176,13 +180,13 @@ PyTypeObject ViewVertex_Type = {
 	0,                              /* tp_iternext */
 	BPy_ViewVertex_methods,         /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_ViewVertex_getseters,       /* tp_getset */
 	&Interface0D_Type,              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)ViewVertex___init__,  /* tp_init */
+	(initproc)ViewVertex_init,      /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp
index ebb2920353d..a0e0717ef37 100644
--- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp
@@ -9,9 +9,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------NonTVertex methods ----------------------------*/
 
-static char NonTVertex___doc__[] =
+PyDoc_STRVAR(NonTVertex_doc,
 "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`NonTVertex`\n"
 "\n"
 "View vertex for corners, cusps, etc. associated to a single SVertex.\n"
@@ -33,21 +33,20 @@ static char NonTVertex___doc__[] =
 "   Builds a NonTVertex from a SVertex.\n"
 "\n"
 "   :arg iSVertex: An SVertex object.\n"
-"   :type iSVertex: :class:`SVertex`\n";
+"   :type iSVertex: :class:`SVertex`");
 
-static int NonTVertex___init__(BPy_NonTVertex *self, PyObject *args, PyObject *kwds)
+static int NonTVertex_init(BPy_NonTVertex *self, PyObject *args, PyObject *kwds)
 {
-
 	PyObject *obj = 0;
 
-    if (! PyArg_ParseTuple(args, "|O!", &SVertex_Type, &obj) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|O!", &SVertex_Type, &obj))
+		return -1;
 
-	if( !obj ){
+	if (!obj) {
 		self->ntv = new NonTVertex();
 
-	} else if( ((BPy_SVertex *) obj)->sv ) {
-		self->ntv = new NonTVertex( ((BPy_SVertex *) obj)->sv );
+	} else if(((BPy_SVertex *)obj)->sv) {
+		self->ntv = new NonTVertex(((BPy_SVertex *)obj)->sv);
 
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
@@ -61,47 +60,38 @@ static int NonTVertex___init__(BPy_NonTVertex *self, PyObject *args, PyObject *k
 	return 0;
 }
 
-static char NonTVertex_svertex___doc__[] =
-".. method:: svertex()\n"
-"\n"
-"   Returns the SVertex on top of which this NonTVertex is built.\n"
+static PyMethodDef BPy_NonTVertex_methods[] = {	
+	{NULL, NULL, 0, NULL}
+};
+
+/*----------------------NonTVertex get/setters ----------------------------*/
+
+PyDoc_STRVAR(NonTVertex_svertex_doc,
+"The SVertex on top of which this NonTVertex is built.\n"
 "\n"
-"   :return: The SVertex on top of which this NonTVertex is built.\n"
-"   :rtype: :class:`SVertex`\n";
+":type: :class:`SVertex`");
 
-static PyObject * NonTVertex_svertex( BPy_NonTVertex *self ) {
+static PyObject *NonTVertex_svertex_get(BPy_NonTVertex *self, void *UNUSED(closure))
+{
 	SVertex *v = self->ntv->svertex();
-	if( v ){
-		return BPy_SVertex_from_SVertex( *v );
-	}
-
+	if (v)
+		return BPy_SVertex_from_SVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char NonTVertex_setSVertex___doc__[] =
-".. method:: setSVertex(iSVertex)\n"
-"\n"
-"   Sets the SVertex on top of which this NonTVertex is built.\n"
-"\n"
-"   :arg iSVertex: The SVertex on top of which this NonTVertex is built.\n"
-"   :type iSVertex: :class:`SVertex`\n";
-
-static PyObject * NonTVertex_setSVertex( BPy_NonTVertex *self, PyObject *args) {
-	PyObject *py_sv;
-
-	if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
-		return NULL;
-
-	self->ntv->setSVertex( ((BPy_SVertex *) py_sv)->sv );
-
-	Py_RETURN_NONE;
+static int NonTVertex_svertex_set(BPy_NonTVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
+	}
+	self->ntv->setSVertex(((BPy_SVertex *)value)->sv);
+	return 0;
 }
 
-/*----------------------NonTVertex instance definitions ----------------------------*/
-static PyMethodDef BPy_NonTVertex_methods[] = {	
-	{"svertex", ( PyCFunction ) NonTVertex_svertex, METH_NOARGS, NonTVertex_svertex___doc__},
-	{"setSVertex", ( PyCFunction ) NonTVertex_setSVertex, METH_VARARGS, NonTVertex_setSVertex___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_NonTVertex_getseters[] = {
+	{(char *)"svertex", (getter)NonTVertex_svertex_get, (setter)NonTVertex_svertex_set, (char *)NonTVertex_svertex_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_NonTVertex type definition ------------------------------*/
@@ -126,7 +116,7 @@ PyTypeObject NonTVertex_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	NonTVertex___doc__,             /* tp_doc */
+	NonTVertex_doc,                 /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -135,13 +125,13 @@ PyTypeObject NonTVertex_Type = {
 	0,                              /* tp_iternext */
 	BPy_NonTVertex_methods,         /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_NonTVertex_getseters,       /* tp_getset */
 	&ViewVertex_Type,               /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)NonTVertex___init__,  /* tp_init */
+	(initproc)NonTVertex_init,      /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
index 14add743a37..55c8b64d13c 100644
--- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
@@ -12,9 +12,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------TVertex methods ----------------------------*/
 
-static char TVertex___doc__[] =
+PyDoc_STRVAR(TVertex_doc,
 "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`TVertex`\n"
 "\n"
 "Class to define a T vertex, i.e. an intersection between two edges.\n"
@@ -32,172 +32,145 @@ static char TVertex___doc__[] =
 "   Copy constructor.\n"
 "\n"
 "   :arg iBrother: A TVertex object.\n"
-"   :type iBrother: :class:`TVertex`\n";
+"   :type iBrother: :class:`TVertex`");
 
-static int TVertex___init__(BPy_TVertex *self, PyObject *args, PyObject *kwds)
+static int TVertex_init(BPy_TVertex *self, PyObject *args, PyObject *kwds)
 {
-    if( !PyArg_ParseTuple(args, "") )
-        return -1;
+	if (!PyArg_ParseTuple(args, ""))
+		return -1;
 	self->tv = new TVertex();
 	self->py_vv.vv = self->tv;
 	self->py_vv.py_if0D.if0D = self->tv;
 	self->py_vv.py_if0D.borrowed = 0;
-
 	return 0;
 }
 
-static char TVertex_frontSVertex___doc__[] =
-".. method:: frontSVertex()\n"
+PyDoc_STRVAR(TVertex_get_svertex_doc,
+".. method:: get_svertex(iFEdge)\n"
 "\n"
-"   Returns the SVertex that is closer to the viewpoint.\n"
+"   Returns the SVertex (among the 2) belonging to the given FEdge.\n"
 "\n"
-"   :return: The SVertex that is closer to the viewpoint.\n"
-"   :rtype: :class:`SVertex`\n";
+"   :arg iFEdge: An FEdge object.\n"
+"   :type iFEdge: :class:`FEdge`\n"
+"   :return: The SVertex belonging to the given FEdge.\n"
+"   :rtype: :class:`SVertex`");
 
-static PyObject * TVertex_frontSVertex( BPy_TVertex *self ) {
-	SVertex *v = self->tv->frontSVertex();
-	if( v ){
-		return BPy_SVertex_from_SVertex( *v );
-	}
+static PyObject * TVertex_get_svertex( BPy_TVertex *self, PyObject *args)
+{
+	PyObject *py_fe;
 
+	if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe))
+		return NULL;
+	SVertex *sv = self->tv->getSVertex(((BPy_FEdge *)py_fe)->fe);
+	if (sv)
+		return BPy_SVertex_from_SVertex(*sv);
 	Py_RETURN_NONE;
 }
 
-static char TVertex_backSVertex___doc__[] =
-".. method:: backSVertex()\n"
+PyDoc_STRVAR(TVertex_get_mate_doc,
+".. method:: get_mate(iEdgeA)\n"
 "\n"
-"   Returns the SVertex that is further away from the viewpoint.\n"
+"   Returns the mate edge of the ViewEdge given as argument.  If the\n"
+"   ViewEdge is frontEdgeA, frontEdgeB is returned.  If the ViewEdge is\n"
+"   frontEdgeB, frontEdgeA is returned.  Same for back edges.\n"
 "\n"
-"   :return: The SVertex that is further away from the viewpoint.\n"
-"   :rtype: :class:`SVertex`\n";
+"   :arg iEdgeA: A ViewEdge object.\n"
+"   :type iEdgeA: :class:`ViewEdge`\n"
+"   :return: The mate edge of the given ViewEdge.\n"
+"   :rtype: :class:`ViewEdge`");
 
-static PyObject * TVertex_backSVertex( BPy_TVertex *self ) {
-	SVertex *v = self->tv->backSVertex();
-	if( v ){
-		return BPy_SVertex_from_SVertex( *v );
-	}
+static PyObject * TVertex_get_mate( BPy_TVertex *self, PyObject *args)
+{
+	PyObject *py_ve;
 
+	if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
+		return NULL;
+	ViewEdge *ve = self->tv->mate(((BPy_ViewEdge *)py_ve)->ve);
+	if (ve)
+		return BPy_ViewEdge_from_ViewEdge(*ve);
 	Py_RETURN_NONE;
 }
 
-static char TVertex_setFrontSVertex___doc__[] =
-".. method:: setFrontSVertex(iFrontSVertex)\n"
-"\n"
-"   Sets the SVertex that is closer to the viewpoint.\n"
-"\n"
-"   :arg iFrontSVertex: An SVertex object.\n"
-"   :type iFrontSVertex: :class:`SVertex`\n";
-
-static PyObject * TVertex_setFrontSVertex( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_sv;
+static PyMethodDef BPy_TVertex_methods[] = {
+	{"get_svertex", (PyCFunction)TVertex_get_svertex, METH_VARARGS, TVertex_get_svertex_doc},
+	{"get_mate", (PyCFunction)TVertex_get_mate, METH_VARARGS, TVertex_get_mate_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-	if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
-		return NULL;
+/*----------------------TVertex get/setters ----------------------------*/
 
-	self->tv->setFrontSVertex( ((BPy_SVertex *) py_sv)->sv );
+PyDoc_STRVAR(TVertex_front_svertex_doc,
+"The SVertex that is closer to the viewpoint.\n"
+"\n"
+":type: :class:`SVertex`");
 
+static PyObject *TVertex_front_svertex_get(BPy_TVertex *self, void *UNUSED(closure))
+{
+	SVertex *v = self->tv->frontSVertex();
+	if (v)
+		return BPy_SVertex_from_SVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char TVertex_setBackSVertex___doc__[] =
-".. method:: setBackSVertex(iBackSVertex)\n"
-"\n"
-"   Sets the SVertex that is further away from the viewpoint.\n"
-"\n"
-"   :arg iBackSVertex: An SVertex object.\n"
-"   :type iBackSVertex: :class:`SVertex`\n";
-
-static PyObject * TVertex_setBackSVertex( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_sv;
-
-	if(!( PyArg_ParseTuple(args, "O", &SVertex_Type, &py_sv) ))
-		return NULL;
-
-	self->tv->setBackSVertex( ((BPy_SVertex *) py_sv)->sv );
-
-	Py_RETURN_NONE;
+static int TVertex_front_svertex_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
+	}
+	self->tv->setFrontSVertex(((BPy_SVertex *)value)->sv);
+	return 0;
 }
 
-static char TVertex_setId___doc__[] =
-".. method:: setId(iId)\n"
-"\n"
-"   Sets the Id.\n"
+PyDoc_STRVAR(TVertex_back_svertex_doc,
+"The SVertex that is further away from the viewpoint.\n"
 "\n"
-"   :arg iId: An Id object.\n"
-"   :type iId: :class:`Id`\n";
-
-static PyObject * TVertex_setId( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_id;
-
-	if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ))
-		return NULL;
-
-	if( ((BPy_Id *) py_id)->id )
-		self->tv->setId(*( ((BPy_Id *) py_id)->id ));
+":type: :class:`SVertex`");
 
+static PyObject *TVertex_back_svertex_get(BPy_TVertex *self, void *UNUSED(closure))
+{
+	SVertex *v = self->tv->backSVertex();
+	if (v)
+		return BPy_SVertex_from_SVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char TVertex_getSVertex___doc__[] =
-".. method:: getSVertex(iFEdge)\n"
-"\n"
-"   Returns the SVertex (among the 2) belonging to the given FEdge.\n"
-"\n"
-"   :arg iFEdge: An FEdge object.\n"
-"   :type iFEdge: :class:`FEdge`\n"
-"   :return: The SVertex belonging to the given FEdge.\n"
-"   :rtype: :class:`SVertex`\n";
-
-static PyObject * TVertex_getSVertex( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_fe;
-
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-
-	SVertex *sv = self->tv->getSVertex( ((BPy_FEdge *) py_fe)->fe );
-	if( sv ){
-		return BPy_SVertex_from_SVertex( *sv );
+static int TVertex_back_svertex_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
 	}
-
-	Py_RETURN_NONE;
+	self->tv->setBackSVertex(((BPy_SVertex *)value)->sv);
+	return 0;
 }
 
-static char TVertex_mate___doc__[] =
-".. method:: mate(iEdgeA)\n"
-"\n"
-"   Returns the mate edge of the ViewEdge given as argument.  If the\n"
-"   ViewEdge is frontEdgeA, frontEdgeB is returned.  If the ViewEdge is\n"
-"   frontEdgeB, frontEdgeA is returned.  Same for back edges.\n"
+PyDoc_STRVAR(TVertex_id_doc,
+"The Id of this TVertex.\n"
 "\n"
-"   :arg iEdgeA: A ViewEdge object.\n"
-"   :type iEdgeA: :class:`ViewEdge`\n"
-"   :return: The mate edge of the given ViewEdge.\n"
-"   :rtype: :class:`ViewEdge`\n";
+":type: :class:`Id`");
 
-static PyObject * TVertex_mate( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_ve;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
-		return NULL;
+static PyObject *TVertex_id_get(BPy_TVertex *self, void *UNUSED(closure))
+{
+	Id id(self->tv->getId());
+	return BPy_Id_from_Id(id); // return a copy
+}
 
-	ViewEdge *ve = self->tv->mate( ((BPy_ViewEdge *) py_ve)->ve );
-	if( ve ){
-		return BPy_ViewEdge_from_ViewEdge( *ve );
+static int TVertex_id_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Id_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an Id");
+		return -1;
 	}
-
-	Py_RETURN_NONE;
+	self->tv->setId(*(((BPy_Id *)value)->id));
+	return 0;
 }
 
-/*----------------------TVertex instance definitions ----------------------------*/
-static PyMethodDef BPy_TVertex_methods[] = {	
-	{"frontSVertex", ( PyCFunction ) TVertex_frontSVertex, METH_NOARGS, TVertex_frontSVertex___doc__},
-	{"backSVertex", ( PyCFunction ) TVertex_backSVertex, METH_NOARGS, TVertex_backSVertex___doc__},
-	{"setFrontSVertex", ( PyCFunction ) TVertex_setFrontSVertex, METH_VARARGS, TVertex_setFrontSVertex___doc__},
-	{"setBackSVertex", ( PyCFunction ) TVertex_setBackSVertex, METH_VARARGS, TVertex_setBackSVertex___doc__},
-	{"setId", ( PyCFunction ) TVertex_setId, METH_VARARGS, TVertex_setId___doc__},
-	{"getSVertex", ( PyCFunction ) TVertex_getSVertex, METH_VARARGS, TVertex_getSVertex___doc__},
-	{"mate", ( PyCFunction ) TVertex_mate, METH_VARARGS, TVertex_mate___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_TVertex_getseters[] = {
+	{(char *)"front_svertex", (getter)TVertex_front_svertex_get, (setter)TVertex_front_svertex_set, (char *)TVertex_front_svertex_doc, NULL},
+	{(char *)"back_svertex", (getter)TVertex_back_svertex_get, (setter)TVertex_back_svertex_set, (char *)TVertex_back_svertex_doc, NULL},
+	{(char *)"id", (getter)TVertex_id_get, (setter)TVertex_id_set, (char *)TVertex_id_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_TVertex type definition ------------------------------*/
@@ -222,7 +195,7 @@ PyTypeObject TVertex_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	TVertex___doc__,                /* tp_doc */
+	TVertex_doc,                    /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -231,13 +204,13 @@ PyTypeObject TVertex_Type = {
 	0,                              /* tp_iternext */
 	BPy_TVertex_methods,            /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_TVertex_getseters,          /* tp_getset */
 	&ViewVertex_Type,               /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)TVertex___init__,     /* tp_init */
+	(initproc)TVertex_init,         /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp
index a7b710f796b..be3d97f5f78 100644
--- a/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp
@@ -12,9 +12,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
-	
-static char FEdge___doc__[] =
+/*----------------------FEdge methods ----------------------------*/
+
+PyDoc_STRVAR(FEdge_doc,
 "Class hierarchy: :class:`Interface1D` > :class:`FEdge`\n"
 "\n"
 "Base Class for feature edges.  This FEdge can represent a silhouette,\n"
@@ -45,23 +45,23 @@ static char FEdge___doc__[] =
 "   :arg vA: The first SVertex.\n"
 "   :type vA: :class:`SVertex`\n"
 "   :arg vB: The second SVertex.\n"
-"   :type vB: :class:`SVertex`\n";
+"   :type vB: :class:`SVertex`");
 
-static int FEdge___init__(BPy_FEdge *self, PyObject *args, PyObject *kwds)
+static int FEdge_init(BPy_FEdge *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *obj1 = 0, *obj2 = 0;
 
-    if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|OO", &obj1, &obj2))
+		return -1;
 
-	if( !obj1 ){
+	if (!obj1) {
 		self->fe = new FEdge();
 
-	} else if( !obj2 && BPy_FEdge_Check(obj1) ) {
-		self->fe = new FEdge(*( ((BPy_FEdge *) obj1)->fe ));
-		
-	} else if( obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) {
-		self->fe = new FEdge( ((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *) obj2)->sv );
+	} else if(!obj2 && BPy_FEdge_Check(obj1)) {
+		self->fe = new FEdge(*(((BPy_FEdge *)obj1)->fe));
+
+	} else if(obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2)) {
+		self->fe = new FEdge(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv);
 
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
@@ -74,296 +74,234 @@ static int FEdge___init__(BPy_FEdge *self, PyObject *args, PyObject *kwds)
 	return 0;
 }
 
-static char FEdge_vertexA___doc__[] =
-".. method:: vertexA()\n"
-"\n"
-"   Returns the first SVertex.\n"
-"\n"
-"   :return: The first SVertex.\n"
-"   :rtype: :class:`SVertex`\n";
+static PyMethodDef BPy_FEdge_methods[] = {
+	{NULL, NULL, 0, NULL}
+};
 
-static PyObject * FEdge_vertexA( BPy_FEdge *self ) {	
-	SVertex *A = self->fe->vertexA();
-	if( A ){
-		return BPy_SVertex_from_SVertex( *A );
-	}
-		
-	Py_RETURN_NONE;
-}
+/*----------------------FEdge sequence protocol ----------------------------*/
 
-static char FEdge_vertexB___doc__[] =
-".. method:: vertexB()\n"
-"\n"
-"   Returns the second SVertex.\n"
-"\n"
-"   :return: The second SVertex.\n"
-"   :rtype: :class:`SVertex`\n";
+static Py_ssize_t FEdge_sq_length(BPy_FEdge *self)
+{
+	return 2;
+}
 
-static PyObject * FEdge_vertexB( BPy_FEdge *self ) {
-	SVertex *B = self->fe->vertexB();
-	if( B ){
-		return BPy_SVertex_from_SVertex( *B );
+static PyObject *FEdge_sq_item(BPy_FEdge *self, int keynum)
+{
+	if (keynum < 0)
+		keynum += FEdge_sq_length(self);
+	if (keynum == 0 || keynum == 1) {
+		SVertex *v = self->fe->operator[](keynum);
+		if (v)
+			return BPy_SVertex_from_SVertex(*v);
+		Py_RETURN_NONE;
 	}
-		
-	Py_RETURN_NONE;
+	PyErr_Format(PyExc_IndexError, "FEdge[index]: index %d out of range", keynum);
+	return NULL;
 }
 
+static PySequenceMethods BPy_FEdge_as_sequence = {
+	(lenfunc)FEdge_sq_length,     /* sq_length */
+	NULL,                         /* sq_concat */
+	NULL,                         /* sq_repeat */
+	(ssizeargfunc)FEdge_sq_item,  /* sq_item */
+	NULL,                         /* sq_slice */
+	NULL,                         /* sq_ass_item */
+	NULL,                         /* *was* sq_ass_slice */
+	NULL,                         /* sq_contains */
+	NULL,                         /* sq_inplace_concat */
+	NULL,                         /* sq_inplace_repeat */
+};
 
-static PyObject * FEdge___getitem__( BPy_FEdge *self, PyObject *args ) {
-	int i;
-
-	if(!( PyArg_ParseTuple(args, "i", &i) ))
-		return NULL;
-	if(!(i == 0 || i == 1)) {
-		PyErr_SetString(PyExc_IndexError, "index must be either 0 or 1");
-		return NULL;
-	}
-	
-	SVertex *v = self->fe->operator[](i);
-	if( v )
-		return BPy_SVertex_from_SVertex( *v );
-
-	Py_RETURN_NONE;
-}
+/*----------------------FEdge get/setters ----------------------------*/
 
-static char FEdge_nextEdge___doc__[] =
-".. method:: nextEdge()\n"
+PyDoc_STRVAR(FEdge_first_svertex_doc,
+"The first SVertex constituting this FEdge.\n"
 "\n"
-"   Returns the FEdge following this one in the ViewEdge.  If this FEdge\n"
-"   is the last of the ViewEdge, None is returned.\n"
-"\n"
-"   :return: The edge following this one in the ViewEdge.\n"
-"   :rtype: :class:`FEdge`\n";
-
-static PyObject * FEdge_nextEdge( BPy_FEdge *self ) {
-	FEdge *fe = self->fe->nextEdge();
-	if( fe )
-		return Any_BPy_FEdge_from_FEdge( *fe );
+":type: :class:`SVertex`");
 
+static PyObject *FEdge_first_svertex_get(BPy_FEdge *self, void *UNUSED(closure))
+{
+	SVertex *A = self->fe->vertexA();
+	if (A)
+		return BPy_SVertex_from_SVertex(*A);
 	Py_RETURN_NONE;
 }
 
-static char FEdge_previousEdge___doc__[] =
-".. method:: previousEdge()\n"
-"\n"
-"   Returns the FEdge preceding this one in the ViewEdge.  If this FEdge\n"
-"   is the first one of the ViewEdge, None is returned.\n"
-"\n"
-"   :return: The edge preceding this one in the ViewEdge.\n"
-"   :rtype: :class:`FEdge`\n";
-
-static PyObject * FEdge_previousEdge( BPy_FEdge *self ) {
-	FEdge *fe = self->fe->previousEdge();
-	if( fe )
-		return Any_BPy_FEdge_from_FEdge( *fe );
-
-	Py_RETURN_NONE;
+static int FEdge_first_svertex_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
+	}
+	self->fe->setVertexA(((BPy_SVertex *)value)->sv);
+	return 0;
 }
 
-static char FEdge_viewedge___doc__[] =
-".. method:: viewedge()\n"
-"\n"
-"   Returns the ViewEdge to which this FEdge belongs to.\n"
+PyDoc_STRVAR(FEdge_second_svertex_doc,
+"The second SVertex constituting this FEdge.\n"
 "\n"
-"   :return: The ViewEdge to which this FEdge belongs to.\n"
-"   :rtype: :class:`ViewEdge`\n";
-
-static PyObject * FEdge_viewedge( BPy_FEdge *self ) {
-	ViewEdge *ve = self->fe->viewedge();
-	if( ve )
-		return BPy_ViewEdge_from_ViewEdge( *ve );
+":type: :class:`SVertex`");
 
+static PyObject *FEdge_second_svertex_get(BPy_FEdge *self, void *UNUSED(closure))
+{
+	SVertex *B = self->fe->vertexB();
+	if (B)
+		return BPy_SVertex_from_SVertex(*B);
 	Py_RETURN_NONE;
 }
 
-static char FEdge_isSmooth___doc__[] =
-".. method:: isSmooth()\n"
-"\n"
-"   Returns true if this FEdge is a smooth FEdge.\n"
-"\n"
-"   :return: True if this FEdge is a smooth FEdge.\n"
-"   :rtype: bool\n";
-
-static PyObject * FEdge_isSmooth( BPy_FEdge *self ) {
-	return PyBool_from_bool( self->fe->isSmooth() );
+static int FEdge_second_svertex_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
+	}
+	self->fe->setVertexB(((BPy_SVertex *)value)->sv);
+	return 0;
 }
-	
-static char FEdge_setVertexA___doc__[] =
-".. method:: setVertexA(vA)\n"
-"\n"
-"   Sets the first SVertex.\n"
-"\n"
-"   :arg vA: An SVertex object.\n"
-"   :type vA: :class:`SVertex`\n";
-
-static PyObject *FEdge_setVertexA( BPy_FEdge *self , PyObject *args) {
-	PyObject *py_sv;
 
-	if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
-		return NULL;
-
-	self->fe->setVertexA( ((BPy_SVertex *) py_sv)->sv );
+PyDoc_STRVAR(FEdge_next_fedge_doc,
+"The FEdge following this one in the ViewEdge.  The value is None if\n"
+"this FEdge is the last of the ViewEdge.\n"
+"\n"
+":type: :class:`FEdge`");
 
+static PyObject *FEdge_next_fedge_get(BPy_FEdge *self, void *UNUSED(closure))
+{
+	FEdge *fe = self->fe->nextEdge();
+	if (fe)
+		return Any_BPy_FEdge_from_FEdge(*fe);
 	Py_RETURN_NONE;
 }
 
-static char FEdge_setVertexB___doc__[] =
-".. method:: setVertexB(vB)\n"
-"\n"
-"   Sets the second SVertex.\n"
-"\n"
-"   :arg vB: An SVertex object.\n"
-"   :type vB: :class:`SVertex`\n";
-
-static PyObject *FEdge_setVertexB( BPy_FEdge *self , PyObject *args) {
-	PyObject *py_sv;
-
-	if(!( PyArg_ParseTuple(args, "O", &py_sv) && BPy_SVertex_Check(py_sv) )) {
-		cout << "ERROR: FEdge_setVertexB" << endl;
-		Py_RETURN_NONE;
+static int FEdge_next_fedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_FEdge_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an FEdge");
+		return -1;
 	}
-
-	self->fe->setVertexB( ((BPy_SVertex *) py_sv)->sv );
-
-	Py_RETURN_NONE;
+	self->fe->setNextEdge(((BPy_FEdge *)value)->fe);
+	return 0;
 }
 
-static char FEdge_setId___doc__[] =
-".. method:: setId(id)\n"
-"\n"
-"   Sets the Id of this FEdge.\n"
+PyDoc_STRVAR(FEdge_previous_fedge_doc,
+"The FEdge preceding this one in the ViewEdge.  The value is None if\n"
+"this FEdge is the first one of the ViewEdge.\n"
 "\n"
-"   :arg id: An Id object.\n"
-"   :type id: :class:`Id`\n";
-
-static PyObject *FEdge_setId( BPy_FEdge *self , PyObject *args) {
-	PyObject *py_id;
-
-	if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ))
-		return NULL;
-
-	self->fe->setId(*( ((BPy_Id *) py_id)->id ));
+":type: :class:`FEdge`");
 
+static PyObject *FEdge_previous_fedge_get(BPy_FEdge *self, void *UNUSED(closure))
+{
+	FEdge *fe = self->fe->previousEdge();
+	if (fe)
+		return Any_BPy_FEdge_from_FEdge(*fe);
 	Py_RETURN_NONE;
 }
 
-static char FEdge_setNextEdge___doc__[] =
-".. method:: setNextEdge(iEdge)\n"
-"\n"
-"   Sets the pointer to the next FEdge.\n"
-"\n"
-"   :arg iEdge: An FEdge object.\n"
-"   :type iEdge: :class:`FEdge`\n";
-
-static PyObject *FEdge_setNextEdge( BPy_FEdge *self , PyObject *args) {
-	PyObject *py_fe;
-
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-
-	self->fe->setNextEdge( ((BPy_FEdge *) py_fe)->fe );
-
-	Py_RETURN_NONE;
+static int FEdge_previous_fedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_FEdge_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an FEdge");
+		return -1;
+	}
+	self->fe->setPreviousEdge(((BPy_FEdge *)value)->fe);
+	return 0;
 }
 
-static char FEdge_setPreviousEdge___doc__[] =
-".. method:: setPreviousEdge(iEdge)\n"
+PyDoc_STRVAR(FEdge_viewedge_doc,
+"The ViewEdge to which this FEdge belongs to.\n"
 "\n"
-"   Sets the pointer to the previous FEdge.\n"
-"\n"
-"   :arg iEdge: An FEdge object.\n"
-"   :type iEdge: :class:`FEdge`\n";
-
-static PyObject *FEdge_setPreviousEdge( BPy_FEdge *self , PyObject *args) {
-	PyObject *py_fe;
-
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-
-	self->fe->setPreviousEdge( ((BPy_FEdge *) py_fe)->fe );
+":type: :class:`ViewEdge`");
 
+static PyObject *FEdge_viewedge_get(BPy_FEdge *self, void *UNUSED(closure))
+{
+	ViewEdge *ve = self->fe->viewedge();
+	if (ve)
+		return BPy_ViewEdge_from_ViewEdge(*ve);
 	Py_RETURN_NONE;
 }
 
-static char FEdge_setNature___doc__[] =
-".. method:: setNature(iNature)\n"
-"\n"
-"   Sets the nature of this FEdge.\n"
-"\n"
-"   :arg iNature: A Nature object.\n"
-"   :type iNature: :class:`Nature`\n";
+static int FEdge_viewedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_ViewEdge_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an ViewEdge");
+		return -1;
+	}
+	self->fe->setViewEdge(((BPy_ViewEdge *)value)->ve);
+	return 0;
+}
 
-static PyObject * FEdge_setNature( BPy_FEdge *self, PyObject *args ) {
-	PyObject *py_n;
+PyDoc_STRVAR(FEdge_is_smooth_doc,
+"True if this FEdge is a smooth FEdge.\n"
+"\n"
+":type: bool");
 
-	if(!( PyArg_ParseTuple(args, "O!", &Nature_Type, &py_n) ))
-		return NULL;
-	
-	PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i );
-	self->fe->setNature( PyLong_AsLong(i) );
+static PyObject *FEdge_is_smooth_get(BPy_FEdge *self, void *UNUSED(closure))
+{
+	return PyBool_from_bool(self->fe->isSmooth());
+}
 
-	Py_RETURN_NONE;
+static int FEdge_is_smooth_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!PyBool_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be boolean");
+		return -1;
+	}
+	self->fe->setSmooth(bool_from_PyBool(value));
+	return 0;
 }
 
-static char FEdge_setViewEdge___doc__[] =
-".. method:: setViewEdge(iViewEdge)\n"
-"\n"
-"   Sets the ViewEdge to which this FEdge belongs to.\n"
+PyDoc_STRVAR(FEdge_id_doc,
+"The Id of this FEdge.\n"
 "\n"
-"   :arg iViewEdge: A ViewEdge object.\n"
-"   :type iViewEdge: :class:`ViewEdge`\n";
+":type: :class:`Id`");
 
-static PyObject * FEdge_setViewEdge( BPy_FEdge *self, PyObject *args ) {
-	PyObject *py_ve;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
-		return NULL;
-
-	ViewEdge *ve = ((BPy_ViewEdge *) py_ve)->ve;
-	self->fe->setViewEdge( ve );
+static PyObject *FEdge_id_get(BPy_FEdge *self, void *UNUSED(closure))
+{
+	Id id(self->fe->getId());
+	return BPy_Id_from_Id(id); // return a copy
+}
 
-	Py_RETURN_NONE;
+static int FEdge_id_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Id_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an Id");
+		return -1;
+	}
+	self->fe->setId(*(((BPy_Id *)value)->id));
+	return 0;
 }
 
-static char FEdge_setSmooth___doc__[] =
-".. method:: setSmooth(iFlag)\n"
-"\n"
-"   Sets the flag telling whether this FEdge is smooth or sharp.  True\n"
-"   for Smooth, false for Sharp.\n"
+PyDoc_STRVAR(FEdge_nature_doc,
+"The nature of this FEdge.\n"
 "\n"
-"   :arg iFlag: True for Smooth, false for Sharp.\n"
-"   :type iFlag: bool\n";
-
-static PyObject *FEdge_setSmooth( BPy_FEdge *self , PyObject *args) {
-	PyObject *py_b;
-
-	if(!( PyArg_ParseTuple(args, "O", &py_b) ))
-		return NULL;
+":type: :class:`Nature`");
 
-	self->fe->setSmooth( bool_from_PyBool(py_b) );
+static PyObject *FEdge_nature_get(BPy_FEdge *self, void *UNUSED(closure))
+{
+	return BPy_Nature_from_Nature(self->fe->getNature());
+}
 
-	Py_RETURN_NONE;
+static int FEdge_nature_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Nature_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a Nature");
+		return -1;
+	}
+	self->fe->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i));
+	return 0;
 }
 
-/*----------------------FEdge instance definitions ----------------------------*/
-
-static PyMethodDef BPy_FEdge_methods[] = {	
-	{"vertexA", ( PyCFunction ) FEdge_vertexA, METH_NOARGS, FEdge_vertexA___doc__},
-	{"vertexB", ( PyCFunction ) FEdge_vertexB, METH_NOARGS, FEdge_vertexB___doc__},
-	{"__getitem__", ( PyCFunction ) FEdge___getitem__, METH_VARARGS, "(int i) Returns the first SVertex if i=0, the seccond SVertex if i=1."},
-	{"nextEdge", ( PyCFunction ) FEdge_nextEdge, METH_NOARGS, FEdge_nextEdge___doc__},
-	{"previousEdge", ( PyCFunction ) FEdge_previousEdge, METH_NOARGS, FEdge_previousEdge___doc__},
-	{"viewedge", ( PyCFunction ) FEdge_viewedge, METH_NOARGS, FEdge_viewedge___doc__},
-	{"isSmooth", ( PyCFunction ) FEdge_isSmooth, METH_NOARGS, FEdge_isSmooth___doc__},
-	{"setVertexA", ( PyCFunction ) FEdge_setVertexA, METH_VARARGS, FEdge_setVertexA___doc__},
-	{"setVertexB", ( PyCFunction ) FEdge_setVertexB, METH_VARARGS, FEdge_setVertexB___doc__},
-	{"setId", ( PyCFunction ) FEdge_setId, METH_VARARGS, FEdge_setId___doc__},
-	{"setNextEdge", ( PyCFunction ) FEdge_setNextEdge, METH_VARARGS, FEdge_setNextEdge___doc__},
-	{"setPreviousEdge", ( PyCFunction ) FEdge_setPreviousEdge, METH_VARARGS, FEdge_setPreviousEdge___doc__},
-	{"setSmooth", ( PyCFunction ) FEdge_setSmooth, METH_VARARGS, FEdge_setSmooth___doc__},
-	{"setViewEdge", ( PyCFunction ) FEdge_setViewEdge, METH_VARARGS, FEdge_setViewEdge___doc__},
-	{"setNature", ( PyCFunction ) FEdge_setNature, METH_VARARGS, FEdge_setNature___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_FEdge_getseters[] = {
+	{(char *)"first_svertex", (getter)FEdge_first_svertex_get, (setter)FEdge_first_svertex_set, (char *)FEdge_first_svertex_doc, NULL},
+	{(char *)"second_svertex", (getter)FEdge_second_svertex_get, (setter)FEdge_second_svertex_set, (char *)FEdge_second_svertex_doc, NULL},
+	{(char *)"next_fedge", (getter)FEdge_next_fedge_get, (setter)FEdge_next_fedge_set, (char *)FEdge_next_fedge_doc, NULL},
+	{(char *)"previous_fedge", (getter)FEdge_previous_fedge_get, (setter)FEdge_previous_fedge_set, (char *)FEdge_previous_fedge_doc, NULL},
+	{(char *)"viewedge", (getter)FEdge_viewedge_get, (setter)FEdge_viewedge_set, (char *)FEdge_viewedge_doc, NULL},
+	{(char *)"is_smooth", (getter)FEdge_is_smooth_get, (setter)FEdge_is_smooth_set, (char *)FEdge_is_smooth_doc, NULL},
+	{(char *)"id", (getter)FEdge_id_get, (setter)FEdge_id_set, (char *)FEdge_id_doc, NULL},
+	{(char *)"nature", (getter)FEdge_nature_get, (setter)FEdge_nature_set, (char *)FEdge_nature_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_FEdge type definition ------------------------------*/
@@ -380,7 +318,7 @@ PyTypeObject FEdge_Type = {
 	0,                              /* tp_reserved */
 	0,                              /* tp_repr */
 	0,                              /* tp_as_number */
-	0,                              /* tp_as_sequence */
+	&BPy_FEdge_as_sequence,         /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
 	0,                              /* tp_hash  */
 	0,                              /* tp_call */
@@ -389,7 +327,7 @@ PyTypeObject FEdge_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	FEdge___doc__,                  /* tp_doc */
+	FEdge_doc,                      /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -398,13 +336,13 @@ PyTypeObject FEdge_Type = {
 	0,                              /* tp_iternext */
 	BPy_FEdge_methods,              /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_FEdge_getseters,            /* tp_getset */
 	&Interface1D_Type,              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)FEdge___init__,       /* tp_init */
+	(initproc)FEdge_init,           /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp
index 5b20db3a267..e5b984e41bd 100644
--- a/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp
@@ -11,9 +11,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------CurvePoint methods ----------------------------*/
 
-static char FrsCurve___doc__[] =
+PyDoc_STRVAR(FrsCurve_doc,
 "Class hierarchy: :class:`Interface1D` > :class:`Curve`\n"
 "\n"
 "Base class for curves made of CurvePoints.  :class:`SVertex` is the\n"
@@ -36,25 +36,25 @@ static char FrsCurve___doc__[] =
 "   Builds a Curve from its Id.\n"
 "\n"
 "   :arg iId: An Id object.\n"
-"   :type iId: :class:`Id`\n";
+"   :type iId: :class:`Id`");
 
-static int FrsCurve___init__(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
+static int FrsCurve_init(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
 {
 
 	PyObject *obj = 0;
 
-    if (! PyArg_ParseTuple(args, "|O", &obj) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|O", &obj))
+		return -1;
 
-	if( !obj ){
+	if (!obj) {
 		self->c = new Curve();
-		
-	} else if( BPy_FrsCurve_Check(obj) ) {
+
+	} else if (BPy_FrsCurve_Check(obj)) {
 		self->c = new Curve(*( ((BPy_FrsCurve *) obj)->c ));
-		
-	} else if( BPy_Id_Check(obj) ) {
+
+	} else if (BPy_Id_Check(obj)) {
 		self->c = new Curve(*( ((BPy_Id *) obj)->id ));
-			
+
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
 		return -1;
@@ -66,24 +66,25 @@ static int FrsCurve___init__(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
 	return 0;
 }
 
-static char FrsCurve_push_vertex_back___doc__[] =
+PyDoc_STRVAR(FrsCurve_push_vertex_back_doc,
 ".. method:: push_vertex_back(iVertex)\n"
 "\n"
 "   Adds a single vertex at the end of the Curve.\n"
 "\n"
 "   :arg iVertex: A vertex object.\n"
-"   :type iVertex: :class:`SVertex` or :class:`CurvePoint`\n";
+"   :type iVertex: :class:`SVertex` or :class:`CurvePoint`");
 
-static PyObject * FrsCurve_push_vertex_back( BPy_FrsCurve *self, PyObject *args ) {
+static PyObject * FrsCurve_push_vertex_back( BPy_FrsCurve *self, PyObject *args )
+{
 	PyObject *obj;
 
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
+	if (!PyArg_ParseTuple(args, "O", &obj))
 		return NULL;
 
-	if( BPy_CurvePoint_Check(obj) ) {
-		self->c->push_vertex_back( ((BPy_CurvePoint *) obj)->cp );
-	} else if( BPy_SVertex_Check(obj) ) {
-		self->c->push_vertex_back( ((BPy_SVertex *) obj)->sv );
+	if (BPy_CurvePoint_Check(obj)) {
+		self->c->push_vertex_back(((BPy_CurvePoint *)obj)->cp);
+	} else if (BPy_SVertex_Check(obj)) {
+		self->c->push_vertex_back(((BPy_SVertex *)obj)->sv);
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
 		return NULL;
@@ -92,24 +93,25 @@ static PyObject * FrsCurve_push_vertex_back( BPy_FrsCurve *self, PyObject *args
 	Py_RETURN_NONE;
 }
 
-static char FrsCurve_push_vertex_front___doc__[] =
+PyDoc_STRVAR(FrsCurve_push_vertex_front_doc,
 ".. method:: push_vertex_front(iVertex)\n"
 "\n"
 "   Adds a single vertex at the front of the Curve.\n"
 "\n"
 "   :arg iVertex: A vertex object.\n"
-"   :type iVertex: :class:`SVertex` or :class:`CurvePoint`\n";
+"   :type iVertex: :class:`SVertex` or :class:`CurvePoint`");
 
-static PyObject * FrsCurve_push_vertex_front( BPy_FrsCurve *self, PyObject *args ) {
+static PyObject * FrsCurve_push_vertex_front( BPy_FrsCurve *self, PyObject *args )
+{
 	PyObject *obj;
 
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
+	if (!PyArg_ParseTuple(args, "O", &obj))
 		return NULL;
 
-	if( BPy_CurvePoint_Check(obj) ) {
-		self->c->push_vertex_front( ((BPy_CurvePoint *) obj)->cp );
-	} else if( BPy_SVertex_Check(obj) ) {
-		self->c->push_vertex_front( ((BPy_SVertex *) obj)->sv );
+	if (BPy_CurvePoint_Check(obj)) {
+		self->c->push_vertex_front(((BPy_CurvePoint *)obj)->cp);
+	} else if( BPy_SVertex_Check(obj)) {
+		self->c->push_vertex_front(((BPy_SVertex *)obj)->sv);
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
 		return NULL;
@@ -118,38 +120,38 @@ static PyObject * FrsCurve_push_vertex_front( BPy_FrsCurve *self, PyObject *args
 	Py_RETURN_NONE;
 }
 
-static char FrsCurve_empty___doc__[] =
-".. method:: empty()\n"
-"\n"
-"   Returns true if the Curve doesn't have any Vertex yet.\n"
+static PyMethodDef BPy_FrsCurve_methods[] = {	
+	{"push_vertex_back", (PyCFunction)FrsCurve_push_vertex_back, METH_VARARGS, FrsCurve_push_vertex_back_doc},
+	{"push_vertex_front", (PyCFunction)FrsCurve_push_vertex_front, METH_VARARGS, FrsCurve_push_vertex_front_doc},
+	{NULL, NULL, 0, NULL}
+};
+
+/*----------------------CurvePoint get/setters ----------------------------*/
+
+PyDoc_STRVAR(FrsCurve_is_empty_doc,
+"True if the Curve doesn't have any Vertex yet.\n"
 "\n"
-"   :return: True if the Curve has no vertices.\n"
-"   :rtype: bool\n";
+":type: bool");
 
-static PyObject * FrsCurve_empty( BPy_FrsCurve *self ) {
-	return PyBool_from_bool( self->c->empty() );
+static PyObject *FrsCurve_is_empty_get(BPy_FrsCurve *self, void *UNUSED(closure))
+{
+	return PyBool_from_bool(self->c->empty());
 }
 
-static char FrsCurve_nSegments___doc__[] =
-".. method:: nSegments()\n"
+PyDoc_STRVAR(FrsCurve_segments_size_doc,
+"The number of segments in the polyline constituing the Curve.\n"
 "\n"
-"   Returns the number of segments in the polyline constituing the\n"
-"   Curve.\n"
-"\n"
-"   :return: The number of segments.\n"
-"   :rtype: int\n";
+":type: int");
 
-static PyObject * FrsCurve_nSegments( BPy_FrsCurve *self ) {
-	return PyLong_FromLong( self->c->nSegments() );
+static PyObject *FrsCurve_segments_size_get(BPy_FrsCurve *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->c->nSegments());
 }
 
-/*----------------------FrsCurve instance definitions ----------------------------*/
-static PyMethodDef BPy_FrsCurve_methods[] = {	
-	{"push_vertex_back", ( PyCFunction ) FrsCurve_push_vertex_back, METH_VARARGS, FrsCurve_push_vertex_back___doc__},
-	{"push_vertex_front", ( PyCFunction ) FrsCurve_push_vertex_front, METH_VARARGS, FrsCurve_push_vertex_front___doc__},
-	{"empty", ( PyCFunction ) FrsCurve_empty, METH_NOARGS, FrsCurve_empty___doc__},
-	{"nSegments", ( PyCFunction ) FrsCurve_nSegments, METH_NOARGS, FrsCurve_nSegments___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_FrsCurve_getseters[] = {
+	{(char *)"is_empty", (getter)FrsCurve_is_empty_get, (setter)NULL, (char *)FrsCurve_is_empty_doc, NULL},
+	{(char *)"segments_size", (getter)FrsCurve_segments_size_get, (setter)NULL, (char *)FrsCurve_segments_size_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_FrsCurve type definition ------------------------------*/
@@ -175,7 +177,7 @@ PyTypeObject FrsCurve_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	FrsCurve___doc__,               /* tp_doc */
+	FrsCurve_doc,                   /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -184,13 +186,13 @@ PyTypeObject FrsCurve_Type = {
 	0,                              /* tp_iternext */
 	BPy_FrsCurve_methods,           /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_FrsCurve_getseters,         /* tp_getset */
 	&Interface1D_Type,              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)FrsCurve___init__,    /* tp_init */
+	(initproc)FrsCurve_init,        /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp
index fe215588275..f0cc91b9a79 100644
--- a/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp
@@ -13,7 +13,7 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------Stroke methods ----------------------------*/
 
 // Stroke ()
 // template<class InputVertexIterator> Stroke (InputVertexIterator iBegin, InputVertexIterator iEnd)
@@ -21,7 +21,7 @@ extern "C" {
 // pb: - need to be able to switch representation: InputVertexIterator <=> position
 //     - is it even used ? not even in SWIG version
 
-static char Stroke___doc__[] =
+PyDoc_STRVAR(Stroke_doc,
 "Class hierarchy: :class:`Interface1D` > :class:`Stroke`\n"
 "\n"
 "Class to define a stroke.  A stroke is made of a set of 2D vertices\n"
@@ -49,25 +49,26 @@ static char Stroke___doc__[] =
 "   :arg iBegin: The iterator pointing to the first vertex.\n"
 "   :type iBegin: InputVertexIterator\n"
 "   :arg iEnd: The iterator pointing to the end of the vertex list.\n"
-"   :type iEnd: InputVertexIterator\n";
+"   :type iEnd: InputVertexIterator");
 
-static int Stroke___init__(BPy_Stroke *self, PyObject *args, PyObject *kwds)
+static int Stroke_init(BPy_Stroke *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *obj1 = NULL, *obj2 = NULL;
 
-	if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|OO", &obj1, &obj2))
+		return -1;
 
-	if( !obj1 ){
+	if (!obj1) {
 		self->s = new Stroke();
 
-	} else if ( !obj2 && BPy_Stroke_Check(obj1) ) {
-		self->s = new Stroke(*( ((BPy_Stroke *)obj1)->s ));
+	} else if (!obj2 && BPy_Stroke_Check(obj1)) {
+		self->s = new Stroke(*(((BPy_Stroke *)obj1)->s));
 
-	} else if ( obj2 ) {
+	} else if (obj2) {
 		PyErr_SetString(PyExc_TypeError,
 			"Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd) not implemented");
 		return -1;
+
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
 		return -1;
@@ -79,41 +80,30 @@ static int Stroke___init__(BPy_Stroke *self, PyObject *args, PyObject *kwds)
 	return 0;
 }
 
-static PyObject * Stroke___iter__( PyObject *self ) {
+static PyObject * Stroke_iter(PyObject *self)
+{
 	StrokeInternal::StrokeVertexIterator sv_it( ((BPy_Stroke *)self)->s->strokeVerticesBegin() );
 	return BPy_StrokeVertexIterator_from_StrokeVertexIterator( sv_it, 0 );
 }
 
-static Py_ssize_t Stroke_length( BPy_Stroke *self ) {
+static Py_ssize_t Stroke_sq_length(BPy_Stroke *self)
+{
 	return self->s->strokeVerticesSize();
 }
 
-static PyObject * Stroke_item( BPy_Stroke *self, Py_ssize_t i ) {
-	if (i < 0 || i >= (Py_ssize_t)self->s->strokeVerticesSize()) {
-		PyErr_SetString(PyExc_IndexError, "subscript index out of range");
-		return NULL;
-	}
-	return BPy_StrokeVertex_from_StrokeVertex( self->s->strokeVerticeAt(i) );
-}
-
-static PyObject * Stroke___getitem__( BPy_Stroke *self, PyObject *item ) {
-	long i;
-
-	if (!PyLong_Check(item)) {
-		PyErr_SetString(PyExc_TypeError, "subscript indices must be integers");
-		return NULL;
-	}
-	i = PyLong_AsLong(item);
-	if (i == -1 && PyErr_Occurred())
+static PyObject *Stroke_sq_item(BPy_Stroke *self, int keynum)
+{
+	if (keynum < 0)
+		keynum += Stroke_sq_length(self);
+	if (keynum < 0 || keynum >= Stroke_sq_length(self)) {
+		PyErr_Format(PyExc_IndexError, "Stroke[index]: index %d out of range", keynum);
 		return NULL;
-	if (i < 0) {
-		i += self->s->strokeVerticesSize();
 	}
-	return Stroke_item(self, i);
+	return BPy_StrokeVertex_from_StrokeVertex(self->s->strokeVerticeAt(keynum));
 }
 
-static char Stroke_ComputeSampling___doc__[] =
-".. method:: ComputeSampling(iNVertices)\n"
+PyDoc_STRVAR(Stroke_compute_sampling_doc,
+".. method:: compute_sampling(iNVertices)\n"
 "\n"
 "   Compute the sampling needed to get iNVertices vertices.  If the\n"
 "   specified number of vertices is less than the actual number of\n"
@@ -125,19 +115,19 @@ static char Stroke_ComputeSampling___doc__[] =
 "   :type iNVertices: int\n"
 "   :return: The sampling that must be used in the Resample(float)\n"
 "      method.\n"
-"   :rtype: float\n";
+"   :rtype: float");
 
-static PyObject * Stroke_ComputeSampling( BPy_Stroke *self, PyObject *args ) {	
+static PyObject * Stroke_compute_sampling(BPy_Stroke *self, PyObject *args)
+{
 	int i;
 
-	if(!( PyArg_ParseTuple(args, "i", &i)  ))
+	if (!PyArg_ParseTuple(args, "i", &i))
 		return NULL;
-
-	return PyFloat_FromDouble( self->s->ComputeSampling( i ) );
+	return PyFloat_FromDouble(self->s->ComputeSampling(i));
 }
 
-static char Stroke_Resample___doc__[] =
-".. method:: Resample(iNPoints)\n"
+PyDoc_STRVAR(Stroke_resample_doc,
+".. method:: resample(iNPoints)\n"
 "\n"
 "   Resamples the stroke so that it eventually has iNPoints.  That means\n"
 "   it is going to add iNPoints-vertices_size, if vertices_size is the\n"
@@ -147,34 +137,33 @@ static char Stroke_Resample___doc__[] =
 "   :arg iNPoints: The number of vertices we eventually want in our stroke.\n"
 "   :type iNPoints: int\n"
 "\n"
-".. method:: Resample(iSampling)\n"
+".. method:: resample(iSampling)\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 iSampling: The new sampling value.\n"
-"   :type iSampling: float\n";
+"   :type iSampling: float");
 
-static PyObject * Stroke_Resample( BPy_Stroke *self, PyObject *args ) {	
+static PyObject * Stroke_resample(BPy_Stroke *self, PyObject *args)
+{
 	PyObject *obj;
 
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
+	if (!PyArg_ParseTuple(args, "O", &obj))
 		return NULL;
-
-	if( PyLong_Check(obj) )
-		self->s->Resample( (int) PyLong_AsLong(obj) );
-	else if( PyFloat_Check(obj) )
-		self->s->Resample( (float) PyFloat_AsDouble(obj) );
-	else {
+	if (PyLong_Check(obj)) {
+		self->s->Resample((int)PyLong_AsLong(obj));
+	} else if (PyFloat_Check(obj)) {
+		self->s->Resample((float)PyFloat_AsDouble(obj));
+	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
 		return NULL;
 	}
-		
 	Py_RETURN_NONE;
 }
 
-static char Stroke_InsertVertex___doc__[] =
-".. method:: InsertVertex(iVertex, next)\n"
+PyDoc_STRVAR(Stroke_insert_vertex_doc,
+".. method:: insert_vertex(iVertex, next)\n"
 "\n"
 "   Inserts the stroke vertex iVertex in the stroke before next.  The\n"
 "   length, curvilinear abscissa are updated consequently.\n"
@@ -183,290 +172,241 @@ static char Stroke_InsertVertex___doc__[] =
 "   :type iVertex: :class:`StrokeVertex`\n"
 "   :arg next: A StrokeVertexIterator pointing to the StrokeVertex\n"
 "      before which iVertex must be inserted.\n"
-"   :type next: :class:`StrokeVertexIterator`\n";
+"   :type next: :class:`StrokeVertexIterator`");
 
-static PyObject * Stroke_InsertVertex( BPy_Stroke *self, PyObject *args ) {
+static PyObject * Stroke_insert_vertex(BPy_Stroke *self, PyObject *args)
+{
 	PyObject *py_sv = 0, *py_sv_it = 0;
 
-	if(!( PyArg_ParseTuple(args, "O!O!", &StrokeVertex_Type, &py_sv, &StrokeVertexIterator_Type, &py_sv_it) ))
+	if (!PyArg_ParseTuple(args, "O!O!", &StrokeVertex_Type, &py_sv, &StrokeVertexIterator_Type, &py_sv_it))
 		return NULL;
-
-	StrokeVertex *sv = ((BPy_StrokeVertex *) py_sv)->sv;
-	StrokeInternal::StrokeVertexIterator sv_it(*( ((BPy_StrokeVertexIterator *) py_sv_it)->sv_it ));
-	self->s->InsertVertex( sv, sv_it );
-
+	StrokeVertex *sv = ((BPy_StrokeVertex *)py_sv)->sv;
+	StrokeInternal::StrokeVertexIterator sv_it(*(((BPy_StrokeVertexIterator *)py_sv_it)->sv_it));
+	self->s->InsertVertex(sv, sv_it);
 	Py_RETURN_NONE;
 }
 
-static char Stroke_RemoveVertex___doc__[] =
-".. method:: RemoveVertex(iVertex)\n"
+PyDoc_STRVAR(Stroke_remove_vertex_doc,
+".. method:: remove_vertex(iVertex)\n"
 "\n"
 "   Removes the stroke vertex iVertex from the stroke. The length and\n"
 "   curvilinear abscissa are updated consequently.\n"
 "\n"
 "   :arg iVertex: \n"
-"   :type iVertex: :class:`StrokeVertex`\n";
+"   :type iVertex: :class:`StrokeVertex`");
 
-static PyObject * Stroke_RemoveVertex( BPy_Stroke *self, PyObject *args ) {	
+static PyObject * Stroke_remove_vertex( BPy_Stroke *self, PyObject *args )
+{
 	PyObject *py_sv;
 
-	if(!( PyArg_ParseTuple(args, "O!", &StrokeVertex_Type, &py_sv) ))
+	if (!PyArg_ParseTuple(args, "O!", &StrokeVertex_Type, &py_sv))
 		return NULL;
-
-	if( ((BPy_StrokeVertex *) py_sv)->sv )
-		self->s->RemoveVertex( ((BPy_StrokeVertex *) py_sv)->sv );
-	else {
+	if (((BPy_StrokeVertex *)py_sv)->sv) {
+		self->s->RemoveVertex(((BPy_StrokeVertex *)py_sv)->sv);
+	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
 		return NULL;
 	}
-		
 	Py_RETURN_NONE;
 }
 
-static char Stroke_UpdateLength___doc__[] =
-".. method:: UpdateLength()\n"
+PyDoc_STRVAR(Stroke_update_length_doc,
+".. method:: update_length()\n"
 "\n"
-"   Updates the 2D length of the Stroke.\n";
+"   Updates the 2D length of the Stroke.");
 
-static PyObject * Stroke_UpdateLength( BPy_Stroke *self ) {
+static PyObject * Stroke_update_length(BPy_Stroke *self)
+{
 	self->s->UpdateLength();
-
 	Py_RETURN_NONE;
 }
 
-static char Stroke_getLength2D___doc__[] =
-".. method:: getLength2D()\n"
+PyDoc_STRVAR(Stroke_stroke_vertices_begin_doc,
+".. method:: stroke_vertices_begin(t=0.0)\n"
 "\n"
-"   Returns the 2D length of the Stroke.\n"
+"   Returns a StrokeVertexIterator pointing on the first StrokeVertex of\n"
+"   the Stroke. O ne can specify a sampling value to resample the Stroke\n"
+"   on the fly if needed.\n"
 "\n"
-"   :return: the 2D length of the Stroke.\n"
-"   :rtype: float\n";
-
-static PyObject * Stroke_getLength2D( BPy_Stroke *self ) {	
-	return PyFloat_FromDouble( self->s->getLength2D() );
-}
+"   :arg t: The resampling value with which we want our Stroke to be\n"
+"      resampled.  If 0 is specified, no resampling is done.\n"
+"   :type t: float\n"
+"   :return: A StrokeVertexIterator pointing on the first StrokeVertex.\n"
+"   :rtype: :class:`StrokeVertexIterator`");
 
-static char Stroke_getMediumType___doc__[] =
-".. method:: getMediumType()\n"
-"\n"
-"   Returns the MediumType used for this Stroke.\n"
-"\n"
-"   :return: the MediumType used for this Stroke.\n"
-"   :rtype: :class:`MediumType`\n";
+static PyObject * Stroke_stroke_vertices_begin( BPy_Stroke *self , PyObject *args)
+{
+	float f = 0;
 
-static PyObject * Stroke_getMediumType( BPy_Stroke *self ) {	
-	return BPy_MediumType_from_MediumType( self->s->getMediumType() );
+	if (!PyArg_ParseTuple(args, "|f", &f))
+		return NULL;
+	StrokeInternal::StrokeVertexIterator sv_it(self->s->strokeVerticesBegin(f));
+	return BPy_StrokeVertexIterator_from_StrokeVertexIterator(sv_it, 0);
 }
 
-static char Stroke_getTextureId___doc__[] =
-".. method:: getTextureId()\n"
+PyDoc_STRVAR(Stroke_stroke_vertices_end_doc,
+".. method:: strokeVerticesEnd()\n"
 "\n"
-"   Returns the ID of the texture used to simulate th marks system for\n"
-"   this Stroke\n"
+"   Returns a StrokeVertexIterator pointing after the last StrokeVertex\n"
+"   of the Stroke.\n"
 "\n"
-"   :return: The texture ID.\n"
-"   :rtype: int\n";
+"   :return: A StrokeVertexIterator pointing after the last StrokeVertex.\n"
+"   :rtype: :class:`StrokeVertexIterator`");
 
-static PyObject * Stroke_getTextureId( BPy_Stroke *self ) {	
-	return PyLong_FromLong( self->s->getTextureId() );
+static PyObject * Stroke_stroke_vertices_end(BPy_Stroke *self)
+{
+	StrokeInternal::StrokeVertexIterator sv_it(self->s->strokeVerticesEnd());
+	return BPy_StrokeVertexIterator_from_StrokeVertexIterator(sv_it, 1);
 }
 
-static char Stroke_hasTips___doc__[] =
-".. method:: hasTips()\n"
+PyDoc_STRVAR(Stroke_stroke_vertices_size_doc,
+".. method:: stroke_vertices_size()\n"
 "\n"
-"   Returns true if this Stroke uses a texture with tips, false\n"
-"   otherwise.\n"
+"   Returns the number of StrokeVertex constituing the Stroke.\n"
 "\n"
-"   :return: True if this Stroke uses a texture with tips.\n"
-"   :rtype: bool\n";
+"   :return: The number of stroke vertices.\n"
+"   :rtype: int");
 
-static PyObject * Stroke_hasTips( BPy_Stroke *self ) {	
-	return PyBool_from_bool( self->s->hasTips() );
+static PyObject * Stroke_stroke_vertices_size(BPy_Stroke *self)
+{
+	return PyLong_FromLong(self->s->strokeVerticesSize());
 }
 
-static char Stroke_setId___doc__[] =
-".. method:: setId(id)\n"
-"\n"
-"   Sets the Id of the Stroke.\n"
-"\n"
-"   :arg id: the Id of the Stroke.\n"
-"   :type id: :class:`Id`\n";
-
-static PyObject *Stroke_setId( BPy_Stroke *self , PyObject *args) {
-	PyObject *py_id;
-
-	if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ))
-		return NULL;
-
-	self->s->setId(*( ((BPy_Id *) py_id)->id ));
+static PyMethodDef BPy_Stroke_methods[] = {	
+	{"compute_sampling", (PyCFunction)Stroke_compute_sampling, METH_VARARGS, Stroke_compute_sampling_doc},
+	{"resample", (PyCFunction)Stroke_resample, METH_VARARGS, Stroke_resample_doc},
+	{"remove_vertex", (PyCFunction)Stroke_remove_vertex, METH_VARARGS, Stroke_remove_vertex_doc},
+	{"insert_vertex", (PyCFunction)Stroke_insert_vertex, METH_VARARGS, Stroke_insert_vertex_doc},
+	{"update_length", (PyCFunction)Stroke_update_length, METH_NOARGS, Stroke_update_length_doc},
+	{"stroke_vertices_begin", (PyCFunction)Stroke_stroke_vertices_begin, METH_VARARGS, Stroke_stroke_vertices_begin_doc},
+	{"stroke_vertices_end", (PyCFunction)Stroke_stroke_vertices_end, METH_NOARGS, Stroke_stroke_vertices_end_doc},
+	{"stroke_vertices_size", (PyCFunction)Stroke_stroke_vertices_size, METH_NOARGS, Stroke_stroke_vertices_size_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-	Py_RETURN_NONE;
-}
+/*----------------------Stroke get/setters ----------------------------*/
 
-static char Stroke_setLength___doc__[] =
-".. method:: setLength(iLength)\n"
+PyDoc_STRVAR(Stroke_medium_type_doc,
+"The MediumType used for this Stroke.\n"
 "\n"
-"   Sets the 2D length of the Stroke.\n"
-"\n"
-"   :arg iLength: The 2D length of the Stroke.\n"
-"   :type iLength: float\n";
-
-static PyObject *Stroke_setLength( BPy_Stroke *self , PyObject *args) {
-	float f;
-
-	if(!( PyArg_ParseTuple(args, "f", &f) ))
-		return NULL;
+":type: :class:`MediumType`");
 
-	self->s->setLength( f );
-
-	Py_RETURN_NONE;
+static PyObject *Stroke_medium_type_get(BPy_Stroke *self, void *UNUSED(closure))
+{
+	return BPy_MediumType_from_MediumType(self->s->getMediumType());
 }
 
-static char Stroke_setMediumType___doc__[] =
-".. method:: setMediumType(iType)\n"
-"\n"
-"   Sets the medium type that must be used for this Stroke.\n"
-"\n"
-"   :arg iType: A MediumType object.\n"
-"   :type iType: :class:`MediumType`\n";
-
-static PyObject *Stroke_setMediumType( BPy_Stroke *self , PyObject *args) {
-	PyObject *py_mt;
-
-	if(!( PyArg_ParseTuple(args, "O!", &MediumType_Type, &py_mt) ))
-		return NULL;
-
-	self->s->setMediumType( MediumType_from_BPy_MediumType(py_mt) );
-
-	Py_RETURN_NONE;
+static int Stroke_medium_type_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_MediumType_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a MediumType");
+		return -1;
+	}
+	self->s->setMediumType(MediumType_from_BPy_MediumType(value));
+	return 0;
 }
 
-static char Stroke_setTextureId___doc__[] =
-".. method:: setTextureId(iId)\n"
+PyDoc_STRVAR(Stroke_texture_id_doc,
+"The ID of the texture used to simulate th marks system for this Stroke.\n"
 "\n"
-"   Sets the texture ID to be used to simulate the marks system for this\n"
-"   Stroke.\n"
-"\n"
-"   :arg iId: A texture ID.\n"
-"   :type iId: int\n";
-
-static PyObject *Stroke_setTextureId( BPy_Stroke *self , PyObject *args) {
-	unsigned int i;
+":type: int");
 
-	if(!( PyArg_ParseTuple(args, "I", &i) ))
-		return NULL;
-
-	self->s->setTextureId( i );
+static PyObject *Stroke_texture_id_get(BPy_Stroke *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong( self->s->getTextureId() );
+}
 
-	Py_RETURN_NONE;
+static int Stroke_texture_id_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure))
+{
+	unsigned int i = PyLong_AsUnsignedLong(value);
+	if(PyErr_Occurred())
+		return -1;
+	self->s->setTextureId(i);
+	return 0;
 }
 
-static char Stroke_setTips___doc__[] =
-".. method:: setTips(iTips)\n"
+PyDoc_STRVAR(Stroke_tips_doc,
+"True if this Stroke uses a texture with tips, and false otherwise.\n"
 "\n"
-"   Sets the flag telling whether this stroke is using a texture with\n"
-"   tips or not.\n"
-"\n"
-"   :arg iTips: True if this stroke uses a texture with tips.\n"
-"   :type iTips: bool\n";
-
-static PyObject *Stroke_setTips( BPy_Stroke *self , PyObject *args) {
-	PyObject *py_b;
-
-	if(!( PyArg_ParseTuple(args, "O", &py_b) ))
-		return NULL;
+":type: bool");
 
-	self->s->setTips( bool_from_PyBool(py_b) );
+static PyObject *Stroke_tips_get(BPy_Stroke *self, void *UNUSED(closure))
+{
+	return PyBool_from_bool(self->s->hasTips());
+}
 
-	Py_RETURN_NONE;
+static int Stroke_tips_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!PyBool_Check(value))
+		return -1;
+	self->s->setTips(bool_from_PyBool(value));
+	return 0;
 }
 
-static char Stroke_strokeVerticesBegin___doc__[] =
-".. method:: strokeVerticesBegin(t=0.0)\n"
+PyDoc_STRVAR(Stroke_length_2d_doc,
+"The 2D length of the Stroke.\n"
 "\n"
-"   Returns a StrokeVertexIterator pointing on the first StrokeVertex of\n"
-"   the Stroke. O ne can specify a sampling value to resample the Stroke\n"
-"   on the fly if needed.\n"
-"\n"
-"   :arg t: The resampling value with which we want our Stroke to be\n"
-"      resampled.  If 0 is specified, no resampling is done.\n"
-"   :type t: float\n"
-"   :return: A StrokeVertexIterator pointing on the first StrokeVertex.\n"
-"   :rtype: :class:`StrokeVertexIterator`\n";
-
-static PyObject * Stroke_strokeVerticesBegin( BPy_Stroke *self , PyObject *args) {
-	float f = 0;
+":type: float");
 
-	if(!( PyArg_ParseTuple(args, "|f", &f)  ))
-		return NULL;
+static PyObject *Stroke_length_2d_get(BPy_Stroke *self, void *UNUSED(closure))
+{
+	return PyFloat_FromDouble(self->s->getLength2D());
+}
 
-	StrokeInternal::StrokeVertexIterator sv_it( self->s->strokeVerticesBegin(f) );
-	return BPy_StrokeVertexIterator_from_StrokeVertexIterator( sv_it, 0 );
+static int Stroke_length_2d_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure))
+{
+	float scalar;
+	if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
+		PyErr_SetString(PyExc_TypeError, "value must be a number");
+		return -1;
+	}
+	self->s->setLength(scalar);
+	return 0;
 }
 
-static char Stroke_strokeVerticesEnd___doc__[] =
-".. method:: strokeVerticesEnd()\n"
+PyDoc_STRVAR(Stroke_id_doc,
+"The Id of this Stroke.\n"
 "\n"
-"   Returns a StrokeVertexIterator pointing after the last StrokeVertex\n"
-"   of the Stroke.\n"
-"\n"
-"   :return: A StrokeVertexIterator pointing after the last StrokeVertex.\n"
-"   :rtype: :class:`StrokeVertexIterator`\n";
+":type: :class:`Id`");
 
-static PyObject * Stroke_strokeVerticesEnd( BPy_Stroke *self ) {
-	StrokeInternal::StrokeVertexIterator sv_it( self->s->strokeVerticesEnd() );
-	return BPy_StrokeVertexIterator_from_StrokeVertexIterator( sv_it, 1 );
+static PyObject *Stroke_id_get(BPy_Stroke *self, void *UNUSED(closure))
+{
+	Id id(self->s->getId());
+	return BPy_Id_from_Id(id); // return a copy
 }
 
-static char Stroke_strokeVerticesSize___doc__[] =
-".. method:: strokeVerticesSize()\n"
-"\n"
-"   Returns the number of StrokeVertex constituing the Stroke.\n"
-"\n"
-"   :return: The number of stroke vertices.\n"
-"   :rtype: int\n";
-
-static PyObject * Stroke_strokeVerticesSize( BPy_Stroke *self ) {
-	return PyLong_FromLong( self->s->strokeVerticesSize() );
+static int Stroke_id_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Id_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an Id");
+		return -1;
+	}
+	self->s->setId(*(((BPy_Id *)value)->id));
+	return 0;
 }
-	
-/*----------------------Stroke instance definitions ----------------------------*/
 
-static PyMethodDef BPy_Stroke_methods[] = {	
-	{"__getitem__", ( PyCFunction ) Stroke___getitem__, METH_O, "(int i) Returns the i-th StrokeVertex constituting the Stroke."},
-	{"ComputeSampling", ( PyCFunction ) Stroke_ComputeSampling, METH_VARARGS, Stroke_ComputeSampling___doc__},
-	{"Resample", ( PyCFunction ) Stroke_Resample, METH_VARARGS, Stroke_Resample___doc__},
-	{"RemoveVertex", ( PyCFunction ) Stroke_RemoveVertex, METH_VARARGS, Stroke_RemoveVertex___doc__},
-	{"InsertVertex", ( PyCFunction ) Stroke_InsertVertex, METH_VARARGS, Stroke_InsertVertex___doc__},
-	{"UpdateLength", ( PyCFunction ) Stroke_UpdateLength, METH_NOARGS, Stroke_UpdateLength___doc__},
-	{"getLength2D", ( PyCFunction ) Stroke_getLength2D, METH_NOARGS, Stroke_getLength2D___doc__},
-	{"getMediumType", ( PyCFunction ) Stroke_getMediumType, METH_NOARGS, Stroke_getMediumType___doc__},
-	{"getTextureId", ( PyCFunction ) Stroke_getTextureId, METH_NOARGS, Stroke_getTextureId___doc__},
-	{"hasTips", ( PyCFunction ) Stroke_hasTips, METH_NOARGS, Stroke_hasTips___doc__},
-	{"setId", ( PyCFunction ) Stroke_setId, METH_VARARGS, Stroke_setId___doc__},
-	{"setLength", ( PyCFunction ) Stroke_setLength, METH_VARARGS, Stroke_setLength___doc__},
-	{"setMediumType", ( PyCFunction ) Stroke_setMediumType, METH_VARARGS, Stroke_setMediumType___doc__},
-	{"setTextureId", ( PyCFunction ) Stroke_setTextureId, METH_VARARGS, Stroke_setTextureId___doc__},
-	{"setTips", ( PyCFunction ) Stroke_setTips, METH_VARARGS, Stroke_setTips___doc__},
-	{"strokeVerticesBegin", ( PyCFunction ) Stroke_strokeVerticesBegin, METH_VARARGS, Stroke_strokeVerticesBegin___doc__},
-	{"strokeVerticesEnd", ( PyCFunction ) Stroke_strokeVerticesEnd, METH_NOARGS, Stroke_strokeVerticesEnd___doc__},
-	{"strokeVerticesSize", ( PyCFunction ) Stroke_strokeVerticesSize, METH_NOARGS, Stroke_strokeVerticesSize___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_Stroke_getseters[] = {
+	{(char *)"medium_type", (getter)Stroke_medium_type_get, (setter)Stroke_medium_type_set, (char *)Stroke_medium_type_doc, NULL},
+	{(char *)"texture_id", (getter)Stroke_texture_id_get, (setter)Stroke_texture_id_set, (char *)Stroke_texture_id_doc, NULL},
+	{(char *)"tips", (getter)Stroke_tips_get, (setter)Stroke_tips_set, (char *)Stroke_tips_doc, NULL},
+	{(char *)"length_2d", (getter)Stroke_length_2d_get, (setter)Stroke_length_2d_set, (char *)Stroke_length_2d_doc, NULL},
+	{(char *)"id", (getter)Stroke_id_get, (setter)Stroke_id_set, (char *)Stroke_id_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_Stroke type definition ------------------------------*/
 
-static PySequenceMethods Stroke_as_sequence = {
-	(lenfunc)Stroke_length,		/* sq_length */
-	NULL,						/* sq_concat */
-	NULL,						/* sq_repeat */
-	(ssizeargfunc)Stroke_item,	/* sq_item */
-	NULL,						/* sq_slice */
-	NULL,						/* sq_ass_item */
-	NULL,						/* sq_ass_slice */
-	NULL,						/* sq_contains */
-	NULL,						/* sq_inplace_concat */
-	NULL,						/* sq_inplace_repeat */
+static PySequenceMethods BPy_Stroke_as_sequence = {
+	(lenfunc)Stroke_sq_length,     /* sq_length */
+	NULL,                          /* sq_concat */
+	NULL,                          /* sq_repeat */
+	(ssizeargfunc)Stroke_sq_item,  /* sq_item */
+	NULL,                          /* sq_slice */
+	NULL,                          /* sq_ass_item */
+	NULL,                          /* *was* sq_ass_slice */
+	NULL,                          /* sq_contains */
+	NULL,                          /* sq_inplace_concat */
+	NULL,                          /* sq_inplace_repeat */
 };
 
 PyTypeObject Stroke_Type = {
@@ -481,7 +421,7 @@ PyTypeObject Stroke_Type = {
 	0,                              /* tp_reserved */
 	0,                              /* tp_repr */
 	0,                              /* tp_as_number */
-	&Stroke_as_sequence,            /* tp_as_sequence */
+	&BPy_Stroke_as_sequence,        /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
 	0,                              /* tp_hash  */
 	0,                              /* tp_call */
@@ -490,22 +430,22 @@ PyTypeObject Stroke_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	Stroke___doc__,                 /* tp_doc */
+	Stroke_doc,                     /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
 	0,                              /* tp_weaklistoffset */
-	(getiterfunc)Stroke___iter__,   /* tp_iter */
+	(getiterfunc)Stroke_iter,       /* tp_iter */
 	0,                              /* tp_iternext */
 	BPy_Stroke_methods,             /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_Stroke_getseters,           /* tp_getset */
 	&Interface1D_Type,              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)Stroke___init__,      /* tp_init */
+	(initproc)Stroke_init,          /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
index e35ea82ace2..8e1cb42f37c 100644
--- a/source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
@@ -14,9 +14,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
-	
-static char ViewEdge___doc__[] =
+/*----------------------ViewEdge methods ----------------------------*/
+
+PyDoc_STRVAR(ViewEdge_doc,
 "Class hierarchy: :class:`Interface1D` > :class:`ViewEdge`\n"
 "\n"
 "Class defining a ViewEdge.  A ViewEdge in an edge of the image graph.\n"
@@ -32,385 +32,267 @@ static char ViewEdge___doc__[] =
 "   Copy constructor.\n"
 "\n"
 "   :arg iBrother: A ViewEdge object.\n"
-"   :type iBrother: :class:`ViewEdge`\n";
+"   :type iBrother: :class:`ViewEdge`");
 
-static int ViewEdge___init__(BPy_ViewEdge *self, PyObject *args, PyObject *kwds)
+static int ViewEdge_init(BPy_ViewEdge *self, PyObject *args, PyObject *kwds)
 {
-    if ( !PyArg_ParseTuple(args, "") )
-        return -1;
+	if (!PyArg_ParseTuple(args, ""))
+		return -1;
 	self->ve = new ViewEdge();
 	self->py_if1D.if1D = self->ve;
 	self->py_if1D.borrowed = 0;
-
 	return 0;
 }
 
-static char ViewEdge_A___doc__[] =
-".. method:: A()\n"
-"\n"
-"   Returns the first ViewVertex.\n"
+PyDoc_STRVAR(ViewEdge_update_fedges_doc,
+".. method:: update_fedges()\n"
 "\n"
-"   :return: The first ViewVertex.\n"
-"   :rtype: :class:`ViewVertex`\n";
+"   Sets Viewedge to this for all embedded fedges.\n");
 
-static PyObject * ViewEdge_A( BPy_ViewEdge *self ) {	
-	ViewVertex *v = self->ve->A();
-	if( v ){
-		return Any_BPy_ViewVertex_from_ViewVertex( *v );
-	}
-		
+static PyObject * ViewEdge_update_fedges(BPy_ViewEdge *self)
+{
+	self->ve->UpdateFEdges();
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_B___doc__[] =
-".. method:: B()\n"
-"\n"
-"   Returns the second ViewVertex.\n"
-"\n"
-"   :return: The second ViewVertex.\n"
-"   :rtype: :class:`ViewVertex`\n";
+static PyMethodDef BPy_ViewEdge_methods[] = {
+	{"update_fedges", (PyCFunction)ViewEdge_update_fedges, METH_NOARGS, ViewEdge_update_fedges_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-static PyObject * ViewEdge_B( BPy_ViewEdge *self ) {	
-	ViewVertex *v = self->ve->B();
-	if( v ){
-		return Any_BPy_ViewVertex_from_ViewVertex( *v );
-	}
-		
-	Py_RETURN_NONE;
-}
+/*----------------------ViewEdge get/setters ----------------------------*/
 
-static char ViewEdge_fedgeA___doc__[] =
-".. method:: fedgeA()\n"
+PyDoc_STRVAR(ViewEdge_first_viewvertex_doc,
+"The first ViewVertex.\n"
 "\n"
-"   Returns the first FEdge that constitutes this ViewEdge.\n"
-"\n"
-"   :return: The first FEdge constituting this ViewEdge.\n"
-"   :rtype: :class:`FEdge`\n";
+":type: :class:`ViewVertex`");
 
-static PyObject * ViewEdge_fedgeA( BPy_ViewEdge *self ) {	
-	FEdge *A = self->ve->fedgeA();
-	if( A ){
-		return Any_BPy_FEdge_from_FEdge( *A );
-	}
-		
+static PyObject *ViewEdge_first_viewvertex_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	ViewVertex *v = self->ve->A();
+	if (v)
+		return Any_BPy_ViewVertex_from_ViewVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_fedgeB___doc__[] =
-".. method:: fedgeB()\n"
-"\n"
-"   Returns the last FEdge that constitutes this ViewEdge.\n"
-"\n"
-"   :return: The last FEdge constituting this ViewEdge.\n"
-"   :rtype: :class:`FEdge`\n";
-
-static PyObject * ViewEdge_fedgeB( BPy_ViewEdge *self ) {	
-	FEdge *B = self->ve->fedgeB();
-	if( B ){
-		return Any_BPy_FEdge_from_FEdge( *B );
-	}
-		
-	Py_RETURN_NONE;
+static int ViewEdge_first_viewvertex_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_ViewVertex_Check(value))
+		return -1;
+	self->ve->setA(((BPy_ViewVertex *)value)->vv);
+	return 0;
 }
 
-static char ViewEdge_viewShape___doc__[] =
-".. method:: viewShape()\n"
-"\n"
-"   Returns the ViewShape to which this ViewEdge belongs to.\n"
+PyDoc_STRVAR(ViewEdge_last_viewvertex_doc,
+"The second ViewVertex.\n"
 "\n"
-"   :return: The ViewShape to which this ViewEdge belongs to.\n"
-"   :rtype: :class:`ViewShape`\n";
+":type: :class:`ViewVertex`");
 
-static PyObject * ViewEdge_viewShape( BPy_ViewEdge *self ) {	
-	ViewShape *vs = self->ve->viewShape();
-	if( vs ){
-		return BPy_ViewShape_from_ViewShape( *vs );
-	}
-		
+static PyObject *ViewEdge_last_viewvertex_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	ViewVertex *v = self->ve->B();
+	if (v)
+		return Any_BPy_ViewVertex_from_ViewVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_aShape___doc__[] =
-".. method:: aShape()\n"
-"\n"
-"   Returns the shape that is occluded by the ViewShape to which this\n"
-"   ViewEdge belongs to.  If no object is occluded, None is returned.\n"
-"\n"
-"   :return: The occluded ViewShape.\n"
-"   :rtype: :class:`ViewShape`\n";
-
-static PyObject * ViewEdge_aShape( BPy_ViewEdge *self ) {	
-	ViewShape *vs = self->ve->aShape();
-	if( vs ){
-		return BPy_ViewShape_from_ViewShape( *vs );
-	}
-		
-	Py_RETURN_NONE;
+static int ViewEdge_last_viewvertex_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_ViewVertex_Check(value))
+		return -1;
+	self->ve->setB(((BPy_ViewVertex *)value)->vv);
+	return 0;
 }
 
-static char ViewEdge_isClosed___doc__[] =
-".. method:: isClosed()\n"
+PyDoc_STRVAR(ViewEdge_first_fedge_doc,
+"The first FEdge that constitutes this ViewEdge.\n"
 "\n"
-"   Tells whether this ViewEdge forms a closed loop or not.\n"
-"\n"
-"   :return: True if this ViewEdge forms a closed loop.\n"
-"   :rtype: bool\n";
+":type: :class:`FEdge`");
 
-static PyObject * ViewEdge_isClosed( BPy_ViewEdge *self ) {
-	return PyBool_from_bool( self->ve->isClosed() );	
+static PyObject *ViewEdge_first_fedge_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	FEdge *fe = self->ve->fedgeA();
+	if (fe)
+		return Any_BPy_FEdge_from_FEdge(*fe);
+	Py_RETURN_NONE;
 }
 
-static char ViewEdge_getChainingTimeStamp___doc__[] =
-".. method:: getChainingTimeStamp()\n"
-"\n"
-"   Returns the time stamp of this ViewEdge.\n"
-"\n"
-"   :return: The time stamp.\n"
-"   :rtype: int\n";
-
-static PyObject * ViewEdge_getChainingTimeStamp( BPy_ViewEdge *self ) {
-	return PyLong_FromLong( self->ve->getChainingTimeStamp() );
+static int ViewEdge_first_fedge_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_FEdge_Check(value))
+		return -1;
+	self->ve->setFEdgeA(((BPy_FEdge *)value)->fe);
+	return 0;
 }
 
-static char ViewEdge_setChainingTimeStamp___doc__[] =
-".. method:: setChainingTimeStamp(ts)\n"
+PyDoc_STRVAR(ViewEdge_last_fedge_doc,
+"The last FEdge that constitutes this ViewEdge.\n"
 "\n"
-"   Sets the time stamp value.\n"
-"\n"
-"   :arg ts: The time stamp.\n"
-"   :type ts: int\n";
-
-static PyObject * ViewEdge_setChainingTimeStamp( BPy_ViewEdge *self, PyObject *args) {
-	int timestamp = 0 ;
-
-	if( !PyArg_ParseTuple(args, "i", &timestamp) )
-		return NULL;
-	
-	self->ve->setChainingTimeStamp( timestamp );
+":type: :class:`FEdge`");
 
+static PyObject *ViewEdge_last_fedge_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	FEdge *fe = self->ve->fedgeB();
+	if (fe)
+		return Any_BPy_FEdge_from_FEdge(*fe);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_setA___doc__[] =
-".. method:: setA(iA)\n"
-"\n"
-"   Sets the first ViewVertex of the ViewEdge.\n"
-"\n"
-"   :arg iA: The first ViewVertex of the ViewEdge.\n"
-"   :type iA: :class:`ViewVertex`\n";
-
-static PyObject *ViewEdge_setA( BPy_ViewEdge *self , PyObject *args) {
-	PyObject *py_vv;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv) ))
-		return NULL;
-
-	self->ve->setA( ((BPy_ViewVertex *) py_vv)->vv );
-
-	Py_RETURN_NONE;
+static int ViewEdge_last_fedge_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_FEdge_Check(value))
+		return -1;
+	self->ve->setFEdgeB(((BPy_FEdge *)value)->fe);
+	return 0;
 }
 
-static char ViewEdge_setB___doc__[] =
-".. method:: setB(iB)\n"
-"\n"
-"   Sets the last ViewVertex of the ViewEdge.\n"
+PyDoc_STRVAR(ViewEdge_viewshape_doc,
+"The ViewShape to which this ViewEdge belongs to.\n"
 "\n"
-"   :arg iB: The last ViewVertex of the ViewEdge.\n"
-"   :type iB: :class:`ViewVertex`\n";
-
-static PyObject *ViewEdge_setB( BPy_ViewEdge *self , PyObject *args) {
-	PyObject *py_vv;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv) ))
-		return NULL;
-
-	self->ve->setB( ((BPy_ViewVertex *) py_vv)->vv );
+":type: :class:`ViewShape`");
 
+static PyObject *ViewEdge_viewshape_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{	
+	ViewShape *vs = self->ve->viewShape();
+	if (vs)
+		return BPy_ViewShape_from_ViewShape(*vs);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_setNature___doc__[] =
-".. method:: setNature(iNature)\n"
-"\n"
-"   Sets the nature of the ViewEdge.\n"
-"\n"
-"   :arg iNature: The nature of the ViewEdge.\n"
-"   :type iNature: :class:`Nature`\n";
-
-static PyObject * ViewEdge_setNature( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_n;
-
-	if(!( PyArg_ParseTuple(args, "O!", &Nature_Type, &py_n) ))
-		return NULL;
-	
-	PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i );
-	self->ve->setNature( PyLong_AsLong(i) );
-
-	Py_RETURN_NONE;
+static int ViewEdge_viewshape_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_ViewShape_Check(value))
+		return -1;
+	self->ve->setShape(((BPy_ViewShape *)value)->vs);
+	return 0;
 }
 
-static char ViewEdge_setFEdgeA___doc__[] =
-".. method:: setFEdgeA(iFEdge)\n"
-"\n"
-"   Sets the first FEdge of the ViewEdge.\n"
+PyDoc_STRVAR(ViewEdge_occludee_doc,
+"The shape that is occluded by the ViewShape to which this ViewEdge\n"
+"belongs to.  If no object is occluded, this property is set to None.\n"
 "\n"
-"   :arg iFEdge: The first FEdge of the ViewEdge.\n"
-"   :type iFEdge: :class:`FEdge`\n";
-
-static PyObject * ViewEdge_setFEdgeA( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_fe;
-
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-
-	self->ve->setFEdgeA( ((BPy_FEdge *) py_fe)->fe );
+":type: :class:`ViewShape`");
 
+static PyObject *ViewEdge_occludee_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	ViewShape *vs = self->ve->aShape();
+	if (vs)
+		return BPy_ViewShape_from_ViewShape(*vs);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_setFEdgeB___doc__[] =
-".. method:: setFEdgeB(iFEdge)\n"
-"\n"
-"   Sets the last FEdge of the ViewEdge.\n"
-"\n"
-"   :arg iFEdge: The last FEdge of the ViewEdge.\n"
-"   :type iFEdge: :class:`FEdge`\n";
-
-static PyObject * ViewEdge_setFEdgeB( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_fe;
-
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-
-	self->ve->setFEdgeB( ((BPy_FEdge *) py_fe)->fe );
-
-	Py_RETURN_NONE;
+static int ViewEdge_occludee_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_ViewShape_Check(value))
+		return -1;
+	self->ve->setaShape(((BPy_ViewShape *)value)->vs);
+	return 0;
 }
 
-static char ViewEdge_setShape___doc__[] =
-".. method:: setShape(iVShape)\n"
+PyDoc_STRVAR(ViewEdge_is_closed_doc,
+"True if this ViewEdge forms a closed loop.\n"
 "\n"
-"   Sets the ViewShape to which this ViewEdge belongs to.\n"
-"\n"
-"   :arg iVShape: The ViewShape to which this ViewEdge belongs to.\n"
-"   :type iVShape: :class:`ViewShape`\n";
-
-static PyObject * ViewEdge_setShape( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_vs;
+":type: bool");
 
-	if(!( PyArg_ParseTuple(args, "O", &ViewShape_Type, &py_vs) ))
-		return NULL;
-
-	self->ve->setShape( ((BPy_ViewShape *) py_vs)->vs );
-
-	Py_RETURN_NONE;
+static PyObject *ViewEdge_is_closed_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	return PyBool_from_bool(self->ve->isClosed());
 }
 
-static char ViewEdge_setId___doc__[] =
-".. method:: setId(id)\n"
+PyDoc_STRVAR(ViewEdge_id_doc,
+"The Id of this ViewEdge.\n"
 "\n"
-"   Sets the ViewEdge id.\n"
-"\n"
-"   :arg id: An Id object.\n"
-"   :type id: :class:`Id`\n";
-
-static PyObject * ViewEdge_setId( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_id;
+":type: :class:`Id`");
 
-	if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ))
-		return NULL;
-
-	Id id(*( ((BPy_Id *) py_id)->id ));
-	self->ve->setId( id );
+static PyObject *ViewEdge_id_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	Id id(self->ve->getId());
+	return BPy_Id_from_Id(id); // return a copy
+}
 
-	Py_RETURN_NONE;
+static int ViewEdge_id_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Id_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an Id");
+		return -1;
+	}
+	self->ve->setId(*(((BPy_Id *)value)->id));
+	return 0;
 }
 
-static char ViewEdge_UpdateFEdges___doc__[] =
-".. method:: UpdateFEdges()\n"
+PyDoc_STRVAR(ViewEdge_nature_doc,
+"The nature of this ViewEdge.\n"
 "\n"
-"   Sets Viewedge to this for all embedded fedges.\n";
+":type: :class:`Nature`");
 
-static PyObject * ViewEdge_UpdateFEdges( BPy_ViewEdge *self ) {
-	self->ve->UpdateFEdges();
+static PyObject *ViewEdge_nature_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	return BPy_Nature_from_Nature(self->ve->getNature());
+}
 
-	Py_RETURN_NONE;
+static int ViewEdge_nature_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Nature_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a Nature");
+		return -1;
+	}
+	self->ve->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i));
+	return 0;
 }
 
-static char ViewEdge_setaShape___doc__[] =
-".. method:: setaShape(iShape)\n"
+PyDoc_STRVAR(ViewEdge_qi_doc,
+"The quantitative invisibility.\n"
 "\n"
-"   Sets the occluded ViewShape.\n"
-"\n"
-"   :arg iShape: A ViewShape object.\n"
-"   :type iShape: :class:`ViewShape`\n";
-
-static PyObject * ViewEdge_setaShape( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_vs;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewShape_Type, &py_vs) ))
-		return NULL;
-
-	ViewShape *vs = ((BPy_ViewShape *) py_vs)->vs;
-	self->ve->setaShape( vs );
+":type: int");
 
-	Py_RETURN_NONE;
+static PyObject *ViewEdge_qi_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->ve->qi());
 }
 
-static char ViewEdge_setQI___doc__[] =
-".. method:: setQI(qi)\n"
-"\n"
-"   Sets the quantitative invisibility value of the ViewEdge.\n"
-"\n"
-"   :arg qi: The quantitative invisibility.\n"
-"   :type qi: int\n";
-
-static PyObject * ViewEdge_setQI( BPy_ViewEdge *self, PyObject *args ) {
+static int ViewEdge_qi_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
 	int qi;
 
-	if(!( PyArg_ParseTuple(args, "i", &qi) ))
-		return NULL;
+	if((qi = PyLong_AsLong(value)) == -1 && PyErr_Occurred())
+		return -1;
+	self->ve->setQI(qi);
+	return 0;
+}
 
-	self->ve->setQI( qi );
+PyDoc_STRVAR(ViewEdge_chaining_time_stamp_doc,
+"The time stamp of this ViewEdge.\n"
+"\n"
+":type: int");
 
-	Py_RETURN_NONE;
+static PyObject *ViewEdge_chaining_time_stamp_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->ve->getChainingTimeStamp());
 }
 
-static char ViewEdge_qi___doc__[] =
-".. method:: getChainingTimeStamp()\n"
-"\n"
-"   Returns the quantitative invisibility value of the ViewEdge.\n"
-"\n"
-"   :return: The quantitative invisibility.\n"
-"   :rtype: int\n";
+static int ViewEdge_chaining_time_stamp_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	int timestamp;
 
-static PyObject * ViewEdge_qi( BPy_ViewEdge *self ) {
-	return PyLong_FromLong( self->ve->qi() );
+	if ((timestamp = PyLong_AsLong(value)) == -1 && PyErr_Occurred())
+		return -1;
+	self->ve->setChainingTimeStamp(timestamp);
+	return 0;
 }
 
-/*----------------------ViewEdge instance definitions ----------------------------*/
-static PyMethodDef BPy_ViewEdge_methods[] = {	
-	{"A", ( PyCFunction ) ViewEdge_A, METH_NOARGS, ViewEdge_A___doc__},
-	{"B", ( PyCFunction ) ViewEdge_B, METH_NOARGS, ViewEdge_B___doc__},
-	{"fedgeA", ( PyCFunction ) ViewEdge_fedgeA, METH_NOARGS, ViewEdge_fedgeA___doc__},
-	{"fedgeB", ( PyCFunction ) ViewEdge_fedgeB, METH_NOARGS, ViewEdge_fedgeB___doc__},
-	{"viewShape", ( PyCFunction ) ViewEdge_viewShape, METH_NOARGS, ViewEdge_viewShape___doc__},
-	{"aShape", ( PyCFunction ) ViewEdge_aShape, METH_NOARGS, ViewEdge_aShape___doc__},
-	{"isClosed", ( PyCFunction ) ViewEdge_isClosed, METH_NOARGS, ViewEdge_isClosed___doc__},
-	{"getChainingTimeStamp", ( PyCFunction ) ViewEdge_getChainingTimeStamp, METH_NOARGS, ViewEdge_getChainingTimeStamp___doc__},
-	{"setChainingTimeStamp", ( PyCFunction ) ViewEdge_setChainingTimeStamp, METH_VARARGS, ViewEdge_setChainingTimeStamp___doc__},
-	{"setA", ( PyCFunction ) ViewEdge_setA, METH_VARARGS, ViewEdge_setA___doc__},
-	{"setB", ( PyCFunction ) ViewEdge_setB, METH_VARARGS, ViewEdge_setB___doc__},
-	{"setNature", ( PyCFunction ) ViewEdge_setNature, METH_VARARGS, ViewEdge_setNature___doc__},
-	{"setFEdgeA", ( PyCFunction ) ViewEdge_setFEdgeA, METH_VARARGS, ViewEdge_setFEdgeA___doc__},
-	{"setFEdgeB", ( PyCFunction ) ViewEdge_setFEdgeB, METH_VARARGS, ViewEdge_setFEdgeB___doc__},
-	{"setShape", ( PyCFunction ) ViewEdge_setShape, METH_VARARGS, ViewEdge_setShape___doc__},
-	{"setId", ( PyCFunction ) ViewEdge_setId, METH_VARARGS, ViewEdge_setId___doc__},
-	{"UpdateFEdges", ( PyCFunction ) ViewEdge_UpdateFEdges, METH_NOARGS, ViewEdge_UpdateFEdges___doc__},
-	{"setaShape", ( PyCFunction ) ViewEdge_setaShape, METH_VARARGS, ViewEdge_setaShape___doc__},
-	{"setQI", ( PyCFunction ) ViewEdge_setQI, METH_VARARGS, ViewEdge_setQI___doc__},
-	{"qi", ( PyCFunction ) ViewEdge_qi, METH_NOARGS, ViewEdge_qi___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_ViewEdge_getseters[] = {
+	{(char *)"first_viewvertex", (getter)ViewEdge_first_viewvertex_get, (setter)ViewEdge_first_viewvertex_set, (char *)ViewEdge_first_viewvertex_doc, NULL},
+	{(char *)"last_viewvertex", (getter)ViewEdge_last_viewvertex_get, (setter)ViewEdge_last_viewvertex_set, (char *)ViewEdge_last_viewvertex_doc, NULL},
+	{(char *)"first_fedge", (getter)ViewEdge_first_fedge_get, (setter)ViewEdge_first_fedge_set, (char *)ViewEdge_first_fedge_doc, NULL},
+	{(char *)"last_fedge", (getter)ViewEdge_last_fedge_get, (setter)ViewEdge_last_fedge_set, (char *)ViewEdge_last_fedge_doc, NULL},
+	{(char *)"viewshape", (getter)ViewEdge_viewshape_get, (setter)ViewEdge_viewshape_set, (char *)ViewEdge_viewshape_doc, NULL},
+	{(char *)"occludee", (getter)ViewEdge_occludee_get, (setter)ViewEdge_occludee_set, (char *)ViewEdge_occludee_doc, NULL},
+	{(char *)"is_closed", (getter)ViewEdge_is_closed_get, (setter)NULL, (char *)ViewEdge_is_closed_doc, NULL},
+	{(char *)"id", (getter)ViewEdge_id_get, (setter)ViewEdge_id_set, (char *)ViewEdge_id_doc, NULL},
+	{(char *)"nature", (getter)ViewEdge_nature_get, (setter)ViewEdge_nature_set, (char *)ViewEdge_nature_doc, NULL},
+	{(char *)"qi", (getter)ViewEdge_qi_get, (setter)ViewEdge_qi_set, (char *)ViewEdge_qi_doc, NULL},
+	{(char *)"chaining_time_stamp", (getter)ViewEdge_chaining_time_stamp_get, (setter)ViewEdge_chaining_time_stamp_set, (char *)ViewEdge_chaining_time_stamp_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_ViewEdge type definition ------------------------------*/
@@ -436,7 +318,7 @@ PyTypeObject ViewEdge_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	ViewEdge___doc__,               /* tp_doc */
+	ViewEdge_doc,                   /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -445,13 +327,13 @@ PyTypeObject ViewEdge_Type = {
 	0,                              /* tp_iternext */
 	BPy_ViewEdge_methods,           /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_ViewEdge_getseters,         /* tp_getset */
 	&Interface1D_Type,              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)ViewEdge___init__,    /* tp_init */
+	(initproc)ViewEdge_init,        /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp
index 39d644b7714..aef1086a641 100644
--- a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp
@@ -9,9 +9,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------FEdgeSharp methods ----------------------------*/
 
-static char FEdgeSharp___doc__[] =
+PyDoc_STRVAR(FEdgeSharp_doc,
 "Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSharp`\n"
 "\n"
 "Class defining a sharp FEdge.  A Sharp FEdge corresponds to an initial\n"
@@ -39,288 +39,320 @@ static char FEdgeSharp___doc__[] =
 "   :arg vA: The first SVertex object.\n"
 "   :type vA: :class:`SVertex`\n"
 "   :arg vB: The second SVertex object.\n"
-"   :type vB: :class:`SVertex`\n";
+"   :type vB: :class:`SVertex`");
 
-static int FEdgeSharp___init__(BPy_FEdgeSharp *self, PyObject *args, PyObject *kwds)
+static int FEdgeSharp_init(BPy_FEdgeSharp *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *obj1 = 0, *obj2 = 0;
 
-    if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|OO", &obj1, &obj2))
+		return -1;
 
-	if( !obj1 ){
+	if (!obj1) {
 		self->fes = new FEdgeSharp();
-		
-	} else if( !obj2 && BPy_FEdgeSharp_Check(obj1) ) {
-		self->fes = new FEdgeSharp(*( ((BPy_FEdgeSharp *) obj1)->fes ));
-		
-	} else if( obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) {
-		self->fes = new FEdgeSharp( ((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *) obj2)->sv );
+
+	} else if (!obj2 && BPy_FEdgeSharp_Check(obj1)) {
+		self->fes = new FEdgeSharp(*(((BPy_FEdgeSharp *)obj1)->fes));
+
+	} else if (obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2)) {
+		self->fes = new FEdgeSharp(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv);
 
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
 		return -1;
 	}
-
 	self->py_fe.fe = self->fes;
 	self->py_fe.py_if1D.if1D = self->fes;
 	self->py_fe.py_if1D.borrowed = 0;
-
 	return 0;
 }
 
-static char FEdgeSharp_normalA___doc__[] =
-".. method:: normalA()\n"
-"\n"
-"   Returns the normal to the face lying on the right of the FEdge.  If\n"
-"   this FEdge is a border, it has no Face on its right and therefore, no\n"
-"   normal.\n"
-"\n"
-"   :return: The normal to the face lying on the right of the FEdge.\n"
-"   :rtype: :class:`mathutils.Vector`\n";
+static PyMethodDef BPy_FEdgeSharp_methods[] = {	
+	{NULL, NULL, 0, NULL}
+};
 
-static PyObject * FEdgeSharp_normalA( BPy_FEdgeSharp *self ) {
-	Vec3r v( self->fes->normalA() );
-	return Vector_from_Vec3r( v );
-}
+/*----------------------mathutils callbacks ----------------------------*/
 
-static char FEdgeSharp_normalB___doc__[] =
-".. method:: normalB()\n"
-"\n"
-"   Returns the normal to the face lying on the left of the FEdge.\n"
-"\n"
-"   :return: The normal to the face lying on the left of the FEdge.\n"
-"   :rtype: :class:`mathutils.Vector`\n";
+/* subtype */
+#define MATHUTILS_SUBTYPE_NORMAL_A  1
+#define MATHUTILS_SUBTYPE_NORMAL_B  2
 
-static PyObject * FEdgeSharp_normalB( BPy_FEdgeSharp *self ) {
-	Vec3r v( self->fes->normalB() );
-	return Vector_from_Vec3r( v );
+static int FEdgeSharp_mathutils_check(BaseMathObject *bmo)
+{
+	if (!BPy_FEdgeSharp_Check(bmo->cb_user))
+		return -1;
+	return 0;
 }
 
-static char FEdgeSharp_aMaterialIndex___doc__[] =
-".. method:: aMaterialIndex()\n"
-"\n"
-"   Returns the index of the material of the face lying on the right of\n"
-"   the FEdge. If this FEdge is a border, it has no Face on its right and\n"
-"   therefore, no material.\n"
-"\n"
-"   :return: The index of the material of the face lying on the right of\n"
-"      the FEdge.\n"
-"   :rtype: int\n";
+static int FEdgeSharp_mathutils_get(BaseMathObject *bmo, int subtype)
+{
+	BPy_FEdgeSharp *self = (BPy_FEdgeSharp *)bmo->cb_user;
+	switch (subtype) {
+	case MATHUTILS_SUBTYPE_NORMAL_A:
+		{
+			Vec3r p(self->fes->normalA());
+			bmo->data[0] = p[0];
+			bmo->data[1] = p[1];
+			bmo->data[2] = p[2];
+		}
+		break;
+	case MATHUTILS_SUBTYPE_NORMAL_B:
+		{
+			Vec3r p(self->fes->normalB());
+			bmo->data[0] = p[0];
+			bmo->data[1] = p[1];
+			bmo->data[2] = p[2];
+		}
+		break;
+	default:
+		return -1;
+	}
+	return 0;
+}
 
-static PyObject * FEdgeSharp_aMaterialIndex( BPy_FEdgeSharp *self ) {
-	return PyLong_FromLong( self->fes->aFrsMaterialIndex() );
+static int FEdgeSharp_mathutils_set(BaseMathObject *bmo, int subtype)
+{
+	BPy_FEdgeSharp *self = (BPy_FEdgeSharp *)bmo->cb_user;
+	switch (subtype) {
+	case MATHUTILS_SUBTYPE_NORMAL_A:
+		{
+			Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]);
+			self->fes->setNormalA(p);
+		}
+		break;
+	case MATHUTILS_SUBTYPE_NORMAL_B:
+		{
+			Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]);
+			self->fes->setNormalB(p);
+		}
+		break;
+	default:
+		return -1;
+	}
+	return 0;
 }
 
-static char FEdgeSharp_bMaterialIndex___doc__[] =
-".. method:: bMaterialIndex()\n"
-"\n"
-"   Returns the index of the material of the face lying on the left of\n"
-"   the FEdge.\n"
-"\n"
-"   :return: The index of the material of the face lying on the left of\n"
-"      the FEdge.\n"
-"   :rtype: int\n";
+static int FEdgeSharp_mathutils_get_index(BaseMathObject *bmo, int subtype, int index)
+{
+	BPy_FEdgeSharp *self = (BPy_FEdgeSharp *)bmo->cb_user;
+	switch (subtype) {
+	case MATHUTILS_SUBTYPE_NORMAL_A:
+		{
+			Vec3r p(self->fes->normalA());
+			bmo->data[index] = p[index];
+		}
+		break;
+	case MATHUTILS_SUBTYPE_NORMAL_B:
+		{
+			Vec3r p(self->fes->normalB());
+			bmo->data[index] = p[index];
+		}
+		break;
+	default:
+		return -1;
+	}
+	return 0;
+}
 
-static PyObject * FEdgeSharp_bMaterialIndex( BPy_FEdgeSharp *self ) {
-	return PyLong_FromLong( self->fes->bFrsMaterialIndex() );
+static int FEdgeSharp_mathutils_set_index(BaseMathObject *bmo, int subtype, int index)
+{
+	BPy_FEdgeSharp *self = (BPy_FEdgeSharp *)bmo->cb_user;
+	switch (subtype) {
+	case MATHUTILS_SUBTYPE_NORMAL_A:
+		{
+			Vec3r p(self->fes->normalA());
+			p[index] = bmo->data[index];
+			self->fes->setNormalA(p);
+		}
+		break;
+	case MATHUTILS_SUBTYPE_NORMAL_B:
+		{
+			Vec3r p(self->fes->normalB());
+			p[index] = bmo->data[index];
+			self->fes->setNormalB(p);
+		}
+		break;
+	default:
+		return -1;
+	}
+	return 0;
 }
 
-static char FEdgeSharp_aMaterial___doc__[] =
-".. method:: aMaterial()\n"
-"\n"
-"   Returns the material of the face lying on the right of the FEdge.  If\n"
-"   this FEdge is a border, it has no Face on its right and therefore, no\n"
-"   material.\n"
-"\n"
-"   :return: The material of the face lying on the right of the FEdge.\n"
-"   :rtype: :class:`Material`\n";
+static Mathutils_Callback FEdgeSharp_mathutils_cb = {
+	FEdgeSharp_mathutils_check,
+	FEdgeSharp_mathutils_get,
+	FEdgeSharp_mathutils_set,
+	FEdgeSharp_mathutils_get_index,
+	FEdgeSharp_mathutils_set_index
+};
 
-static PyObject * FEdgeSharp_aMaterial( BPy_FEdgeSharp *self ) {
-	FrsMaterial m( self->fes->aFrsMaterial() );
-	return BPy_FrsMaterial_from_FrsMaterial(m);
+static unsigned char FEdgeSharp_mathutils_cb_index = -1;
+
+void FEdgeSharp_mathutils_register_callback()
+{
+	FEdgeSharp_mathutils_cb_index = Mathutils_RegisterCallback(&FEdgeSharp_mathutils_cb);
 }
 
-static char FEdgeSharp_bMaterial___doc__[] =
-".. method:: bMaterial()\n"
-"\n"
-"   Returns the material of the face lying on the left of the FEdge.\n"
+/*----------------------FEdgeSharp get/setters ----------------------------*/
+
+PyDoc_STRVAR(FEdgeSharp_normal_right_doc,
+"The normal to the face lying on the right of the FEdge.  If this FEdge\n"
+"is a border, it has no Face on its right and therefore no normal.\n"
 "\n"
-"   :return: The material of the face lying on the left of the FEdge.\n"
-"   :rtype: :class:`Material`\n";
+":type: :class:`mathutils.Vector`");
 
-static PyObject * FEdgeSharp_bMaterial( BPy_FEdgeSharp *self ) {
-	FrsMaterial m( self->fes->aFrsMaterial() );
-	return BPy_FrsMaterial_from_FrsMaterial(m);
+static PyObject *FEdgeSharp_normal_right_get(BPy_FEdgeSharp *self, void *UNUSED(closure))
+{
+	return Vector_CreatePyObject_cb((PyObject *)self, 3, FEdgeSharp_mathutils_cb_index, MATHUTILS_SUBTYPE_NORMAL_A);
 }
 
-static char FEdgeSharp_aFaceMark___doc__[] =
-".. method:: aFaceMark()\n"
-"\n"
-"   Returns the face mark of the face lying on the right of the FEdge.\n"
-"   If this FEdge is a border, it has no face on the right, and thus\n"
-"   false is returned.\n"
-"\n"
-"   :return: The face mark of the face lying on the right of the FEdge.\n"
-"   :rtype: bool\n";
-
-static PyObject * FEdgeSharp_aFaceMark( BPy_FEdgeSharp *self ) {
-	return PyBool_from_bool( self->fes->aFaceMark() );
+static int FEdgeSharp_normal_right_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure))
+{
+	float v[3];
+	if (!float_array_from_PyObject(value, v, 3)) {
+		PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector");
+		return -1;
+	}
+	Vec3r p(v[0], v[1], v[2]);
+	self->fes->setNormalA(p);
+	return 0;
 }
 
-static char FEdgeSharp_bFaceMark___doc__[] =
-".. method:: bFaceMark()\n"
+PyDoc_STRVAR(FEdgeSharp_normal_left_doc,
+"The normal to the face lying on the left of the FEdge.\n"
 "\n"
-"   Returns the face mark of the face lying on the left of the FEdge.\n"
-"\n"
-"   :return: The face mark of the face lying on the left of the FEdge.\n"
-"   :rtype: bool\n";
+":type: :class:`mathutils.Vector`");
 
-static PyObject * FEdgeSharp_bFaceMark( BPy_FEdgeSharp *self ) {
-	return PyBool_from_bool( self->fes->bFaceMark() );
+static PyObject *FEdgeSharp_normal_left_get(BPy_FEdgeSharp *self, void *UNUSED(closure))
+{
+	return Vector_CreatePyObject_cb((PyObject *)self, 3, FEdgeSharp_mathutils_cb_index, MATHUTILS_SUBTYPE_NORMAL_B);
 }
 
-static char FEdgeSharp_setNormalA___doc__[] =
-".. method:: setNormalA(iNormal)\n"
-"\n"
-"   Sets the normal to the face lying on the right of the FEdge.\n"
-"\n"
-"   :arg iNormal: A three-dimensional vector.\n"
-"   :type iNormal: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
-
-static PyObject * FEdgeSharp_setNormalA( BPy_FEdgeSharp *self, PyObject *args ) {
-	PyObject *obj = 0;
-
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
-		return NULL;
-	Vec3r *v = Vec3r_ptr_from_PyObject(obj);
-	if( !v ) {
-		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
-		return NULL;
+static int FEdgeSharp_normal_left_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure))
+{
+	float v[3];
+	if (!float_array_from_PyObject(value, v, 3)) {
+		PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector");
+		return -1;
 	}
-	self->fes->setNormalA( *v );
-	delete v;
-
-	Py_RETURN_NONE;
+	Vec3r p(v[0], v[1], v[2]);
+	self->fes->setNormalB(p);
+	return 0;
 }
 
-static char FEdgeSharp_setNormalB___doc__[] =
-".. method:: setNormalB(iNormal)\n"
-"\n"
-"   Sets the normal to the face lying on the left of the FEdge.\n"
+PyDoc_STRVAR(FEdgeSharp_material_index_right_doc,
+"The index of the material of the face lying on the right of the FEdge.\n"
+"If this FEdge is a border, it has no Face on its right and therefore\n"
+"no material.\n"
 "\n"
-"   :arg iNormal: A three-dimensional vector.\n"
-"   :type iNormal: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
-
-static PyObject * FEdgeSharp_setNormalB( BPy_FEdgeSharp *self, PyObject *args ) {
-	PyObject *obj = 0;
-
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
-		return NULL;
-	Vec3r *v = Vec3r_ptr_from_PyObject(obj);
-	if( !v ) {
-		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
-		return NULL;
-	}
-	self->fes->setNormalB( *v );
-	delete v;
+":type: int");
 
-	Py_RETURN_NONE;
+static PyObject *FEdgeSharp_material_index_right_get(BPy_FEdgeSharp *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->fes->aFrsMaterialIndex());
 }
 
-static char FEdgeSharp_setaMaterialIndex___doc__[] =
-".. method:: setaMaterialIndex(i)\n"
-"\n"
-"   Sets the index of the material lying on the right of the FEdge.\n"
-"\n"
-"   :arg i: A material index.\n"
-"   :type i: int\n";
+static int FEdgeSharp_material_index_right_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure))
+{
+	unsigned int i = PyLong_AsUnsignedLong(value);
+	if(PyErr_Occurred())
+		return -1;
+	self->fes->setaFrsMaterialIndex(i);
+	return 0;
+}
 
-static PyObject * FEdgeSharp_setaMaterialIndex( BPy_FEdgeSharp *self, PyObject *args ) {
-	unsigned int i;
+PyDoc_STRVAR(FEdgeSharp_material_index_left_doc,
+"The index of the material of the face lying on the left of the FEdge.\n"
+"\n"
+":type: int");
 
-	if(!( PyArg_ParseTuple(args, "I", &i) ))
-		return NULL;
-	
-	self->fes->setaFrsMaterialIndex( i );
+static PyObject *FEdgeSharp_material_index_left_get(BPy_FEdgeSharp *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->fes->aFrsMaterialIndex());
+}
 
-	Py_RETURN_NONE;
+static int FEdgeSharp_material_index_left_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure))
+{
+	unsigned int i = PyLong_AsUnsignedLong(value);
+	if(PyErr_Occurred())
+		return -1;
+	self->fes->setbFrsMaterialIndex(i);
+	return 0;
 }
 
-static char FEdgeSharp_setbMaterialIndex___doc__[] =
-".. method:: setbMaterialIndex(i)\n"
+PyDoc_STRVAR(FEdgeSharp_material_right_doc,
+"The material of the face lying on the right of the FEdge.  If this FEdge\n"
+"is a border, it has no Face on its right and therefore no material.\n"
 "\n"
-"   Sets the index of the material lying on the left of the FEdge.\n"
-"\n"
-"   :arg i: A material index.\n"
-"   :type i: int\n";
+":type: :class:`Material`");
 
-static PyObject * FEdgeSharp_setbMaterialIndex( BPy_FEdgeSharp *self, PyObject *args ) {
-	unsigned int i;
+static PyObject *FEdgeSharp_material_right_get(BPy_FEdgeSharp *self, void *UNUSED(closure))
+{
+	// FIXME aFrsMaterial() returns a const reference.
+	FrsMaterial m(self->fes->aFrsMaterial());
+	return BPy_FrsMaterial_from_FrsMaterial(m);
+}
 
-	if(!( PyArg_ParseTuple(args, "I", &i) ))
-		return NULL;
-	
-	self->fes->setbFrsMaterialIndex( i );
+PyDoc_STRVAR(FEdgeSharp_material_left_doc,
+"The material of the face lying on the left of the FEdge.\n"
+"\n"
+":type: :class:`Material`");
 
-	Py_RETURN_NONE;
+static PyObject *FEdgeSharp_material_left_get(BPy_FEdgeSharp *self, void *UNUSED(closure))
+{
+	// FIXME bFrsMaterial() returns a const reference.
+	FrsMaterial m(self->fes->bFrsMaterial());
+	return BPy_FrsMaterial_from_FrsMaterial(m);
 }
 
-static char FEdgeSharp_setaFaceMark___doc__[] =
-".. method:: setaFaceMark(i)\n"
-"\n"
-"   Sets the face mark of the face lying on the right of the FEdge.\n"
+PyDoc_STRVAR(FEdgeSharp_face_mark_right_doc,
+"The face mark of the face lying on the right of the FEdge.  If this FEdge\n"
+"is a border, it has no face on the right and thus this property is set to\n"
+"false.\n"
 "\n"
-"   :arg i: A face mark.\n"
-"   :type i: bool\n";
+":type: bool");
 
-static PyObject * FEdgeSharp_setaFaceMark( BPy_FEdgeSharp *self, PyObject *args ) {
-	PyObject *obj;
-
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
-		return NULL;
-	
-	self->fes->setaFaceMark( bool_from_PyBool(obj) );
+static PyObject *FEdgeSharp_face_mark_right_get(BPy_FEdgeSharp *self, void *UNUSED(closure))
+{
+	return PyBool_from_bool(self->fes->aFaceMark());
+}
 
-	Py_RETURN_NONE;
+static int FEdgeSharp_face_mark_right_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!PyBool_Check(value))
+		return -1;
+	self->fes->setaFaceMark(bool_from_PyBool(value));
+	return 0;
 }
 
-static char FEdgeSharp_setbFaceMark___doc__[] =
-".. method:: setbFaceMark(i)\n"
+PyDoc_STRVAR(FEdgeSharp_face_mark_left_doc,
+"The face mark of the face lying on the left of the FEdge.\n"
 "\n"
-"   Sets the face mark of the face lying on the left of the FEdge.\n"
-"\n"
-"   :arg i: A face mark.\n"
-"   :type i: bool\n";
-
-static PyObject * FEdgeSharp_setbFaceMark( BPy_FEdgeSharp *self, PyObject *args ) {
-	PyObject *obj;
+":type: bool");
 
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
-		return NULL;
-	
-	self->fes->setbFaceMark( bool_from_PyBool(obj) );
+static PyObject *FEdgeSharp_face_mark_left_get(BPy_FEdgeSharp *self, void *UNUSED(closure))
+{
+	return PyBool_from_bool(self->fes->bFaceMark());
+}
 
-	Py_RETURN_NONE;
+static int FEdgeSharp_face_mark_left_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!PyBool_Check(value))
+		return -1;
+	self->fes->setbFaceMark(bool_from_PyBool(value));
+	return 0;
 }
 
-/*----------------------FEdgeSharp instance definitions ----------------------------*/
-static PyMethodDef BPy_FEdgeSharp_methods[] = {	
-	{"normalA", ( PyCFunction ) FEdgeSharp_normalA, METH_NOARGS, FEdgeSharp_normalA___doc__},
-	{"normalB", ( PyCFunction ) FEdgeSharp_normalB, METH_NOARGS, FEdgeSharp_normalB___doc__},
-	{"aMaterialIndex", ( PyCFunction ) FEdgeSharp_aMaterialIndex, METH_NOARGS, FEdgeSharp_aMaterialIndex___doc__},
-	{"bMaterialIndex", ( PyCFunction ) FEdgeSharp_bMaterialIndex, METH_NOARGS, FEdgeSharp_bMaterialIndex___doc__},
-	{"aMaterial", ( PyCFunction ) FEdgeSharp_aMaterial, METH_NOARGS, FEdgeSharp_aMaterial___doc__},
-	{"bMaterial", ( PyCFunction ) FEdgeSharp_bMaterial, METH_NOARGS, FEdgeSharp_bMaterial___doc__},
-	{"aFaceMark", ( PyCFunction ) FEdgeSharp_aFaceMark, METH_NOARGS, FEdgeSharp_aFaceMark___doc__},
-	{"bFaceMark", ( PyCFunction ) FEdgeSharp_bFaceMark, METH_NOARGS, FEdgeSharp_bFaceMark___doc__},
-	{"setNormalA", ( PyCFunction ) FEdgeSharp_setNormalA, METH_VARARGS, FEdgeSharp_setNormalA___doc__},
-	{"setNormalB", ( PyCFunction ) FEdgeSharp_setNormalB, METH_VARARGS, FEdgeSharp_setNormalB___doc__},
-	{"setaMaterialIndex", ( PyCFunction ) FEdgeSharp_setaMaterialIndex, METH_VARARGS, FEdgeSharp_setaMaterialIndex___doc__},
-	{"setbMaterialIndex", ( PyCFunction ) FEdgeSharp_setbMaterialIndex, METH_VARARGS, FEdgeSharp_setbMaterialIndex___doc__},
-	{"setaFaceMark", ( PyCFunction ) FEdgeSharp_setaFaceMark, METH_NOARGS, FEdgeSharp_setaFaceMark___doc__},
-	{"setbFaceMark", ( PyCFunction ) FEdgeSharp_setbFaceMark, METH_NOARGS, FEdgeSharp_setbFaceMark___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_FEdgeSharp_getseters[] = {
+	{(char *)"normal_right", (getter)FEdgeSharp_normal_right_get, (setter)FEdgeSharp_normal_right_set, (char *)FEdgeSharp_normal_right_doc, NULL},
+	{(char *)"normal_left", (getter)FEdgeSharp_normal_left_get, (setter)FEdgeSharp_normal_left_set, (char *)FEdgeSharp_normal_left_doc, NULL},
+	{(char *)"material_index_right", (getter)FEdgeSharp_material_index_right_get, (setter)FEdgeSharp_material_index_right_set, (char *)FEdgeSharp_material_index_right_doc, NULL},
+	{(char *)"material_index_left", (getter)FEdgeSharp_material_index_left_get, (setter)FEdgeSharp_material_index_left_set, (char *)FEdgeSharp_material_index_left_doc, NULL},
+	{(char *)"material_right", (getter)FEdgeSharp_material_right_get, (setter)NULL, (char *)FEdgeSharp_material_right_doc, NULL},
+	{(char *)"material_left", (getter)FEdgeSharp_material_left_get, (setter)NULL, (char *)FEdgeSharp_material_left_doc, NULL},
+	{(char *)"face_mark_right", (getter)FEdgeSharp_face_mark_right_get, (setter)FEdgeSharp_face_mark_right_set, (char *)FEdgeSharp_face_mark_right_doc, NULL},
+	{(char *)"face_mark_left", (getter)FEdgeSharp_face_mark_left_get, (setter)FEdgeSharp_face_mark_left_set, (char *)FEdgeSharp_face_mark_left_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_FEdgeSharp type definition ------------------------------*/
@@ -346,7 +378,7 @@ PyTypeObject FEdgeSharp_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	FEdgeSharp___doc__,             /* tp_doc */
+	FEdgeSharp_doc,                 /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -355,13 +387,13 @@ PyTypeObject FEdgeSharp_Type = {
 	0,                              /* tp_iternext */
 	BPy_FEdgeSharp_methods,         /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_FEdgeSharp_getseters,       /* tp_getset */
 	&FEdge_Type,                    /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)FEdgeSharp___init__,  /* tp_init */
+	(initproc)FEdgeSharp_init,      /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h
index 84b01e27c21..b0e35395b66 100644
--- a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h
+++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h
@@ -22,6 +22,10 @@ typedef struct {
 	FEdgeSharp *fes;
 } BPy_FEdgeSharp;
 
+/*---------------------------Python BPy_FEdgeSharp visible prototypes-----------*/
+
+void FEdgeSharp_mathutils_register_callback();
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __cplusplus
diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp
index 3ddb4d060de..abda2ca1179 100644
--- a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp
@@ -9,9 +9,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------FEdgeSmooth methods ----------------------------*/
 
-static char FEdgeSmooth___doc__[] =
+PyDoc_STRVAR(FEdgeSmooth_doc,
 "Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSmooth`\n"
 "\n"
 "Class defining a smooth edge.  This kind of edge typically runs across\n"
@@ -36,23 +36,23 @@ static char FEdgeSmooth___doc__[] =
 "   :arg vA: The first SVertex object.\n"
 "   :type vA: :class:`SVertex`\n"
 "   :arg vB: The second SVertex object.\n"
-"   :type vB: :class:`SVertex`\n";
+"   :type vB: :class:`SVertex`");
 
-static int FEdgeSmooth___init__(BPy_FEdgeSmooth *self, PyObject *args, PyObject *kwds)
+static int FEdgeSmooth_init(BPy_FEdgeSmooth *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *obj1 = 0, *obj2 = 0;
 
-    if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|OO", &obj1, &obj2))
+		return -1;
 
-	if( !obj1 ){
+	if (!obj1) {
 		self->fes = new FEdgeSmooth();
-		
-	} else if( !obj2 && BPy_FEdgeSmooth_Check(obj1) ) {
-		self->fes = new FEdgeSmooth(*( ((BPy_FEdgeSmooth *) obj1)->fes ));
-		
-	} else if( obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) {
-		self->fes = new FEdgeSmooth( ((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *) obj2)->sv );
+
+	} else if (!obj2 && BPy_FEdgeSmooth_Check(obj1)) {
+		self->fes = new FEdgeSmooth(*(((BPy_FEdgeSmooth *)obj1)->fes));
+
+	} else if (obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2)) {
+		self->fes = new FEdgeSmooth(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv);
 
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
@@ -66,128 +66,148 @@ static int FEdgeSmooth___init__(BPy_FEdgeSmooth *self, PyObject *args, PyObject
 	return 0;
 }
 
-static char FEdgeSmooth_normal___doc__[] =
-".. method:: normal()\n"
-"\n"
-"   Returns the normal to the Face it is running accross.\n"
-"\n"
-"   :return: The normal to the Face it is running accross.\n"
-"   :rtype: :class:`mathutils.Vector`\n";
+static PyMethodDef BPy_FEdgeSmooth_methods[] = {
+	{NULL, NULL, 0, NULL}
+};
+
+/*----------------------mathutils callbacks ----------------------------*/
 
-static PyObject * FEdgeSmooth_normal( BPy_FEdgeSmooth *self ) {
-	Vec3r v( self->fes->normal() );
-	return Vector_from_Vec3r( v );
+static int FEdgeSmooth_mathutils_check(BaseMathObject *bmo)
+{
+	if (!BPy_FEdgeSmooth_Check(bmo->cb_user))
+		return -1;
+	return 0;
 }
 
-static char FEdgeSmooth_materialIndex___doc__[] =
-".. method:: materialIndex()\n"
-"\n"
-"   Returns the index of the material of the face it is running accross.\n"
-"\n"
-"   :return: The index of the material of the face it is running accross.\n"
-"   :rtype: int\n";
+static int FEdgeSmooth_mathutils_get(BaseMathObject *bmo, int subtype)
+{
+	BPy_FEdgeSmooth *self = (BPy_FEdgeSmooth *)bmo->cb_user;
+	Vec3r p(self->fes->normal());
+	bmo->data[0] = p[0];
+	bmo->data[1] = p[1];
+	bmo->data[2] = p[2];
+	return 0;
+}
 
-static PyObject * FEdgeSmooth_materialIndex( BPy_FEdgeSmooth *self ) {
-	return PyLong_FromLong( self->fes->frs_materialIndex() );
+static int FEdgeSmooth_mathutils_set(BaseMathObject *bmo, int subtype)
+{
+	BPy_FEdgeSmooth *self = (BPy_FEdgeSmooth *)bmo->cb_user;
+	Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]);
+	self->fes->setNormal(p);
+	return 0;
 }
 
-static char FEdgeSmooth_material___doc__[] =
-".. method:: material()\n"
-"\n"
-"   Returns the material of the face it is running accross.\n"
-"\n"
-"   :return: The material of the face it is running accross.\n"
-"   :rtype: :class:`Material`\n";
+static int FEdgeSmooth_mathutils_get_index(BaseMathObject *bmo, int subtype, int index)
+{
+	BPy_FEdgeSmooth *self = (BPy_FEdgeSmooth *)bmo->cb_user;
+	Vec3r p(self->fes->normal());
+	bmo->data[index] = p[index];
+	return 0;
+}
 
-static PyObject * FEdgeSmooth_material( BPy_FEdgeSmooth *self ) {
-	FrsMaterial m( self->fes->frs_material() );
-	return BPy_FrsMaterial_from_FrsMaterial(m);
+static int FEdgeSmooth_mathutils_set_index(BaseMathObject *bmo, int subtype, int index)
+{
+	BPy_FEdgeSmooth *self = (BPy_FEdgeSmooth *)bmo->cb_user;
+	Vec3r p(self->fes->normal());
+	p[index] = bmo->data[index];
+	self->fes->setNormal(p);
+	return 0;
 }
 
-static char FEdgeSmooth_faceMark___doc__[] =
-".. method:: faceMark()\n"
-"\n"
-"   Returns the face mark of the face it is running across.\n"
-"\n"
-"   :return: The face mark of the face it is running across.\n"
-"   :rtype: bool\n";
+static Mathutils_Callback FEdgeSmooth_mathutils_cb = {
+	FEdgeSmooth_mathutils_check,
+	FEdgeSmooth_mathutils_get,
+	FEdgeSmooth_mathutils_set,
+	FEdgeSmooth_mathutils_get_index,
+	FEdgeSmooth_mathutils_set_index
+};
+
+static unsigned char FEdgeSmooth_mathutils_cb_index = -1;
 
-static PyObject * FEdgeSmooth_faceMark( BPy_FEdgeSmooth *self ) {
-	return PyBool_from_bool( self->fes->faceMark() );
+void FEdgeSmooth_mathutils_register_callback()
+{
+	FEdgeSmooth_mathutils_cb_index = Mathutils_RegisterCallback(&FEdgeSmooth_mathutils_cb);
 }
 
-static char FEdgeSmooth_setNormal___doc__[] =
-".. method:: setNormal(iNormal)\n"
-"\n"
-"   Sets the normal to the Face it is running accross.\n"
+/*----------------------FEdgeSmooth get/setters ----------------------------*/
+
+PyDoc_STRVAR(FEdgeSmooth_normal_doc,
+"The normal of the face that this FEdge is running across.\n"
 "\n"
-"   :arg iNormal: A three-dimensional vector.\n"
-"   :type iNormal: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
-
-static PyObject * FEdgeSmooth_setNormal( BPy_FEdgeSmooth *self, PyObject *args ) {
-	PyObject *obj = 0;
-
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
-		return NULL;
-	Vec3r *v = Vec3r_ptr_from_PyObject(obj);
-	if( !v ) {
-		PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
-		return NULL;
-	}
-	self->fes->setNormal( *v );
-	delete v;
+":type: :class:`mathutils.Vector`");
 
-	Py_RETURN_NONE;
+static PyObject *FEdgeSmooth_normal_get(BPy_FEdgeSmooth *self, void *UNUSED(closure))
+{
+	return Vector_CreatePyObject_cb((PyObject *)self, 3, FEdgeSmooth_mathutils_cb_index, 0);
 }
 
-static char FEdgeSmooth_setMaterialIndex___doc__[] =
-".. method:: setMaterialIndex(i)\n"
-"\n"
-"   Sets the index of the material of the face it is running accross.\n"
-"\n"
-"   :arg i: The index of the material of the face it is running accross.\n"
-"   :type i: int\n";
+static int FEdgeSmooth_normal_set(BPy_FEdgeSmooth *self, PyObject *value, void *UNUSED(closure))
+{
+	float v[3];
+	if (!float_array_from_PyObject(value, v, 3)) {
+		PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector");
+		return -1;
+	}
+	Vec3r p(v[0], v[1], v[2]);
+	self->fes->setNormal(p);
+	return 0;
+}
 
-static PyObject * FEdgeSmooth_setMaterialIndex( BPy_FEdgeSmooth *self, PyObject *args ) {
-	unsigned int i;
+PyDoc_STRVAR(FEdgeSmooth_material_index_doc,
+"The index of the material of the face that this FEdge is running across.\n"
+"\n"
+":type: int");
 
-	if(!( PyArg_ParseTuple(args, "I", &i) ))
-		return NULL;
-	
-	self->fes->setFrsMaterialIndex( i );
+static PyObject *FEdgeSmooth_material_index_get(BPy_FEdgeSmooth *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->fes->frs_materialIndex());
+}
 
-	Py_RETURN_NONE;
+static int FEdgeSmooth_material_index_set(BPy_FEdgeSmooth *self, PyObject *value, void *UNUSED(closure))
+{
+	unsigned int i = PyLong_AsUnsignedLong(value);
+	if(PyErr_Occurred())
+		return -1;
+	self->fes->setFrsMaterialIndex(i);
+	return 0;
 }
 
-static char FEdgeSmooth_setFaceMark___doc__[] =
-".. method:: setFaceMark(i)\n"
-"\n"
-"   Sets the face mark of the face it is running across.\n"
+PyDoc_STRVAR(FEdgeSmooth_material_doc,
+"The material of the face that this FEdge is running across.\n"
 "\n"
-"   :arg i: A face mark.\n"
-"   :type i: bool\n";
+":type: :class:`Material`");
 
-static PyObject * FEdgeSmooth_setFaceMark( BPy_FEdgeSmooth *self, PyObject *args ) {
-	PyObject *obj;
+static PyObject *FEdgeSmooth_material_get(BPy_FEdgeSmooth *self, void *UNUSED(closure))
+{
+	// FIXME frs_material() returns a const reference.
+	FrsMaterial m(self->fes->frs_material());
+	return BPy_FrsMaterial_from_FrsMaterial(m);
+}
 
-	if(!( PyArg_ParseTuple(args, "O", &obj) ))
-		return NULL;
-	
-	self->fes->setFaceMark( bool_from_PyBool(obj) );
+PyDoc_STRVAR(FEdgeSmooth_face_mark_doc,
+"The face mark of the face that this FEdge is running across.\n"
+"\n"
+":type: bool");
 
-	Py_RETURN_NONE;
+static PyObject *FEdgeSmooth_face_mark_get(BPy_FEdgeSmooth *self, void *UNUSED(closure))
+{
+	return PyBool_from_bool(self->fes->faceMark());
 }
 
-/*----------------------FEdgeSmooth instance definitions ----------------------------*/
-static PyMethodDef BPy_FEdgeSmooth_methods[] = {	
-	{"normal", ( PyCFunction ) FEdgeSmooth_normal, METH_NOARGS, FEdgeSmooth_normal___doc__},
-	{"materialIndex", ( PyCFunction ) FEdgeSmooth_materialIndex, METH_NOARGS, FEdgeSmooth_materialIndex___doc__},
-	{"material", ( PyCFunction ) FEdgeSmooth_material, METH_NOARGS, FEdgeSmooth_material___doc__},
-	{"faceMark", ( PyCFunction ) FEdgeSmooth_faceMark, METH_NOARGS, FEdgeSmooth_faceMark___doc__},
-	{"setNormal", ( PyCFunction ) FEdgeSmooth_setNormal, METH_VARARGS, FEdgeSmooth_setNormal___doc__},
-	{"setMaterialIndex", ( PyCFunction ) FEdgeSmooth_setMaterialIndex, METH_VARARGS, FEdgeSmooth_setMaterialIndex___doc__},
-	{"setFaceMark", ( PyCFunction ) FEdgeSmooth_setFaceMark, METH_VARARGS, FEdgeSmooth_setFaceMark___doc__},
-	{NULL, NULL, 0, NULL}
+static int FEdgeSmooth_face_mark_set(BPy_FEdgeSmooth *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!PyBool_Check(value))
+		return -1;
+	self->fes->setFaceMark(bool_from_PyBool(value));
+	return 0;
+}
+
+static PyGetSetDef BPy_FEdgeSmooth_getseters[] = {
+	{(char *)"normal", (getter)FEdgeSmooth_normal_get, (setter)FEdgeSmooth_normal_set, (char *)FEdgeSmooth_normal_doc, NULL},
+	{(char *)"material_index", (getter)FEdgeSmooth_material_index_get, (setter)FEdgeSmooth_material_index_set, (char *)FEdgeSmooth_material_index_doc, NULL},
+	{(char *)"material", (getter)FEdgeSmooth_material_get, (setter)NULL, (char *)FEdgeSmooth_material_doc, NULL},
+	{(char *)"face_mark", (getter)FEdgeSmooth_face_mark_get, (setter)FEdgeSmooth_face_mark_set, (char *)FEdgeSmooth_face_mark_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_FEdgeSmooth type definition ------------------------------*/
@@ -213,7 +233,7 @@ PyTypeObject FEdgeSmooth_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	FEdgeSmooth___doc__,            /* tp_doc */
+	FEdgeSmooth_doc,                /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -222,13 +242,13 @@ PyTypeObject FEdgeSmooth_Type = {
 	0,                              /* tp_iternext */
 	BPy_FEdgeSmooth_methods,        /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_FEdgeSmooth_getseters,      /* tp_getset */
 	&FEdge_Type,                    /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)FEdgeSmooth___init__, /* tp_init */
+	(initproc)FEdgeSmooth_init,     /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };
diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h
index d7b44bb1da7..7f7d0aaa3b7 100644
--- a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h
+++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h
@@ -22,6 +22,10 @@ typedef struct {
 	FEdgeSmooth *fes;
 } BPy_FEdgeSmooth;
 
+/*---------------------------Python BPy_FEdgeSmooth visible prototypes-----------*/
+
+void FEdgeSmooth_mathutils_register_callback();
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __cplusplus