soc-2008-mxcurioni: ported ALL 1D unary functions, representing 32 new classes.

83 files changed, 5702 insertions, 280 deletions

diff --git a/source/blender/freestyle/SConscript b/source/blender/freestyle/SConscript
index 3ee1a79ce0c..3abce0d3ec1 100644
--- a/source/blender/freestyle/SConscript
+++ b/source/blender/freestyle/SConscript
@@ -138,6 +138,39 @@ python_sources = [
 							prefix + '/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetOccludeeF0D.cpp',
 							prefix + '/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetShapeF0D.cpp',
 					prefix + '/BPy_UnaryFunction1D.cpp',
+							prefix + '/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.cpp',
+							prefix + '/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp',
+									prefix + '/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.cpp',
+							prefix + '/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp',
+							prefix + '/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.cpp',
+							prefix + '/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp',
+							prefix + '/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp',
+							prefix + '/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.cpp',
+							prefix + '/UnaryFunction1D/BPy_UnaryFunction1DVoid.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp',
+								prefix + '/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.cpp',
 					prefix + '/BPy_UnaryPredicate0D.cpp',
 					prefix + '/BPy_UnaryPredicate1D.cpp',
 					prefix + '/BPy_ViewMap.cpp',
diff --git a/source/blender/freestyle/intern/python/BPy_Convert.cpp b/source/blender/freestyle/intern/python/BPy_Convert.cpp
index 4d66b46420a..d7b8bfa6cce 100644
--- a/source/blender/freestyle/intern/python/BPy_Convert.cpp
+++ b/source/blender/freestyle/intern/python/BPy_Convert.cpp
@@ -189,6 +189,22 @@ PyObject * BPy_FrsMaterial_from_Material( Material& m ){
 	return py_m;
 }
 
+PyObject * BPy_IntegrationType_from_IntegrationType( int i ) {
+	PyObject *py_it = IntegrationType_Type.tp_new( &IntegrationType_Type, 0, 0 );
+
+	PyObject *args = PyTuple_New(1);
+	PyTuple_SetItem( args, 0, PyInt_FromLong(i) );
+	IntegrationType_Type.tp_init( py_it, args, 0 );
+	Py_DECREF(args);
+
+	return py_it;
+}
+
+IntegrationType IntegrationType_from_BPy_IntegrationType( PyObject* obj ) {
+	return static_cast<IntegrationType>( PyInt_AsLong(obj) );
+}
+
+
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
diff --git a/source/blender/freestyle/intern/python/BPy_Convert.h b/source/blender/freestyle/intern/python/BPy_Convert.h
index 9bf535ead6a..4d318fcbc1d 100644
--- a/source/blender/freestyle/intern/python/BPy_Convert.h
+++ b/source/blender/freestyle/intern/python/BPy_Convert.h
@@ -58,10 +58,13 @@ PyObject * Vector_from_Vec2f( Vec2f& v );
 PyObject * Vector_from_Vec3f( Vec3f& v );
 PyObject * Vector_from_Vec3r( Vec3r& v );
 
+IntegrationType IntegrationType_from_BPy_IntegrationType( PyObject* obj );
+
 PyObject * BPy_BBox_from_BBox( BBox< Vec3r > &bb );
 PyObject * BPy_FEdge_from_FEdge( FEdge& fe );
 PyObject * BPy_Id_from_Id( Id& id );
 PyObject * BPy_Interface0D_from_Interface0D( Interface0D& if0D );
+PyObject * BPy_IntegrationType_from_IntegrationType( int i );
 PyObject * BPy_FrsMaterial_from_Material( Material& m );
 PyObject * BPy_Nature_from_Nature( unsigned short n );
 PyObject * BPy_MediumType_from_MediumType( int n );
diff --git a/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.cpp b/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.cpp
index 70f6feb02d3..9ab0ce41fb3 100644
--- a/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.cpp
+++ b/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.cpp
@@ -1,6 +1,13 @@
 #include "BPy_UnaryFunction1D.h"
 
-#include "BPy_Convert.h"
+#include "UnaryFunction1D/BPy_UnaryFunction1DDouble.h"
+#include "UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.h"
+#include "UnaryFunction1D/BPy_UnaryFunction1DFloat.h"
+#include "UnaryFunction1D/BPy_UnaryFunction1DUnsigned.h"
+#include "UnaryFunction1D/BPy_UnaryFunction1DVec2f.h"
+#include "UnaryFunction1D/BPy_UnaryFunction1DVec3f.h"
+#include "UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h"
+
 
 #ifdef __cplusplus
 extern "C" {
@@ -9,17 +16,11 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 /*---------------  Python API function prototypes for UnaryFunction1D instance  -----------*/
-static int UnaryFunction1D___init__(BPy_UnaryFunction1D *self, PyObject *args, PyObject *kwds);
 static void UnaryFunction1D___dealloc__(BPy_UnaryFunction1D *self);
 static PyObject * UnaryFunction1D___repr__(BPy_UnaryFunction1D *self);
 
-static PyObject * UnaryFunction1D_getName( BPy_UnaryFunction1D *self, PyObject *args);
-static PyObject * UnaryFunction1D___call__( BPy_UnaryFunction1D *self, PyObject *args);
-
 /*----------------------UnaryFunction1D instance definitions ----------------------------*/
 static PyMethodDef BPy_UnaryFunction1D_methods[] = {
-	{"getName", ( PyCFunction ) UnaryFunction1D_getName, METH_NOARGS, ""},
-	{"__call__", ( PyCFunction ) UnaryFunction1D___call__, METH_VARARGS, "" },
 	{NULL, NULL, 0, NULL}
 };
 
@@ -73,7 +74,7 @@ PyTypeObject UnaryFunction1D_Type = {
 	NULL,                       /* richcmpfunc tp_richcompare; */
 
   /***  weak reference enabler ***/
-	NULL,                          /* long tp_weaklistoffset; */
+	0,                          /* long tp_weaklistoffset; */
 
   /*** Added in release 2.2 ***/
 	/*   Iterators */
@@ -88,8 +89,8 @@ PyTypeObject UnaryFunction1D_Type = {
 	NULL,							/* PyObject *tp_dict; */
 	NULL,							/* descrgetfunc tp_descr_get; */
 	NULL,							/* descrsetfunc tp_descr_set; */
-	NULL,                          	/* long tp_dictoffset; */
-	(initproc)UnaryFunction1D___init__, /* initproc tp_init; */
+	0,                          	/* long tp_dictoffset; */
+	NULL, /* initproc tp_init; */
 	NULL,							/* allocfunc tp_alloc; */
 	PyType_GenericNew,		/* newfunc tp_new; */
 	
@@ -118,56 +119,29 @@ PyMODINIT_FUNC UnaryFunction1D_Init( PyObject *module )
 		return;
 	Py_INCREF( &UnaryFunction1D_Type );
 	PyModule_AddObject(module, "UnaryFunction1D", (PyObject *)&UnaryFunction1D_Type);
+
+	UnaryFunction1DDouble_Init( module );
+	UnaryFunction1DEdgeNature_Init( module );
+	UnaryFunction1DFloat_Init( module );
+	UnaryFunction1DUnsigned_Init( module );
+	UnaryFunction1DVec2f_Init( module );
+	UnaryFunction1DVec3f_Init( module );
+	UnaryFunction1DVectorViewShape_Init( module );
 }
 
 //------------------------INSTANCE METHODS ----------------------------------
 
-int UnaryFunction1D___init__(BPy_UnaryFunction1D *self, PyObject *args, PyObject *kwds)
-{
-	return 0;
-}
-
 void UnaryFunction1D___dealloc__(BPy_UnaryFunction1D* self)
 {
-	//delete self->uf1D;
     self->ob_type->tp_free((PyObject*)self);
 }
 
 
 PyObject * UnaryFunction1D___repr__(BPy_UnaryFunction1D* self)
 {
-    return PyString_FromFormat("type: %s - address: %p", ((UnaryFunction1D<void> *) self->uf1D)->getName().c_str(), self->uf1D );
-}
-
-
-PyObject * UnaryFunction1D_getName( BPy_UnaryFunction1D *self, PyObject *args)
-{
-	return PyString_FromString( ((UnaryFunction1D<void> *) self->uf1D)->getName().c_str() );
+    return PyString_FromString("UnaryFunction1D");
 }
 
-PyObject * UnaryFunction1D___call__( BPy_UnaryFunction1D *self, PyObject *args)
-{
-	PyObject *l;
-
-	if( !PyArg_ParseTuple(args, "O", &l) ) {
-		cout << "ERROR: UnaryFunction1D___call__ " << endl;		
-		return NULL;
-	}
-	
-	// pb: operator() is called on Interface0DIterator while we have a list
-	// solutions:
-	// 1)reconvert back to iterator ?
-	// 2) adapt interface0d to have t(), u() functions
-	
-	// b = self->bp0D->operator()( *(obj1->uf0D) );
-	// return PyBool_from_bool( b );
-	
-	Py_RETURN_NONE;
-}
-
-// void 	setIntegrationType (IntegrationType integration)
-// IntegrationType 	getIntegrationType () const
-
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __cplusplus
diff --git a/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h b/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h
index 4c509f50b85..21cece45fa4 100644
--- a/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h
+++ b/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h
@@ -18,7 +18,6 @@ extern PyTypeObject UnaryFunction1D_Type;
 /*---------------------------Python BPy_UnaryFunction1D structure definition----------*/
 typedef struct {
 	PyObject_HEAD
- 	void *uf1D;
 } BPy_UnaryFunction1D;
 
 /*---------------------------Python BPy_UnaryFunction1D visible prototypes-----------*/
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.cpp
index f7c520b1492..02aef4e28cf 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.cpp
@@ -168,7 +168,7 @@ PyObject * UnaryFunction0DVectorViewShape___call__( BPy_UnaryFunction0DVectorVie
 	std::vector<ViewShape*> vs( self->uf0D_vectorviewshape->operator()(*( ((BPy_Interface0DIterator *) obj)->if0D_it )) );
 	PyObject *list = PyList_New(NULL);
 	
-	for( int i = 0; i < vs.size(); i++)
+	for( unsigned int i = 0; i < vs.size(); i++)
 		PyList_Append(list, BPy_ViewShape_from_ViewShape(*( vs[i] )) );
 	
 	return list;
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp
index ad7c6627799..5b6aed936b9 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp
@@ -1,20 +1,285 @@
- PyObject *_wrap_UnaryFunction1DDouble_getName(PyObject *self , PyObject *args) {
+#include "BPy_UnaryFunction1DDouble.h"
+
+#include "../BPy_Convert.h"
+#include "../BPy_Interface1D.h"
+#include "../BPy_IntegrationType.h"
+
+#include "UnaryFunction1D_double/BPy_Curvature2DAngleF1D.h"
+#include "UnaryFunction1D_double/BPy_DensityF1D.h"
+#include "UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.h"
+#include "UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.h"
+#include "UnaryFunction1D_double/BPy_GetProjectedXF1D.h"
+#include "UnaryFunction1D_double/BPy_GetProjectedYF1D.h"
+#include "UnaryFunction1D_double/BPy_GetProjectedZF1D.h"
+#include "UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.h"
+#include "UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.h"
+#include "UnaryFunction1D_double/BPy_GetXF1D.h"
+#include "UnaryFunction1D_double/BPy_GetYF1D.h"
+#include "UnaryFunction1D_double/BPy_GetZF1D.h"
+#include "UnaryFunction1D_double/BPy_LocalAverageDepthF1D.h"
+#include "UnaryFunction1D_double/BPy_ZDiscontinuityF1D.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction1DDouble instance  -----------*/
+static int UnaryFunction1DDouble___init__(BPy_UnaryFunction1DDouble* self, PyObject *args);
+static void UnaryFunction1DDouble___dealloc__(BPy_UnaryFunction1DDouble* self);
+static PyObject * UnaryFunction1DDouble___repr__(BPy_UnaryFunction1DDouble* self);
+
+static PyObject * UnaryFunction1DDouble_getName( BPy_UnaryFunction1DDouble *self);
+static PyObject * UnaryFunction1DDouble___call__( BPy_UnaryFunction1DDouble *self, PyObject *args);
+static PyObject * UnaryFunction1DDouble_setIntegrationType(BPy_UnaryFunction1DDouble* self, PyObject *args);
+static PyObject * UnaryFunction1DDouble_getIntegrationType(BPy_UnaryFunction1DDouble* self);
+
+/*----------------------UnaryFunction1DDouble instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction1DDouble_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction1DDouble_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
+	{"__call__", ( PyCFunction ) UnaryFunction1DDouble___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
+	{"setIntegrationType", ( PyCFunction ) UnaryFunction1DDouble_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
+	{"getIntegrationType", ( PyCFunction ) UnaryFunction1DDouble_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction1DDouble type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1DDouble_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1DDouble",				/* tp_name */
+	sizeof( BPy_UnaryFunction1DDouble ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1DDouble___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1DDouble___repr__,					/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1DDouble_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1D_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1DDouble___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,		/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//-------------------MODULE INITIALIZATION--------------------------------
+
+PyMODINIT_FUNC UnaryFunction1DDouble_Init( PyObject *module ) {
+
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1DDouble_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1DDouble_Type );
+	PyModule_AddObject(module, "UnaryFunction1DDouble", (PyObject *)&UnaryFunction1DDouble_Type);
+
+	if( PyType_Ready( &DensityF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &DensityF1D_Type );
+	PyModule_AddObject(module, "DensityF1D", (PyObject *)&DensityF1D_Type);
+
+	if( PyType_Ready( &GetCompleteViewMapDensityF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetCompleteViewMapDensityF1D_Type );
+	PyModule_AddObject(module, "GetCompleteViewMapDensityF1D", (PyObject *)&GetCompleteViewMapDensityF1D_Type);
+
+	if( PyType_Ready( &GetDirectionalViewMapDensityF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetDirectionalViewMapDensityF1D_Type );
+	PyModule_AddObject(module, "GetDirectionalViewMapDensityF1D", (PyObject *)&GetDirectionalViewMapDensityF1D_Type);
+
+	if( PyType_Ready( &GetProjectedXF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetProjectedXF1D_Type );
+	PyModule_AddObject(module, "GetProjectedXF1D", (PyObject *)&GetProjectedXF1D_Type);
+
+	if( PyType_Ready( &GetProjectedYF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetProjectedYF1D_Type );
+	PyModule_AddObject(module, "GetProjectedYF1D", (PyObject *)&GetProjectedYF1D_Type);
+	
+	if( PyType_Ready( &GetProjectedZF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetProjectedZF1D_Type );
+	PyModule_AddObject(module, "GetProjectedZF1D", (PyObject *)&GetProjectedZF1D_Type);
+
+	if( PyType_Ready( &GetSteerableViewMapDensityF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetSteerableViewMapDensityF1D_Type );
+	PyModule_AddObject(module, "GetSteerableViewMapDensityF1D", (PyObject *)&GetSteerableViewMapDensityF1D_Type);
+
+	if( PyType_Ready( &GetViewMapGradientNormF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetViewMapGradientNormF1D_Type );
+	PyModule_AddObject(module, "GetViewMapGradientNormF1D", (PyObject *)&GetViewMapGradientNormF1D_Type);
+
+	if( PyType_Ready( &GetXF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetXF1D_Type );
+	PyModule_AddObject(module, "GetXF1D", (PyObject *)&GetXF1D_Type);
+
+	if( PyType_Ready( &GetYF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetYF1D_Type );
+	PyModule_AddObject(module, "GetYF1D", (PyObject *)&GetYF1D_Type);
+
+	if( PyType_Ready( &GetZF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetZF1D_Type );
+	PyModule_AddObject(module, "GetZF1D", (PyObject *)&GetZF1D_Type);
+
+	if( PyType_Ready( &LocalAverageDepthF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &LocalAverageDepthF1D_Type );
+	PyModule_AddObject(module, "LocalAverageDepthF1D", (PyObject *)&LocalAverageDepthF1D_Type);
+
+	if( PyType_Ready( &ZDiscontinuityF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &ZDiscontinuityF1D_Type );
+	PyModule_AddObject(module, "ZDiscontinuityF1D", (PyObject *)&ZDiscontinuityF1D_Type);
+		
 }
 
+//------------------------INSTANCE METHODS ----------------------------------
+
+int UnaryFunction1DDouble___init__(BPy_UnaryFunction1DDouble* self, PyObject *args)
+{
+	PyObject *obj;
 
- PyObject *_wrap_UnaryFunction1DDouble___call__(PyObject *self , PyObject *args) {
+	if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DDouble___init__ " << endl;		
+		return -1;
+	}
+	
+	if( !obj )
+		self->uf1D_double = new UnaryFunction1D<double>();
+	else {
+		self->uf1D_double = new UnaryFunction1D<double>( IntegrationType_from_BPy_IntegrationType(obj) );
+	}
+	
+	return 0;
 }
 
+void UnaryFunction1DDouble___dealloc__(BPy_UnaryFunction1DDouble* self)
+{
+	delete self->uf1D_double;
+	UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
+}
+
+
+PyObject * UnaryFunction1DDouble___repr__(BPy_UnaryFunction1DDouble* self)
+{
+	return PyString_FromFormat("type: %s - address: %p", self->uf1D_double->getName().c_str(), self->uf1D_double );
+}
 
- PyObject *_wrap_UnaryFunction1DDouble_setIntegrationType(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DDouble_getName( BPy_UnaryFunction1DDouble *self )
+{
+	return PyString_FromString( self->uf1D_double->getName().c_str() );
 }
 
+PyObject * UnaryFunction1DDouble___call__( BPy_UnaryFunction1DDouble *self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DDouble___call__ " << endl;		
+		return NULL;
+	}
+	
+	double d = self->uf1D_double->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
+	return PyFloat_FromDouble( d );
 
- PyObject *_wrap_UnaryFunction1DDouble_getIntegrationType(PyObject *self , PyObject *args) {
 }
 
+PyObject * UnaryFunction1DDouble_setIntegrationType(BPy_UnaryFunction1DDouble* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DDouble_setIntegrationType " << endl;		
+		Py_RETURN_NONE;
+	}
+	
+	self->uf1D_double->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
+	Py_RETURN_NONE;
+}
 
- PyObject *_wrap_disown_UnaryFunction1DDouble(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DDouble_getIntegrationType(BPy_UnaryFunction1DDouble* self) {
+	return BPy_IntegrationType_from_IntegrationType( self->uf1D_double->getIntegrationType() );
 }
 
 
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.h b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.h
new file mode 100644
index 00000000000..7b6e9430498
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DDOUBLE_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1DDOUBLE_H
+
+#include "../BPy_UnaryFunction1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1DDouble_Type;
+
+#define BPy_UnaryFunction1DDouble_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1DDouble_Type)
+
+/*---------------------------Python BPy_UnaryFunction1DDouble structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1D py_uf1D;
+	UnaryFunction1D<double> *uf1D_double;
+} BPy_UnaryFunction1DDouble;
+
+/*---------------------------Python BPy_UnaryFunction1DDouble visible prototypes-----------*/
+PyMODINIT_FUNC UnaryFunction1DDouble_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DDOUBLE_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp
new file mode 100644
index 00000000000..d4d7f642494
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp
@@ -0,0 +1,209 @@
+#include "BPy_UnaryFunction1DEdgeNature.h"
+
+#include "../BPy_Convert.h"
+#include "../BPy_Interface1D.h"
+#include "../BPy_IntegrationType.h"
+
+#include "UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction1DEdgeNature instance  -----------*/
+static int UnaryFunction1DEdgeNature___init__(BPy_UnaryFunction1DEdgeNature* self, PyObject *args);
+static void UnaryFunction1DEdgeNature___dealloc__(BPy_UnaryFunction1DEdgeNature* self);
+static PyObject * UnaryFunction1DEdgeNature___repr__(BPy_UnaryFunction1DEdgeNature* self);
+
+static PyObject * UnaryFunction1DEdgeNature_getName( BPy_UnaryFunction1DEdgeNature *self);
+static PyObject * UnaryFunction1DEdgeNature___call__( BPy_UnaryFunction1DEdgeNature *self, PyObject *args);
+static PyObject * UnaryFunction1DEdgeNature_setIntegrationType(BPy_UnaryFunction1DEdgeNature* self, PyObject *args);
+static PyObject * UnaryFunction1DEdgeNature_getIntegrationType(BPy_UnaryFunction1DEdgeNature* self);
+
+/*----------------------UnaryFunction1DEdgeNature instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction1DEdgeNature_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction1DEdgeNature_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
+	{"__call__", ( PyCFunction ) UnaryFunction1DEdgeNature___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
+	{"setIntegrationType", ( PyCFunction ) UnaryFunction1DEdgeNature_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
+	{"getIntegrationType", ( PyCFunction ) UnaryFunction1DEdgeNature_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction1DEdgeNature type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1DEdgeNature_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1DEdgeNature",				/* tp_name */
+	sizeof( BPy_UnaryFunction1DEdgeNature ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1DEdgeNature___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1DEdgeNature___repr__,					/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1DEdgeNature_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1D_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1DEdgeNature___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,		/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//-------------------MODULE INITIALIZATION--------------------------------
+
+PyMODINIT_FUNC UnaryFunction1DEdgeNature_Init( PyObject *module ) {
+
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1DEdgeNature_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1DEdgeNature_Type );
+	PyModule_AddObject(module, "UnaryFunction1DEdgeNature", (PyObject *)&UnaryFunction1DEdgeNature_Type);
+	
+	if( PyType_Ready( &CurveNatureF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &CurveNatureF1D_Type );
+	PyModule_AddObject(module, "CurveNatureF1D", (PyObject *)&CurveNatureF1D_Type);
+		
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int UnaryFunction1DEdgeNature___init__(BPy_UnaryFunction1DEdgeNature* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DEdgeNature___init__ " << endl;		
+		return -1;
+	}
+	
+	if( !obj )
+		self->uf1D_edgenature = new UnaryFunction1D<Nature::EdgeNature>();
+	else {
+		self->uf1D_edgenature = new UnaryFunction1D<Nature::EdgeNature>( IntegrationType_from_BPy_IntegrationType(obj) );
+	}
+	
+	return 0;
+}
+void UnaryFunction1DEdgeNature___dealloc__(BPy_UnaryFunction1DEdgeNature* self)
+{
+	delete self->uf1D_edgenature;
+	UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
+}
+
+
+PyObject * UnaryFunction1DEdgeNature___repr__(BPy_UnaryFunction1DEdgeNature* self)
+{
+	return PyString_FromFormat("type: %s - address: %p", self->uf1D_edgenature->getName().c_str(), self->uf1D_edgenature );
+}
+
+PyObject * UnaryFunction1DEdgeNature_getName( BPy_UnaryFunction1DEdgeNature *self )
+{
+	return PyString_FromString( self->uf1D_edgenature->getName().c_str() );
+}
+
+PyObject * UnaryFunction1DEdgeNature___call__( BPy_UnaryFunction1DEdgeNature *self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DEdgeNature___call__ " << endl;		
+		return NULL;
+	}
+	
+	Nature::EdgeNature n = self->uf1D_edgenature->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
+	return BPy_Nature_from_Nature( n );
+
+}
+
+PyObject * UnaryFunction1DEdgeNature_setIntegrationType(BPy_UnaryFunction1DEdgeNature* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DEdgeNature_setIntegrationType " << endl;		
+		Py_RETURN_NONE;
+	}
+	
+	self->uf1D_edgenature->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
+	Py_RETURN_NONE;
+}
+
+PyObject * UnaryFunction1DEdgeNature_getIntegrationType(BPy_UnaryFunction1DEdgeNature* self) {
+	return BPy_IntegrationType_from_IntegrationType( self->uf1D_edgenature->getIntegrationType() );
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.h b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.h
new file mode 100644
index 00000000000..9e899916a95
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.h
@@ -0,0 +1,36 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DEDGENATURE_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1DEDGENATURE_H
+
+#include "../BPy_UnaryFunction1D.h"
+
+#include "../../winged_edge/Nature.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1DEdgeNature_Type;
+
+#define BPy_UnaryFunction1DEdgeNature_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1DEdgeNature_Type)
+
+/*---------------------------Python BPy_UnaryFunction1DEdgeNature structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1D py_uf1D;
+	UnaryFunction1D<Nature::EdgeNature> *uf1D_edgenature;
+} BPy_UnaryFunction1DEdgeNature;
+
+/*---------------------------Python BPy_UnaryFunction1DEdgeNature visible prototypes-----------*/
+PyMODINIT_FUNC UnaryFunction1DEdgeNature_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DEDGENATURE_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp
index cb572980f8f..f4c8a9e53ce 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp
@@ -1,20 +1,202 @@
- PyObject *_wrap_UnaryFunction1DFloat_getName(PyObject *self , PyObject *args) {
+#include "BPy_UnaryFunction1DFloat.h"
+
+#include "../BPy_Convert.h"
+#include "../BPy_Interface1D.h"
+#include "../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction1DFloat instance  -----------*/
+static int UnaryFunction1DFloat___init__(BPy_UnaryFunction1DFloat* self, PyObject *args);
+static void UnaryFunction1DFloat___dealloc__(BPy_UnaryFunction1DFloat* self);
+static PyObject * UnaryFunction1DFloat___repr__(BPy_UnaryFunction1DFloat* self);
+
+static PyObject * UnaryFunction1DFloat_getName( BPy_UnaryFunction1DFloat *self);
+static PyObject * UnaryFunction1DFloat___call__( BPy_UnaryFunction1DFloat *self, PyObject *args);
+static PyObject * UnaryFunction1DFloat_setIntegrationType(BPy_UnaryFunction1DFloat* self, PyObject *args);
+static PyObject * UnaryFunction1DFloat_getIntegrationType(BPy_UnaryFunction1DFloat* self);
+
+/*----------------------UnaryFunction1DFloat instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction1DFloat_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction1DFloat_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
+	{"__call__", ( PyCFunction ) UnaryFunction1DFloat___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
+	{"setIntegrationType", ( PyCFunction ) UnaryFunction1DFloat_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
+	{"getIntegrationType", ( PyCFunction ) UnaryFunction1DFloat_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction1DFloat type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1DFloat_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1DFloat",				/* tp_name */
+	sizeof( BPy_UnaryFunction1DFloat ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1DFloat___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1DFloat___repr__,					/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1DFloat_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1D_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1DFloat___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,		/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//-------------------MODULE INITIALIZATION--------------------------------
+
+PyMODINIT_FUNC UnaryFunction1DFloat_Init( PyObject *module ) {
+
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1DFloat_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1DFloat_Type );
+	PyModule_AddObject(module, "UnaryFunction1DFloat", (PyObject *)&UnaryFunction1DFloat_Type);
+		
 }
 
+//------------------------INSTANCE METHODS ----------------------------------
 
- PyObject *_wrap_UnaryFunction1DFloat___call__(PyObject *self , PyObject *args) {
+int UnaryFunction1DFloat___init__(BPy_UnaryFunction1DFloat* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DFloat___init__ " << endl;		
+		return -1;
+	}
+	
+	if( !obj )
+		self->uf1D_float = new UnaryFunction1D<float>();
+	else {
+		self->uf1D_float = new UnaryFunction1D<float>( IntegrationType_from_BPy_IntegrationType(obj) );
+	}
+	
+	return 0;
+}
+void UnaryFunction1DFloat___dealloc__(BPy_UnaryFunction1DFloat* self)
+{
+	delete self->uf1D_float;
+	UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
 }
 
 
- PyObject *_wrap_UnaryFunction1DFloat_setIntegrationType(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DFloat___repr__(BPy_UnaryFunction1DFloat* self)
+{
+	return PyString_FromFormat("type: %s - address: %p", self->uf1D_float->getName().c_str(), self->uf1D_float );
+}
+
+PyObject * UnaryFunction1DFloat_getName( BPy_UnaryFunction1DFloat *self )
+{
+	return PyString_FromString( self->uf1D_float->getName().c_str() );
 }
 
+PyObject * UnaryFunction1DFloat___call__( BPy_UnaryFunction1DFloat *self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DFloat___call__ " << endl;		
+		return NULL;
+	}
+	
+	float f = self->uf1D_float->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
+	return PyFloat_FromDouble( f );
 
- PyObject *_wrap_UnaryFunction1DFloat_getIntegrationType(PyObject *self , PyObject *args) {
 }
 
+PyObject * UnaryFunction1DFloat_setIntegrationType(BPy_UnaryFunction1DFloat* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DFloat_setIntegrationType " << endl;		
+		Py_RETURN_NONE;
+	}
+	
+	self->uf1D_float->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
+	Py_RETURN_NONE;
+}
 
- PyObject *_wrap_disown_UnaryFunction1DFloat(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DFloat_getIntegrationType(BPy_UnaryFunction1DFloat* self) {
+	return BPy_IntegrationType_from_IntegrationType( self->uf1D_float->getIntegrationType() );
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.h b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.h
new file mode 100644
index 00000000000..f454ab664ed
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DFLOAT_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1DFLOAT_H
+
+#include "../BPy_UnaryFunction1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1DFloat_Type;
+
+#define BPy_UnaryFunction1DFloat_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1DFloat_Type)
+
+/*---------------------------Python BPy_UnaryFunction1DFloat structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1D py_uf1D;
+	UnaryFunction1D<float> *uf1D_float;
+} BPy_UnaryFunction1DFloat;
+
+/*---------------------------Python BPy_UnaryFunction1DFloat visible prototypes-----------*/
+PyMODINIT_FUNC UnaryFunction1DFloat_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DFLOAT_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp
index eb230a2d49f..ef75f3bad5b 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp
@@ -1,20 +1,209 @@
- PyObject *_wrap_UnaryFunction1DUnsigned_getName(PyObject *self , PyObject *args) {
+#include "BPy_UnaryFunction1DUnsigned.h"
+
+#include "../BPy_Convert.h"
+#include "../BPy_Interface1D.h"
+#include "../BPy_IntegrationType.h"
+
+#include "UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction1DUnsigned instance  -----------*/
+static int UnaryFunction1DUnsigned___init__(BPy_UnaryFunction1DUnsigned* self, PyObject *args);
+static void UnaryFunction1DUnsigned___dealloc__(BPy_UnaryFunction1DUnsigned* self);
+static PyObject * UnaryFunction1DUnsigned___repr__(BPy_UnaryFunction1DUnsigned* self);
+
+static PyObject * UnaryFunction1DUnsigned_getName( BPy_UnaryFunction1DUnsigned *self);
+static PyObject * UnaryFunction1DUnsigned___call__( BPy_UnaryFunction1DUnsigned *self, PyObject *args);
+static PyObject * UnaryFunction1DUnsigned_setIntegrationType(BPy_UnaryFunction1DUnsigned* self, PyObject *args);
+static PyObject * UnaryFunction1DUnsigned_getIntegrationType(BPy_UnaryFunction1DUnsigned* self);
+
+/*----------------------UnaryFunction1DUnsigned instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction1DUnsigned_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction1DUnsigned_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
+	{"__call__", ( PyCFunction ) UnaryFunction1DUnsigned___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
+	{"setIntegrationType", ( PyCFunction ) UnaryFunction1DUnsigned_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
+	{"getIntegrationType", ( PyCFunction ) UnaryFunction1DUnsigned_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction1DUnsigned type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1DUnsigned_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1DUnsigned",				/* tp_name */
+	sizeof( BPy_UnaryFunction1DUnsigned ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1DUnsigned___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1DUnsigned___repr__,					/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1DUnsigned_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1D_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1DUnsigned___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,		/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//-------------------MODULE INITIALIZATION--------------------------------
+
+PyMODINIT_FUNC UnaryFunction1DUnsigned_Init( PyObject *module ) {
+
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1DUnsigned_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1DUnsigned_Type );
+	PyModule_AddObject(module, "UnaryFunction1DUnsigned", (PyObject *)&UnaryFunction1DUnsigned_Type);
+	
+	if( PyType_Ready( &QuantitativeInvisibilityF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &QuantitativeInvisibilityF1D_Type );
+	PyModule_AddObject(module, "QuantitativeInvisibilityF1D", (PyObject *)&QuantitativeInvisibilityF1D_Type);
+			
 }
 
+//------------------------INSTANCE METHODS ----------------------------------
 
- PyObject *_wrap_UnaryFunction1DUnsigned___call__(PyObject *self , PyObject *args) {
+int UnaryFunction1DUnsigned___init__(BPy_UnaryFunction1DUnsigned* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DUnsigned___init__ " << endl;		
+		return -1;
+	}
+	
+	if( !obj )
+		self->uf1D_unsigned = new UnaryFunction1D<unsigned int>();
+	else {
+		self->uf1D_unsigned = new UnaryFunction1D<unsigned int>( IntegrationType_from_BPy_IntegrationType(obj) );
+	}
+	
+	return 0;
+}
+void UnaryFunction1DUnsigned___dealloc__(BPy_UnaryFunction1DUnsigned* self)
+{
+	delete self->uf1D_unsigned;
+	UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
 }
 
 
- PyObject *_wrap_UnaryFunction1DUnsigned_setIntegrationType(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DUnsigned___repr__(BPy_UnaryFunction1DUnsigned* self)
+{
+	return PyString_FromFormat("type: %s - address: %p", self->uf1D_unsigned->getName().c_str(), self->uf1D_unsigned );
+}
+
+PyObject * UnaryFunction1DUnsigned_getName( BPy_UnaryFunction1DUnsigned *self )
+{
+	return PyString_FromString( self->uf1D_unsigned->getName().c_str() );
 }
 
+PyObject * UnaryFunction1DUnsigned___call__( BPy_UnaryFunction1DUnsigned *self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DUnsigned___call__ " << endl;		
+		return NULL;
+	}
+	
+	unsigned int i = self->uf1D_unsigned->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
+	return PyInt_FromLong( i );
 
- PyObject *_wrap_UnaryFunction1DUnsigned_getIntegrationType(PyObject *self , PyObject *args) {
 }
 
+PyObject * UnaryFunction1DUnsigned_setIntegrationType(BPy_UnaryFunction1DUnsigned* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DUnsigned_setIntegrationType " << endl;		
+		Py_RETURN_NONE;
+	}
+	
+	self->uf1D_unsigned->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
+	Py_RETURN_NONE;
+}
 
- PyObject *_wrap_disown_UnaryFunction1DUnsigned(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DUnsigned_getIntegrationType(BPy_UnaryFunction1DUnsigned* self) {
+	return BPy_IntegrationType_from_IntegrationType( self->uf1D_unsigned->getIntegrationType() );
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.h b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.h
new file mode 100644
index 00000000000..0df50d9a999
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DUNSIGNED_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1DUNSIGNED_H
+
+#include "../BPy_UnaryFunction1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1DUnsigned_Type;
+
+#define BPy_UnaryFunction1DUnsigned_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1DUnsigned_Type)
+
+/*---------------------------Python BPy_UnaryFunction1DUnsigned structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1D py_uf1D;
+	UnaryFunction1D<unsigned int> *uf1D_unsigned;
+} BPy_UnaryFunction1DUnsigned;
+
+/*---------------------------Python BPy_UnaryFunction1DUnsigned visible prototypes-----------*/
+PyMODINIT_FUNC UnaryFunction1DUnsigned_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DUNSIGNED_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp
index 64fb6ef6ed7..e0fa12c66e6 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp
@@ -1,20 +1,215 @@
- PyObject *_wrap_UnaryFunction1DVec2f_getName(PyObject *self , PyObject *args) {
+#include "BPy_UnaryFunction1DVec2f.h"
+
+#include "../BPy_Convert.h"
+#include "../BPy_Interface1D.h"
+#include "../BPy_IntegrationType.h"
+
+#include "UnaryFunction1D_Vec2f/BPy_Normal2DF1D.h"
+#include "UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction1DVec2f instance  -----------*/
+static int UnaryFunction1DVec2f___init__(BPy_UnaryFunction1DVec2f* self, PyObject *args);
+static void UnaryFunction1DVec2f___dealloc__(BPy_UnaryFunction1DVec2f* self);
+static PyObject * UnaryFunction1DVec2f___repr__(BPy_UnaryFunction1DVec2f* self);
+
+static PyObject * UnaryFunction1DVec2f_getName( BPy_UnaryFunction1DVec2f *self);
+static PyObject * UnaryFunction1DVec2f___call__( BPy_UnaryFunction1DVec2f *self, PyObject *args);
+static PyObject * UnaryFunction1DVec2f_setIntegrationType(BPy_UnaryFunction1DVec2f* self, PyObject *args);
+static PyObject * UnaryFunction1DVec2f_getIntegrationType(BPy_UnaryFunction1DVec2f* self);
+
+/*----------------------UnaryFunction1DVec2f instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction1DVec2f_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction1DVec2f_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
+	{"__call__", ( PyCFunction ) UnaryFunction1DVec2f___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
+	{"setIntegrationType", ( PyCFunction ) UnaryFunction1DVec2f_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
+	{"getIntegrationType", ( PyCFunction ) UnaryFunction1DVec2f_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction1DVec2f type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1DVec2f_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1DVec2f",				/* tp_name */
+	sizeof( BPy_UnaryFunction1DVec2f ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1DVec2f___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1DVec2f___repr__,					/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1DVec2f_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1D_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1DVec2f___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,		/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//-------------------MODULE INITIALIZATION--------------------------------
+
+PyMODINIT_FUNC UnaryFunction1DVec2f_Init( PyObject *module ) {
+
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1DVec2f_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1DVec2f_Type );
+	PyModule_AddObject(module, "UnaryFunction1DVec2f", (PyObject *)&UnaryFunction1DVec2f_Type);
+	
+	if( PyType_Ready( &Normal2DF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &Normal2DF1D_Type );
+	PyModule_AddObject(module, "Normal2DF1D", (PyObject *)&Normal2DF1D_Type);
+	
+	if( PyType_Ready( &Orientation2DF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &Orientation2DF1D_Type );
+	PyModule_AddObject(module, "Orientation2DF1D", (PyObject *)&Orientation2DF1D_Type);
+		
 }
 
+//------------------------INSTANCE METHODS ----------------------------------
 
- PyObject *_wrap_UnaryFunction1DVec2f___call__(PyObject *self , PyObject *args) {
+int UnaryFunction1DVec2f___init__(BPy_UnaryFunction1DVec2f* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVec2f___init__ " << endl;		
+		return -1;
+	}
+	
+	if( !obj )
+		self->uf1D_vec2f = new UnaryFunction1D<Vec2f>();
+	else {
+		self->uf1D_vec2f = new UnaryFunction1D<Vec2f>( IntegrationType_from_BPy_IntegrationType(obj) );
+	}
+	
+	return 0;
+}
+void UnaryFunction1DVec2f___dealloc__(BPy_UnaryFunction1DVec2f* self)
+{
+	delete self->uf1D_vec2f;
+	UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
 }
 
 
- PyObject *_wrap_UnaryFunction1DVec2f_setIntegrationType(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DVec2f___repr__(BPy_UnaryFunction1DVec2f* self)
+{
+	return PyString_FromFormat("type: %s - address: %p", self->uf1D_vec2f->getName().c_str(), self->uf1D_vec2f );
+}
+
+PyObject * UnaryFunction1DVec2f_getName( BPy_UnaryFunction1DVec2f *self )
+{
+	return PyString_FromString( self->uf1D_vec2f->getName().c_str() );
 }
 
+PyObject * UnaryFunction1DVec2f___call__( BPy_UnaryFunction1DVec2f *self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVec2f___call__ " << endl;		
+		return NULL;
+	}
+	
+	Vec2f v( self->uf1D_vec2f->operator()(*( ((BPy_Interface1D *) obj)->if1D )) );
+	return Vector_from_Vec2f( v );
 
- PyObject *_wrap_UnaryFunction1DVec2f_getIntegrationType(PyObject *self , PyObject *args) {
 }
 
+PyObject * UnaryFunction1DVec2f_setIntegrationType(BPy_UnaryFunction1DVec2f* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVec2f_setIntegrationType " << endl;		
+		Py_RETURN_NONE;
+	}
+	
+	self->uf1D_vec2f->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
+	Py_RETURN_NONE;
+}
 
- PyObject *_wrap_disown_UnaryFunction1DVec2f(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DVec2f_getIntegrationType(BPy_UnaryFunction1DVec2f* self) {
+	return BPy_IntegrationType_from_IntegrationType( self->uf1D_vec2f->getIntegrationType() );
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.h b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.h
new file mode 100644
index 00000000000..098992e6631
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.h
@@ -0,0 +1,37 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DVEC2F_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1DVEC2F_H
+
+#include "../BPy_UnaryFunction1D.h"
+
+#include "../../geometry/Geom.h"
+using namespace Geometry;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1DVec2f_Type;
+
+#define BPy_UnaryFunction1DVec2f_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1DVec2f_Type)
+
+/*---------------------------Python BPy_UnaryFunction1DVec2f structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1D py_uf1D;
+	UnaryFunction1D<Vec2f> *uf1D_vec2f;
+} BPy_UnaryFunction1DVec2f;
+
+/*---------------------------Python BPy_UnaryFunction1DVec2f visible prototypes-----------*/
+PyMODINIT_FUNC UnaryFunction1DVec2f_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DVEC2F_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp
index d7b360eb10e..3a3c7d4e835 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp
@@ -1,20 +1,209 @@
- PyObject *_wrap_UnaryFunction1DVec3f_getName(PyObject *self , PyObject *args) {
+#include "BPy_UnaryFunction1DVec3f.h"
+
+#include "../BPy_Convert.h"
+#include "../BPy_Interface1D.h"
+#include "../BPy_IntegrationType.h"
+
+#include "UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction1DVec3f instance  -----------*/
+static int UnaryFunction1DVec3f___init__(BPy_UnaryFunction1DVec3f* self, PyObject *args);
+static void UnaryFunction1DVec3f___dealloc__(BPy_UnaryFunction1DVec3f* self);
+static PyObject * UnaryFunction1DVec3f___repr__(BPy_UnaryFunction1DVec3f* self);
+
+static PyObject * UnaryFunction1DVec3f_getName( BPy_UnaryFunction1DVec3f *self);
+static PyObject * UnaryFunction1DVec3f___call__( BPy_UnaryFunction1DVec3f *self, PyObject *args);
+static PyObject * UnaryFunction1DVec3f_setIntegrationType(BPy_UnaryFunction1DVec3f* self, PyObject *args);
+static PyObject * UnaryFunction1DVec3f_getIntegrationType(BPy_UnaryFunction1DVec3f* self);
+
+/*----------------------UnaryFunction1DVec3f instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction1DVec3f_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction1DVec3f_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
+	{"__call__", ( PyCFunction ) UnaryFunction1DVec3f___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
+	{"setIntegrationType", ( PyCFunction ) UnaryFunction1DVec3f_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
+	{"getIntegrationType", ( PyCFunction ) UnaryFunction1DVec3f_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction1DVec3f type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1DVec3f_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1DVec3f",				/* tp_name */
+	sizeof( BPy_UnaryFunction1DVec3f ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1DVec3f___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1DVec3f___repr__,					/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1DVec3f_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1D_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1DVec3f___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,		/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//-------------------MODULE INITIALIZATION--------------------------------
+
+PyMODINIT_FUNC UnaryFunction1DVec3f_Init( PyObject *module ) {
+
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1DVec3f_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1DVec3f_Type );
+	PyModule_AddObject(module, "UnaryFunction1DVec3f", (PyObject *)&UnaryFunction1DVec3f_Type);
+	
+	if( PyType_Ready( &Orientation3DF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &Orientation3DF1D_Type );
+	PyModule_AddObject(module, "Orientation3DF1D", (PyObject *)&Orientation3DF1D_Type);
+		
 }
 
+//------------------------INSTANCE METHODS ----------------------------------
 
- PyObject *_wrap_UnaryFunction1DVec3f___call__(PyObject *self , PyObject *args) {
+int UnaryFunction1DVec3f___init__(BPy_UnaryFunction1DVec3f* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVec3f___init__ " << endl;		
+		return -1;
+	}
+	
+	if( !obj )
+		self->uf1D_vec3f = new UnaryFunction1D<Vec3f>();
+	else {
+		self->uf1D_vec3f = new UnaryFunction1D<Vec3f>( IntegrationType_from_BPy_IntegrationType(obj) );
+	}
+	
+	return 0;
+}
+void UnaryFunction1DVec3f___dealloc__(BPy_UnaryFunction1DVec3f* self)
+{
+	delete self->uf1D_vec3f;
+	UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
 }
 
 
- PyObject *_wrap_UnaryFunction1DVec3f_setIntegrationType(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DVec3f___repr__(BPy_UnaryFunction1DVec3f* self)
+{
+	return PyString_FromFormat("type: %s - address: %p", self->uf1D_vec3f->getName().c_str(), self->uf1D_vec3f );
+}
+
+PyObject * UnaryFunction1DVec3f_getName( BPy_UnaryFunction1DVec3f *self )
+{
+	return PyString_FromString( self->uf1D_vec3f->getName().c_str() );
 }
 
+PyObject * UnaryFunction1DVec3f___call__( BPy_UnaryFunction1DVec3f *self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVec3f___call__ " << endl;		
+		return NULL;
+	}
+	
+	Vec3f v( self->uf1D_vec3f->operator()(*( ((BPy_Interface1D *) obj)->if1D )) );
+	return Vector_from_Vec3f( v );
 
- PyObject *_wrap_UnaryFunction1DVec3f_getIntegrationType(PyObject *self , PyObject *args) {
 }
 
+PyObject * UnaryFunction1DVec3f_setIntegrationType(BPy_UnaryFunction1DVec3f* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVec3f_setIntegrationType " << endl;		
+		Py_RETURN_NONE;
+	}
+	
+	self->uf1D_vec3f->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
+	Py_RETURN_NONE;
+}
 
- PyObject *_wrap_disown_UnaryFunction1DVec3f(PyObject *self , PyObject *args) {
+PyObject * UnaryFunction1DVec3f_getIntegrationType(BPy_UnaryFunction1DVec3f* self) {
+	return BPy_IntegrationType_from_IntegrationType( self->uf1D_vec3f->getIntegrationType() );
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.h b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.h
new file mode 100644
index 00000000000..3829fa12b62
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.h
@@ -0,0 +1,37 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DVEC3F_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1DVEC3F_H
+
+#include "../BPy_UnaryFunction1D.h"
+
+#include "../../geometry/Geom.h"
+using namespace Geometry;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1DVec3f_Type;
+
+#define BPy_UnaryFunction1DVec3f_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1DVec3f_Type)
+
+/*---------------------------Python BPy_UnaryFunction1DVec3f structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1D py_uf1D;
+	UnaryFunction1D<Vec3f> *uf1D_vec3f;
+} BPy_UnaryFunction1DVec3f;
+
+/*---------------------------Python BPy_UnaryFunction1DVec3f visible prototypes-----------*/
+PyMODINIT_FUNC UnaryFunction1DVec3f_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DVEC3F_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp
index 1fe16797593..c0b25403706 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp
@@ -1,16 +1,228 @@
- PyObject *_wrap_UnaryFunction1DVectorViewShape_getName(PyObject *self , PyObject *args) {
+#include "BPy_UnaryFunction1DVectorViewShape.h"
+
+#include "../BPy_Convert.h"
+#include "../BPy_Interface1D.h"
+#include "../BPy_IntegrationType.h"
+
+#include "UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.h"
+#include "UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.h"
+#include "UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction1DVectorViewShape instance  -----------*/
+static int UnaryFunction1DVectorViewShape___init__(BPy_UnaryFunction1DVectorViewShape* self, PyObject *args);
+static void UnaryFunction1DVectorViewShape___dealloc__(BPy_UnaryFunction1DVectorViewShape* self);
+static PyObject * UnaryFunction1DVectorViewShape___repr__(BPy_UnaryFunction1DVectorViewShape* self);
+
+static PyObject * UnaryFunction1DVectorViewShape_getName( BPy_UnaryFunction1DVectorViewShape *self);
+static PyObject * UnaryFunction1DVectorViewShape___call__( BPy_UnaryFunction1DVectorViewShape *self, PyObject *args);
+static PyObject * UnaryFunction1DVectorViewShape_setIntegrationType(BPy_UnaryFunction1DVectorViewShape* self, PyObject *args);
+static PyObject * UnaryFunction1DVectorViewShape_getIntegrationType(BPy_UnaryFunction1DVectorViewShape* self);
+
+/*----------------------UnaryFunction1DVectorViewShape instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction1DVectorViewShape_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction1DVectorViewShape_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
+	{"__call__", ( PyCFunction ) UnaryFunction1DVectorViewShape___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
+	{"setIntegrationType", ( PyCFunction ) UnaryFunction1DVectorViewShape_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
+	{"getIntegrationType", ( PyCFunction ) UnaryFunction1DVectorViewShape_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction1DVectorViewShape type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1DVectorViewShape_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1DVectorViewShape",				/* tp_name */
+	sizeof( BPy_UnaryFunction1DVectorViewShape ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1DVectorViewShape___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1DVectorViewShape___repr__,					/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1DVectorViewShape_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1D_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1DVectorViewShape___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,		/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//-------------------MODULE INITIALIZATION--------------------------------
+
+PyMODINIT_FUNC UnaryFunction1DVectorViewShape_Init( PyObject *module ) {
+
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1DVectorViewShape_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1DVectorViewShape_Type );
+	PyModule_AddObject(module, "UnaryFunction1DVectorViewShape", (PyObject *)&UnaryFunction1DVectorViewShape_Type);
+	
+	if( PyType_Ready( &GetOccludeeF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetOccludeeF1D_Type );
+	PyModule_AddObject(module, "GetOccludeeF1D", (PyObject *)&GetOccludeeF1D_Type);
+
+	if( PyType_Ready( &GetOccludersF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetOccludersF1D_Type );
+	PyModule_AddObject(module, "GetOccludersF1D", (PyObject *)&GetOccludersF1D_Type);
+	
+	if( PyType_Ready( &GetShapeF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &GetShapeF1D_Type );
+	PyModule_AddObject(module, "GetShapeF1D", (PyObject *)&GetShapeF1D_Type);
+	
 }
 
 
- PyObject *_wrap_UnaryFunction1DVectorViewShape___call__(PyObject *self , PyObject *args) {
+//------------------------INSTANCE METHODS ----------------------------------
+
+int UnaryFunction1DVectorViewShape___init__(BPy_UnaryFunction1DVectorViewShape* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVectorViewShape___init__ " << endl;		
+		return -1;
+	}
+	
+	if( !obj )
+		self->uf1D_vectorviewshape = new UnaryFunction1D< std::vector<ViewShape*> >();
+	else {
+		self->uf1D_vectorviewshape = new UnaryFunction1D< std::vector<ViewShape*> >( IntegrationType_from_BPy_IntegrationType(obj) );
+	}
+	
+	return 0;
 }
 
+void UnaryFunction1DVectorViewShape___dealloc__(BPy_UnaryFunction1DVectorViewShape* self)
+{
+	delete self->uf1D_vectorviewshape;
+	UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
+}
 
- PyObject *_wrap_UnaryFunction1DVectorViewShape_setIntegrationType(PyObject *self , PyObject *args) {
+
+PyObject * UnaryFunction1DVectorViewShape___repr__(BPy_UnaryFunction1DVectorViewShape* self)
+{
+	return PyString_FromFormat("type: %s - address: %p", self->uf1D_vectorviewshape->getName().c_str(), self->uf1D_vectorviewshape );
+}
+
+PyObject * UnaryFunction1DVectorViewShape_getName( BPy_UnaryFunction1DVectorViewShape *self )
+{
+	return PyString_FromString( self->uf1D_vectorviewshape->getName().c_str() );
 }
 
+PyObject * UnaryFunction1DVectorViewShape___call__( BPy_UnaryFunction1DVectorViewShape *self, PyObject *args)
+{
+	PyObject *obj;
 
- PyObject *_wrap_UnaryFunction1DVectorViewShape_getIntegrationType(PyObject *self , PyObject *args) {
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVectorViewShape___call__ " << endl;		
+		return NULL;
+	}
+	
+	
+	std::vector<ViewShape*> vs( self->uf1D_vectorviewshape->operator()(*( ((BPy_Interface1D *) obj)->if1D )) );
+	PyObject *list = PyList_New(NULL);
+	
+	for( unsigned int i = 0; i < vs.size(); i++)
+		PyList_Append(list, BPy_ViewShape_from_ViewShape(*( vs[i] )) );
+	
+	return list;
 }
 
+PyObject * UnaryFunction1DVectorViewShape_setIntegrationType(BPy_UnaryFunction1DVectorViewShape* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVectorViewShape_setIntegrationType " << endl;		
+		Py_RETURN_NONE;
+	}
+	
+	self->uf1D_vectorviewshape->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
+	Py_RETURN_NONE;
+}
 
+PyObject * UnaryFunction1DVectorViewShape_getIntegrationType(BPy_UnaryFunction1DVectorViewShape* self) {
+	return BPy_IntegrationType_from_IntegrationType( self->uf1D_vectorviewshape->getIntegrationType() );
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h
new file mode 100644
index 00000000000..cdde1926c86
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h
@@ -0,0 +1,37 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DVECTORVIEWSHAPE_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1DVECTORVIEWSHAPE_H
+
+#include "../BPy_UnaryFunction1D.h"
+
+#include <vector>
+#include "../../view_map/ViewMap.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1DVectorViewShape_Type;
+
+#define BPy_UnaryFunction1DVectorViewShape_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1DVectorViewShape_Type)
+
+/*---------------------------Python BPy_UnaryFunction1DVectorViewShape structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1D py_uf1D;
+	UnaryFunction1D< std::vector<ViewShape*> > *uf1D_vectorviewshape;
+} BPy_UnaryFunction1DVectorViewShape;
+
+/*---------------------------Python BPy_UnaryFunction1DVectorViewShape visible prototypes-----------*/
+PyMODINIT_FUNC UnaryFunction1DVectorViewShape_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DVECTORVIEWSHAPE_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.cpp
new file mode 100644
index 00000000000..99cc6838997
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.cpp
@@ -0,0 +1,224 @@
+#include "BPy_UnaryFunction1DVoid.h"
+
+#include "../BPy_Convert.h"
+#include "../BPy_Interface1D.h"
+#include "../BPy_IntegrationType.h"
+
+#include "UnaryFunction1D_void/BPy_ChainingTimeStampF1D.h"
+#include "UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.h"
+#include "UnaryFunction1D_void/BPy_TimeStampF1D.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction1DVoid instance  -----------*/
+static int UnaryFunction1DVoid___init__(BPy_UnaryFunction1DVoid* self, PyObject *args);
+static void UnaryFunction1DVoid___dealloc__(BPy_UnaryFunction1DVoid* self);
+static PyObject * UnaryFunction1DVoid___repr__(BPy_UnaryFunction1DVoid* self);
+
+static PyObject * UnaryFunction1DVoid_getName( BPy_UnaryFunction1DVoid *self);
+static PyObject * UnaryFunction1DVoid___call__( BPy_UnaryFunction1DVoid *self, PyObject *args);
+
+static PyObject * UnaryFunction1DVoid_setIntegrationType(BPy_UnaryFunction1DVoid* self, PyObject *args);
+static PyObject * UnaryFunction1DVoid_getIntegrationType(BPy_UnaryFunction1DVoid* self);
+
+/*----------------------UnaryFunction1DVoid instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction1DVoid_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction1DVoid_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
+	{"__call__", ( PyCFunction ) UnaryFunction1DVoid___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
+	{"setIntegrationType", ( PyCFunction ) UnaryFunction1DVoid_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
+	{"getIntegrationType", ( PyCFunction ) UnaryFunction1DVoid_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction1DVoid type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1DVoid_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1DVoid",				/* tp_name */
+	sizeof( BPy_UnaryFunction1DVoid ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1DVoid___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1DVoid___repr__,					/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1DVoid_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1D_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1DVoid___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,		/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//-------------------MODULE INITIALIZATION--------------------------------
+
+PyMODINIT_FUNC UnaryFunction1DVoid_Init( PyObject *module ) {
+
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1DVoid_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1DVoid_Type );
+	PyModule_AddObject(module, "UnaryFunction1DVoid", (PyObject *)&UnaryFunction1DVoid_Type);
+	
+	if( PyType_Ready( &ChainingTimeStampF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &ChainingTimeStampF1D_Type );
+	PyModule_AddObject(module, "ChainingTimeStampF1D", (PyObject *)&ChainingTimeStampF1D_Type);
+	
+	if( PyType_Ready( &IncrementChainingTimeStampF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &IncrementChainingTimeStampF1D_Type );
+	PyModule_AddObject(module, "IncrementChainingTimeStampF1D", (PyObject *)&IncrementChainingTimeStampF1D_Type);
+	
+	if( PyType_Ready( &TimeStampF1D_Type ) < 0 )
+		return;
+	Py_INCREF( &TimeStampF1D_Type );
+	PyModule_AddObject(module, "TimeStampF1D", (PyObject *)&TimeStampF1D_Type);
+	
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int UnaryFunction1DVoid___init__(BPy_UnaryFunction1DVoid* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVoid___init__ " << endl;		
+		return -1;
+	}
+	
+	if( !obj )
+		self->uf1D_void = new UnaryFunction1D<void>();
+	else {
+		self->uf1D_void = new UnaryFunction1D<void>( IntegrationType_from_BPy_IntegrationType(obj) );
+	}
+	
+	return 0;
+}
+
+void UnaryFunction1DVoid___dealloc__(BPy_UnaryFunction1DVoid* self)
+{
+	delete self->uf1D_void;
+	UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
+}
+
+
+PyObject * UnaryFunction1DVoid___repr__(BPy_UnaryFunction1DVoid* self)
+{
+	return PyString_FromFormat("type: %s - address: %p", self->uf1D_void->getName().c_str(), self->uf1D_void );
+}
+
+PyObject * UnaryFunction1DVoid_getName( BPy_UnaryFunction1DVoid *self )
+{
+	return PyString_FromString( self->uf1D_void->getName().c_str() );
+}
+
+PyObject * UnaryFunction1DVoid___call__( BPy_UnaryFunction1DVoid *self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVoid___call__ " << endl;		
+		return NULL;
+	}
+	
+	self->uf1D_void->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
+	Py_RETURN_NONE;
+}
+
+PyObject * UnaryFunction1DVoid_setIntegrationType(BPy_UnaryFunction1DVoid* self, PyObject *args)
+{
+	PyObject *obj;
+
+	if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
+		cout << "ERROR: UnaryFunction1DVoid_setIntegrationType " << endl;		
+		Py_RETURN_NONE;
+	}
+	
+	self->uf1D_void->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
+	Py_RETURN_NONE;
+}
+
+PyObject * UnaryFunction1DVoid_getIntegrationType(BPy_UnaryFunction1DVoid* self) {
+	return BPy_IntegrationType_from_IntegrationType( self->uf1D_void->getIntegrationType() );
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.h b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.h
new file mode 100644
index 00000000000..68d9c61569c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DVOID_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1DVOID_H
+
+#include "../BPy_UnaryFunction1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1DVoid_Type;
+
+#define BPy_UnaryFunction1DVoid_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1DVoid_Type)
+
+/*---------------------------Python BPy_UnaryFunction1DVoid structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1D py_uf1D;
+	UnaryFunction1D<void> *uf1D_void;
+} BPy_UnaryFunction1DVoid;
+
+/*---------------------------Python BPy_UnaryFunction1DVoid visible prototypes-----------*/
+PyMODINIT_FUNC UnaryFunction1DVoid_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DVOID_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.cpp
index 94d180e6cc8..a6a6d69de30 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.cpp
@@ -1,12 +1,123 @@
- PyObject *_wrap_CurveNatureF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_CurveNatureF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_CurveNatureF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for CurveNatureF1D instance  -----------*/
+	static int CurveNatureF1D___init__( BPy_CurveNatureF1D* self, PyObject *args);
+
+/*-----------------------BPy_CurveNatureF1D type definition ------------------------------*/
+
+PyTypeObject CurveNatureF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"CurveNatureF1D",				/* tp_name */
+	sizeof( BPy_CurveNatureF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DEdgeNature_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)CurveNatureF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int CurveNatureF1D___init__( BPy_CurveNatureF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: CurveNatureF1D___init__" << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_edgenature.uf1D_edgenature = new Functions1D::CurveNatureF1D(t);
+	return 0;
 
- PyObject *_wrap_delete_CurveNatureF1D(PyObject *self , PyObject *args) {
 }
 
 
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.h
new file mode 100644
index 00000000000..7e9344dddda
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_CURVENATUREF1D_H
+#define FREESTYLE_PYTHON_CURVENATUREF1D_H
+
+#include "../BPy_UnaryFunction1DEdgeNature.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject CurveNatureF1D_Type;
+
+#define BPy_CurveNatureF1D_Check(v)	(( (PyObject *) v)->ob_type == &CurveNatureF1D_Type)
+
+/*---------------------------Python BPy_CurveNatureF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DEdgeNature py_uf1D_edgenature;
+} BPy_CurveNatureF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_CURVENATUREF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp
index 81e5a18cb2c..e8421277bf2 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp
@@ -1,12 +1,122 @@
- PyObject *_wrap_Normal2DF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_Normal2DF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_Normal2DF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Normal2DF1D instance  -----------*/
+	static int Normal2DF1D___init__( BPy_Normal2DF1D* self, PyObject *args);
+
+/*-----------------------BPy_Normal2DF1D type definition ------------------------------*/
+
+PyTypeObject Normal2DF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Normal2DF1D",				/* tp_name */
+	sizeof( BPy_Normal2DF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVec2f_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Normal2DF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int Normal2DF1D___init__( BPy_Normal2DF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: Normal2DF1D___init__" << endl;		
+		return -1;
+	}
+
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_vec2f.uf1D_vec2f = new Functions1D::Normal2DF1D(t);
+	return 0;
 
- PyObject *_wrap_delete_Normal2DF1D(PyObject *self , PyObject *args) {
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.h
new file mode 100644
index 00000000000..70bfb0adb12
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_NORMAL2DF1D_H
+#define FREESTYLE_PYTHON_NORMAL2DF1D_H
+
+#include "../BPy_UnaryFunction1DVec2f.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Normal2DF1D_Type;
+
+#define BPy_Normal2DF1D_Check(v)	(( (PyObject *) v)->ob_type == &Normal2DF1D_Type)
+
+/*---------------------------Python BPy_Normal2DF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVec2f py_uf1D_vec2f;
+} BPy_Normal2DF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_NORMAL2DF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp
index 2d6cfed8575..b6e69b80bce 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp
@@ -1,12 +1,123 @@
- PyObject *_wrap_Orientation2DF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_Orientation2DF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_Orientation2DF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Orientation2DF1D instance  -----------*/
+	static int Orientation2DF1D___init__( BPy_Orientation2DF1D* self, PyObject *args);
+
+/*-----------------------BPy_Orientation2DF1D type definition ------------------------------*/
+
+PyTypeObject Orientation2DF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Orientation2DF1D",				/* tp_name */
+	sizeof( BPy_Orientation2DF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
 
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVec2f_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Orientation2DF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int Orientation2DF1D___init__( BPy_Orientation2DF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: Orientation2DF1D___init__" << endl;		
+		return -1;
+	}
+
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_vec2f.uf1D_vec2f = new Functions1D::Orientation2DF1D(t);
+	return 0;
 
- PyObject *_wrap_delete_Orientation2DF1D(PyObject *self , PyObject *args) {
 }
 
 
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.h
new file mode 100644
index 00000000000..bcae5fc220f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_ORIENTATION2DF1D_H
+#define FREESTYLE_PYTHON_ORIENTATION2DF1D_H
+
+#include "../BPy_UnaryFunction1DVec2f.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Orientation2DF1D_Type;
+
+#define BPy_Orientation2DF1D_Check(v)	(( (PyObject *) v)->ob_type == &Orientation2DF1D_Type)
+
+/*---------------------------Python BPy_Orientation2DF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVec2f py_uf1D_vec2f;
+} BPy_Orientation2DF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_ORIENTATION2DF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp
index f416f2ace03..5501a875683 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp
@@ -1,12 +1,124 @@
- PyObject *_wrap_Orientation3DF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_Orientation3DF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_Orientation3DF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Orientation3DF1D instance  -----------*/
+	static int Orientation3DF1D___init__( BPy_Orientation3DF1D* self, PyObject *args);
+
+/*-----------------------BPy_Orientation3DF1D type definition ------------------------------*/
+
+PyTypeObject Orientation3DF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Orientation3DF1D",				/* tp_name */
+	sizeof( BPy_Orientation3DF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
 
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVec3f_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Orientation3DF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int Orientation3DF1D___init__( BPy_Orientation3DF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: Orientation3DF1D___init__" << endl;		
+		return -1;
+	}
+
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_vec3f.uf1D_vec3f = new Functions1D::Orientation3DF1D(t);
+	return 0;
 
- PyObject *_wrap_delete_Orientation3DF1D(PyObject *self , PyObject *args) {
 }
 
 
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.h
new file mode 100644
index 00000000000..a868c04ce15
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_ORIENTATION3DF1D_H
+#define FREESTYLE_PYTHON_ORIENTATION3DF1D_H
+
+#include "../BPy_UnaryFunction1DVec3f.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Orientation3DF1D_Type;
+
+#define BPy_Orientation3DF1D_Check(v)	(( (PyObject *) v)->ob_type == &Orientation3DF1D_Type)
+
+/*---------------------------Python BPy_Orientation3DF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVec3f py_uf1D_vec3f;
+} BPy_Orientation3DF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_ORIENTATION3DF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.cpp
new file mode 100644
index 00000000000..ae4a6c7f33d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.cpp
@@ -0,0 +1,121 @@
+#include "BPy_Curvature2DAngleF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Curvature2DAngleF1D instance  -----------*/
+static int Curvature2DAngleF1D___init__(BPy_Curvature2DAngleF1D* self, PyObject *args);
+
+/*-----------------------BPy_Curvature2DAngleF1D type definition ------------------------------*/
+
+PyTypeObject Curvature2DAngleF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Curvature2DAngleF1D",				/* tp_name */
+	sizeof( BPy_Curvature2DAngleF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Curvature2DAngleF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int Curvature2DAngleF1D___init__( BPy_Curvature2DAngleF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: Curvature2DAngleF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::Curvature2DAngleF1D(t);
+	return 0;
+
+}
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.h
new file mode 100644
index 00000000000..838bb229844
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_CURVATURE2DANGLEF1D_H
+#define FREESTYLE_PYTHON_CURVATURE2DANGLEF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Curvature2DAngleF1D_Type;
+
+#define BPy_Curvature2DAngleF1D_Check(v)	(( (PyObject *) v)->ob_type == &Curvature2DAngleF1D_Type)
+
+/*---------------------------Python BPy_Curvature2DAngleF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_Curvature2DAngleF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_CURVATURE2DANGLEF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.cpp
index 861a94b7cd3..b6b3262d1cc 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.cpp
@@ -1,8 +1,124 @@
- PyObject *_wrap_DensityF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_DensityF1D.h"
+
+#include "../../../stroke/AdvancedFunctions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for DensityF1D instance  -----------*/
+	static int DensityF1D___init__(BPy_DensityF1D* self, PyObject *args);
+
+/*-----------------------BPy_DensityF1D type definition ------------------------------*/
+
+PyTypeObject DensityF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"DensityF1D",				/* tp_name */
+	sizeof( BPy_DensityF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
 
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)DensityF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int DensityF1D___init__( BPy_DensityF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+	double d = 2.0;
+	float f = 2.0;
+
+	if( !PyArg_ParseTuple(args, "|dOf", &d, &obj, &f) ) {
+		cout << "ERROR: DensityF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::DensityF1D(d,t,f);
+	return 0;
 
- PyObject *_wrap_DensityF1D___call__(PyObject *self , PyObject *args) {
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.h
new file mode 100644
index 00000000000..c7839b86d4d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_DENSITYF1D_H
+#define FREESTYLE_PYTHON_DENSITYF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject DensityF1D_Type;
+
+#define BPy_DensityF1D_Check(v)	(( (PyObject *) v)->ob_type == &DensityF1D_Type)
+
+/*---------------------------Python BPy_DensityF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_DensityF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_DENSITYF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp
index c8220604cb8..e9d47e1d945 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp
@@ -1,12 +1,124 @@
- PyObject *_wrap_GetCompleteViewMapDensityF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_GetCompleteViewMapDensityF1D.h"
 
+#include "../../../stroke/AdvancedFunctions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_GetCompleteViewMapDensityF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetCompleteViewMapDensityF1D instance  -----------*/
+	static int GetCompleteViewMapDensityF1D___init__(BPy_GetCompleteViewMapDensityF1D* self, PyObject *args);
+
+/*-----------------------BPy_GetCompleteViewMapDensityF1D type definition ------------------------------*/
+
+PyTypeObject GetCompleteViewMapDensityF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetCompleteViewMapDensityF1D",				/* tp_name */
+	sizeof( BPy_GetCompleteViewMapDensityF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetCompleteViewMapDensityF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetCompleteViewMapDensityF1D___init__( BPy_GetCompleteViewMapDensityF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+	unsigned i;
+	float f = 2.0;
+
+	if( !PyArg_ParseTuple(args, "i|Of", &i, &obj, &f) ) {
+		cout << "ERROR: GetCompleteViewMapDensityF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetCompleteViewMapDensityF1D(i,t,f);
+	return 0;
 
- PyObject *_wrap_delete_GetCompleteViewMapDensityF1D(PyObject *self , PyObject *args) {
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.h
new file mode 100644
index 00000000000..5106930be75
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETCOMPLETEVIEWMAPDENSITYF1D_H
+#define FREESTYLE_PYTHON_GETCOMPLETEVIEWMAPDENSITYF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetCompleteViewMapDensityF1D_Type;
+
+#define BPy_GetCompleteViewMapDensityF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetCompleteViewMapDensityF1D_Type)
+
+/*---------------------------Python BPy_GetCompleteViewMapDensityF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetCompleteViewMapDensityF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETCOMPLETEVIEWMAPDENSITYF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp
index b7c4e40fd82..7691cda9a30 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp
@@ -1,12 +1,124 @@
- PyObject *_wrap_GetDirectionalViewMapDensityF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_GetDirectionalViewMapDensityF1D.h"
 
+#include "../../../stroke/AdvancedFunctions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_GetDirectionalViewMapDensityF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetDirectionalViewMapDensityF1D instance  -----------*/
+	static int GetDirectionalViewMapDensityF1D___init__(BPy_GetDirectionalViewMapDensityF1D* self, PyObject *args);
+
+/*-----------------------BPy_GetDirectionalViewMapDensityF1D type definition ------------------------------*/
+
+PyTypeObject GetDirectionalViewMapDensityF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetDirectionalViewMapDensityF1D",				/* tp_name */
+	sizeof( BPy_GetDirectionalViewMapDensityF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetDirectionalViewMapDensityF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetDirectionalViewMapDensityF1D___init__( BPy_GetDirectionalViewMapDensityF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+	unsigned int u1, u2;
+	float f = 2.0;
+
+	if( !PyArg_ParseTuple(args, "II|Of", &u1, &u2, &obj, &f) ) {
+		cout << "ERROR: GetDirectionalViewMapDensityF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetDirectionalViewMapDensityF1D(u1, u2, t, f);
+	return 0;
 
- PyObject *_wrap_delete_GetDirectionalViewMapDensityF1D(PyObject *self , PyObject *args) {
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.h
new file mode 100644
index 00000000000..a2c3572694f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETDIRECTIONALVIEWMAPDENSITYF1D_H
+#define FREESTYLE_PYTHON_GETDIRECTIONALVIEWMAPDENSITYF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetDirectionalViewMapDensityF1D_Type;
+
+#define BPy_GetDirectionalViewMapDensityF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetDirectionalViewMapDensityF1D_Type)
+
+/*---------------------------Python BPy_GetDirectionalViewMapDensityF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetDirectionalViewMapDensityF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETDIRECTIONALVIEWMAPDENSITYF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.cpp
new file mode 100644
index 00000000000..9832053f11b
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.cpp
@@ -0,0 +1,122 @@
+#include "BPy_GetProjectedXF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetProjectedXF1D instance  -----------*/
+	static int GetProjectedXF1D___init__(BPy_GetProjectedXF1D* self, PyObject *args );
+
+/*-----------------------BPy_GetProjectedXF1D type definition ------------------------------*/
+
+PyTypeObject GetProjectedXF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetProjectedXF1D",				/* tp_name */
+	sizeof( BPy_GetProjectedXF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetProjectedXF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetProjectedXF1D___init__( BPy_GetProjectedXF1D* self, PyObject *args )
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: GetProjectedXF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetProjectedXF1D(t);
+	return 0;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.h
new file mode 100644
index 00000000000..26350df2013
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETPROJECTEDXF1D_H
+#define FREESTYLE_PYTHON_GETPROJECTEDXF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetProjectedXF1D_Type;
+
+#define BPy_GetProjectedXF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetProjectedXF1D_Type)
+
+/*---------------------------Python BPy_GetProjectedXF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetProjectedXF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETPROJECTEDXF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.cpp
new file mode 100644
index 00000000000..83b7c82691d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.cpp
@@ -0,0 +1,121 @@
+#include "BPy_GetProjectedYF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetProjectedYF1D instance  -----------*/
+	static int GetProjectedYF1D___init__(BPy_GetProjectedYF1D* self, PyObject *args );
+
+/*-----------------------BPy_GetProjectedYF1D type definition ------------------------------*/
+
+PyTypeObject GetProjectedYF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetProjectedYF1D",				/* tp_name */
+	sizeof( BPy_GetProjectedYF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetProjectedYF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetProjectedYF1D___init__( BPy_GetProjectedYF1D* self, PyObject *args )
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: GetProjectedYF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetProjectedYF1D(t);
+	return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.h
new file mode 100644
index 00000000000..86602d9619c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETPROJECTEDYF1D_H
+#define FREESTYLE_PYTHON_GETPROJECTEDYF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetProjectedYF1D_Type;
+
+#define BPy_GetProjectedYF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetProjectedYF1D_Type)
+
+/*---------------------------Python BPy_GetProjectedYF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetProjectedYF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETPROJECTEDYF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.cpp
new file mode 100644
index 00000000000..78f8dccc4c7
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.cpp
@@ -0,0 +1,121 @@
+#include "BPy_GetProjectedZF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetProjectedZF1D instance  -----------*/
+	static int GetProjectedZF1D___init__(BPy_GetProjectedZF1D* self, PyObject *args );
+
+/*-----------------------BPy_GetProjectedZF1D type definition ------------------------------*/
+
+PyTypeObject GetProjectedZF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetProjectedZF1D",				/* tp_name */
+	sizeof( BPy_GetProjectedZF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetProjectedZF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetProjectedZF1D___init__( BPy_GetProjectedZF1D* self, PyObject *args )
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: GetProjectedZF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetProjectedZF1D(t);
+	return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.h
new file mode 100644
index 00000000000..9f2a4bc1a3e
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETPROJECTEDZF1D_H
+#define FREESTYLE_PYTHON_GETPROJECTEDZF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetProjectedZF1D_Type;
+
+#define BPy_GetProjectedZF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetProjectedZF1D_Type)
+
+/*---------------------------Python BPy_GetProjectedZF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetProjectedZF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETPROJECTEDZF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.cpp
new file mode 100644
index 00000000000..3960cc91456
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.cpp
@@ -0,0 +1,124 @@
+#include "BPy_GetSteerableViewMapDensityF1D.h"
+
+#include "../../../stroke/AdvancedFunctions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetSteerableViewMapDensityF1D instance  -----------*/
+	static int GetSteerableViewMapDensityF1D___init__(BPy_GetSteerableViewMapDensityF1D* self, PyObject *args);
+
+/*-----------------------BPy_GetSteerableViewMapDensityF1D type definition ------------------------------*/
+
+PyTypeObject GetSteerableViewMapDensityF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetSteerableViewMapDensityF1D",				/* tp_name */
+	sizeof( BPy_GetSteerableViewMapDensityF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetSteerableViewMapDensityF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetSteerableViewMapDensityF1D___init__( BPy_GetSteerableViewMapDensityF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+	int i;
+	float f = 2.0;
+
+	if( !PyArg_ParseTuple(args, "i|Of", &i, &obj, &f) ) {
+		cout << "ERROR: GetSteerableViewMapDensityF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetSteerableViewMapDensityF1D(i,t,f);
+	return 0;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.h
new file mode 100644
index 00000000000..fa9942a55a1
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETSTEERABLEVIEWMAPDENSITYF1D_H
+#define FREESTYLE_PYTHON_GETSTEERABLEVIEWMAPDENSITYF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetSteerableViewMapDensityF1D_Type;
+
+#define BPy_GetSteerableViewMapDensityF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetSteerableViewMapDensityF1D_Type)
+
+/*---------------------------Python BPy_GetSteerableViewMapDensityF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetSteerableViewMapDensityF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETSTEERABLEVIEWMAPDENSITYF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.cpp
new file mode 100644
index 00000000000..6549e0bf2ce
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.cpp
@@ -0,0 +1,124 @@
+#include "BPy_GetViewMapGradientNormF1D.h"
+
+#include "../../../stroke/AdvancedFunctions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetViewMapGradientNormF1D instance  -----------*/
+	static int GetViewMapGradientNormF1D___init__(BPy_GetViewMapGradientNormF1D* self, PyObject *args);
+
+/*-----------------------BPy_GetViewMapGradientNormF1D type definition ------------------------------*/
+
+PyTypeObject GetViewMapGradientNormF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetViewMapGradientNormF1D",				/* tp_name */
+	sizeof( BPy_GetViewMapGradientNormF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetViewMapGradientNormF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetViewMapGradientNormF1D___init__( BPy_GetViewMapGradientNormF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+	int i;
+	float f = 2.0;
+
+	if( !PyArg_ParseTuple(args, "i|Of", &i, &obj, &f) ) {
+		cout << "ERROR: GetViewMapGradientNormF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetViewMapGradientNormF1D(i,t,f);
+	return 0;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.h
new file mode 100644
index 00000000000..5fcb88d5a29
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETVIEWMAPGRADIENTNORMF1D_H
+#define FREESTYLE_PYTHON_GETVIEWMAPGRADIENTNORMF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetViewMapGradientNormF1D_Type;
+
+#define BPy_GetViewMapGradientNormF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetViewMapGradientNormF1D_Type)
+
+/*---------------------------Python BPy_GetViewMapGradientNormF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetViewMapGradientNormF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETVIEWMAPGRADIENTNORMF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.cpp
new file mode 100644
index 00000000000..d7c4c82639d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.cpp
@@ -0,0 +1,122 @@
+#include "BPy_GetXF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetXF1D instance  -----------*/
+	static int GetXF1D___init__(BPy_GetXF1D* self, PyObject *args );
+
+/*-----------------------BPy_GetXF1D type definition ------------------------------*/
+
+PyTypeObject GetXF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetXF1D",				/* tp_name */
+	sizeof( BPy_GetXF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetXF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetXF1D___init__( BPy_GetXF1D* self, PyObject *args )
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: GetXF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetXF1D(t);
+	return 0;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.h
new file mode 100644
index 00000000000..ad39a5a9b10
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETXF1D_H
+#define FREESTYLE_PYTHON_GETXF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetXF1D_Type;
+
+#define BPy_GetXF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetXF1D_Type)
+
+/*---------------------------Python BPy_GetXF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetXF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETXF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.cpp
new file mode 100644
index 00000000000..cb4cf1c01b1
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.cpp
@@ -0,0 +1,120 @@
+#include "BPy_GetYF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetYF1D instance  -----------*/
+	static int GetYF1D___init__(BPy_GetYF1D* self, PyObject *args );
+
+/*-----------------------BPy_GetYF1D type definition ------------------------------*/
+
+PyTypeObject GetYF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetYF1D",				/* tp_name */
+	sizeof( BPy_GetYF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetYF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetYF1D___init__( BPy_GetYF1D* self, PyObject *args )
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: GetYF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetYF1D(t);
+	return 0;
+}
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.h
new file mode 100644
index 00000000000..6fc7da72752
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETYF1D_H
+#define FREESTYLE_PYTHON_GETYF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetYF1D_Type;
+
+#define BPy_GetYF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetYF1D_Type)
+
+/*---------------------------Python BPy_GetYF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetYF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETYF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.cpp
new file mode 100644
index 00000000000..02a6a9aaa5d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.cpp
@@ -0,0 +1,121 @@
+#include "BPy_GetZF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetZF1D instance  -----------*/
+	static int GetZF1D___init__(BPy_GetZF1D* self, PyObject *args );
+
+/*-----------------------BPy_GetZF1D type definition ------------------------------*/
+
+PyTypeObject GetZF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetZF1D",				/* tp_name */
+	sizeof( BPy_GetZF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetZF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetZF1D___init__( BPy_GetZF1D* self, PyObject *args )
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: GetZF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::GetZF1D(t);
+	return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.h
new file mode 100644
index 00000000000..71e57faa7ef
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETZF1D_H
+#define FREESTYLE_PYTHON_GETZF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetZF1D_Type;
+
+#define BPy_GetZF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetZF1D_Type)
+
+/*---------------------------Python BPy_GetZF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_GetZF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETZF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.cpp
index 6b9c687e9e0..9623b9d6fc6 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.cpp
@@ -1,12 +1,121 @@
- PyObject *_wrap_LocalAverageDepthF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_LocalAverageDepthF1D.h"
 
+#include "../../../stroke/AdvancedFunctions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_LocalAverageDepthF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
- PyObject *_wrap_delete_LocalAverageDepthF1D(PyObject *self , PyObject *args) {
-}
+/*---------------  Python API function prototypes for LocalAverageDepthF1D instance  -----------*/
+	static int LocalAverageDepthF1D___init__(BPy_LocalAverageDepthF1D* self, PyObject *args);
+
+/*-----------------------BPy_LocalAverageDepthF1D type definition ------------------------------*/
+
+PyTypeObject LocalAverageDepthF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"LocalAverageDepthF1D",				/* tp_name */
+	sizeof( BPy_LocalAverageDepthF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
 
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
 
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)LocalAverageDepthF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int LocalAverageDepthF1D___init__( BPy_LocalAverageDepthF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+	double d;
+
+	if( !PyArg_ParseTuple(args, "d|O", &d, &obj) ) {
+		cout << "ERROR: LocalAverageDepthF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::LocalAverageDepthF1D(d,t);
+	return 0;
+}
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.h
new file mode 100644
index 00000000000..cb9902cc38f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF1D_H
+#define FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject LocalAverageDepthF1D_Type;
+
+#define BPy_LocalAverageDepthF1D_Check(v)	(( (PyObject *) v)->ob_type == &LocalAverageDepthF1D_Type)
+
+/*---------------------------Python BPy_LocalAverageDepthF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_LocalAverageDepthF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.cpp
new file mode 100644
index 00000000000..17ddcda299a
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.cpp
@@ -0,0 +1,122 @@
+#include "BPy_ZDiscontinuityF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for ZDiscontinuityF1D instance  -----------*/
+	static int ZDiscontinuityF1D___init__(BPy_ZDiscontinuityF1D* self, PyObject *args );
+
+/*-----------------------BPy_ZDiscontinuityF1D type definition ------------------------------*/
+
+PyTypeObject ZDiscontinuityF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"ZDiscontinuityF1D",				/* tp_name */
+	sizeof( BPy_ZDiscontinuityF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DDouble_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)ZDiscontinuityF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int ZDiscontinuityF1D___init__( BPy_ZDiscontinuityF1D* self, PyObject *args )
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: ZDiscontinuityF1D___init__ " << endl;		
+		return -1;
+	}
+	
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_double.uf1D_double = new Functions1D::ZDiscontinuityF1D(t);
+	return 0;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.h
new file mode 100644
index 00000000000..66524e5c16a
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_ZDISCONTINUITYF1D_H
+#define FREESTYLE_PYTHON_ZDISCONTINUITYF1D_H
+
+#include "../BPy_UnaryFunction1DDouble.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject ZDiscontinuityF1D_Type;
+
+#define BPy_ZDiscontinuityF1D_Check(v)	(( (PyObject *) v)->ob_type == &ZDiscontinuityF1D_Type)
+
+/*---------------------------Python BPy_ZDiscontinuityF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DDouble py_uf1D_double;
+} BPy_ZDiscontinuityF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_ZDISCONTINUITYF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_Curvature2DAngleF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_Curvature2DAngleF1D.cpp
deleted file mode 100644
index d2057990944..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_Curvature2DAngleF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_Curvature2DAngleF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_Curvature2DAngleF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_Curvature2DAngleF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedXF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedXF1D.cpp
deleted file mode 100644
index d7c8ace1bb2..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedXF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_GetProjectedXF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_GetProjectedXF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_GetProjectedXF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedYF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedYF1D.cpp
deleted file mode 100644
index e567e07ba5a..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedYF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_GetProjectedYF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_GetProjectedYF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_GetProjectedYF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedZF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedZF1D.cpp
deleted file mode 100644
index b20ee1443e7..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedZF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_GetProjectedZF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_GetProjectedZF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_GetProjectedZF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetSteerableViewMapDensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetSteerableViewMapDensityF1D.cpp
deleted file mode 100644
index 21df4596b5e..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetSteerableViewMapDensityF1D.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
- PyObject *_wrap_GetSteerableViewMapDensityF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_GetSteerableViewMapDensityF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetViewMapGradientNormF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetViewMapGradientNormF1D.cpp
deleted file mode 100644
index bd5425450e8..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetViewMapGradientNormF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_GetViewMapGradientNormF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_GetViewMapGradientNormF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_GetViewMapGradientNormF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetXF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetXF1D.cpp
deleted file mode 100644
index 73b4df64df6..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetXF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_GetXF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_GetXF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_GetXF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetYF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetYF1D.cpp
deleted file mode 100644
index 36a1ffed9c6..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetYF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_GetYF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_GetYF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_GetYF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetZF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetZF1D.cpp
deleted file mode 100644
index ad0fc844a1c..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetZF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_GetZF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_GetZF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_GetZF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_ZDiscontinuityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_ZDiscontinuityF1D.cpp
deleted file mode 100644
index 886607f7ca9..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_ZDiscontinuityF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_ZDiscontinuityF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_ZDiscontinuityF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_ZDiscontinuityF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned/BPy_QuantitativeInvisibilityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned/BPy_QuantitativeInvisibilityF1D.cpp
deleted file mode 100644
index 436b617886b..00000000000
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned/BPy_QuantitativeInvisibilityF1D.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
- PyObject *_wrap_QuantitativeInvisibilityF1D_getName(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_QuantitativeInvisibilityF1D___call__(PyObject *self , PyObject *args) {
-}
-
-
- PyObject *_wrap_delete_QuantitativeInvisibilityF1D(PyObject *self , PyObject *args) {
-}
-
-
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.cpp
new file mode 100644
index 00000000000..f6d466b61fa
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.cpp
@@ -0,0 +1,122 @@
+#include "BPy_QuantitativeInvisibilityF1D.h"
+
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for QuantitativeInvisibilityF1D instance  -----------*/
+	static int QuantitativeInvisibilityF1D___init__(BPy_QuantitativeInvisibilityF1D* self, PyObject *args);
+
+/*-----------------------BPy_QuantitativeInvisibilityF1D type definition ------------------------------*/
+
+PyTypeObject QuantitativeInvisibilityF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"QuantitativeInvisibilityF1D",				/* tp_name */
+	sizeof( BPy_QuantitativeInvisibilityF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DUnsigned_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)QuantitativeInvisibilityF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int QuantitativeInvisibilityF1D___init__( BPy_QuantitativeInvisibilityF1D* self, PyObject *args)
+{
+	PyObject *obj = 0;
+
+	if( !PyArg_ParseTuple(args, "|O", &obj) ) {
+		cout << "ERROR: QuantitativeInvisibilityF1D___init__" << endl;		
+		return -1;
+	}
+
+	IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
+	self->py_uf1D_unsigned.uf1D_unsigned = new Functions1D::QuantitativeInvisibilityF1D(t);
+	return 0;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.h
new file mode 100644
index 00000000000..8b8e793582f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_QUANTITATIVEINVISIBILITYF1D_H
+#define FREESTYLE_PYTHON_QUANTITATIVEINVISIBILITYF1D_H
+
+#include "../BPy_UnaryFunction1DUnsigned.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject QuantitativeInvisibilityF1D_Type;
+
+#define BPy_QuantitativeInvisibilityF1D_Check(v)	(( (PyObject *) v)->ob_type == &QuantitativeInvisibilityF1D_Type)
+
+/*---------------------------Python BPy_QuantitativeInvisibilityF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DUnsigned py_uf1D_unsigned;
+} BPy_QuantitativeInvisibilityF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_QUANTITATIVEINVISIBILITYF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.cpp
index 7df4ea835ca..b4a5c7180b6 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.cpp
@@ -1,12 +1,113 @@
- PyObject *_wrap_GetOccludeeF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_GetOccludeeF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_GetOccludeeF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetOccludeeF1D instance  -----------*/
+	static int GetOccludeeF1D___init__(BPy_GetOccludeeF1D* self);
+
+/*-----------------------BPy_GetOccludeeF1D type definition ------------------------------*/
+
+PyTypeObject GetOccludeeF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetOccludeeF1D",				/* tp_name */
+	sizeof( BPy_GetOccludeeF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
 
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
- PyObject *_wrap_delete_GetOccludeeF1D(PyObject *self , PyObject *args) {
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVectorViewShape_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetOccludeeF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetOccludeeF1D___init__( BPy_GetOccludeeF1D* self )
+{
+	self->py_uf1D_vectorviewshape.uf1D_vectorviewshape = new Functions1D::GetOccludeeF1D();
+	return 0;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.h
new file mode 100644
index 00000000000..0377214cb70
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETOCCLUDEEF1D_H
+#define FREESTYLE_PYTHON_GETOCCLUDEEF1D_H
+
+#include "../BPy_UnaryFunction1DVectorViewShape.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetOccludeeF1D_Type;
+
+#define BPy_GetOccludeeF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetOccludeeF1D_Type)
+
+/*---------------------------Python BPy_GetOccludeeF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVectorViewShape py_uf1D_vectorviewshape;
+} BPy_GetOccludeeF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETOCCLUDEEF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.cpp
index 26c14fc4a81..d5e057117f5 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.cpp
@@ -1,12 +1,113 @@
- PyObject *_wrap_GetOccludersF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_GetOccludersF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_GetOccludersF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetOccludersF1D instance  -----------*/
+	static int GetOccludersF1D___init__(BPy_GetOccludersF1D* self);
+
+/*-----------------------BPy_GetOccludersF1D type definition ------------------------------*/
+
+PyTypeObject GetOccludersF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetOccludersF1D",				/* tp_name */
+	sizeof( BPy_GetOccludersF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
 
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
- PyObject *_wrap_delete_GetOccludersF1D(PyObject *self , PyObject *args) {
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVectorViewShape_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetOccludersF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetOccludersF1D___init__( BPy_GetOccludersF1D* self )
+{
+	self->py_uf1D_vectorviewshape.uf1D_vectorviewshape = new Functions1D::GetOccludersF1D();
+	return 0;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.h
new file mode 100644
index 00000000000..76031c5a811
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETOCCLUDERSF1D_H
+#define FREESTYLE_PYTHON_GETOCCLUDERSF1D_H
+
+#include "../BPy_UnaryFunction1DVectorViewShape.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetOccludersF1D_Type;
+
+#define BPy_GetOccludersF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetOccludersF1D_Type)
+
+/*---------------------------Python BPy_GetOccludersF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVectorViewShape py_uf1D_vectorviewshape;
+} BPy_GetOccludersF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETOCCLUDERSF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.cpp
index e1fd19d5d3b..2349b36fa3d 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.cpp
@@ -1,12 +1,113 @@
- PyObject *_wrap_GetShapeF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_GetShapeF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_GetShapeF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for GetShapeF1D instance  -----------*/
+	static int GetShapeF1D___init__(BPy_GetShapeF1D* self);
+
+/*-----------------------BPy_GetShapeF1D type definition ------------------------------*/
+
+PyTypeObject GetShapeF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"GetShapeF1D",				/* tp_name */
+	sizeof( BPy_GetShapeF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
 
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
- PyObject *_wrap_delete_GetShapeF1D(PyObject *self , PyObject *args) {
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVectorViewShape_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)GetShapeF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int GetShapeF1D___init__( BPy_GetShapeF1D* self )
+{
+	self->py_uf1D_vectorviewshape.uf1D_vectorviewshape = new Functions1D::GetShapeF1D();
+	return 0;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.h
new file mode 100644
index 00000000000..3505e6688b0
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_GETSHAPEF1D_H
+#define FREESTYLE_PYTHON_GETSHAPEF1D_H
+
+#include "../BPy_UnaryFunction1DVectorViewShape.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject GetShapeF1D_Type;
+
+#define BPy_GetShapeF1D_Check(v)	(( (PyObject *) v)->ob_type == &GetShapeF1D_Type)
+
+/*---------------------------Python BPy_GetShapeF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVectorViewShape py_uf1D_vectorviewshape;
+} BPy_GetShapeF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_GETSHAPEF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.cpp
index daf3c773267..4ea90ad9f0d 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.cpp
@@ -1,16 +1,113 @@
- PyObject *_wrap_ChainingTimeStampF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_ChainingTimeStampF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_ChainingTimeStampF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
- PyObject *_wrap_new_ChainingTimeStampF1D(PyObject *self , PyObject *args) {
-}
+/*---------------  Python API function prototypes for ChainingTimeStampF1D instance  -----------*/
+	static int ChainingTimeStampF1D___init__(BPy_ChainingTimeStampF1D* self);
+
+/*-----------------------BPy_ChainingTimeStampF1D type definition ------------------------------*/
+
+PyTypeObject ChainingTimeStampF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"ChainingTimeStampF1D",				/* tp_name */
+	sizeof( BPy_ChainingTimeStampF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
 
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
- PyObject *_wrap_delete_ChainingTimeStampF1D(PyObject *self , PyObject *args) {
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVoid_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)ChainingTimeStampF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int ChainingTimeStampF1D___init__( BPy_ChainingTimeStampF1D* self )
+{
+	self->py_uf1D_void.uf1D_void = new Functions1D::ChainingTimeStampF1D();
+	return 0;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.h
new file mode 100644
index 00000000000..e52e037e986
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_CHAININGTIMESTAMPF1D_H
+#define FREESTYLE_PYTHON_CHAININGTIMESTAMPF1D_H
+
+#include "../BPy_UnaryFunction1DVoid.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject ChainingTimeStampF1D_Type;
+
+#define BPy_ChainingTimeStampF1D_Check(v)	(( (PyObject *) v)->ob_type == &ChainingTimeStampF1D_Type)
+
+/*---------------------------Python BPy_ChainingTimeStampF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVoid py_uf1D_void;
+} BPy_ChainingTimeStampF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_CHAININGTIMESTAMPF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp
index 291d180a3fe..509a1e34195 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp
@@ -1,16 +1,113 @@
- PyObject *_wrap_IncrementChainingTimeStampF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_IncrementChainingTimeStampF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_IncrementChainingTimeStampF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
- PyObject *_wrap_new_IncrementChainingTimeStampF1D(PyObject *self , PyObject *args) {
-}
+/*---------------  Python API function prototypes for IncrementChainingTimeStampF1D instance  -----------*/
+	static int IncrementChainingTimeStampF1D___init__(BPy_IncrementChainingTimeStampF1D* self);
+
+/*-----------------------BPy_IncrementChainingTimeStampF1D type definition ------------------------------*/
+
+PyTypeObject IncrementChainingTimeStampF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"IncrementChainingTimeStampF1D",				/* tp_name */
+	sizeof( BPy_IncrementChainingTimeStampF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
 
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
- PyObject *_wrap_delete_IncrementChainingTimeStampF1D(PyObject *self , PyObject *args) {
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVoid_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)IncrementChainingTimeStampF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int IncrementChainingTimeStampF1D___init__( BPy_IncrementChainingTimeStampF1D* self )
+{
+	self->py_uf1D_void.uf1D_void = new Functions1D::IncrementChainingTimeStampF1D();
+	return 0;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.h
new file mode 100644
index 00000000000..82236dd0b79
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_INCREMENTCHAININGTIMESTAMPF1D_H
+#define FREESTYLE_PYTHON_INCREMENTCHAININGTIMESTAMPF1D_H
+
+#include "../BPy_UnaryFunction1DVoid.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject IncrementChainingTimeStampF1D_Type;
+
+#define BPy_IncrementChainingTimeStampF1D_Check(v)	(( (PyObject *) v)->ob_type == &IncrementChainingTimeStampF1D_Type)
+
+/*---------------------------Python BPy_IncrementChainingTimeStampF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVoid py_uf1D_void;
+} BPy_IncrementChainingTimeStampF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_INCREMENTCHAININGTIMESTAMPF1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.cpp
index 8df3b712a30..516f6cada60 100644
--- a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.cpp
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.cpp
@@ -1,16 +1,113 @@
- PyObject *_wrap_TimeStampF1D_getName(PyObject *self , PyObject *args) {
-}
+#include "BPy_TimeStampF1D.h"
 
+#include "../../../view_map/Functions1D.h"
+#include "../../BPy_Convert.h"
+#include "../../BPy_IntegrationType.h"
 
- PyObject *_wrap_TimeStampF1D___call__(PyObject *self , PyObject *args) {
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
- PyObject *_wrap_new_TimeStampF1D(PyObject *self , PyObject *args) {
-}
+/*---------------  Python API function prototypes for TimeStampF1D instance  -----------*/
+	static int TimeStampF1D___init__(BPy_TimeStampF1D* self);
+
+/*-----------------------BPy_TimeStampF1D type definition ------------------------------*/
+
+PyTypeObject TimeStampF1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"TimeStampF1D",				/* tp_name */
+	sizeof( BPy_TimeStampF1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	NULL,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	NULL,										/* tp_repr */
+
+	/* Method suites for standard classes */
+
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+
+	NULL,						/* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
 
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
 
- PyObject *_wrap_delete_TimeStampF1D(PyObject *self , PyObject *args) {
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, 		/* long tp_flags; */
+
+	NULL,                       /*  char *tp_doc;  Documentation string */
+  /*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+  /***  Assigned meaning in release 2.1 ***/
+  /*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+  /***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	NULL,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&UnaryFunction1DVoid_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)TimeStampF1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	NULL,				/* newfunc tp_new; */
+	
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int TimeStampF1D___init__( BPy_TimeStampF1D* self )
+{
+	self->py_uf1D_void.uf1D_void = new Functions1D::TimeStampF1D();
+	return 0;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.h
new file mode 100644
index 00000000000..f1f91d2cd6e
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.h
@@ -0,0 +1,30 @@
+#ifndef FREESTYLE_PYTHON_TIMESTAMPF1D_H
+#define FREESTYLE_PYTHON_TIMESTAMPF1D_H
+
+#include "../BPy_UnaryFunction1DVoid.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject TimeStampF1D_Type;
+
+#define BPy_TimeStampF1D_Check(v)	(( (PyObject *) v)->ob_type == &TimeStampF1D_Type)
+
+/*---------------------------Python BPy_TimeStampF1D structure definition----------*/
+typedef struct {
+	BPy_UnaryFunction1DVoid py_uf1D_void;
+} BPy_TimeStampF1D;
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_CHAININGTIMESTAMPF1D_H */