Merged changes in the trunk up to revision 28247.
authorTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Sun, 18 Apr 2010 02:03:19 +0000 (02:03 +0000)
committerTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Sun, 18 Apr 2010 02:03:19 +0000 (02:03 +0000)
41 files changed:
1  2 
release/scripts/freestyle/style_modules/freestyle_init.py
release/scripts/ui/properties_render.py
release/scripts/ui/space_userpref.py
source/blender/CMakeLists.txt
source/blender/SConscript
source/blender/blenkernel/CMakeLists.txt
source/blender/blenkernel/SConscript
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/scene.c
source/blender/blenloader/intern/readfile.c
source/blender/editors/render/render_shading.c
source/blender/editors/space_outliner/outliner.c
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/transform/transform.c
source/blender/freestyle/intern/python/BPy_Convert.h
source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp
source/blender/freestyle/intern/python/BPy_FrsNoise.cpp
source/blender/freestyle/intern/python/BPy_Interface0D.cpp
source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp
source/blender/freestyle/intern/python/StrokeShader/BPy_CalligraphicShader.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_Normal2DF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_VertexOrientation2DF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec3f/BPy_VertexOrientation3DF0D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp
source/blender/makesdna/DNA_scene_types.h
source/blender/makesrna/RNA_access.h
source/blender/makesrna/intern/rna_scene.c
source/blender/python/doc/sphinx_doc_gen.py
source/blender/python/intern/bpy.c
source/blender/render/intern/source/pipeline.c
source/blender/render/intern/source/shadeinput.c
source/blender/render/intern/source/shadeoutput.c
source/creator/CMakeLists.txt
source/creator/SConscript
source/creator/creator.c

index 95f170a,0000000..9eb8b2d
mode 100644,000000..100644
--- /dev/null
@@@ -1,2 -1,0 +1,2 @@@
- from Mathutils import Vector
 +from Freestyle import *
++from mathutils import Vector
Simple merge
Simple merge
Simple merge
  FILE(GLOB SRC intern/*.c)
  
  SET(INC 
-       . ../../../intern/guardedalloc ../../../intern/memutil ../editors/include ../blenlib ../makesdna
+       . ../../../intern/guardedalloc ../../../intern/memutil ../editors/include ../blenlib ../makesdna ../modifiers
        ../render/extern/include ../../../intern/decimation/extern
        ../imbuf ../avi ../../../intern/elbeem/extern ../../../intern/opennl/extern
 -      ../../../intern/iksolver/extern ../blenloader ../ikplugin
 +      ../../../intern/iksolver/extern ../blenloader ../ikplugin ../freestyle
        ../nodes ../../../extern/glew/include ../gpu ../makesrna ../../../intern/smoke/extern
        ../../../intern/bsp/extern ../blenfont
        ../../../intern/audaspace/intern
@@@ -6,8 -6,8 +6,8 @@@ sources = env.Glob('intern/*.c'
  incs = '. #/intern/guardedalloc #/intern/memutil ../editors/include'
  incs += ' ../blenlib ../blenfont ../makesdna ../windowmanager'
  incs += ' ../render/extern/include #/intern/decimation/extern ../makesrna'
- incs += ' ../imbuf ../ikplugin ../avi #/intern/elbeem/extern ../nodes'
+ incs += ' ../imbuf ../ikplugin ../avi #/intern/elbeem/extern ../nodes ../modifiers'
 -incs += ' #/intern/iksolver/extern ../blenloader'
 +incs += ' #/intern/iksolver/extern ../blenloader ../freestyle'
  incs += ' #/extern/bullet2/src'
  incs += ' #/intern/opennl/extern #/intern/bsp/extern'
  incs += ' ../gpu #/extern/glew/include'
index 1e861e2,0000000..7e4e074
mode 100644,000000..100644
--- /dev/null
@@@ -1,147 -1,0 +1,147 @@@
- #include "generic/Mathutils.h"
 +#ifndef FREESTYLE_PYTHON_CONVERT_H
 +#define FREESTYLE_PYTHON_CONVERT_H
 +
 +#include <Python.h>
 +#include <typeinfo>
 +
 +#include "../geometry/Geom.h"
 +using namespace Geometry;
 +
 +// BBox
 +#include "../geometry/BBox.h"
 +
 +// FEdge, FEdgeSharp, FEdgeSmooth, SShape, SVertex, FEdgeInternal::SVertexIterator
 +#include "../view_map/Silhouette.h" 
 +
 +// Id
 +#include "../system/Id.h"
 +
 +// Interface0D, Interface0DIteratorNested, Interface0DIterator
 +#include "../view_map/Interface0D.h"
 +
 +// Interface1D
 +#include "../view_map/Interface1D.h"
 +
 +// FrsMaterial
 +#include "../scene_graph/FrsMaterial.h"
 +
 +// Nature::VertexNature, Nature::EdgeNature
 +#include "../winged_edge/Nature.h"
 +
 +// Stroke, StrokeAttribute, StrokeVertex
 +#include "../stroke/Stroke.h"
 +
 +// NonTVertex, TVertex, ViewEdge, ViewMap, ViewShape, ViewVertex
 +#include "../view_map/ViewMap.h"
 +
 +// CurvePoint, Curve
 +#include "../stroke/Curve.h"
 +
 +// Chain
 +#include "../stroke/Chain.h"
 +
 +//====== ITERATORS
 +
 +// AdjacencyIterator, ChainingIterator, ChainSilhouetteIterator, ChainPredicateIterator
 +#include "../stroke/ChainingIterators.h"
 +
 +// ViewVertexInternal::orientedViewEdgeIterator
 +// ViewEdgeInternal::SVertexIterator
 +// ViewEdgeInternal::ViewEdgeIterator
 +#include "../view_map/ViewMapIterators.h"
 +
 +// StrokeInternal::StrokeVertexIterator
 +#include "../stroke/StrokeIterators.h"
 +
 +// CurveInternal::CurvePointIterator
 +#include "../stroke/CurveIterators.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
++#include "generic/mathutils.h"
 +
 +//==============================
 +// C++ => Python
 +//==============================
 +
 +PyObject * PyBool_from_bool( bool b );
 +PyObject * Vector_from_Vec2f( Vec2f& v );
 +PyObject * Vector_from_Vec3f( Vec3f& v );
 +PyObject * Vector_from_Vec3r( Vec3r& v );
 +
 +PyObject * Any_BPy_Interface0D_from_Interface0D( Interface0D& if0D );
 +PyObject * Any_BPy_Interface1D_from_Interface1D( Interface1D& if1D );
 +PyObject * Any_BPy_FEdge_from_FEdge( FEdge& fe );
 +PyObject * Any_BPy_ViewVertex_from_ViewVertex( ViewVertex& vv );
 +
 +PyObject * BPy_BBox_from_BBox( BBox< Vec3r > &bb );
 +PyObject * BPy_CurvePoint_from_CurvePoint( CurvePoint& cp );
 +PyObject * BPy_directedViewEdge_from_directedViewEdge( ViewVertex::directedViewEdge& dve );
 +PyObject * BPy_FEdge_from_FEdge( FEdge& fe );
 +PyObject * BPy_FEdgeSharp_from_FEdgeSharp( FEdgeSharp& fes );
 +PyObject * BPy_FEdgeSmooth_from_FEdgeSmooth( FEdgeSmooth& fes );
 +PyObject * BPy_Id_from_Id( Id& id );
 +PyObject * BPy_Interface0D_from_Interface0D( Interface0D& if0D );
 +PyObject * BPy_Interface1D_from_Interface1D( Interface1D& if1D );
 +PyObject * BPy_IntegrationType_from_IntegrationType( IntegrationType i );
 +PyObject * BPy_FrsMaterial_from_FrsMaterial( FrsMaterial& m );
 +PyObject * BPy_Nature_from_Nature( unsigned short n );
 +PyObject * BPy_MediumType_from_MediumType( Stroke::MediumType n );
 +PyObject * BPy_SShape_from_SShape( SShape& ss );
 +PyObject * BPy_Stroke_from_Stroke( Stroke& s );
 +PyObject * BPy_StrokeAttribute_from_StrokeAttribute( StrokeAttribute& sa );
 +PyObject * BPy_StrokeVertex_from_StrokeVertex( StrokeVertex& sv );
 +PyObject * BPy_SVertex_from_SVertex( SVertex& sv );
 +PyObject * BPy_ViewVertex_from_ViewVertex( ViewVertex& vv );
 +PyObject * BPy_NonTVertex_from_NonTVertex( NonTVertex& ntv );
 +PyObject * BPy_TVertex_from_TVertex( TVertex& tv );
 +PyObject * BPy_ViewEdge_from_ViewEdge( ViewEdge& ve );
 +PyObject * BPy_Chain_from_Chain( Chain& c );
 +PyObject * BPy_ViewShape_from_ViewShape( ViewShape& vs );
 +
 +PyObject * BPy_AdjacencyIterator_from_AdjacencyIterator( AdjacencyIterator& a_it );
 +PyObject * BPy_Interface0DIterator_from_Interface0DIterator( Interface0DIterator& if0D_it, int reversed );
 +PyObject * BPy_CurvePointIterator_from_CurvePointIterator( CurveInternal::CurvePointIterator& cp_it );
 +PyObject * BPy_StrokeVertexIterator_from_StrokeVertexIterator( StrokeInternal::StrokeVertexIterator& sv_it, int reversed);
 +PyObject * BPy_SVertexIterator_from_SVertexIterator( ViewEdgeInternal::SVertexIterator& sv_it );
 +PyObject * BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator( ViewVertexInternal::orientedViewEdgeIterator& ove_it, int reversed );
 +PyObject * BPy_ViewEdgeIterator_from_ViewEdgeIterator( ViewEdgeInternal::ViewEdgeIterator& ve_it );
 +PyObject * BPy_ChainingIterator_from_ChainingIterator( ChainingIterator& c_it );
 +PyObject * BPy_ChainPredicateIterator_from_ChainPredicateIterator( ChainPredicateIterator& cp_it );
 +PyObject * BPy_ChainSilhouetteIterator_from_ChainSilhouetteIterator( ChainSilhouetteIterator& cs_it );
 +
 +//==============================
 +// Python => C++
 +//==============================
 +
 +bool bool_from_PyBool( PyObject *b );
 +IntegrationType IntegrationType_from_BPy_IntegrationType( PyObject* obj );
 +Stroke::MediumType MediumType_from_BPy_MediumType( PyObject* obj );
 +Nature::EdgeNature EdgeNature_from_BPy_Nature( PyObject* obj );
 +Vec2f * Vec2f_ptr_from_PyObject( PyObject* obj );
 +Vec3f * Vec3f_ptr_from_PyObject( PyObject* obj );
 +Vec3r * Vec3r_ptr_from_PyObject( PyObject* obj );
 +Vec2f * Vec2f_ptr_from_Vector( PyObject* obj );
 +Vec3f * Vec3f_ptr_from_Vector( PyObject* obj );
 +Vec3r * Vec3r_ptr_from_Vector( PyObject* obj );
 +Vec2f * Vec2f_ptr_from_PyList( PyObject* obj );
 +Vec3f * Vec3f_ptr_from_PyList( PyObject* obj );
 +Vec3r * Vec3r_ptr_from_PyList( PyObject* obj );
 +Vec2f * Vec2f_ptr_from_PyTuple( PyObject* obj );
 +Vec3f * Vec3f_ptr_from_PyTuple( PyObject* obj );
 +Vec3r * Vec3r_ptr_from_PyTuple( PyObject* obj );
 +
 +
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +
 +
 +#endif /* FREESTYLE_PYTHON_CONVERT_H */
index 0eea750,0000000..27582b7
mode 100644,000000..100644
--- /dev/null
@@@ -1,599 -1,0 +1,599 @@@
- "   :type iDiffuse: :class:`Mathutils.Vector`, list of tuple of 4 float values\n"
 +#include "BPy_FrsMaterial.h"
 +
 +#include "BPy_Convert.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//-------------------MODULE INITIALIZATION--------------------------------
 +int FrsMaterial_Init( PyObject *module )
 +{
 +      if( module == NULL )
 +              return -1;
 +
 +      if( PyType_Ready( &FrsMaterial_Type ) < 0 )
 +              return -1;
 +
 +      Py_INCREF( &FrsMaterial_Type );
 +      PyModule_AddObject(module, "FrsMaterial", (PyObject *)&FrsMaterial_Type);
 +      return 0;
 +}
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char FrsMaterial___doc__[] =
 +"Class defining a material.\n"
 +"\n"
 +".. method:: __init__()\n"
 +"\n"
 +"   Default constructor.\n"
 +"\n"
 +".. method:: __init__(m)\n"
 +"\n"
 +"   Copy constructor.\n"
 +"\n"
 +"   :arg m: A Material object.\n"
 +"   :type m: :class:`FrsMaterial`\n"
 +"\n"
 +".. method:: __init__(iDiffuse, iAmbiant, iSpecular, iEmission, iShininess)\n"
 +"\n"
 +"   Builds a Material from its diffuse, ambiant, specular, emissive\n"
 +"   colors and a shininess coefficient.\n"
 +"\n"
 +"   :arg iDiffuse: The diffuse color.\n"
- "   :type iAmbiant: :class:`Mathutils.Vector`, list of tuple of 4 float values\n"
++"   :type iDiffuse: :class:`mathutils.Vector`, list of tuple of 4 float values\n"
 +"   :arg iAmbiant: The ambiant color.\n"
- "   :type iSpecular: :class:`Mathutils.Vector`, list of tuple of 4 float values\n"
++"   :type iAmbiant: :class:`mathutils.Vector`, list of tuple of 4 float values\n"
 +"   :arg iSpecular: The specular color.\n"
- "   :type iEmission: :class:`Mathutils.Vector`, list of tuple of 4 float values\n"
++"   :type iSpecular: :class:`mathutils.Vector`, list of tuple of 4 float values\n"
 +"   :arg iEmission: The emissive color.\n"
- "   :type iShininess: :class:`Mathutils.Vector`, list of tuple of 4 float values\n";
++"   :type iEmission: :class:`mathutils.Vector`, list of tuple of 4 float values\n"
 +"   :arg iShininess: The shininess coefficient.\n"
++"   :type iShininess: :class:`mathutils.Vector`, list of tuple of 4 float values\n";
 +
 +static int Vec4(PyObject *obj, float *v)
 +{
 +      if (VectorObject_Check(obj) && ((VectorObject *)obj)->size == 4) {
 +              for (int i = 0; i < 4; i++)
 +                      v[i] = ((VectorObject *)obj)->vec[i];
 +      } else if( PyList_Check(obj) && PyList_Size(obj) == 4 ) {
 +              for (int i = 0; i < 4; i++)
 +                      v[i] = PyFloat_AsDouble(PyList_GetItem(obj, i));
 +      } else if( PyTuple_Check(obj) && PyTuple_Size(obj) == 4 ) {
 +              for (int i = 0; i < 4; i++)
 +                      v[i] = PyFloat_AsDouble(PyTuple_GetItem(obj, i));
 +      } else {
 +              return 0;
 +      }
 +      return 1;
 +}
 +
 +static int FrsMaterial___init__(BPy_FrsMaterial *self, PyObject *args, PyObject *kwds)
 +{
 +      PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0, *obj4 = 0;
 +      float f1[4], f2[4], f3[4], f4[4], f5 = 0.;
 +
 +    if (! PyArg_ParseTuple(args, "|OOOOf", &obj1, &obj2, &obj3, &obj4, &f5) )
 +        return -1;
 +
 +      if( !obj1 ){
 +              self->m = new FrsMaterial();
 +
 +      } else if( BPy_FrsMaterial_Check(obj1) && !obj2 ) {
 +              FrsMaterial *m = ((BPy_FrsMaterial *) obj1)->m;
 +              if( !m ) {
 +                      PyErr_SetString(PyExc_RuntimeError, "invalid FrsMaterial object");
 +                      return -1;
 +              }
 +              self->m = new FrsMaterial( *m );
 +
 +      } else if( Vec4(obj1, f1) && obj2 && Vec4(obj2, f2) && obj3 && Vec4(obj3, f3) && obj4 && Vec4(obj4, f4) ) {
 +              self->m = new FrsMaterial(f1, f2, f3, f4, f5);
 +
 +      } else {
 +              PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
 +              return -1;
 +      }
 +      self->borrowed = 0;
 +
 +      return 0;
 +}
 +
 +static void FrsMaterial___dealloc__( BPy_FrsMaterial* self)
 +{
 +      if( self->m && !self->borrowed )
 +              delete self->m;
 +    Py_TYPE(self)->tp_free((PyObject*)self);
 +}
 +
 +
 +static PyObject * FrsMaterial___repr__( BPy_FrsMaterial* self)
 +{
 +    return PyUnicode_FromFormat("FrsMaterial - address: %p", self->m );
 +}
 +
 +static char FrsMaterial_diffuse___doc__[] =
 +".. method:: diffuse()\n"
 +"\n"
 +"   Returns the diffuse color.\n"
 +"\n"
 +"   :return: The diffuse color.\n"
 +"   :rtype: Tuple of 4 float values\n";
 +
 +static PyObject * FrsMaterial_diffuse( BPy_FrsMaterial* self) {
 +      const float *diffuse = self->m->diffuse();
 +      PyObject *py_diffuse = PyTuple_New(4);
 +      
 +      PyTuple_SetItem( py_diffuse, 0, PyFloat_FromDouble( diffuse[0] ) );
 +      PyTuple_SetItem( py_diffuse, 1, PyFloat_FromDouble( diffuse[1] ) );
 +      PyTuple_SetItem( py_diffuse, 2, PyFloat_FromDouble( diffuse[2] ) );
 +      PyTuple_SetItem( py_diffuse, 3, PyFloat_FromDouble( diffuse[3] ) );
 +      
 +      return py_diffuse;
 +}
 +
 +static char FrsMaterial_diffuseR___doc__[] =
 +".. method:: diffuseR()\n"
 +"\n"
 +"   Returns the red component of the diffuse color.\n"
 +"\n"
 +"   :return: The red component of the diffuse color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_diffuseR( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->diffuseR() );
 +}
 +
 +static char FrsMaterial_diffuseG___doc__[] =
 +".. method:: diffuseG()\n"
 +"\n"
 +"   Returns the green component of the diffuse color.\n"
 +"\n"
 +"   :return: The green component of the diffuse color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_diffuseG( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->diffuseG() );
 +}
 +
 +static char FrsMaterial_diffuseB___doc__[] =
 +".. method:: diffuseB()\n"
 +"\n"
 +"   Returns the blue component of the diffuse color.\n"
 +"\n"
 +"   :return: The blue component of the diffuse color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_diffuseB( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->diffuseB() );
 +}
 +
 +static char FrsMaterial_diffuseA___doc__[] =
 +".. method:: diffuseA()\n"
 +"\n"
 +"   Returns the alpha component of the diffuse color.\n"
 +"\n"
 +"   :return: The alpha component of the diffuse color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_diffuseA( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->diffuseA() );
 +}
 +
 +static char FrsMaterial_specular___doc__[] =
 +".. method:: specular()\n"
 +"\n"
 +"   Returns the specular color.\n"
 +"\n"
 +"   :return: The specular color.\n"
 +"   :rtype: Tuple of 4 float values\n";
 +
 +static PyObject * FrsMaterial_specular( BPy_FrsMaterial* self) {
 +      const float *specular = self->m->specular();
 +      PyObject *py_specular = PyTuple_New(4);
 +      
 +      PyTuple_SetItem( py_specular, 0, PyFloat_FromDouble( specular[0] ) );
 +      PyTuple_SetItem( py_specular, 1, PyFloat_FromDouble( specular[1] ) );
 +      PyTuple_SetItem( py_specular, 2, PyFloat_FromDouble( specular[2] ) );
 +      PyTuple_SetItem( py_specular, 3, PyFloat_FromDouble( specular[3] ) );
 +      
 +      return py_specular;
 +}
 +
 +static char FrsMaterial_specularR___doc__[] =
 +".. method:: specularR()\n"
 +"\n"
 +"   Returns the red component of the specular color.\n"
 +"\n"
 +"   :return: The red component of the specular color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_specularR( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->specularR() );
 +}
 +
 +static char FrsMaterial_specularG___doc__[] =
 +".. method:: specularG()\n"
 +"\n"
 +"   Returns the green component of the specular color.\n"
 +"\n"
 +"   :return: The green component of the specular color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_specularG( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->specularG() );
 +}
 +
 +static char FrsMaterial_specularB___doc__[] =
 +".. method:: specularB()\n"
 +"\n"
 +"   Returns the blue component of the specular color.\n"
 +"\n"
 +"   :return: The blue component of the specular color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_specularB( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->specularB() );
 +}
 +
 +static char FrsMaterial_specularA___doc__[] =
 +".. method:: specularA()\n"
 +"\n"
 +"   Returns the alpha component of the specular color.\n"
 +"\n"
 +"   :return: The alpha component of the specular color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_specularA( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->specularA() );
 +}
 +
 +static char FrsMaterial_ambient___doc__[] =
 +".. method:: ambient()\n"
 +"\n"
 +"   Returns the ambiant color.\n"
 +"\n"
 +"   :return: The ambiant color.\n"
 +"   :rtype: Tuple of 4 float values\n";
 +
 +static PyObject * FrsMaterial_ambient( BPy_FrsMaterial* self) {
 +      const float *ambient = self->m->ambient();
 +      PyObject *py_ambient = PyTuple_New(4);
 +      
 +      PyTuple_SetItem( py_ambient, 0, PyFloat_FromDouble( ambient[0] ) );
 +      PyTuple_SetItem( py_ambient, 1, PyFloat_FromDouble( ambient[1] ) );
 +      PyTuple_SetItem( py_ambient, 2, PyFloat_FromDouble( ambient[2] ) );
 +      PyTuple_SetItem( py_ambient, 3, PyFloat_FromDouble( ambient[3] ) );
 +      
 +      return py_ambient;
 +}
 +
 +static char FrsMaterial_ambientR___doc__[] =
 +".. method:: ambientR()\n"
 +"\n"
 +"   Returns the red component of the ambiant color.\n"
 +"\n"
 +"   :return: The red component of the ambiant color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_ambientR( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->ambientR() );
 +}
 +
 +static char FrsMaterial_ambientG___doc__[] =
 +".. method:: ambientG()\n"
 +"\n"
 +"   Returns the green component of the ambiant color.\n"
 +"\n"
 +"   :return: The green component of the ambiant color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_ambientG( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->ambientG() );
 +}
 +
 +static char FrsMaterial_ambientB___doc__[] =
 +".. method:: ambientB()\n"
 +"\n"
 +"   Returns the blue component of the ambiant color.\n"
 +"\n"
 +"   :return: The blue component of the ambiant color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_ambientB( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->ambientB() );
 +}
 +
 +static char FrsMaterial_ambientA___doc__[] =
 +".. method:: ambientA()\n"
 +"\n"
 +"   Returns the alpha component of the ambiant color.\n"
 +"\n"
 +"   :return: The alpha component of the ambiant color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_ambientA( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->ambientA() );
 +}
 +
 +static char FrsMaterial_emission___doc__[] =
 +".. method:: emission()\n"
 +"\n"
 +"   Returns the emissive color.\n"
 +"\n"
 +"   :return: the emissive color.\n"
 +"   :rtype: Tuple of 4 float values\n";
 +
 +static PyObject * FrsMaterial_emission( BPy_FrsMaterial* self) {
 +      const float *emission = self->m->emission();
 +      PyObject *py_emission = PyTuple_New(4);
 +      
 +      PyTuple_SetItem( py_emission, 0, PyFloat_FromDouble( emission[0] ) );
 +      PyTuple_SetItem( py_emission, 1, PyFloat_FromDouble( emission[1] ) );
 +      PyTuple_SetItem( py_emission, 2, PyFloat_FromDouble( emission[2] ) );
 +      PyTuple_SetItem( py_emission, 3, PyFloat_FromDouble( emission[3] ) );
 +      
 +      return py_emission;
 +}
 +
 +static char FrsMaterial_emissionR___doc__[] =
 +".. method:: emissionR()\n"
 +"\n"
 +"   Returns the red component of the emissive color.\n"
 +"\n"
 +"   :return: The red component of the emissive color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_emissionR( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->emissionR() );
 +}
 +
 +static char FrsMaterial_emissionG___doc__[] =
 +".. method:: emissionG()\n"
 +"\n"
 +"   Returns the green component of the emissive color.\n"
 +"\n"
 +"   :return: The green component of the emissive color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_emissionG( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->emissionG() );
 +}
 +
 +static char FrsMaterial_emissionB___doc__[] =
 +".. method:: emissionB()\n"
 +"\n"
 +"   Returns the blue component of the emissive color.\n"
 +"\n"
 +"   :return: The blue component of the emissive color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_emissionB( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->emissionB() );
 +}
 +
 +static char FrsMaterial_emissionA___doc__[] =
 +".. method:: emissionA()\n"
 +"\n"
 +"   Returns the alpha component of the emissive color.\n"
 +"\n"
 +"   :return: The alpha component of the emissive color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_emissionA( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->emissionA() );
 +}
 +
 +static char FrsMaterial_shininess___doc__[] =
 +".. method:: shininess()\n"
 +"\n"
 +"   Returns the shininess coefficient.\n"
 +"\n"
 +"   :return: Shininess\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsMaterial_shininess( BPy_FrsMaterial* self) {
 +      return PyFloat_FromDouble( self->m->shininess() );
 +}
 +
 +static char FrsMaterial_setDiffuse___doc__[] =
 +".. method:: setDiffuse(r, g, b, a)\n"
 +"\n"
 +"   Sets the diffuse color.\n"
 +"\n"
 +"   :arg r: Red component.\n"
 +"   :type r: float\n"
 +"   :arg g: Green component.\n"
 +"   :type g: float\n"
 +"   :arg b: Blue component.\n"
 +"   :type b: float\n"
 +"   :arg a: Alpha component.\n"
 +"   :type a: float\n";
 +
 +static PyObject * FrsMaterial_setDiffuse( BPy_FrsMaterial *self, PyObject *args ) {
 +      float f1, f2, f3, f4;
 +
 +      if(!( PyArg_ParseTuple(args, "ffff", &f1, &f2, &f3, &f4)  ))
 +              return NULL;
 +
 +      self->m->setDiffuse(f1, f2, f3, f4);
 +
 +      Py_RETURN_NONE;
 +}
 + 
 +static char FrsMaterial_setSpecular___doc__[] =
 +".. method:: setSpecular(r, g, b, a)\n"
 +"\n"
 +"   Sets the specular color.\n"
 +"\n"
 +"   :arg r: Red component.\n"
 +"   :type r: float\n"
 +"   :arg g: Green component.\n"
 +"   :type g: float\n"
 +"   :arg b: Blue component.\n"
 +"   :type b: float\n"
 +"   :arg a: Alpha component.\n"
 +"   :type a: float\n";
 +
 +static PyObject * FrsMaterial_setSpecular( BPy_FrsMaterial *self, PyObject *args ) {
 +      float f1, f2, f3, f4;
 +
 +      if(!( PyArg_ParseTuple(args, "ffff", &f1, &f2, &f3, &f4)  ))
 +              return NULL;
 +
 +      self->m->setSpecular(f1, f2, f3, f4);
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char FrsMaterial_setAmbient___doc__[] =
 +".. method:: setAmbient(r, g, b, a)\n"
 +"\n"
 +"   Sets the ambiant color.\n"
 +"\n"
 +"   :arg r: Red component.\n"
 +"   :type r: float\n"
 +"   :arg g: Green component.\n"
 +"   :type g: float\n"
 +"   :arg b: Blue component.\n"
 +"   :type b: float\n"
 +"   :arg a: Alpha component.\n"
 +"   :type a: float\n";
 +
 +static PyObject * FrsMaterial_setAmbient( BPy_FrsMaterial *self, PyObject *args ) {
 +      float f1, f2, f3, f4;
 +
 +      if(!( PyArg_ParseTuple(args, "ffff", &f1, &f2, &f3, &f4)  ))
 +              return NULL;
 +
 +      self->m->setAmbient(f1, f2, f3, f4);
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char FrsMaterial_setEmission___doc__[] =
 +".. method:: setEmission(r, g, b, a)\n"
 +"\n"
 +"   Sets the emissive color.\n"
 +"\n"
 +"   :arg r: Red component.\n"
 +"   :type r: float\n"
 +"   :arg g: Green component.\n"
 +"   :type g: float\n"
 +"   :arg b: Blue component.\n"
 +"   :type b: float\n"
 +"   :arg a: Alpha component.\n"
 +"   :type a: float\n";
 +
 +static PyObject * FrsMaterial_setEmission( BPy_FrsMaterial *self, PyObject *args ) {
 +      float f1, f2, f3, f4;
 +
 +      if(!( PyArg_ParseTuple(args, "ffff", &f1, &f2, &f3, &f4)  ))
 +              return NULL;
 +
 +      self->m->setEmission(f1, f2, f3, f4);
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char FrsMaterial_setShininess___doc__[] =
 +".. method:: setShininess(s)\n"
 +"\n"
 +"   Sets the shininess.\n"
 +"\n"
 +"   :arg s: Shininess.\n"
 +"   :type s: float\n";
 +
 +static PyObject * FrsMaterial_setShininess( BPy_FrsMaterial *self, PyObject *args ) {
 +      float f;
 +
 +      if(!( PyArg_ParseTuple(args, "f", &f)  ))
 +              return NULL;
 +
 +      self->m->setShininess(f);
 +
 +      Py_RETURN_NONE;
 +}
 +
 +/*----------------------FrsMaterial instance definitions ----------------------------*/
 +static PyMethodDef BPy_FrsMaterial_methods[] = {
 +      {"diffuse", ( PyCFunction ) FrsMaterial_diffuse, METH_NOARGS, FrsMaterial_diffuse___doc__},
 +      {"diffuseR", ( PyCFunction ) FrsMaterial_diffuseR, METH_NOARGS, FrsMaterial_diffuseR___doc__},
 +      {"diffuseG", ( PyCFunction ) FrsMaterial_diffuseG, METH_NOARGS, FrsMaterial_diffuseG___doc__},
 +      {"diffuseB", ( PyCFunction ) FrsMaterial_diffuseB, METH_NOARGS, FrsMaterial_diffuseB___doc__},
 +      {"diffuseA", ( PyCFunction ) FrsMaterial_diffuseA, METH_NOARGS, FrsMaterial_diffuseA___doc__},
 +      {"specular", ( PyCFunction ) FrsMaterial_specular, METH_NOARGS, FrsMaterial_specular___doc__},
 +      {"specularR", ( PyCFunction ) FrsMaterial_specularR, METH_NOARGS, FrsMaterial_specularR___doc__},
 +      {"specularG", ( PyCFunction ) FrsMaterial_specularG, METH_NOARGS, FrsMaterial_specularG___doc__},
 +      {"specularB", ( PyCFunction ) FrsMaterial_specularB, METH_NOARGS, FrsMaterial_specularB___doc__},
 +      {"specularA", ( PyCFunction ) FrsMaterial_specularA, METH_NOARGS, FrsMaterial_specularA___doc__},
 +      {"ambient", ( PyCFunction ) FrsMaterial_ambient, METH_NOARGS, FrsMaterial_ambient___doc__},
 +      {"ambientR", ( PyCFunction ) FrsMaterial_ambientR, METH_NOARGS, FrsMaterial_ambientR___doc__},
 +      {"ambientG", ( PyCFunction ) FrsMaterial_ambientG, METH_NOARGS, FrsMaterial_ambientG___doc__},
 +      {"ambientB", ( PyCFunction ) FrsMaterial_ambientB, METH_NOARGS, FrsMaterial_ambientB___doc__},
 +      {"ambientA", ( PyCFunction ) FrsMaterial_ambientA, METH_NOARGS, FrsMaterial_ambientA___doc__},
 +      {"emission", ( PyCFunction ) FrsMaterial_emission, METH_NOARGS, FrsMaterial_emission___doc__},
 +      {"emissionR", ( PyCFunction ) FrsMaterial_emissionR, METH_NOARGS, FrsMaterial_emissionR___doc__},
 +      {"emissionG", ( PyCFunction ) FrsMaterial_emissionG, METH_NOARGS, FrsMaterial_emissionG___doc__},
 +      {"emissionB", ( PyCFunction ) FrsMaterial_emissionB, METH_NOARGS, FrsMaterial_emissionB___doc__},
 +      {"emissionA", ( PyCFunction ) FrsMaterial_emissionA, METH_NOARGS, FrsMaterial_emissionA___doc__},
 +      {"shininess", ( PyCFunction ) FrsMaterial_shininess, METH_NOARGS, FrsMaterial_shininess___doc__},
 +      {"setDiffuse", ( PyCFunction ) FrsMaterial_setDiffuse, METH_NOARGS, FrsMaterial_setDiffuse___doc__},
 +      {"setSpecular", ( PyCFunction ) FrsMaterial_setSpecular, METH_NOARGS, FrsMaterial_setSpecular___doc__},
 +      {"setAmbient", ( PyCFunction ) FrsMaterial_setAmbient, METH_NOARGS, FrsMaterial_setAmbient___doc__},
 +      {"setEmission", ( PyCFunction ) FrsMaterial_setEmission, METH_NOARGS, FrsMaterial_setEmission___doc__},
 +      {"setShininess", ( PyCFunction ) FrsMaterial_setShininess, METH_NOARGS, FrsMaterial_setShininess___doc__},
 +      {NULL, NULL, 0, NULL}
 +};
 +
 +/*-----------------------BPy_FrsMaterial type definition ------------------------------*/
 +
 +PyTypeObject FrsMaterial_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "FrsMaterial",                  /* tp_name */
 +      sizeof(BPy_FrsMaterial),        /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      (destructor)FrsMaterial___dealloc__, /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      (reprfunc)FrsMaterial___repr__, /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      FrsMaterial___doc__,            /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      BPy_FrsMaterial_methods,        /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      0,                              /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)FrsMaterial___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      PyType_GenericNew,              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index ed6be31,0000000..d9d2540
mode 100644,000000..100644
--- /dev/null
@@@ -1,274 -1,0 +1,274 @@@
- "   :type v: :class:`Mathutils.Vector`, list or tuple of 2 real numbers\n"
 +#include "BPy_FrsNoise.h"
 +#include "BPy_Convert.h"
 +
 +#include <sstream>
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//-------------------MODULE INITIALIZATION--------------------------------
 +int FrsNoise_Init( PyObject *module )
 +{
 +      if( module == NULL )
 +              return -1;
 +
 +      if( PyType_Ready( &FrsNoise_Type ) < 0 )
 +              return -1;
 +
 +      Py_INCREF( &FrsNoise_Type );
 +      PyModule_AddObject(module, "FrsNoise", (PyObject *)&FrsNoise_Type);
 +      return 0;
 +}
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char FrsNoise___doc__[] =
 +"Class to provide Perlin noise functionalities.\n"
 +"\n"
 +".. method:: __init__()\n"
 +"\n"
 +"   Builds a Noise object.\n";
 +
 +static int FrsNoise___init__(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
 +{
 +      if(!( PyArg_ParseTuple(args, "") ))
 +              return -1;
 +      self->n = new Noise();
 +      return 0;
 +}
 +
 +static void FrsNoise___dealloc__(BPy_FrsNoise* self)
 +{
 +      delete self->n;
 +    Py_TYPE(self)->tp_free((PyObject*)self);
 +}
 +
 +
 +static PyObject * FrsNoise___repr__(BPy_FrsNoise* self)
 +{
 +    return PyUnicode_FromFormat("FrsNoise - address: %p", self->n );
 +}
 +
 +static char FrsNoise_turbulence1___doc__[] =
 +".. method:: turbulence1(v, freq, amp, oct=4)\n"
 +"\n"
 +"   Returns a noise value for a 1D element.\n"
 +"\n"
 +"   :arg v: One-dimensional sample point.\n"
 +"   :type v: float\n"
 +"   :arg freq: Noise frequency.\n"
 +"   :type freq: float\n"
 +"   :arg amp: Amplitude.\n"
 +"   :type amp: float\n"
 +"   :arg oct: Number of octaves.\n"
 +"   :type oct: int\n"
 +"   :return: A noise value.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsNoise_turbulence1( BPy_FrsNoise *self , PyObject *args) {
 +      float f1, f2, f3;
 +      unsigned int i = 4;
 +
 +      if(!( PyArg_ParseTuple(args, "fff|I", &f1, &f2, &f3, &i) ))
 +              return NULL;
 +
 +      return PyFloat_FromDouble( self->n->turbulence1(f1, f2, f3, i) );
 +}
 +
 +static char FrsNoise_turbulence2___doc__[] =
 +".. method:: turbulence2(v, freq, amp, oct=4)\n"
 +"\n"
 +"   Returns a noise value for a 2D element.\n"
 +"\n"
 +"   :arg v: Two-dimensional sample point.\n"
- "   :type v: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n"
++"   :type v: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n"
 +"   :arg freq: Noise frequency.\n"
 +"   :type freq: float\n"
 +"   :arg amp: Amplitude.\n"
 +"   :type amp: float\n"
 +"   :arg oct: Number of octaves.\n"
 +"   :type oct: int\n"
 +"   :return: A noise value.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsNoise_turbulence2( BPy_FrsNoise *self , PyObject *args) {
 +      PyObject *obj1;
 +      float f2, f3;
 +      unsigned int i = 4;
 +
 +      if(!( PyArg_ParseTuple(args, "Off|I", &obj1, &f2, &f3, &i) ))
 +              return NULL;
 +      Vec2f *v = Vec2f_ptr_from_PyObject(obj1);
 +      if( !v ) {
 +              PyErr_SetString(PyExc_TypeError, "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
 +              return NULL;
 +      }
 +      float t = self->n->turbulence2(*v, f2, f3, i);
 +      delete v;
 +      return PyFloat_FromDouble( t );
 +}
 +
 +static char FrsNoise_turbulence3___doc__[] =
 +".. method:: turbulence3(v, freq, amp, oct=4)\n"
 +"\n"
 +"   Returns a noise value for a 3D element.\n"
 +"\n"
 +"   :arg v: Three-dimensional sample point.\n"
- "   :type v: :class:`Mathutils.Vector`, list or tuple of 2 real numbers\n"
++"   :type v: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"
 +"   :arg freq: Noise frequency.\n"
 +"   :type freq: float\n"
 +"   :arg amp: Amplitude.\n"
 +"   :type amp: float\n"
 +"   :arg oct: Number of octaves.\n"
 +"   :type oct: int\n"
 +"   :return: A noise value.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsNoise_turbulence3( BPy_FrsNoise *self , PyObject *args) {
 +      PyObject *obj1;
 +      float f2, f3;
 +      unsigned int i = 4;
 +
 +      if(!( PyArg_ParseTuple(args, "Off|I", &obj1, &f2, &f3, &i) ))
 +              return NULL;
 +      Vec3f *v = Vec3f_ptr_from_PyObject(obj1);
 +      if( !v ) {
 +              PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
 +              return NULL;
 +      }
 +      float t = self->n->turbulence3(*v, f2, f3, i);
 +      delete v;
 +      return PyFloat_FromDouble( t );
 +}
 +
 +static char FrsNoise_smoothNoise1___doc__[] =
 +".. method:: smoothNoise1(v)\n"
 +"\n"
 +"   Returns a smooth noise value for a 1D element.\n"
 +"\n"
 +"   :arg v: One-dimensional sample point.\n"
 +"   :type v: float\n"
 +"   :return: A smooth noise value.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsNoise_smoothNoise1( BPy_FrsNoise *self , PyObject *args) {
 +      float f;
 +
 +      if(!( PyArg_ParseTuple(args, "f", &f) ))
 +              return NULL;
 +
 +      return PyFloat_FromDouble( self->n->smoothNoise1(f) );
 +}
 +
 +static char FrsNoise_smoothNoise2___doc__[] =
 +".. method:: smoothNoise2(v)\n"
 +"\n"
 +"   Returns a smooth noise value for a 2D element.\n"
 +"\n"
 +"   :arg v: Two-dimensional sample point.\n"
- "   :type v: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n"
++"   :type v: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n"
 +"   :return: A smooth noise value.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsNoise_smoothNoise2( BPy_FrsNoise *self , PyObject *args) {
 +      PyObject *obj;
 +
 +      if(!( PyArg_ParseTuple(args, "O", &obj) ))
 +              return NULL;
 +      Vec2f *v = Vec2f_ptr_from_PyObject(obj);
 +      if( !v ) {
 +              PyErr_SetString(PyExc_TypeError, "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
 +              return NULL;
 +      }
 +      float t = self->n->smoothNoise2(*v);
 +      delete v;
 +      return PyFloat_FromDouble( t );
 +}
 +
 +static char FrsNoise_smoothNoise3___doc__[] =
 +".. method:: smoothNoise3(v)\n"
 +"\n"
 +"   Returns a smooth noise value for a 3D element.\n"
 +"\n"
 +"   :arg v: Three-dimensional sample point.\n"
++"   :type v: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"
 +"   :return: A smooth noise value.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * FrsNoise_smoothNoise3( BPy_FrsNoise *self , PyObject *args) {
 +      PyObject *obj;
 +
 +      if(!( PyArg_ParseTuple(args, "O", &obj) ))
 +              return NULL;
 +      Vec3f *v = Vec3f_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;
 +      }
 +      float t = self->n->smoothNoise3(*v);
 +      delete v;
 +      return PyFloat_FromDouble( t );
 +}
 +
 +/*----------------------FrsNoise instance definitions ----------------------------*/
 +static PyMethodDef BPy_FrsNoise_methods[] = {
 +      {"turbulence1", ( PyCFunction ) FrsNoise_turbulence1, METH_VARARGS, FrsNoise_turbulence1___doc__},
 +      {"turbulence2", ( PyCFunction ) FrsNoise_turbulence2, METH_VARARGS, FrsNoise_turbulence2___doc__},
 +      {"turbulence3", ( PyCFunction ) FrsNoise_turbulence3, METH_VARARGS, FrsNoise_turbulence3___doc__},
 +      {"smoothNoise1", ( PyCFunction ) FrsNoise_smoothNoise1, METH_VARARGS, FrsNoise_smoothNoise1___doc__},
 +      {"smoothNoise2", ( PyCFunction ) FrsNoise_smoothNoise2, METH_VARARGS, FrsNoise_smoothNoise2___doc__},
 +      {"smoothNoise3", ( PyCFunction ) FrsNoise_smoothNoise3, METH_VARARGS, FrsNoise_smoothNoise3___doc__},
 +      {NULL, NULL, 0, NULL}
 +};
 +
 +/*-----------------------BPy_FrsNoise type definition ------------------------------*/
 +
 +PyTypeObject FrsNoise_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "FrsNoise",                     /* tp_name */
 +      sizeof(BPy_FrsNoise),           /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      (destructor)FrsNoise___dealloc__, /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      (reprfunc)FrsNoise___repr__,    /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      FrsNoise___doc__,               /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      BPy_FrsNoise_methods,           /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      0,                              /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)FrsNoise___init__,    /* tp_init */
 +      0,                              /* tp_alloc */
 +      PyType_GenericNew,              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index efa1484,0000000..adf26de
mode 100644,000000..100644
--- /dev/null
@@@ -1,354 -1,0 +1,354 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_Interface0D.h"
 +
 +#include "BPy_Convert.h"
 +#include "Interface0D/BPy_CurvePoint.h"
 +#include "Interface0D/CurvePoint/BPy_StrokeVertex.h"
 +#include "Interface0D/BPy_SVertex.h"
 +#include "Interface0D/BPy_ViewVertex.h"
 +#include "Interface0D/ViewVertex/BPy_NonTVertex.h"
 +#include "Interface0D/ViewVertex/BPy_TVertex.h"
 +#include "Interface1D/BPy_FEdge.h"
 +#include "BPy_Nature.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//-------------------MODULE INITIALIZATION--------------------------------
 +int Interface0D_Init( PyObject *module )
 +{
 +      if( module == NULL )
 +              return -1;
 +
 +      if( PyType_Ready( &Interface0D_Type ) < 0 )
 +              return -1;
 +      Py_INCREF( &Interface0D_Type );
 +      PyModule_AddObject(module, "Interface0D", (PyObject *)&Interface0D_Type);
 +      
 +      if( PyType_Ready( &CurvePoint_Type ) < 0 )
 +              return -1;
 +      Py_INCREF( &CurvePoint_Type );
 +      PyModule_AddObject(module, "CurvePoint", (PyObject *)&CurvePoint_Type);
 +      
 +      if( PyType_Ready( &SVertex_Type ) < 0 )
 +              return -1;
 +      Py_INCREF( &SVertex_Type );
 +      PyModule_AddObject(module, "SVertex", (PyObject *)&SVertex_Type);       
 +      
 +      if( PyType_Ready( &ViewVertex_Type ) < 0 )
 +              return -1;
 +      Py_INCREF( &ViewVertex_Type );
 +      PyModule_AddObject(module, "ViewVertex", (PyObject *)&ViewVertex_Type);
 +      
 +      if( PyType_Ready( &StrokeVertex_Type ) < 0 )
 +              return -1;
 +      Py_INCREF( &StrokeVertex_Type );
 +      PyModule_AddObject(module, "StrokeVertex", (PyObject *)&StrokeVertex_Type);
 +      
 +      if( PyType_Ready( &NonTVertex_Type ) < 0 )
 +              return -1;
 +      Py_INCREF( &NonTVertex_Type );
 +      PyModule_AddObject(module, "NonTVertex", (PyObject *)&NonTVertex_Type);
 +      
 +      if( PyType_Ready( &TVertex_Type ) < 0 )
 +              return -1;
 +      Py_INCREF( &TVertex_Type );
 +      PyModule_AddObject(module, "TVertex", (PyObject *)&TVertex_Type);
 +
 +      return 0;
 +}
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char Interface0D___doc__[] =
 +"Base class for any 0D element.\n"
 +"\n"
 +".. method:: __init__()\n"
 +"\n"
 +"   Default constructor.\n";
 +
 +static int Interface0D___init__(BPy_Interface0D *self, PyObject *args, PyObject *kwds)
 +{
 +    if ( !PyArg_ParseTuple(args, "") )
 +        return -1;
 +      self->if0D = new Interface0D();
 +      self->borrowed = 0;
 +      return 0;
 +}
 +
 +static void Interface0D___dealloc__(BPy_Interface0D* self)
 +{
 +      if( self->if0D && !self->borrowed )
 +              delete self->if0D;
 +    Py_TYPE(self)->tp_free((PyObject*)self);
 +}
 +
 +static PyObject * Interface0D___repr__(BPy_Interface0D* self)
 +{
 +    return PyUnicode_FromFormat("type: %s - address: %p", self->if0D->getExactTypeName().c_str(), self->if0D );
 +}
 +
 +static char Interface0D_getExactTypeName___doc__[] =
 +".. method:: getExactTypeName()\n"
 +"\n"
 +"   Returns the name of the 0D element.\n"
 +"\n"
 +"   :return: Name of the interface.\n"
 +"   :rtype: string\n";
 +
 +static PyObject *Interface0D_getExactTypeName( BPy_Interface0D *self ) {
 +      return PyUnicode_FromFormat( self->if0D->getExactTypeName().c_str() );  
 +}
 +
 +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_getX( BPy_Interface0D *self ) {
 +      double x = self->if0D->getX();
 +      if (PyErr_Occurred())
 +              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();
 +      if (PyErr_Occurred())
 +              return NULL;
 +      return PyFloat_FromDouble( y );
 +}
 +
 +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 PyObject *Interface0D_getZ( BPy_Interface0D *self ) {
 +      double z = self->if0D->getZ();
 +      if (PyErr_Occurred())
 +              return NULL;
 +      return PyFloat_FromDouble( z );
 +}
 +
 +static char Interface0D_getPoint3D___doc__[] =
 +".. method:: getPoint3D()\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";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject *Interface0D_getPoint3D( BPy_Interface0D *self ) {
 +      Vec3f v( self->if0D->getPoint3D() );
 +      if (PyErr_Occurred())
 +              return NULL;
 +      return Vector_from_Vec3f( v );
 +}
 +
 +static char Interface0D_getProjectedX___doc__[] =
 +".. method:: getProjectedX()\n"
 +"\n"
 +"   Returns the X coordinate of the 2D point of the 0D element.\n"
 +"\n"
 +"   :return: The X coordinate of the 2D point.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *Interface0D_getProjectedX( BPy_Interface0D *self ) {
 +      double x = self->if0D->getProjectedX();
 +      if (PyErr_Occurred())
 +              return NULL;
 +      return PyFloat_FromDouble( x );
 +}
 +
 +static char Interface0D_getProjectedY___doc__[] =
 +".. method:: getProjectedY()\n"
 +"\n"
 +"   Returns the Y coordinate of the 2D point of the 0D element.\n"
 +"\n"
 +"   :return: The Y coordinate of the 2D point.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *Interface0D_getProjectedY( BPy_Interface0D *self ) {
 +      double y = self->if0D->getProjectedY();
 +      if (PyErr_Occurred())
 +              return NULL;
 +      return PyFloat_FromDouble( y );
 +}
 +
 +static char Interface0D_getProjectedZ___doc__[] =
 +".. method:: getProjectedZ()\n"
 +"\n"
 +"   Returns the Z coordinate of the 2D point of the 0D element.\n"
 +"\n"
 +"   :return: The Z coordinate of the 2D point.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *Interface0D_getProjectedZ( BPy_Interface0D *self ) {
 +      double z = self->if0D->getProjectedZ();
 +      if (PyErr_Occurred())
 +              return NULL;
 +      return PyFloat_FromDouble( z );
 +}
 +
 +static char Interface0D_getPoint2D___doc__[] =
 +".. method:: getPoint2D()\n"
 +"\n"
 +"   Returns the location of the 0D element in the 2D space.\n"
 +"\n"
 +"   :return: The 2D point of the 0D element.\n"
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject *Interface0D_getPoint2D( BPy_Interface0D *self ) {
 +      Vec2f v( self->if0D->getPoint2D() );
 +      if (PyErr_Occurred())
 +              return NULL;
 +      return Vector_from_Vec2f( v );
 +}
 +
 +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"
 +"\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";
 +
 +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 ));
 +      if (PyErr_Occurred())
 +              return NULL;
 +      if( fe )
 +              return Any_BPy_FEdge_from_FEdge( *fe );
 +      
 +      Py_RETURN_NONE;
 +}
 +
 +static char Interface0D_getId___doc__[] =
 +".. method:: getId()\n"
 +"\n"
 +"   Returns the identifier of the 0D element.\n"
 +"\n"
 +"   :return: The identifier of the 0D element.\n"
 +"   :rtype: :class:`Id`\n";
 +
 +static PyObject *Interface0D_getId( BPy_Interface0D *self ) {
 +      Id id( self->if0D->getId() );
 +      if (PyErr_Occurred())
 +              return NULL;
 +      return BPy_Id_from_Id( id );
 +}
 +
 +static char Interface0D_getNature___doc__[] =
 +".. method:: getNature()\n"
 +"\n"
 +"   Returns the nature of the 0D element.\n"
 +"\n"
 +"   :return: The nature of the 0D element.\n"
 +"   :rtype: :class:`Nature`\n";
 +
 +static PyObject *Interface0D_getNature( BPy_Interface0D *self ) {
 +      Nature::VertexNature nature = self->if0D->getNature();
 +      if (PyErr_Occurred())
 +              return NULL;
 +      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}
 +};
 +
 +/*-----------------------BPy_Interface0D type definition ------------------------------*/
 +
 +PyTypeObject Interface0D_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "Interface0D",                  /* tp_name */
 +      sizeof(BPy_Interface0D),        /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      (destructor)Interface0D___dealloc__, /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      (reprfunc)Interface0D___repr__, /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      Interface0D___doc__,            /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      BPy_Interface0D_methods,        /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      0,                              /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (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 */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +
index 875edae,0000000..4db7110
mode 100644,000000..100644
--- /dev/null
@@@ -1,658 -1,0 +1,658 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_StrokeAttribute.h"
 +
 +#include "BPy_Convert.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//-------------------MODULE INITIALIZATION--------------------------------
 +int StrokeAttribute_Init( PyObject *module )
 +{
 +      if( module == NULL )
 +              return -1;
 +
 +      if( PyType_Ready( &StrokeAttribute_Type ) < 0 )
 +              return -1;
 +      Py_INCREF( &StrokeAttribute_Type );
 +      PyModule_AddObject(module, "StrokeAttribute", (PyObject *)&StrokeAttribute_Type);
 +      return 0;
 +}
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char StrokeAttribute___doc__[] =
 +"Class to define a set of attributes associated with a :class:`StrokeVertex`.\n"
 +"The attribute set stores the color, alpha and thickness values for a Stroke\n"
 +"Vertex.\n"
 +"\n"
 +".. method:: __init__()\n"
 +"\n"
 +"   Default constructor.\n"
 +"\n"
 +".. method:: __init__(iBrother)\n"
 +"\n"
 +"   Copy constructor.\n"
 +"\n"
 +"   :arg iBrother: A StrokeAttribute object.\n"
 +"   :type iBrother: :class:`StrokeAttribute`\n"
 +"\n"
 +".. method:: __init__(iRColor, iGColor, iBColor, iAlpha, iRThickness, iLThickness)\n"
 +"\n"
 +"   Builds a stroke vertex attribute from a set of parameters.\n"
 +"\n"
 +"   :arg iRColor: Red component of a stroke color.\n"
 +"   :type iRColor: float\n"
 +"   :arg iGColor: Green component of a stroke color.\n"
 +"   :type iGColor: float\n"
 +"   :arg iBColor: Blue component of a stroke color.\n"
 +"   :type iBColor: float\n"
 +"   :arg iAlpha: Alpha component of a stroke color.\n"
 +"   :type iAlpha: float\n"
 +"   :arg iRThickness: Stroke thickness on the right.\n"
 +"   :type iRThickness: float\n"
 +"   :arg iLThickness: Stroke thickness on the left.\n"
 +"   :type iLThickness: float\n"
 +"\n"
 +".. method:: __init__(a1, a2, t)\n"
 +"\n"
 +"   Interpolation constructor. Builds a StrokeAttribute from two\n"
 +"   StrokeAttribute objects and an interpolation parameter.\n"
 +"\n"
 +"   :arg a1: The first StrokeAttribute object.\n"
 +"   :type a1: :class:`StrokeAttribute`\n"
 +"   :arg a2: The second StrokeAttribute object.\n"
 +"   :type a2: :class:`StrokeAttribute`\n"
 +"   :arg t: The interpolation parameter.\n"
 +"   :type t: float\n";
 +
 +static int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 +{
 +
 +      PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0, *obj4 = 0, *obj5 = 0 , *obj6 = 0;
 +
 +    if (! PyArg_ParseTuple(args, "|OOOOOO", &obj1, &obj2, &obj3, &obj4, &obj5, &obj6) )
 +        return -1;
 +
 +      if( !obj1 || !obj2 || !obj3 ){
 +              
 +              self->sa = new StrokeAttribute();
 +              
 +      } else if(      BPy_StrokeAttribute_Check(obj1) && 
 +                              BPy_StrokeAttribute_Check(obj2) &&
 +                              PyFloat_Check(obj3) ) { 
 +              
 +                      self->sa = new StrokeAttribute( *( ((BPy_StrokeAttribute *) obj1)->sa ),
 +                                                                                      *( ((BPy_StrokeAttribute *) obj2)->sa ),
 +                                                                                      PyFloat_AsDouble( obj3 ) );     
 +                                                                              
 +      } else if(      obj4 && obj5 && obj6 ) {
 +      
 +                      self->sa = new StrokeAttribute( PyFloat_AsDouble( obj1 ),
 +                                                                                      PyFloat_AsDouble( obj2 ),
 +                                                                                      PyFloat_AsDouble( obj3 ),
 +                                                                                      PyFloat_AsDouble( obj4 ),
 +                                                                                      PyFloat_AsDouble( obj5 ),
 +                                                                                      PyFloat_AsDouble( obj6 ) );
 +
 +      } else {
 +              PyErr_SetString(PyExc_TypeError, "invalid arguments");
 +              return -1;
 +      }
 +
 +      self->borrowed = 0;
 +
 +      return 0;
 +
 +}
 +
 +static void StrokeAttribute___dealloc__(BPy_StrokeAttribute* self)
 +{
 +      if( self->sa && !self->borrowed )
 +              delete self->sa;
 +    Py_TYPE(self)->tp_free((PyObject*)self);
 +}
 +
 +static PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute* self)
 +{
 +      stringstream repr("StrokeAttribute:");
 +      repr << " r: " << self->sa->getColorR()
 +               << " g: " << self->sa->getColorG()
 +               << " b: " << self->sa->getColorB()
 +               << " a: " << self->sa->getAlpha()
 +               << " - R: " << self->sa->getThicknessR() 
 +               << " L: " << self->sa->getThicknessL();
 +
 +      return PyUnicode_FromFormat( repr.str().c_str() );
 +}
 +
 +
 +static char StrokeAttribute_getColorR___doc__[] =
 +".. method:: getColorR()\n"
 +"\n"
 +"   Returns the red component of the stroke color.\n"
 +"\n"
 +"   :return: Red component of the stroke color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *StrokeAttribute_getColorR( BPy_StrokeAttribute *self ) {
 +      return PyFloat_FromDouble( self->sa->getColorR() );     
 +}
 +
 +static char StrokeAttribute_getColorG___doc__[] =
 +".. method:: getColorG()\n"
 +"\n"
 +"   Returns the green component of the stroke color.\n"
 +"\n"
 +"   :return: Green component of the stroke color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *StrokeAttribute_getColorG( BPy_StrokeAttribute *self ) {
 +      return PyFloat_FromDouble( self->sa->getColorG() );     
 +}
 +
 +static char StrokeAttribute_getColorB___doc__[] =
 +".. method:: getColorB()\n"
 +"\n"
 +"   Returns the blue component of the stroke color.\n"
 +"\n"
 +"   :return: Blue component of the stroke color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *StrokeAttribute_getColorB( BPy_StrokeAttribute *self ) {
 +      return PyFloat_FromDouble( self->sa->getColorB() );     
 +}
 +
 +static char StrokeAttribute_getColorRGB___doc__[] =
 +".. method:: getColorRGB()\n"
 +"\n"
 +"   Returns the RGB components of the stroke color.\n"
 +"\n"
 +"   :return: RGB components of the stroke color.\n"
- "   :rtype: :class:`Mathutils.Vector`\n";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject *StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self ) {
 +      Vec3f v( self->sa->getColorRGB() );
 +      return Vector_from_Vec3f( v );  
 +}
 +
 +static char StrokeAttribute_getAlpha___doc__[] =
 +".. method:: getAlpha()\n"
 +"\n"
 +"   Returns the alpha component of the stroke color.\n"
 +"\n"
 +"   :return: Alpha component of the stroke color.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *StrokeAttribute_getAlpha( BPy_StrokeAttribute *self ) {
 +      return PyFloat_FromDouble( self->sa->getAlpha() );      
 +}
 +
 +static char StrokeAttribute_getThicknessR___doc__[] =
 +".. method:: getThicknessR()\n"
 +"\n"
 +"   Returns the thickness on the right of the vertex when following\n"
 +"   the stroke.\n"
 +"\n"
 +"   :return: The thickness on the right of the vertex.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self ) {
 +      return PyFloat_FromDouble( self->sa->getThicknessR() ); 
 +}
 +
 +static char StrokeAttribute_getThicknessL___doc__[] =
 +".. method:: getThicknessL()\n"
 +"\n"
 +"   Returns the thickness on the left of the vertex when following\n"
 +"   the stroke.\n"
 +"\n"
 +"   :return: The thickness on the left of the vertex.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self ) {
 +      return PyFloat_FromDouble( self->sa->getThicknessL() ); 
 +}
 +
 +static char StrokeAttribute_getThicknessRL___doc__[] =
 +".. method:: getThicknessRL()\n"
 +"\n"
 +"   Returns the thickness on the right and on the left of the vertex\n"
 +"   when following the stroke.\n"
 +"\n"
 +"   :return: A two-dimensional vector.  The first value is the\n"
 +"      thickness on the right of the vertex when following the stroke,\n"
 +"      and the second one is the thickness on the left.\n"
- "   :rtype: :class:`Mathutils.Vector`\n";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject *StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self ) {
 +      Vec2f v( self->sa->getThicknessRL() );
 +      return Vector_from_Vec2f( v );
 +}
 +
 +static char StrokeAttribute_isVisible___doc__[] =
 +".. method:: isVisible()\n"
 +"\n"
 +"   Returns true if the StrokeVertex is visible, false otherwise.\n"
 +"\n"
 +"   :return: True if the StrokeVertex is visible, false otherwise.\n"
 +"   :rtype: bool\n";
 +
 +static PyObject *StrokeAttribute_isVisible( BPy_StrokeAttribute *self ) {
 +      return PyBool_from_bool( self->sa->isVisible() );       
 +}
 +
 +static char StrokeAttribute_getAttributeReal___doc__[] =
 +".. method:: getAttributeReal(iName)\n"
 +"\n"
 +"   Returns an attribute of float type.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :return: The attribute value.\n"
 +"   :rtype: float\n";
 +
 +static PyObject *StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *attr;
 +
 +      if(!( PyArg_ParseTuple(args, "s", &attr) ))
 +              return NULL;
 +
 +      double a = self->sa->getAttributeReal( attr );
 +      return PyFloat_FromDouble( a );
 +}
 +
 +static char StrokeAttribute_getAttributeVec2f___doc__[] =
 +".. method:: getAttributeVec2f(iName)\n"
 +"\n"
 +"   Returns an attribute of two-dimensional vector type.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :return: The attribute value.\n"
- "   :rtype: :class:`Mathutils.Vector`\n";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject *StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *attr;
 +
 +      if(!( PyArg_ParseTuple(args, "s", &attr) ))
 +              return NULL;
 +
 +      Vec2f a = self->sa->getAttributeVec2f( attr );
 +      return Vector_from_Vec2f( a );
 +}
 +
 +static char StrokeAttribute_getAttributeVec3f___doc__[] =
 +".. method:: getAttributeVec3f(iName)\n"
 +"\n"
 +"   Returns an attribute of three-dimensional vector type.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :return: The attribute value.\n"
- "   :type iRGB: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject *StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *attr;
 +
 +      if(!( PyArg_ParseTuple(args, "s", &attr) ))
 +              return NULL;
 +
 +      Vec3f a = self->sa->getAttributeVec3f( attr );
 +      return Vector_from_Vec3f( a );
 +}
 +
 +static char StrokeAttribute_isAttributeAvailableReal___doc__[] =
 +".. method:: isAttributeAvailableReal(iName)\n"
 +"\n"
 +"   Checks whether the attribute iName of float type is available.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :return: True if the attribute is availbale.\n"
 +"   :rtype: bool\n";
 +
 +static PyObject *StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *attr;
 +
 +      if(!( PyArg_ParseTuple(args, "s", &attr) ))
 +              return NULL;
 +
 +      return PyBool_from_bool( self->sa->isAttributeAvailableReal( attr ) );
 +}
 +
 +static char StrokeAttribute_isAttributeAvailableVec2f___doc__[] =
 +".. method:: isAttributeAvailableVec2f(iName)\n"
 +"\n"
 +"   Checks whether the attribute iName of two-dimensional vector type\n"
 +"   is available.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :return: True if the attribute is availbale.\n"
 +"   :rtype: bool\n";
 +
 +static PyObject *StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *attr;
 +
 +      if(!( PyArg_ParseTuple(args, "s", &attr) ))
 +              return NULL;
 +
 +      return PyBool_from_bool( self->sa->isAttributeAvailableVec2f( attr ) );
 +}
 +
 +static char StrokeAttribute_isAttributeAvailableVec3f___doc__[] =
 +".. method:: isAttributeAvailableVec3f(iName)\n"
 +"\n"
 +"   Checks whether the attribute iName of three-dimensional vector\n"
 +"   type is available.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :return: True if the attribute is availbale.\n"
 +"   :rtype: bool\n";
 +
 +static PyObject *StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *attr;
 +
 +      if(!( PyArg_ParseTuple(args, "s", &attr) ))
 +              return NULL;
 +
 +      return PyBool_from_bool( self->sa->isAttributeAvailableVec3f( attr ) );
 +}
 +
 +
 +static char StrokeAttribute_setColor___doc__[] =
 +".. method:: setColor(r, g, b)\n"
 +"\n"
 +"   Sets the stroke color.\n"
 +"\n"
 +"   :arg r: Red component of the stroke color.\n"
 +"   :type r: float\n"
 +"   :arg g: Green component of the stroke color.\n"
 +"   :type g: float\n"
 +"   :arg b: Blue component of the stroke color.\n"
 +"   :type b: float\n"
 +"\n"
 +".. method:: setColor(iRGB)\n"
 +"\n"
 +"   Sets the stroke color.\n"
 +"\n"
 +"   :arg iRGB: The new RGB values.\n"
- "   :type tRL: :class:`Mathutils.Vector`, list or tuple of 2 real numbers\n";
++"   :type iRGB: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
 +
 +static PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args ) {
 +      PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0 ;
 +
 +      if(!( PyArg_ParseTuple(args, "O|OO", &obj1, &obj2, &obj3) ))
 +              return NULL;
 +
 +      if( obj1 && !obj2 && !obj3 ){
 +
 +              Vec3f *v = Vec3f_ptr_from_PyObject(obj1);
 +              if( !v ) {
 +                      PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
 +                      return NULL;
 +              }
 +              self->sa->setColor( *v );
 +              delete v;
 +              
 +      } else if(      obj1 && obj2 && obj3 ){
 +
 +              self->sa->setColor(     PyFloat_AsDouble(obj1),
 +                                                      PyFloat_AsDouble(obj2),
 +                                                      PyFloat_AsDouble(obj3) );
 +
 +      } else {
 +              PyErr_SetString(PyExc_TypeError, "invalid arguments");
 +              return NULL;
 +      }
 +      
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeAttribute_setAlpha___doc__[] =
 +".. method:: setAlpha(alpha)\n"
 +"\n"
 +"   Sets the alpha component of the stroke color.\n"
 +"\n"
 +"   :arg alpha: The new alpha value.\n"
 +"   :type alpha: float\n";
 +
 +static PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args ){
 +      float f = 0;
 +
 +      if(!( PyArg_ParseTuple(args, "f", &f) ))
 +              return NULL;
 +      
 +      self->sa->setAlpha( f );
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeAttribute_setThickness___doc__[] =
 +".. method:: setThickness(tr, tl)\n"
 +"\n"
 +"   Sets the stroke thickness.\n"
 +"\n"
 +"   :arg tr: The thickness on the right of the vertex when following\n"
 +"      the stroke.\n"
 +"   :type tr: float\n"
 +"   :arg tl: The thickness on the left of the vertex when following\n"
 +"      the stroke.\n"
 +"   :type tl: float\n"
 +"\n"
 +".. method:: setThickness(tRL)\n"
 +"\n"
 +"   Sets the stroke thickness.\n"
 +"\n"
 +"   :arg tRL: The thickness on the right and on the left of the vertex\n"
 +"      when following the stroke.\n"
- "   :type att: :class:`Mathutils.Vector`, list or tuple of 2 real numbers\n";
++"   :type tRL: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n";
 +
 +static PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args )  {
 +      PyObject *obj1 = 0, *obj2 = 0;
 +
 +      if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) ))
 +              return NULL;
 +
 +      if( obj1 && !obj2 ){
 +              
 +              Vec2f *v = Vec2f_ptr_from_PyObject(obj1);
 +              if( !v ) {
 +                      PyErr_SetString(PyExc_TypeError, "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
 +                      return NULL;
 +              }
 +              self->sa->setThickness( *v );
 +              delete v;
 +                              
 +      } else if(      obj1 && obj2 ){
 +                                      
 +              self->sa->setThickness( PyFloat_AsDouble(obj1),
 +                                                              PyFloat_AsDouble(obj2) );
 +
 +      } else {
 +              PyErr_SetString(PyExc_TypeError, "invalid arguments");
 +              return NULL;
 +      }
 +      
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeAttribute_setVisible___doc__[] =
 +".. method:: setVisible(iVisible)\n"
 +"\n"
 +"   Sets the visibility flag.  True means the StrokeVertex is visible.\n"
 +"\n"
 +"   :arg iVisible: True if the StrokeVertex is visible.\n"
 +"   :type iVisible: bool\n";
 +
 +static PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args ) {
 +      PyObject *py_b;
 +
 +      if(!( PyArg_ParseTuple(args, "O", &py_b) ))
 +              return NULL;
 +
 +      self->sa->setVisible( bool_from_PyBool(py_b) );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeAttribute_setAttributeReal___doc__[] =
 +".. method:: setAttributeReal(iName, att)\n"
 +"\n"
 +"   Adds a user-defined attribute of float type.  If there is no\n"
 +"   attribute of the given name, it is added.  Otherwise, the new value\n"
 +"   replaces the old one.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :arg att: The attribute value.\n"
 +"   :type att: float\n";
 +
 +static PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *s = 0;
 +      double d = 0;
 +
 +      if(!( PyArg_ParseTuple(args, "sd", &s, &d) ))
 +              return NULL;
 +
 +      self->sa->setAttributeReal( s, d );
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeAttribute_setAttributeVec2f___doc__[] =
 +".. method:: setAttributeVec2f(iName, att)\n"
 +"\n"
 +"   Adds a user-defined attribute of two-dimensional vector type.  If\n"
 +"   there is no attribute of the given name, it is added.  Otherwise,\n"
 +"   the new value replaces the old one.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :arg att: The attribute value.\n"
- "   :type att: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n";
++"   :type att: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n";
 +
 +static PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *s;
 +      PyObject *obj = 0;
 +
 +      if(!( PyArg_ParseTuple(args, "sO", &s, &obj) ))
 +              return NULL;
 +      Vec2f *v = Vec2f_ptr_from_PyObject(obj);
 +      if( !v ) {
 +              PyErr_SetString(PyExc_TypeError, "argument 2 must be a 2D vector (either a list of 2 elements or Vector)");
 +              return NULL;
 +      }
 +      self->sa->setAttributeVec2f( s, *v );
 +      delete v;
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeAttribute_setAttributeVec3f___doc__[] =
 +".. method:: setAttributeVec3f(iName, att)\n"
 +"\n"
 +"   Adds a user-defined attribute of three-dimensional vector type.\n"
 +"   If there is no attribute of the given name, it is added.\n"
 +"   Otherwise, the new value replaces the old one.\n"
 +"\n"
 +"   :arg iName: The name of the attribute.\n"
 +"   :type iName: string\n"
 +"   :arg att: The attribute value.\n"
++"   :type att: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
 +
 +static PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 +      char *s;
 +      PyObject *obj = 0;
 +
 +      if(!( PyArg_ParseTuple(args, "sO", &s, &obj) ))
 +              return NULL;
 +      Vec3f *v = Vec3f_ptr_from_PyObject(obj);
 +      if( !v ) {
 +              PyErr_SetString(PyExc_TypeError, "argument 2 must be a 3D vector (either a list of 3 elements or Vector)");
 +              return NULL;
 +      }
 +      self->sa->setAttributeVec3f( s, *v );
 +      delete v;
 +
 +      Py_RETURN_NONE;
 +}
 +
 +/*----------------------StrokeAttribute instance definitions ----------------------------*/
 +static PyMethodDef BPy_StrokeAttribute_methods[] = {
 +      {"getColorR", ( PyCFunction ) StrokeAttribute_getColorR, METH_NOARGS, StrokeAttribute_getColorR___doc__},
 +      {"getColorG", ( PyCFunction ) StrokeAttribute_getColorG, METH_NOARGS, StrokeAttribute_getColorG___doc__},
 +      {"getColorB", ( PyCFunction ) StrokeAttribute_getColorB, METH_NOARGS, StrokeAttribute_getColorB___doc__},
 +      {"getColorRGB", ( PyCFunction ) StrokeAttribute_getColorRGB, METH_NOARGS, StrokeAttribute_getColorRGB___doc__},
 +      {"getAlpha", ( PyCFunction ) StrokeAttribute_getAlpha, METH_NOARGS, StrokeAttribute_getAlpha___doc__},
 +      {"getThicknessR", ( PyCFunction ) StrokeAttribute_getThicknessR, METH_NOARGS, StrokeAttribute_getThicknessR___doc__},
 +      {"getThicknessL", ( PyCFunction ) StrokeAttribute_getThicknessL, METH_NOARGS, StrokeAttribute_getThicknessL___doc__},
 +      {"getThicknessRL", ( PyCFunction ) StrokeAttribute_getThicknessRL, METH_NOARGS, StrokeAttribute_getThicknessRL___doc__},
 +      {"isVisible", ( PyCFunction ) StrokeAttribute_isVisible, METH_NOARGS, StrokeAttribute_isVisible___doc__},
 +      {"getAttributeReal", ( PyCFunction ) StrokeAttribute_getAttributeReal, METH_VARARGS, StrokeAttribute_getAttributeReal___doc__},
 +      {"getAttributeVec2f", ( PyCFunction ) StrokeAttribute_getAttributeVec2f, METH_VARARGS, StrokeAttribute_getAttributeVec2f___doc__},
 +      {"getAttributeVec3f", ( PyCFunction ) StrokeAttribute_getAttributeVec3f, METH_VARARGS, StrokeAttribute_getAttributeVec3f___doc__},
 +      {"isAttributeAvailableReal", ( PyCFunction ) StrokeAttribute_isAttributeAvailableReal, METH_VARARGS, StrokeAttribute_isAttributeAvailableReal___doc__},
 +      {"isAttributeAvailableVec2f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec2f, METH_VARARGS, StrokeAttribute_isAttributeAvailableVec2f___doc__},
 +      {"isAttributeAvailableVec3f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec3f, METH_VARARGS, StrokeAttribute_isAttributeAvailableVec3f___doc__},
 +      {"setColor", ( PyCFunction ) StrokeAttribute_setColor, METH_VARARGS, StrokeAttribute_setColor___doc__},
 +      {"setAlpha", ( PyCFunction ) StrokeAttribute_setAlpha, METH_VARARGS, StrokeAttribute_setAlpha___doc__},
 +      {"setThickness", ( PyCFunction ) StrokeAttribute_setThickness, METH_VARARGS, StrokeAttribute_setThickness___doc__},
 +      {"setVisible", ( PyCFunction ) StrokeAttribute_setVisible, METH_VARARGS, StrokeAttribute_setVisible___doc__},
 +      {"setAttributeReal", ( PyCFunction ) StrokeAttribute_setAttributeReal, METH_VARARGS, StrokeAttribute_setAttributeReal___doc__},
 +      {"setAttributeVec2f", ( PyCFunction ) StrokeAttribute_setAttributeVec2f, METH_VARARGS, StrokeAttribute_setAttributeVec2f___doc__},
 +      {"setAttributeVec3f", ( PyCFunction ) StrokeAttribute_setAttributeVec3f, METH_VARARGS, StrokeAttribute_setAttributeVec3f___doc__},
 +      {NULL, NULL, 0, NULL}
 +};
 +
 +/*-----------------------BPy_StrokeAttribute type definition ------------------------------*/
 +
 +PyTypeObject StrokeAttribute_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "StrokeAttribute",              /* tp_name */
 +      sizeof(BPy_StrokeAttribute),    /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      (destructor)StrokeAttribute___dealloc__, /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      (reprfunc)StrokeAttribute___repr__, /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      StrokeAttribute___doc__,        /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      BPy_StrokeAttribute_methods,    /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      0,                              /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)StrokeAttribute___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      PyType_GenericNew,              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +
index 751955e,0000000..327f392
mode 100644,000000..100644
--- /dev/null
@@@ -1,314 -1,0 +1,314 @@@
- "   :type iPoint3D: :class:`Mathutils.Vector`\n"
 +#include "BPy_SVertex.h"
 +
 +#include "../BPy_Convert.h"
 +#include "../BPy_Id.h"
 +#include "../Interface1D/BPy_FEdge.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +static char SVertex___doc__[] =
 +"Class to define a vertex of the embedding.\n"
 +"\n"
 +".. method:: __init__()\n"
 +"\n"
 +"   Default constructor.\n"
 +"\n"
 +".. method:: __init__(iBrother)\n"
 +"\n"
 +"   Copy constructor.\n"
 +"\n"
 +"   :arg iBrother: A SVertex object.\n"
 +"   :type iBrother: :class:`SVertex`\n"
 +"\n"
 +".. method:: __init__(iPoint3D, id)\n"
 +"\n"
 +"   Builds a SVertex from 3D coordinates and an Id.\n"
 +"\n"
 +"   :arg iPoint3D: A three-dimensional vector.\n"
- "   :rtype: List of :class:`Mathutils.Vector` objects\n";
++"   :type iPoint3D: :class:`mathutils.Vector`\n"
 +"   :arg id: An Id object.\n"
 +"   :type id: :class:`Id`\n";
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +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( !py_point ) {
 +              self->sv = new SVertex();
 +
 +      } else if( !py_id && BPy_SVertex_Check(py_point) ) {
 +              self->sv = new SVertex( *(((BPy_SVertex *)py_point)->sv) );
 +
 +      } else if( py_point && py_id ) {
 +              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 -1;
 +              }
 +              self->sv = new SVertex( *v, *(py_id->id) );
 +              delete v;
 +
 +      } else {
 +              PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
 +              return -1;
 +      }
 +
 +      self->py_if0D.if0D = self->sv;
 +      self->py_if0D.borrowed = 0;
 +      
 +      return 0;
 +}
 +
 +static PyObject * SVertex___copy__( BPy_SVertex *self ) {
 +      BPy_SVertex *py_svertex;
 +      
 +      py_svertex = (BPy_SVertex *) SVertex_Type.tp_new( &SVertex_Type, 0, 0 );
 +      
 +      py_svertex->sv = self->sv->duplicate();
 +      py_svertex->py_if0D.if0D = py_svertex->sv;
 +      py_svertex->py_if0D.borrowed = 0;
 +
 +      return (PyObject *) py_svertex;
 +}
 +
 +static char SVertex_normals___doc__[] =
 +".. method:: normals()\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"
 +"\n"
 +"   :return: A list of normals.\n"
- "   :type p: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n";
++"   :rtype: List of :class:`mathutils.Vector` objects\n";
 +
 +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) );
 +      }
 +      
 +      return py_normals;
 +}
 +
 +static char SVertex_normalsSize___doc__[] =
 +".. method:: normalsSize()\n"
 +"\n"
 +"   Returns the number of different normals for this vertex.\n"
 +"\n"
 +"   :return: The number of normals.\n"
 +"   :rtype: int\n";
 +
 +static PyObject * SVertex_normalsSize( BPy_SVertex *self ) {
 +      return PyLong_FromLong( self->sv->normalsSize() );
 +}
 +
 +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";
 +
 +static PyObject * SVertex_viewvertex( BPy_SVertex *self ) {
 +      ViewVertex *vv = self->sv->viewvertex();
 +      if( vv )
 +              return Any_BPy_ViewVertex_from_ViewVertex( *vv );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +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";
++"   :type p: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
 +
 +static PyObject *SVertex_setPoint3D( BPy_SVertex *self , PyObject *args) {
 +      PyObject *py_point;
 +
 +      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;
 +      }
 +      self->sv->setPoint3D( *v );
 +      delete v;
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char SVertex_setPoint2D___doc__[] =
 +".. method:: setPoint2D(p)\n"
 +"\n"
 +"   Sets the 2D projected coordinates of the SVertex.\n"
 +"\n"
 +"   :arg p: A three-dimensional vector.\n"
- "   :type n: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n";
++"   :type p: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
 +
 +static PyObject *SVertex_setPoint2D( BPy_SVertex *self , PyObject *args) {
 +      PyObject *py_point;
 +
 +      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;
 +      }
 +      self->sv->setPoint2D( *v );
 +      delete v;
 +
 +      Py_RETURN_NONE;
 +}
 +
 +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"
 +"\n"
 +"   :arg n: A three-dimensional vector.\n"
++"   :type n: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n";
 +
 +static PyObject *SVertex_AddNormal( 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;
 +      }
 +      self->sv->AddNormal( *n );
 +      delete n;
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char SVertex_setId___doc__[] =
 +".. method:: setId(id)\n"
 +"\n"
 +"   Sets the identifier of the SVertex.\n"
 +"\n"
 +"   :arg id: The identifier.\n"
 +"   :type id: :class:`Id`\n";
 +
 +static PyObject *SVertex_setId( BPy_SVertex *self , PyObject *args) {
 +      BPy_Id *py_id;
 +
 +      if( !PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) )
 +              return NULL;
 +
 +      self->sv->setId( *(py_id->id) );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char SVertex_AddFEdge___doc__[] =
 +".. method:: AddFEdge(fe)\n"
 +"\n"
 +"   Add an FEdge to the list of edges emanating from this SVertex.\n"
 +"\n"
 +"   :arg fe: An FEdge.\n"
 +"   :type fe: :class:`FEdge`\n";
 +
 +static PyObject *SVertex_AddFEdge( BPy_SVertex *self , PyObject *args) {
 +      PyObject *py_fe;
 +
 +      if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
 +              return NULL;
 +      
 +      self->sv->AddFEdge( ((BPy_FEdge *) py_fe)->fe );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +// virtual bool       operator== (const SVertex &iBrother)
 +// ViewVertex *       viewvertex ()
 +
 +/*----------------------SVertex instance definitions ----------------------------*/
 +static PyMethodDef BPy_SVertex_methods[] = {
 +      {"__copy__", ( PyCFunction ) SVertex___copy__, METH_NOARGS, "() Cloning method."},
 +      {"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__},
 +      {NULL, NULL, 0, NULL}
 +};
 +
 +/*-----------------------BPy_SVertex type definition ------------------------------*/
 +PyTypeObject SVertex_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "SVertex",                      /* tp_name */
 +      sizeof(BPy_SVertex),            /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      SVertex___doc__,                /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      BPy_SVertex_methods,            /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* 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 */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +
index 91002b8,0000000..d19069e
mode 100644,000000..100644
--- /dev/null
@@@ -1,399 -1,0 +1,399 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_StrokeVertex.h"
 +
 +#include "../../BPy_Convert.h"
 +#include "../../BPy_StrokeAttribute.h"
 +#include "../../Interface0D/BPy_SVertex.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char StrokeVertex___doc__[] =
 +"Class to define a stroke vertex.\n"
 +"\n"
 +".. method:: __init__()\n"
 +"\n"
 +"   Default constructor.\n"
 +"\n"
 +".. method:: __init__(iBrother)\n"
 +"\n"
 +"   Copy constructor.\n"
 +"\n"
 +"   :arg iBrother: A StrokeVertex object.\n"
 +"   :type iBrother: :class:`StrokeVertex`\n"
 +"\n"
 +".. method:: __init__(iA, iB, t3)\n"
 +"\n"
 +"   Builds a stroke vertex from 2 stroke vertices and an interpolation\n"
 +"   parameter.\n"
 +"\n"
 +"   :arg iA: The first StrokeVertex.\n"
 +"   :type iA: :class:`StrokeVertex`\n"
 +"   :arg iB: The second StrokeVertex.\n"
 +"   :type iB: :class:`StrokeVertex`\n"
 +"   :arg t3: An interpolation parameter.\n"
 +"   :type t3: float\n"
 +"\n"
 +".. method:: __init__(iPoint)\n"
 +"\n"
 +"   Builds a stroke vertex from a CurvePoint\n"
 +"\n"
 +"   :arg iPoint: A CurvePoint object.\n"
 +"   :type iPoint: :class:`CurvePoint`\n"
 +"\n"
 +".. method:: __init__(iSVertex)\n"
 +"\n"
 +"   Builds a stroke vertex from a SVertex\n"
 +"\n"
 +"   :arg iSVertex: An SVertex object.\n"
 +"   :type iSVertex: :class:`SVertex`\n"
 +"\n"
 +".. method:: __init__(iSVertex, iAttribute)\n"
 +"\n"
 +"   Builds a stroke vertex from an SVertex and a StrokeAttribute object.\n"
 +"\n"
 +"   :arg iSVertex: An SVertex object.\n"
 +"   :type iSVertex: :class:`SVertex`\n"
 +"   :arg iAttribute: A StrokeAttribute object.\n"
 +"   :type iAttribute: :class:`StrokeAttribute`\n";
 +
 +static int StrokeVertex___init__(BPy_StrokeVertex *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( !obj1 ){
 +              self->sv = new StrokeVertex();
 +              
 +      } else if( !obj2 && BPy_StrokeVertex_Check(obj1) && ((BPy_StrokeVertex *) obj1)->sv ) {
 +              self->sv = new StrokeVertex( *(((BPy_StrokeVertex *) obj1)->sv) );
 +
 +      } else if( !obj2 && BPy_CurvePoint_Check(obj1) && ((BPy_CurvePoint *) obj1)->cp ) {
 +              self->sv = new StrokeVertex( ((BPy_CurvePoint *) obj1)->cp );
 +      
 +      } else if( !obj2 && BPy_SVertex_Check(obj1) && ((BPy_SVertex *) obj1)->sv ) {
 +              self->sv = new StrokeVertex( ((BPy_SVertex *) obj1)->sv );
 +      
 +      } else if( obj3 && BPy_StrokeVertex_Check(obj1) && BPy_StrokeVertex_Check(obj2) ) {
 +              StrokeVertex *sv1 = ((BPy_StrokeVertex *) obj1)->sv;
 +              StrokeVertex *sv2 = ((BPy_StrokeVertex *) obj2)->sv;
 +              if( !sv1 || ( sv1->A() == 0 && sv1->B() == 0 ) ) {
 +                      PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid StrokeVertex object");
 +                      return -1;
 +              }
 +              if( !sv2 || ( sv2->A() == 0 && sv2->B() == 0 ) ) {
 +                      PyErr_SetString(PyExc_TypeError, "argument 2 is an invalid StrokeVertex object");
 +                      return -1;
 +              }
 +              self->sv = new StrokeVertex( sv1, sv2, PyFloat_AsDouble( obj3 ) );
 +
 +      } else {
 +              PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
 +              return -1;
 +      }
 +
 +      self->py_cp.cp = self->sv;
 +      self->py_cp.py_if0D.if0D = self->sv;
 +      self->py_cp.py_if0D.borrowed = 0;
 +
 +      return 0;
 +}
 +
 +static char StrokeVertex_x___doc__[] =
 +".. method:: x()\n"
 +"\n"
 +"   Returns the 2D point X coordinate.\n"
 +"\n"
 +"   :return: The X coordinate.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * StrokeVertex_x( BPy_StrokeVertex *self ) {
 +      return PyFloat_FromDouble( self->sv->x() );
 +}
 +
 +static char StrokeVertex_y___doc__[] =
 +".. method:: y()\n"
 +"\n"
 +"   Returns the 2D point Y coordinate.\n"
 +"\n"
 +"   :return: The Y coordinate.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * StrokeVertex_y( BPy_StrokeVertex *self ) {
 +      return PyFloat_FromDouble( self->sv->y() );
 +}
 +
 +static char StrokeVertex_getPoint___doc__[] =
 +".. method:: getPoint()\n"
 +"\n"
 +"   Returns the 2D point coordinates as a two-dimensional vector.\n"
 +"\n"
 +"   :return: The 2D coordinates.\n"
- "   :type p: :class:`Mathutils.Vector`, list or tuple of 2 real numbers\n";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject * StrokeVertex_getPoint( BPy_StrokeVertex *self ) {
 +      Vec2f v( self->sv->getPoint() );
 +      return Vector_from_Vec2f( v );
 +}
 +
 +static char StrokeVertex_attribute___doc__[] =
 +".. method:: attribute()\n"
 +"\n"
 +"   Returns the StrokeAttribute for this StrokeVertex.\n"
 +"\n"
 +"   :return: The StrokeAttribute object.\n"
 +"   :rtype: :class:`StrokeAttribute`\n";
 +
 +static PyObject * StrokeVertex_attribute( BPy_StrokeVertex *self ) {
 +      return BPy_StrokeAttribute_from_StrokeAttribute( self->sv->attribute() );
 +}
 +
 +static char StrokeVertex_curvilinearAbscissa___doc__[] =
 +".. method:: curvilinearAbscissa()\n"
 +"\n"
 +"   Returns the curvilinear abscissa.\n"
 +"\n"
 +"   :return: The curvilinear abscissa.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * StrokeVertex_curvilinearAbscissa( BPy_StrokeVertex *self ) {
 +      return PyFloat_FromDouble( self->sv->curvilinearAbscissa() );
 +}
 +
 +static char StrokeVertex_strokeLength___doc__[] =
 +".. method:: strokeLength()\n"
 +"\n"
 +"   Returns the length of the Stroke to which this StrokeVertex belongs\n"
 +"\n"
 +"   :return: The stroke length.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * StrokeVertex_strokeLength( BPy_StrokeVertex *self ) {
 +      return PyFloat_FromDouble( self->sv->strokeLength() );
 +}
 +
 +static char StrokeVertex_u___doc__[] =
 +".. method:: u()\n"
 +"\n"
 +"   Returns the curvilinear abscissa of this StrokeVertex in the Stroke\n"
 +"\n"
 +"   :return: The curvilinear abscissa.\n"
 +"   :rtype: float\n";
 +
 +static PyObject * StrokeVertex_u( BPy_StrokeVertex *self ) {
 +      return PyFloat_FromDouble( self->sv->u() );
 +}
 +
 +static char StrokeVertex_setX___doc__[] =
 +".. method:: setX(x)\n"
 +"\n"
 +"   Sets the 2D point X coordinate.\n"
 +"\n"
 +"   :arg x: The X coordinate.\n"
 +"   :type x: float\n";
 +
 +static PyObject *StrokeVertex_setX( BPy_StrokeVertex *self , PyObject *args) {
 +      double r;
 +
 +      if(!( PyArg_ParseTuple(args, "d", &r)  ))
 +              return NULL;
 +
 +      self->sv->setX( r );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeVertex_setY___doc__[] =
 +".. method:: setY(y)\n"
 +"\n"
 +"   Sets the 2D point Y coordinate.\n"
 +"\n"
 +"   :arg y: The Y coordinate.\n"
 +"   :type y: float\n";
 +
 +static PyObject *StrokeVertex_setY( BPy_StrokeVertex *self , PyObject *args) {
 +      double r;
 +
 +      if(!( PyArg_ParseTuple(args, "d", &r)  ))
 +              return NULL;
 +
 +      self->sv->setY( r );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeVertex_setPoint___doc__[] =
 +".. method:: setPoint(x, y)\n"
 +"\n"
 +"   Sets the 2D point X and Y coordinates.\n"
 +"\n"
 +"   :arg x: The X coordinate.\n"
 +"   :type x: float\n"
 +"   :arg y: The Y coordinate.\n"
 +"   :type y: float\n"
 +"\n"
 +".. method:: SetPoint(p)\n"
 +"\n"
 +"   Sets the 2D point X and Y coordinates.\n"
 +"\n"
 +"   :arg p: A two-dimensional vector.\n"
++"   :type p: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n";
 +
 +static PyObject *StrokeVertex_setPoint( BPy_StrokeVertex *self , PyObject *args) {
 +      PyObject *obj1 = 0, *obj2 = 0;
 +
 +      if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) ))
 +              return NULL;
 +      
 +      if( obj1 && !obj2 ){
 +              Vec2f *v = Vec2f_ptr_from_PyObject(obj1);
 +              if( !v ) {
 +                      PyErr_SetString(PyExc_TypeError, "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
 +                      return NULL;
 +              }
 +              self->sv->setPoint( *v );
 +              delete v; 
 +      } else if( PyFloat_Check(obj1) && obj2 && PyFloat_Check(obj2) ){
 +              self->sv->setPoint( PyFloat_AsDouble(obj1), PyFloat_AsDouble(obj2) );
 +      } else {
 +              PyErr_SetString(PyExc_TypeError, "invalid arguments");
 +              return NULL;
 +      }
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeVertex_setAttribute___doc__[] =
 +".. method:: setAttribute(iAttribute)\n"
 +"\n"
 +"   Sets the attribute.\n"
 +"\n"
 +"   :arg iAttribute: A StrokeAttribute object.\n"
 +"   :type iAttribute: :class:`StrokeAttribute`\n";
 +
 +static PyObject *StrokeVertex_setAttribute( BPy_StrokeVertex *self , PyObject *args) {
 +      PyObject *py_sa;
 +
 +      if(!( PyArg_ParseTuple(args, "O!", &StrokeAttribute_Type, &py_sa) ))
 +              return NULL;
 +
 +      self->sv->setAttribute(*( ((BPy_StrokeAttribute *) py_sa)->sa ));
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeVertex_setCurvilinearAbscissa___doc__[] =
 +".. method:: setCurvilinearAbscissa(iAbscissa)\n"
 +"\n"
 +"   Sets the curvilinear abscissa of this StrokeVertex in the Stroke\n"
 +"\n"
 +"   :arg iAbscissa: The curvilinear abscissa.\n"
 +"   :type iAbscissa: float\n";
 +
 +static PyObject *StrokeVertex_setCurvilinearAbscissa( BPy_StrokeVertex *self , PyObject *args) {
 +      double r;
 +
 +      if(!( PyArg_ParseTuple(args, "d", &r)  ))
 +              return NULL;
 +
 +      self->sv->setCurvilinearAbscissa( r );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char StrokeVertex_setStrokeLength___doc__[] =
 +".. method:: setStrokeLength(iLength)\n"
 +"\n"
 +"   Sets the stroke length (it is only a value retained by the\n"
 +"   StrokeVertex, and it won't change the real stroke length).\n"
 +"\n"
 +"   :arg iLength: The stroke length.\n"
 +"   :type iLength: float\n";
 +
 +static PyObject *StrokeVertex_setStrokeLength( BPy_StrokeVertex *self , PyObject *args) {
 +      double r;
 +
 +      if(!( PyArg_ParseTuple(args, "d", &r)  ))
 +              return NULL;
 +
 +      self->sv->setStrokeLength( r );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +// real       operator[] (const int i) const
 +// real &     operator[] (const int i)
 +
 +/*----------------------StrokeVertex instance definitions ----------------------------*/
 +static PyMethodDef BPy_StrokeVertex_methods[] = {     
 +//    {"__copy__", ( PyCFunction ) StrokeVertex___copy__, METH_NOARGS, "() Cloning method."},
 +      {"x", ( PyCFunction ) StrokeVertex_x, METH_NOARGS, StrokeVertex_x___doc__},
 +      {"y", ( PyCFunction ) StrokeVertex_y, METH_NOARGS, StrokeVertex_y___doc__},
 +      {"getPoint", ( PyCFunction ) StrokeVertex_getPoint, METH_NOARGS, StrokeVertex_getPoint___doc__},
 +      {"attribute", ( PyCFunction ) StrokeVertex_attribute, METH_NOARGS, StrokeVertex_attribute___doc__},
 +      {"curvilinearAbscissa", ( PyCFunction ) StrokeVertex_curvilinearAbscissa, METH_NOARGS, StrokeVertex_curvilinearAbscissa___doc__},
 +      {"strokeLength", ( PyCFunction ) StrokeVertex_strokeLength, METH_NOARGS, StrokeVertex_strokeLength___doc__},
 +      {"u", ( PyCFunction ) StrokeVertex_u, METH_NOARGS, StrokeVertex_u___doc__},
 +      {"setX", ( PyCFunction ) StrokeVertex_setX, METH_VARARGS, StrokeVertex_setX___doc__},
 +      {"setY", ( PyCFunction ) StrokeVertex_setY, METH_VARARGS, StrokeVertex_setY___doc__},
 +      {"setPoint", ( PyCFunction ) StrokeVertex_setPoint, METH_VARARGS, StrokeVertex_setPoint___doc__},
 +      {"setAttribute", ( PyCFunction ) StrokeVertex_setAttribute, METH_VARARGS, StrokeVertex_setAttribute___doc__},
 +      {"setCurvilinearAbscissa", ( PyCFunction ) StrokeVertex_setCurvilinearAbscissa, METH_VARARGS, StrokeVertex_setCurvilinearAbscissa___doc__},
 +      {"setStrokeLength", ( PyCFunction ) StrokeVertex_setStrokeLength, METH_VARARGS, StrokeVertex_setStrokeLength___doc__},
 +      {NULL, NULL, 0, NULL}
 +};
 +
 +/*-----------------------BPy_StrokeVertex type definition ------------------------------*/
 +PyTypeObject StrokeVertex_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "StrokeVertex",                 /* tp_name */
 +      sizeof(BPy_StrokeVertex),       /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      StrokeVertex___doc__,           /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      BPy_StrokeVertex_methods,       /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      &CurvePoint_Type,               /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)StrokeVertex___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index 2c66653,0000000..f98b6f4
mode 100644,000000..100644
--- /dev/null
@@@ -1,303 -1,0 +1,303 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_FEdgeSharp.h"
 +
 +#include "../../BPy_Convert.h"
 +#include "../../Interface0D/BPy_SVertex.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char FEdgeSharp___doc__[] =
 +"Class defining a sharp FEdge.  A Sharp FEdge corresponds to an initial\n"
 +"edge of the input mesh.  It can be a silhouette, a crease or a border.\n"
 +"If it is a crease edge, then it is borded by two faces of the mesh.\n"
 +"Face a lies on its right whereas Face b lies on its left.  If it is a\n"
 +"border edge, then it doesn't have any face on its right, and thus Face\n"
 +"a is None.\n"
 +"\n"
 +".. method:: __init__()\n"
 +"\n"
 +"   Default constructor.\n"
 +"\n"
 +".. method:: __init__(iBrother)\n"
 +"\n"
 +"   Copy constructor.\n"
 +"\n"
 +"   :arg iBrother: An FEdgeSharp object.\n"
 +"   :type iBrother: :class:`FEdgeSharp`\n"
 +"\n"
 +".. method:: __init__(vA, vB)\n"
 +"\n"
 +"   Builds an FEdgeSharp going from vA to vB.\n"
 +"\n"
 +"   :arg vA: The first SVertex object.\n"
 +"   :type vA: :class:`SVertex`\n"
 +"   :arg vB: The second SVertex object.\n"
 +"   :type vB: :class:`SVertex`\n";
 +
 +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( !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 {
 +              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";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject * FEdgeSharp_normalA( BPy_FEdgeSharp *self ) {
 +      Vec3r v( self->fes->normalA() );
 +      return Vector_from_Vec3r( v );
 +}
 +
 +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"
- "   :type iNormal: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject * FEdgeSharp_normalB( BPy_FEdgeSharp *self ) {
 +      Vec3r v( self->fes->normalB() );
 +      return Vector_from_Vec3r( v );
 +}
 +
 +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 PyObject * FEdgeSharp_aMaterialIndex( BPy_FEdgeSharp *self ) {
 +      return PyLong_FromLong( self->fes->aFrsMaterialIndex() );
 +}
 +
 +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 PyObject * FEdgeSharp_bMaterialIndex( BPy_FEdgeSharp *self ) {
 +      return PyLong_FromLong( self->fes->bFrsMaterialIndex() );
 +}
 +
 +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 PyObject * FEdgeSharp_aMaterial( BPy_FEdgeSharp *self ) {
 +      FrsMaterial m( self->fes->aFrsMaterial() );
 +      return BPy_FrsMaterial_from_FrsMaterial(m);
 +}
 +
 +static char FEdgeSharp_bMaterial___doc__[] =
 +".. method:: bMaterial()\n"
 +"\n"
 +"   Returns the material of the face lying on the left of the FEdge.\n"
 +"\n"
 +"   :return: The material of the face lying on the left of the FEdge.\n"
 +"   :rtype: :class:`Material`\n";
 +
 +static PyObject * FEdgeSharp_bMaterial( BPy_FEdgeSharp *self ) {
 +      FrsMaterial m( self->fes->aFrsMaterial() );
 +      return BPy_FrsMaterial_from_FrsMaterial(m);
 +}
 +
 +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";
++"   :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;
 +      }
 +      self->fes->setNormalA( *v );
 +      delete v;
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char FEdgeSharp_setNormalB___doc__[] =
 +".. method:: setNormalB(iNormal)\n"
 +"\n"
 +"   Sets the normal to the face lying on the left 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_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;
 +
 +      Py_RETURN_NONE;
 +}
 +
 +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 PyObject * FEdgeSharp_setaMaterialIndex( BPy_FEdgeSharp *self, PyObject *args ) {
 +      unsigned int i;
 +
 +      if(!( PyArg_ParseTuple(args, "I", &i) ))
 +              return NULL;
 +      
 +      self->fes->setaFrsMaterialIndex( i );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +static char FEdgeSharp_setbMaterialIndex___doc__[] =
 +".. method:: setbMaterialIndex(i)\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";
 +
 +static PyObject * FEdgeSharp_setbMaterialIndex( BPy_FEdgeSharp *self, PyObject *args ) {
 +      unsigned int i;
 +
 +      if(!( PyArg_ParseTuple(args, "I", &i) ))
 +              return NULL;
 +      
 +      self->fes->setbFrsMaterialIndex( i );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +/*----------------------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__},
 +      {"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__},
 +      {NULL, NULL, 0, NULL}
 +};
 +
 +/*-----------------------BPy_FEdgeSharp type definition ------------------------------*/
 +
 +PyTypeObject FEdgeSharp_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "FEdgeSharp",                   /* tp_name */
 +      sizeof(BPy_FEdgeSharp),         /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      FEdgeSharp___doc__,             /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      BPy_FEdgeSharp_methods,         /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* 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 */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index 71dbe6f,0000000..3e04310
mode 100644,000000..100644
--- /dev/null
@@@ -1,205 -1,0 +1,205 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_FEdgeSmooth.h"
 +
 +#include "../../BPy_Convert.h"
 +#include "../../Interface0D/BPy_SVertex.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char FEdgeSmooth___doc__[] =
 +"Class defining a smooth edge.  This kind of edge typically runs across\n"
 +"a face of the input mesh.  It can be a silhouette, a ridge or valley,\n"
 +"a suggestive contour.\n"
 +"\n"
 +".. method:: __init__()\n"
 +"\n"
 +"   Default constructor.\n"
 +"\n"
 +".. method:: __init__(iBrother)\n"
 +"\n"
 +"   Copy constructor.\n"
 +"\n"
 +"   :arg iBrother: An FEdgeSmooth object.\n"
 +"   :type iBrother: :class:`FEdgeSmooth`\n"
 +"\n"
 +".. method:: __init__(vA, vB)\n"
 +"\n"
 +"   Builds an FEdgeSmooth going from vA to vB.\n"
 +"\n"
 +"   :arg vA: The first SVertex object.\n"
 +"   :type vA: :class:`SVertex`\n"
 +"   :arg vB: The second SVertex object.\n"
 +"   :type vB: :class:`SVertex`\n";
 +
 +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( !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 {
 +              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 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"
- "   :type iNormal: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n";
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static PyObject * FEdgeSmooth_normal( BPy_FEdgeSmooth *self ) {
 +      Vec3r v( self->fes->normal() );
 +      return Vector_from_Vec3r( v );
 +}
 +
 +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 PyObject * FEdgeSmooth_materialIndex( BPy_FEdgeSmooth *self ) {
 +      return PyLong_FromLong( self->fes->frs_materialIndex() );
 +}
 +
 +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 PyObject * FEdgeSmooth_material( BPy_FEdgeSmooth *self ) {
 +      FrsMaterial m( self->fes->frs_material() );
 +      return BPy_FrsMaterial_from_FrsMaterial(m);
 +}
 +
 +static char FEdgeSmooth_setNormal___doc__[] =
 +".. method:: setNormal(iNormal)\n"
 +"\n"
 +"   Sets the normal to the Face it is running accross.\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;
 +
 +      Py_RETURN_NONE;
 +}
 +
 +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 PyObject * FEdgeSmooth_setMaterialIndex( BPy_FEdgeSmooth *self, PyObject *args ) {
 +      unsigned int i;
 +
 +      if(!( PyArg_ParseTuple(args, "I", &i) ))
 +              return NULL;
 +      
 +      self->fes->setFrsMaterialIndex( i );
 +
 +      Py_RETURN_NONE;
 +}
 +
 +/*----------------------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__},
 +      {"setNormal", ( PyCFunction ) FEdgeSmooth_setNormal, METH_VARARGS, FEdgeSmooth_setNormal___doc__},
 +      {"setMaterialIndex", ( PyCFunction ) FEdgeSmooth_setMaterialIndex, METH_VARARGS, FEdgeSmooth_setMaterialIndex___doc__},
 +      {NULL, NULL, 0, NULL}
 +};
 +
 +/*-----------------------BPy_FEdgeSmooth type definition ------------------------------*/
 +
 +PyTypeObject FEdgeSmooth_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "FEdgeSmooth",                  /* tp_name */
 +      sizeof(BPy_FEdgeSmooth),        /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      FEdgeSmooth___doc__,            /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      BPy_FEdgeSmooth_methods,        /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* 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 */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index 40afe17,0000000..acb2569
mode 100644,000000..100644
--- /dev/null
@@@ -1,111 -1,0 +1,111 @@@
- "   :type iOrientation: :class:`Mathutils.Vector`\n"
 +#include "BPy_CalligraphicShader.h"
 +
 +#include "../../stroke/AdvancedStrokeShaders.h"
 +#include "../BPy_Convert.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char CalligraphicShader___doc__[] =
 +"[Thickness Shader]\n"
 +"\n"
 +".. method:: __init__(iMinThickness, iMaxThickness, iOrientation, iClamp)\n"
 +"\n"
 +"   Builds a CalligraphicShader object.\n"
 +"\n"
 +"   :arg iMinThickness: The minimum thickness in the direction\n"
 +"      perpandicular to the main direction.\n"
 +"   :type iMinThickness: float\n"
 +"   :arg iMaxThickness: The maximum thickness in the main direction.\n"
 +"   :type iMaxThickness: float\n"
 +"   :arg iOrientation: The 2D vector giving the main direction.\n"
++"   :type iOrientation: :class:`mathutils.Vector`\n"
 +"   :arg iClamp: If true, the strokes are drawn in black when the stroke\n"
 +"      direction is between -90 and 90 degrees with respect to the main\n"
 +"      direction and drawn in white otherwise.  If false, the strokes\n"
 +"      are always drawn in black.\n"
 +"   :type iClamp: bool\n"
 +"\n"
 +".. method:: shade(s)\n"
 +"\n"
 +"   Assigns thicknesses to the stroke vertices so that the stroke looks\n"
 +"   like made with a calligraphic tool, i.e. the stroke will be the\n"
 +"   thickest in a main direction, and the thinest in the direction\n"
 +"   perpendicular to this one, and an interpolation inbetween.\n"
 +"\n"
 +"   :arg s: A Stroke object.\n"
 +"   :type s: :class:`Stroke`\n";
 +
 +static int CalligraphicShader___init__( BPy_CalligraphicShader* self, PyObject *args)
 +{
 +      double d1, d2;
 +      PyObject *obj3 = 0, *obj4 = 0;
 +      
 +
 +      if(!( PyArg_ParseTuple(args, "ddOO", &d1, &d2, &obj3, &obj4) ))
 +              return -1;
 +      Vec2f *v = Vec2f_ptr_from_PyObject(obj3);
 +      if( !v ) {
 +              PyErr_SetString(PyExc_TypeError, "argument 3 must be a 2D vector (either a list of 2 elements or Vector)");
 +              return -1;
 +      }
 +      self->py_ss.ss = new CalligraphicShader(d1, d2, *v, bool_from_PyBool(obj4) );
 +      delete v;
 +
 +      return 0;
 +
 +}
 +
 +/*-----------------------BPy_CalligraphicShader type definition ------------------------------*/
 +
 +PyTypeObject CalligraphicShader_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "CalligraphicShader",           /* tp_name */
 +      sizeof(BPy_CalligraphicShader), /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      CalligraphicShader___doc__,     /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      0,                              /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      &StrokeShader_Type,             /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)CalligraphicShader___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index e5b2413,0000000..e1b5e14
mode 100644,000000..100644
--- /dev/null
@@@ -1,87 -1,0 +1,87 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_Normal2DF0D.h"
 +
 +#include "../../../view_map/Functions0D.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char Normal2DF0D___doc__[] =
 +".. method:: __init__()\n"
 +"\n"
 +"   Builds a Normal2DF0D object.\n"
 +"\n"
 +".. method:: __call__(it)\n"
 +"\n"
 +"   Returns a two-dimensional vector giving the normalized 2D normal to\n"
 +"   the 1D element to which the :class:`Interface0D` pointed by the\n"
 +"   Interface0DIterator belongs.  The normal is evaluated at the pointed\n"
 +"   Interface0D.\n"
 +"\n"
 +"   :arg it: An Interface0DIterator object.\n"
 +"   :type it: :class:`Interface0DIterator`\n"
 +"   :return: The 2D normal of the 1D element evaluated at the pointed\n"
 +"      Interface0D.\n"
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static int Normal2DF0D___init__( BPy_Normal2DF0D* self, PyObject *args )
 +{
 +      if( !PyArg_ParseTuple(args, "") )
 +              return -1;
 +      self->py_uf0D_vec2f.uf0D_vec2f = new Functions0D::Normal2DF0D();
 +      self->py_uf0D_vec2f.uf0D_vec2f->py_uf0D = (PyObject *)self;
 +      return 0;
 +}
 +
 +/*-----------------------BPy_Normal2DF0D type definition ------------------------------*/
 +
 +PyTypeObject Normal2DF0D_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "Normal2DF0D",                  /* tp_name */
 +      sizeof(BPy_Normal2DF0D),        /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      Normal2DF0D___doc__,            /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      0,                              /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      &UnaryFunction0DVec2f_Type,     /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)Normal2DF0D___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index e111abd,0000000..e166346
mode 100644,000000..100644
--- /dev/null
@@@ -1,87 -1,0 +1,87 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_VertexOrientation2DF0D.h"
 +
 +#include "../../../view_map/Functions0D.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char VertexOrientation2DF0D___doc__[] =
 +".. method:: __init__()\n"
 +"\n"
 +"   Builds a VertexOrientation2DF0D object.\n"
 +"\n"
 +".. method:: __call__(it)\n"
 +"\n"
 +"   Returns a two-dimensional vector giving the 2D oriented tangent to\n"
 +"   the 1D element to which the :class:`Interface0D` pointed by the\n"
 +"   Interface0DIterator belongs.  The 2D oriented tangent is evaluated\n"
 +"   at the pointed Interface0D.\n"
 +"\n"
 +"   :arg it: An Interface0DIterator object.\n"
 +"   :type it: :class:`Interface0DIterator`\n"
 +"   :return: The 2D oriented tangent to the 1D element evaluated at the\n"
 +"      pointed Interface0D.\n"
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static int VertexOrientation2DF0D___init__( BPy_VertexOrientation2DF0D* self, PyObject *args )
 +{
 +      if( !PyArg_ParseTuple(args, "") )
 +              return -1;
 +      self->py_uf0D_vec2f.uf0D_vec2f = new Functions0D::VertexOrientation2DF0D();
 +      self->py_uf0D_vec2f.uf0D_vec2f->py_uf0D = (PyObject *)self;
 +      return 0;
 +}
 +
 +/*-----------------------BPy_VertexOrientation2DF0D type definition ------------------------------*/
 +
 +PyTypeObject VertexOrientation2DF0D_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "VertexOrientation2DF0D",       /* tp_name */
 +      sizeof(BPy_VertexOrientation2DF0D), /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      VertexOrientation2DF0D___doc__, /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      0,                              /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      &UnaryFunction0DVec2f_Type,     /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)VertexOrientation2DF0D___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index 4ed0450,0000000..0455eea
mode 100644,000000..100644
--- /dev/null
@@@ -1,87 -1,0 +1,87 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_VertexOrientation3DF0D.h"
 +
 +#include "../../../view_map/Functions0D.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char VertexOrientation3DF0D___doc__[] =
 +".. method:: __init__()\n"
 +"\n"
 +"   Builds a VertexOrientation3DF0D object.\n"
 +"\n"
 +".. method:: __call__(it)\n"
 +"\n"
 +"   Returns a three-dimensional vector giving the 3D oriented tangent\n"
 +"   to the 1D element to which the :class:`Interface0D` pointed by the\n"
 +"   Interface0DIterator belongs.  The 3D oriented tangent is evaluated\n"
 +"   at the pointed Interface0D.\n"
 +"\n"
 +"   :arg it: An Interface0DIterator object.\n"
 +"   :type it: :class:`Interface0DIterator`\n"
 +"   :return: The 3D oriented tangent to the 1D element evaluated at the\n"
 +"      pointed Interface0D.\n"
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static int VertexOrientation3DF0D___init__( BPy_VertexOrientation3DF0D* self, PyObject *args )
 +{
 +      if( !PyArg_ParseTuple(args, "") )
 +              return -1;
 +      self->py_uf0D_vec3f.uf0D_vec3f = new Functions0D::VertexOrientation3DF0D();
 +      self->py_uf0D_vec3f.uf0D_vec3f->py_uf0D = (PyObject *)self;
 +      return 0;
 +}
 +
 +/*-----------------------BPy_VertexOrientation3DF0D type definition ------------------------------*/
 +
 +PyTypeObject VertexOrientation3DF0D_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "VertexOrientation3DF0D",       /* tp_name */
 +      sizeof(BPy_VertexOrientation3DF0D), /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      VertexOrientation3DF0D___doc__, /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      0,                              /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      &UnaryFunction0DVec3f_Type,     /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)VertexOrientation3DF0D___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index 61c5dbd,0000000..f5ae4e8
mode 100644,000000..100644
--- /dev/null
@@@ -1,92 -1,0 +1,92 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_Normal2DF1D.h"
 +
 +#include "../../../view_map/Functions1D.h"
 +#include "../../BPy_Convert.h"
 +#include "../../BPy_IntegrationType.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char Normal2DF1D___doc__[] =
 +".. method:: __init__(iType=IntegrationType.MEAN)\n"
 +"\n"
 +"   Builds a Normal2DF1D object.\n"
 +"\n"
 +"   :arg iType: The integration method used to compute a single value\n"
 +"      from a set of values.\n"
 +"   :type iType: :class:`IntegrationType`\n"
 +"\n"
 +".. method:: __call__(inter)\n"
 +"\n"
 +"   Returns the 2D normal for the Interface1D.\n"
 +"\n"
 +"   :arg inter: An Interface1D object.\n"
 +"   :type inter: :class:`Interface1D`\n"
 +"   :return: The 2D normal for the Interface1D.\n"
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static int Normal2DF1D___init__( BPy_Normal2DF1D* self, PyObject *args)
 +{
 +      PyObject *obj = 0;
 +
 +      if( !PyArg_ParseTuple(args, "|O!", &IntegrationType_Type, &obj) )
 +              return -1;
 +
 +      IntegrationType t = ( obj ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
 +      self->py_uf1D_vec2f.uf1D_vec2f = new Functions1D::Normal2DF1D(t);
 +      return 0;
 +}
 +
 +/*-----------------------BPy_Normal2DF1D type definition ------------------------------*/
 +
 +PyTypeObject Normal2DF1D_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "Normal2DF1D",                  /* tp_name */
 +      sizeof(BPy_Normal2DF1D),        /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      Normal2DF1D___doc__,            /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      0,                              /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      &UnaryFunction1DVec2f_Type,     /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)Normal2DF1D___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index 6b984c9,0000000..c83ea65
mode 100644,000000..100644
--- /dev/null
@@@ -1,94 -1,0 +1,94 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_Orientation2DF1D.h"
 +
 +#include "../../../view_map/Functions1D.h"
 +#include "../../BPy_Convert.h"
 +#include "../../BPy_IntegrationType.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char Orientation2DF1D___doc__[] =
 +".. method:: __init__(iType=IntegrationType.MEAN)\n"
 +"\n"
 +"   Builds an Orientation2DF1D object.\n"
 +"\n"
 +"   :arg iType: The integration method used to compute a single value\n"
 +"      from a set of values.\n"
 +"   :type iType: :class:`IntegrationType`\n"
 +"\n"
 +".. method:: __call__(inter)\n"
 +"\n"
 +"   Returns the 2D orientation of the Interface1D.\n"
 +"\n"
 +"   :arg inter: An Interface1D object.\n"
 +"   :type inter: :class:`Interface1D`\n"
 +"   :return: The 2D orientation of the Interface1D.\n"
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static int Orientation2DF1D___init__( BPy_Orientation2DF1D* self, PyObject *args)
 +{
 +      PyObject *obj = 0;
 +
 +      if( !PyArg_ParseTuple(args, "|O!", &IntegrationType_Type, &obj) )
 +              return -1;
 +
 +      IntegrationType t = ( obj ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
 +      self->py_uf1D_vec2f.uf1D_vec2f = new Functions1D::Orientation2DF1D(t);
 +      return 0;
 +
 +}
 +
 +
 +/*-----------------------BPy_Orientation2DF1D type definition ------------------------------*/
 +
 +PyTypeObject Orientation2DF1D_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "Orientation2DF1D",             /* tp_name */
 +      sizeof(BPy_Orientation2DF1D),   /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      Orientation2DF1D___doc__,       /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      0,                              /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      &UnaryFunction1DVec2f_Type,     /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)Orientation2DF1D___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
index 862e4af,0000000..4133911
mode 100644,000000..100644
--- /dev/null
@@@ -1,92 -1,0 +1,92 @@@
- "   :rtype: :class:`Mathutils.Vector`\n";
 +#include "BPy_Orientation3DF1D.h"
 +
 +#include "../../../view_map/Functions1D.h"
 +#include "../../BPy_Convert.h"
 +#include "../../BPy_IntegrationType.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +//------------------------INSTANCE METHODS ----------------------------------
 +
 +static char Orientation3DF1D___doc__[] =
 +".. method:: __init__(iType=IntegrationType.MEAN)\n"
 +"\n"
 +"   Builds an Orientation3DF1D object.\n"
 +"\n"
 +"   :arg iType: The integration method used to compute a single value\n"
 +"      from a set of values.\n"
 +"   :type iType: :class:`IntegrationType`\n"
 +"\n"
 +".. method:: __call__(inter)\n"
 +"\n"
 +"   Returns the 3D orientation of the Interface1D.\n"
 +"\n"
 +"   :arg inter: An Interface1D object.\n"
 +"   :type inter: :class:`Interface1D`\n"
 +"   :return: The 3D orientation of the Interface1D.\n"
++"   :rtype: :class:`mathutils.Vector`\n";
 +
 +static int Orientation3DF1D___init__( BPy_Orientation3DF1D* self, PyObject *args)
 +{
 +      PyObject *obj = 0;
 +
 +      if( !PyArg_ParseTuple(args, "|O!", &IntegrationType_Type, &obj) )
 +              return -1;
 +
 +      IntegrationType t = ( obj ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
 +      self->py_uf1D_vec3f.uf1D_vec3f = new Functions1D::Orientation3DF1D(t);
 +      return 0;
 +}
 +
 +/*-----------------------BPy_Orientation3DF1D type definition ------------------------------*/
 +
 +PyTypeObject Orientation3DF1D_Type = {
 +      PyVarObject_HEAD_INIT(NULL, 0)
 +      "Orientation3DF1D",             /* tp_name */
 +      sizeof(BPy_Orientation3DF1D),   /* tp_basicsize */
 +      0,                              /* tp_itemsize */
 +      0,                              /* tp_dealloc */
 +      0,                              /* tp_print */
 +      0,                              /* tp_getattr */
 +      0,                              /* tp_setattr */
 +      0,                              /* tp_reserved */
 +      0,                              /* tp_repr */
 +      0,                              /* tp_as_number */
 +      0,                              /* tp_as_sequence */
 +      0,                              /* tp_as_mapping */
 +      0,                              /* tp_hash  */
 +      0,                              /* tp_call */
 +      0,                              /* tp_str */
 +      0,                              /* tp_getattro */
 +      0,                              /* tp_setattro */
 +      0,                              /* tp_as_buffer */
 +      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 +      Orientation3DF1D___doc__,       /* tp_doc */
 +      0,                              /* tp_traverse */
 +      0,                              /* tp_clear */
 +      0,                              /* tp_richcompare */
 +      0,                              /* tp_weaklistoffset */
 +      0,                              /* tp_iter */
 +      0,                              /* tp_iternext */
 +      0,                              /* tp_methods */
 +      0,                              /* tp_members */
 +      0,                              /* tp_getset */
 +      &UnaryFunction1DVec3f_Type,     /* tp_base */
 +      0,                              /* tp_dict */
 +      0,                              /* tp_descr_get */
 +      0,                              /* tp_descr_set */
 +      0,                              /* tp_dictoffset */
 +      (initproc)Orientation3DF1D___init__, /* tp_init */
 +      0,                              /* tp_alloc */
 +      0,                              /* tp_new */
 +};
 +
 +///////////////////////////////////////////////////////////////////////////////////////////
 +
 +#ifdef __cplusplus
 +}
 +#endif
Simple merge
@@@ -2330,11 -2366,7 +2439,12 @@@ static void rna_def_scene_render_data(B
        RNA_def_property_ui_text(prop, "Edge Color", "");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
 +      prop= RNA_def_property(srna, "freestyle", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", R_EDGE_FRS);
 +      RNA_def_property_ui_text(prop, "Edge", "Draw stylized strokes using Freestyle.");
 +      RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 +
+       /* threads */
        prop= RNA_def_property(srna, "threads", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "threads");
        RNA_def_property_range(prop, 1, BLENDER_MAX_THREADS);
@@@ -43,6 -43,10 +43,11 @@@ import bp
  import rna_info
  reload(rna_info)
  
+ # lame, python wont give some access
+ MethodDescriptorType = type(dict.get)
+ GetSetDescriptorType = type(int.real)
++StaticMethodType = type(staticmethod(lambda: None))
  EXAMPLE_SET = set()
  EXAMPLE_SET_USED = set()
  
@@@ -204,35 -240,18 +241,24 @@@ def pymodule2sphinx(BASEPATH, module_na
          if value.__doc__:
              write_indented_lines("   ", fw, value.__doc__, False)
              fw("\n")
-         write_example_ref("   ", fw, module_name + "." + attribute)
+         write_example_ref("   ", fw, module_name + "." + type_name)
  
-         for key in sorted(value.__dict__.keys()):
-             if key.startswith("__"):
-                 continue
-             descr = value.__dict__[key]
-             if type(descr) == GetSetDescriptorType:
-                 if descr.__doc__:
-                     fw("   .. attribute:: %s\n\n" % key)
-                     write_indented_lines("   ", fw, descr.__doc__, False)
-                     write_example_ref("   ", fw, module_name + "." + attribute + "." + key)
-                     fw("\n")
-         for key in sorted(value.__dict__.keys()):
-             if key.startswith("__"):
-                 continue
-             descr = value.__dict__[key]
+         descr_items = [(key, descr) for key, descr in sorted(value.__dict__.items()) if not key.startswith("__")]
+         for key, descr in descr_items:
              if type(descr) == MethodDescriptorType: # GetSetDescriptorType, GetSetDescriptorType's are not documented yet
-                 if descr.__doc__:
-                     write_indented_lines("   ", fw, descr.__doc__, False)
-                     write_example_ref("   ", fw, module_name + "." + attribute + "." + key)
-                     fw("\n")
-             elif type(descr) == StaticMethodType:
+                 py_descr2sphinx("   ", fw, descr, module_name, type_name, key)
+         for key, descr in descr_items:
+             if type(descr) == GetSetDescriptorType:
+                 py_descr2sphinx("   ", fw, descr, module_name, type_name, key)
++        for key, descr in descr_items:
++            if type(descr) == StaticMethodType:
 +                descr = getattr(value, key)
-                 if descr.__doc__:
-                     write_indented_lines("   ", fw, descr.__doc__, False)
-                     write_example_ref("   ", fw, module_name + "." + attribute + "." + key)
-                     fw("\n")
-             
++                write_indented_lines("   ", fw, descr.__doc__ or "Undocumented", False)
++                fw("\n")
++
          fw("\n\n")
  
      file.close()
@@@ -313,8 -332,7 +339,8 @@@ def rna2sphinx(BASEPATH)
      # C modules
      fw("   bpy.props.rst\n\n")
      
-     fw("   Mathutils.rst\n\n")
+     fw("   mathutils.rst\n\n")
 +    fw("   Freestyle.rst\n\n")
      fw("   blf.rst\n\n")
      file.close()
  
      from bpy import props as module
      pymodule2sphinx(BASEPATH, "bpy.props", module, "Property Definitions (bpy.props)")
      
-     import Mathutils as module
-     pymodule2sphinx(BASEPATH, "Mathutils", module, "Math Types & Utilities (Mathutils)")
+     import mathutils as module
+     pymodule2sphinx(BASEPATH, "mathutils", module, "Math Types & Utilities (mathutils)")
      del module
  
 +    import Freestyle as module
 +    pymodule2sphinx(BASEPATH, "Freestyle", module, "Freestyle Operators & Rules (Freestyle)")
 +    del module
 +
      import blf as module
      pymodule2sphinx(BASEPATH, "blf", module, "Blender Font Drawing (blf)")
      del module
  #include "BLI_path_util.h"
   
   /* external util modules */
- #include "../generic/Geometry.h"
+ #include "../generic/geometry.h"
  #include "../generic/bgl.h"
- #include "../generic/blf.h"
+ #include "../generic/blf_api.h"
  #include "../generic/IDProp.h"
  
 +#include "BPy_Freestyle.h"
 +
  static char bpy_home_paths_doc[] =
  ".. function:: home_paths(subfolder)\n"
  "\n"
@@@ -360,8 -361,6 +362,7 @@@ ENDIF(CMAKE_SYSTEM_NAME MATCHES "Linux"
        SET(BLENDER_SORTED_LIBS
                bf_windowmanager
                bf_editors
-               bf_decimation 
 +              bf_freestyle
                blender_BSP 
                bf_ghost 
                bf_string 
Simple merge
Simple merge